diff --git a/research/marked-residual-reflection/.gitattributes b/research/marked-residual-reflection/.gitattributes new file mode 100644 index 0000000000..fa1385d99a --- /dev/null +++ b/research/marked-residual-reflection/.gitattributes @@ -0,0 +1 @@ +* -text diff --git a/research/marked-residual-reflection/.gitignore b/research/marked-residual-reflection/.gitignore new file mode 100644 index 0000000000..43ae0e2a6c --- /dev/null +++ b/research/marked-residual-reflection/.gitignore @@ -0,0 +1,2 @@ +__pycache__/ +*.py[cod] diff --git a/research/marked-residual-reflection/BINDINGS.json b/research/marked-residual-reflection/BINDINGS.json new file mode 100644 index 0000000000..13c27c8308 --- /dev/null +++ b/research/marked-residual-reflection/BINDINGS.json @@ -0,0 +1,332 @@ +{ + "claims": [ + "C32", + "C33" + ], + "files": [ + { + "kind": "unchanged frozen source", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/native_model.py", + "path": "original/native-frames/native_model.py", + "sha256": "6397a86bd3d1461be182fcfa8602b0c70c489964a8c14f12436ba2506e11d9e3" + }, + { + "kind": "unchanged frozen source", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/root-chronology/audit_marked_plane_bound.py", + "path": "original/root-chronology/audit_marked_plane_bound.py", + "sha256": "e66fe9b60753f33a58e1c4ee8e46d9ba9aa2759ffb875eb4e3275c2f49ed6b49" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/caller/HANDOFF-FAMILY.json", + "path": "source/caller/HANDOFF-FAMILY.json", + "sha256": "75a32dd9f41998b63ac8913ee16a2333242b82508f5bba405fda9eb13c1ae955" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/caller/NESTED-FAMILY.json", + "path": "source/caller/NESTED-FAMILY.json", + "sha256": "4067d48c279697238c9ec1a8c0050de89372db22552913052b4ae9cfe44cd80b" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/caller/NESTED-SIX.json", + "path": "source/caller/NESTED-SIX.json", + "sha256": "539a8b44cb46a93c3b7b056d7eff94c4402fba67b8850e03b725b9e2b05952d1" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/caller/PIVOT-PLANE-PROBE.json", + "path": "source/caller/PIVOT-PLANE-PROBE.json", + "sha256": "ac259dc841ee38ad496acd81a017d1b0415fe0567a3057e7776cfe4a265cc85b" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/caller/free_ops.py", + "path": "source/caller/free_ops.py", + "sha256": "5806fe91b9fda162d5986b12e085b14eb3df9a4703f749f61c1f10363138ca77" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/caller/handoff_family.py", + "path": "source/caller/handoff_family.py", + "sha256": "337c5c061f283673fd00057ba16d1cc0b65257cd29b02a3e071eb6c569294fe4" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/caller/nested_family.py", + "path": "source/caller/nested_family.py", + "sha256": "88f425d12baf8a4f849cccd24605f21680eb8ce8d199054db4b4e7734eca72b6" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/caller/nested_prefix.py", + "path": "source/caller/nested_prefix.py", + "sha256": "9ec10cb0243c0c829475ad7290f4953cdff27cb0f90f70b687c4bbee98af676b" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/caller/nested_six.py", + "path": "source/caller/nested_six.py", + "sha256": "1719e560816ffa9e5193f6275c44c688fa280bede36a11c307f61783eb995bf0" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/caller/pivot_plane_probe.py", + "path": "source/caller/pivot_plane_probe.py", + "sha256": "fcd0a4a0a301c4fddfb8b132894e8b5b751b08cacdb0e5ed41e80b0d4903d499" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/caller/plane_group.py", + "path": "source/caller/plane_group.py", + "sha256": "0c54c2e2462390bd0e9a8d47fc765b70e168ced1e0ef5de49e0afed653e26feb" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/CONJUGATED-FACTORY.json", + "path": "source/native-frames/CONJUGATED-FACTORY.json", + "sha256": "dc3a105b7ce7d226aeb8996aea6454ee66d65d9b9529af159d417f00bec02d34" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/CONJUGATED-REFLECTION.json", + "path": "source/native-frames/CONJUGATED-REFLECTION.json", + "sha256": "15980d81733f121d23f7e95f1fb50aa3dccfdc67fb79794b4a93e34f8874293f" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/HALF-CHUNK-COMMUTANT-AUDIT.md", + "path": "source/native-frames/HALF-CHUNK-COMMUTANT-AUDIT.md", + "sha256": "c2608fc41e15f60376c19bff0d3d6f9b6e60e9eb0a5833c0b3451841e4d69864" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/ONE-CHUNK-PHASE.json", + "path": "source/native-frames/ONE-CHUNK-PHASE.json", + "sha256": "be4407444781fea998e49b71d85e54e26dc6dc06f0ce4296846c1c9dca1a7705" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/ORTHOGONAL-REFLECTION-PROOF.md", + "path": "source/native-frames/ORTHOGONAL-REFLECTION-PROOF.md", + "sha256": "38859131f623d315144c0c7da12cf8bae81e3920f2f0d941d67bab374b6f844c" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/ORTHOGONAL-SOURCE-NORMALIZER.json", + "path": "source/native-frames/ORTHOGONAL-SOURCE-NORMALIZER.json", + "sha256": "7bc4603273dcd5177f01fd60c68c439fc0e5668d8e329bf24d02323c4391ea2a" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/SOURCE-PROGRESS-TRADEOFF.json", + "path": "source/native-frames/SOURCE-PROGRESS-TRADEOFF.json", + "sha256": "979b77603903e518dd132892eb9835f83106bb21845824ed828237732fd82c78" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/conjugated_factory.py", + "path": "source/native-frames/conjugated_factory.py", + "sha256": "81a75479e21d70181e4aa70746be3a4a31bcb3ddd1bd00a4a1b812bf126d7caf" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/conjugated_reflection.py", + "path": "source/native-frames/conjugated_reflection.py", + "sha256": "6b68a4a60b160fe28227c31909ed86bd7f80b1f3e07591032cd001dbeb242f6f" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/lifted_algebra.py", + "path": "source/native-frames/lifted_algebra.py", + "sha256": "3b9a58a2048a762ab520ac7fdbb28cbfeb7b30345aaeb777d8dabdd9fb1034d9" + }, + { + "kind": "path-adapted source", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/native_model.py", + "path": "source/native-frames/native_model.py", + "sha256": "b4291b2868f91f6e77058e58e936b2efe965a9d9ae58095745fa2dad8c1d5c68" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/one_chunk_phase.py", + "path": "source/native-frames/one_chunk_phase.py", + "sha256": "d1490bed667bcae939bdb74002471bfa221c22df5a527d3726ec2bf038ee17a0" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/orthogonal_source_normalizer.py", + "path": "source/native-frames/orthogonal_source_normalizer.py", + "sha256": "c6373762bd15763625cc9237bb280a5e26ab8e53d6bfb034474f068b1525e6fa" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/source_progress_tradeoff.py", + "path": "source/native-frames/source_progress_tradeoff.py", + "sha256": "847a7654eddf538745416d48dbd4394beda8d0b13b1e3e46164e5e41b6475f52" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/q4-pauli-fusion/MARKED-RESIDUAL-GLOBAL-FLOOR.json", + "path": "source/q4-pauli-fusion/MARKED-RESIDUAL-GLOBAL-FLOOR.json", + "sha256": "bf1ba9973be787aaf8267b08b2d6bf3665953fc87ab8d8938534a526339dbef3" + }, + { + "kind": "query-count scope correction", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/q4-pauli-fusion/MARKED-RESIDUAL-GLOBAL-FLOOR.md", + "path": "source/q4-pauli-fusion/MARKED-RESIDUAL-GLOBAL-FLOOR.md", + "sha256": "4bf6716e3801a96bda041e639e0581bf137a9c722cd73b4a28497c9e68e32e97" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/q4-pauli-fusion/SOURCE-HANDOFF-PREFIX.json", + "path": "source/q4-pauli-fusion/SOURCE-HANDOFF-PREFIX.json", + "sha256": "62ca588d29406ca49a19f6484784840aeaafd48bce6ed2971b5465d25f0879bb" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/q4-pauli-fusion/handoff_family_independent.py", + "path": "source/q4-pauli-fusion/handoff_family_independent.py", + "sha256": "8d3137072860b1e7d85307fac79f8349d6a41f26786f7f42bf6a8a667b769718" + }, + { + "kind": "query-count scope correction", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/q4-pauli-fusion/marked_residual_gate.py", + "path": "source/q4-pauli-fusion/marked_residual_gate.py", + "sha256": "7a0c286af1d908030f8d89bf7062a4f91b1279705b56654e9b279e7c6d2b0c30" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/q4-pauli-fusion/source_handoff_prefix.py", + "path": "source/q4-pauli-fusion/source_handoff_prefix.py", + "sha256": "d9169c729610e4346c56ab28f498c4f2d37dd5c34bc027309372f9d7f50ed06f" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/root-chronology/CHRONOLOGY.json", + "path": "source/root-chronology/CHRONOLOGY.json", + "sha256": "583daa7b7f0027e93417cb1907d1f4ddc89249d95adc9f94de0ad8968a71fea2" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/root-chronology/INDEPENDENT-MARKED-PLANE-BOUND.json", + "path": "source/root-chronology/INDEPENDENT-MARKED-PLANE-BOUND.json", + "sha256": "8310ceb066be281a5c2f89085cb5c55b4215914c87cdf5caed95d6fc1695815b" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/root-chronology/INDEPENDENT-PARTIAL-REFLECTION.json", + "path": "source/root-chronology/INDEPENDENT-PARTIAL-REFLECTION.json", + "sha256": "3e7e2f91e111bc4552c10f308f4a16d64ccf8d150e8ac0bf0f5020bd4715c2e7" + }, + { + "kind": "path-adapted source", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/root-chronology/audit_marked_plane_bound.py", + "path": "source/root-chronology/audit_marked_plane_bound.py", + "sha256": "6a55a3651e9efd814b1bb2d0268ad1467d7fd09b8fbb32c9034ea54311139f0d" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/root-chronology/audit_partial_reflection.py", + "path": "source/root-chronology/audit_partial_reflection.py", + "sha256": "085eae2cb416de93293bef7c1aae922e49853329a172ec95c0ee093c752a5f0f" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/root-chronology/chronology.py", + "path": "source/root-chronology/chronology.py", + "sha256": "eed0590640dadcd48c683d142899396b563e843a6c15c9df3cc5d1ecdc107a2c" + }, + { + "kind": "unchanged inherited implementation", + "origin": "/Users/ross/git/math/integer-mult-bounds/research/kernel92-frame-composition/vendor/pr531/vendor/clifford/clifford_exact.py", + "path": "source/vendor/clifford_exact.py", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + }, + { + "kind": "unchanged source-specific notice/provenance", + "origin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90:research/kernel92-frame-composition/NOTICE.md", + "path": "source/vendor/credits/NOTICE.md", + "sha256": "538e7634331d7e24791be08dedd737bf458f35a3b46ce651e6aacd905f3dee6e" + }, + { + "kind": "unchanged source-specific notice/provenance", + "origin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90:research/kernel92-frame-composition/PR533-NOTICE.md", + "path": "source/vendor/credits/PR533-NOTICE.md", + "sha256": "2c1961a07b0976e29e8e6f4da14a9aaeb2f961a3a78d842488065aa433fa2f98" + }, + { + "kind": "unchanged source-specific notice/provenance", + "origin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90:research/kernel92-frame-composition/vendor/pr531/NOTICE.md", + "path": "source/vendor/credits/vendor/pr531/NOTICE.md", + "sha256": "a92f49c5ced455160fbedcc8954e3c9255e3605e88ad12ae5a84f1c4302986f1" + }, + { + "kind": "unchanged source-specific notice/provenance", + "origin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90:research/kernel92-frame-composition/vendor/pr531/SOURCES.json", + "path": "source/vendor/credits/vendor/pr531/SOURCES.json", + "sha256": "9e8182e6e659f4671fe0873e324b622cc871df7344157093df40476c8687be5f" + }, + { + "kind": "unchanged source-specific notice/provenance", + "origin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90:research/kernel92-frame-composition/vendor/pr531/inputs/PR523-ANCESTRY.json", + "path": "source/vendor/credits/vendor/pr531/inputs/PR523-ANCESTRY.json", + "sha256": "0bfce40d86c849f18e8872ee9e8462b0a69a34ed04e01e942a6614645f686f4b" + }, + { + "kind": "unchanged inherited implementation", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/stabilizer-escape/full_stabilizer_bound.py", + "path": "source/vendor/full_stabilizer_bound.py", + "sha256": "f073a00ad4831616e873eb110fd33ad7226010a7c2f6cfa6a6b63167bf58ef75" + }, + { + "kind": "unchanged pre-correction source", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/q4-pauli-fusion/MARKED-RESIDUAL-GLOBAL-FLOOR.md", + "path": "original/q4-pauli-fusion/MARKED-RESIDUAL-GLOBAL-FLOOR.md", + "sha256": "79d1c134fe1c9930b13ec6b580239f100102ce23558d9246f7438a21b949f2a0" + }, + { + "kind": "unchanged pre-correction source", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/q4-pauli-fusion/marked_residual_gate.py", + "path": "original/q4-pauli-fusion/marked_residual_gate.py", + "sha256": "0110b774289bd52284a8605dab44ffe88a225c64790a43025b60d1eb33295061" + } + ], + "limits": "Byte retention and replay bindings are not mathematical acceptance. Historical receipt paths and producer hashes remain original; selected entrypoints are replayed through the explicit source-byte loader.", + "original_run": "kappa-four-coordinate-20261019T0717Z", + "path_adaptations": [ + { + "adapted_sha256": "b4291b2868f91f6e77058e58e936b2efe965a9d9ae58095745fa2dad8c1d5c68", + "change": "Three source locations only: package-local BASE and immutable CE/BOUND locations. No arithmetic, assertions, constants or coverage changed.", + "original_sha256": "6397a86bd3d1461be182fcfa8602b0c70c489964a8c14f12436ba2506e11d9e3", + "path": "source/native-frames/native_model.py" + }, + { + "adapted_sha256": "6a55a3651e9efd814b1bb2d0268ad1467d7fd09b8fbb32c9034ea54311139f0d", + "change": "Only the read-only chirp-source location is package-local.", + "original_sha256": "e66fe9b60753f33a58e1c4ee8e46d9ba9aa2759ffb875eb4e3275c2f49ed6b49", + "path": "source/root-chronology/audit_marked_plane_bound.py" + } + ], + "schema_version": 1, + "scientific_base": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "source_corrections": [ + { + "change": "Restrict joint-debt query-count claims to single-plane rank-2f calls; give the multi-plane two/three-query realizations at the unchanged rank-mass floor.", + "corrected_sha256": "4bf6716e3801a96bda041e639e0581bf137a9c722cd73b4a28497c9e68e32e97", + "original_path": "original/q4-pauli-fusion/MARKED-RESIDUAL-GLOBAL-FLOOR.md", + "original_sha256": "79d1c134fe1c9930b13ec6b580239f100102ce23558d9246f7438a21b949f2a0", + "path": "source/q4-pauli-fusion/MARKED-RESIDUAL-GLOBAL-FLOOR.md", + "review": "https://github.com/CrocSwap/integer-mult-bounds/pull/4056#discussion_r4313846357" + }, + { + "change": "Clarify one assertion message as single-plane/rank-2f queries. No arithmetic, certificate fields, predicates or coverage changed.", + "corrected_sha256": "7a0c286af1d908030f8d89bf7062a4f91b1279705b56654e9b279e7c6d2b0c30", + "original_path": "original/q4-pauli-fusion/marked_residual_gate.py", + "original_sha256": "0110b774289bd52284a8605dab44ffe88a225c64790a43025b60d1eb33295061", + "path": "source/q4-pauli-fusion/marked_residual_gate.py", + "review": "https://github.com/CrocSwap/integer-mult-bounds/pull/4056#discussion_r4313846357" + } + ] +} diff --git a/research/marked-residual-reflection/LICENSE b/research/marked-residual-reflection/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/marked-residual-reflection/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/research/marked-residual-reflection/NOTICE.md b/research/marked-residual-reflection/NOTICE.md new file mode 100644 index 0000000000..9b2e471c3f --- /dev/null +++ b/research/marked-residual-reflection/NOTICE.md @@ -0,0 +1,19 @@ +# Attribution and scope + +Copyright 2026 Ross Richardson. New caller derivations, exact replay adapter +and packaging: Ross Richardson with substantial OpenAI Codex assistance. +Apache-2.0, under the included LICENSE. + +The exact inherited Gaussian-dyadic compiler is not new work. The unchanged +kernel92/PR531 notices, source manifest and PR523 ancestry remain under +source/vendor/credits/. Their source authors and AI disclosures are retained. +The locally frozen predecessor proofs and mathematical scripts are retained +with original bytes and original AI assistance notices, except the explicitly +identified read-only path adaptations whose originals are also retained. + +PR3987 (Chris R / Clear1nsight) and PR4002 (ToikY) retain generic signed-lift +and phase-normalization credit. PR3989/4045 retain their separate interface +and physical-volume theorems. Separate BIT PR4021/4023 and older Ross-authored +PR3630/3632/3645/3649/3655 are prior publications, not unpublished new results. +No arithmetic, κ, selected-record or scientific-acceptance claim is imported +from a PR title, publication state, archive or source-integrity check. diff --git a/research/marked-residual-reflection/README.md b/research/marked-residual-reflection/README.md new file mode 100644 index 0000000000..6f5e899cb2 --- /dev/null +++ b/research/marked-residual-reflection/README.md @@ -0,0 +1,131 @@ +# Marked-residual stock floor and an actual reflection escape + +**Scoped caller result; no new κ or selected-frontier change.** + +## Result + +For `L` ordered planes of `2f` bits, native products on whole +planes, whole-plane ADDRESS permutations, X translations and arbitrary +Gaussian scalar bank GL bridges, a complete word producing the full +native target on `n` independent data banks pays native rank mass at +least `n(2Lf)`, its full stock. Arbitrary dirty helpers restored to +identity contribute no escape. Outer endpoints within the same commuting +algebra do not change the bound. + +The [typed half-chunk extension](source/native-frames/HALF-CHUNK-COMMUTANT-AUDIT.md) +gives the analogous stock floor for f>=2 with its explicitly stated chunk +query alphabet. It is a written argument, separate from the plane audit. + +An actual bitwise orthogonal transvection `A=I+vv^T`, with four-chunk +support `{p0,q0,p1,p2}`, commutes with the old full three-plane native +source and sends a one-mark residual to a three-mark residual. This is a +concrete escape from the invariant used in the floor. Its conjugated +queries have exact arity `2f`, phases and monomial adapters. The cheap +source-factory conjugation also reduces retained source progress by the +same rank; it does not supply a favorable complete caller. + +## Proof and exact coverage + +The [plane proof](source/q4-pauli-fusion/MARKED-RESIDUAL-GLOBAL-FLOOR.md) +constructs the invariant residual space and prices the rank of `[C,U]`. +The independent Gaussian audit checks the literal one-bit C/Hp/Hq factors, +all characters for f=1..5, and every native support for L=1..8. The written +tensor embedding and rank subadditivity prove the stated all-parameter +result. + +The joint-debt query-count corollaries apply to **single-plane**, rank-`2f` +queries. A unary query may cover several planes: `diag(N0 N1,N0 N1)` +uses two rank-`4f` queries, still paying four planes and rank mass `8f`. +The registered replay checks the complete marked-basis actions and phases +of the two-, three- and four-query realizations, plus the q3 split `(1,2)`. +These controls distinguish query count from the unchanged rank-mass floor. + +The [reflection proof](source/native-frames/ORTHOGONAL-REFLECTION-PROOF.md) +and independent 64x64 matrix check retain exact physical phases and the +marked-space leakage. The incorrectly uncorrected paired reflection fails. +The registered command also replays all source-specific conjugated-query +recipes, progress-tradeoff cases and one-chunk phase controls. + +## Limits + +The floor excludes general bit-linear ADDRESS, arbitrary Pauli Z, +native adapters outside the commuting algebra and changed endpoints. +The reflection is outside this proof, so the two statements are +consistent. ADDRESS scans and all source/reader/cleanup work remain paid. +The reflection resource and a native-rank label are not physical supplier +admission, complete ownership, numerical precision or an exponent gain. + +## Reproduce + +From the repository root, on Python 3.12: + +```sh +python3.12 -B scripts/research_package.py --package research/marked-residual-reflection +python3.12 -B scripts/check_research_commit.py --package research/marked-residual-reflection --check-source-history +``` + +The registered manifest runs `verify.py` normally and with `-O`. Its direct +portable equivalent is `python3 -B verify.py` (or `python3 -O -B verify.py`) +from this package. The direct command needs only standard-library Python, +no Git/network and no original Ross-specific directory. `--json` prints the +complete replay summary. It writes no package files. + +[BINDINGS.json](BINDINGS.json) retains every consumed original source/data +byte hash and explicitly records the path-only adaptations and the query-count +scope correction. Original versions of adapted/corrected files remain under +`original/`; the old proof and checker are retained byte-for-byte in +`original/q4-pauli-fusion/`. The correction changes only the joint-debt prose +and one assertion message; historical certificate fields and arithmetic are +unchanged. Its old `full_pair_three_query_gate` field concerns single-plane +queries. Other source bytes and historical receipts remain unchanged. Those +receipts retain their old absolute provenance +paths; they are data, not required filesystem locations. The replay adapter +resolves only the explicitly retained original source inventory. Original lane +notes are archival and keep their original scope and attribution. + +The source loader hashes and compiles the **same bytes**, never loads `.pyc`, +and compiles historical implementations with `optimize=0` in both parent +Python modes, preserving inherited assertions. Mathematical receipt comparison +omits only the enumerated provenance fields in `verify.py`; all such retained +input bytes are checked separately. A changed-source control rejects. Hashes +provide integrity against the trusted publication, not external authentication +or mathematical correctness. Git/source-history, export integrity, finite +replay, written proof, hosted CI and supplier admission remain separate. + +## Related work and credit + +Ross Richardson with substantial OpenAI Codex assistance, including separate +mathematical checking contexts and this packaging adapter. No independent +human or formal-kernel review is claimed. New work is Apache-2.0. + +The Gaussian-dyadic compiler is inherited unchanged from icekylinx's PR531 +through Rohan Arun's kernel92 composition. The exact original notices and +source ancestry are retained in `source/vendor/credits/`; they preserve +DreamingOfClouds, Dugongue, eumemic and the geometry/compiler lineage. + +Chris R / Clear1nsight's PR3987 and ToikY's PR4002 retain credit for generic +native-lift phase/cocycle normalization and the need for exact signed/global +phase witnesses. This package makes no generic normalization priority claim. +Chris R's PR3989 and PR4045 are related explicit interface/volume-cost results; +their different fixed sources and theorems are neither imported nor claimed +as new here. These named overlaps were read at exact heads: + +| PR | Exact head | Contributor | +|---|---|---| +| [#3987](https://github.com/CrocSwap/integer-mult-bounds/pull/3987) | `fc536202fdaa924158789a5ef59ac079bbe21922` | Clear1nsight | +| [#4002](https://github.com/CrocSwap/integer-mult-bounds/pull/4002) | `d593941ea0a4926021cba9d01fe60500579e464f` | ToikY | +| [#4023](https://github.com/CrocSwap/integer-mult-bounds/pull/4023) | `9124007ea9029a9a3b88898bb4c350ddb27ffa58` | RossRichardson | +| [#3989](https://github.com/CrocSwap/integer-mult-bounds/pull/3989) | `7b6dda7ab6ed10d608ecba357ac2f6924166d38b` | Clear1nsight | +| [#4045](https://github.com/CrocSwap/integer-mult-bounds/pull/4045) | `91afbb643f7f4ccf6f34b685ecd959eb790a0f94` | Clear1nsight | + +[RELATED-WORK.json](RELATED-WORK.json) separately inventories the already +published PRs 3630/3632/3645/3649/3655 and separate BIT PRs 4021/4023. +Their publication is not supplier admission. This contribution neither +constructs BIT nor duplicates those results. The recent-PR/live-discussion +overlap has explicit partial coverage, not a proof of novelty. + +## Open next questions + +Can a caller use this actual unpaired reflection while retaining all original readers and a favorable complete charge? Bind one completed original-column word to the exact reflected source/delivery recipes, including the source-progress loss. A reflection outside the commutant removes this witness only; it does not supply the missing complete low-cost caller. +The same question, relevance, feasible first step and blockers are in +[TASK.json](TASK.json). diff --git a/research/marked-residual-reflection/RELATED-WORK.json b/research/marked-residual-reflection/RELATED-WORK.json new file mode 100644 index 0000000000..7b0b0117f0 --- /dev/null +++ b/research/marked-residual-reflection/RELATED-WORK.json @@ -0,0 +1,95 @@ +{ + "scientific_base": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "priority_revision": 6, + "coverage": "Exact named PR head/body reads plus parent recent80-open-PR and partial live Discussion delta; not exhaustive code/closed/unpublished overlap.", + "pull_requests": [ + { + "number": 3987, + "title": "Audit staged544 native phases and expose the binary-inverse lift defect", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3987", + "head": "fc536202fdaa924158789a5ef59ac079bbe21922", + "author": "Clear1nsight", + "scope": "Related phase/interface result; not rerun or claimed here." + }, + { + "number": 4002, + "title": "Derive explicit native-lift phase tags and signed-word certificates", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/4002", + "head": "d593941ea0a4926021cba9d01fe60500579e464f", + "author": "ToikY", + "scope": "Related phase/interface result; not rerun or claimed here." + }, + { + "number": 4023, + "title": "Prove sharp fixed-support unary-query bounds with restored dirty banks", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/4023", + "head": "9124007ea9029a9a3b88898bb4c350ddb27ffa58", + "author": "RossRichardson", + "scope": "Related phase/interface result; not rerun or claimed here." + }, + { + "number": 3989, + "title": "Construct selected rank-two Pauli fusion and bound its uniform transfer bill", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3989", + "head": "7b6dda7ab6ed10d608ecba357ac2f6924166d38b", + "author": "Clear1nsight", + "scope": "Related phase/interface result; not rerun or claimed here." + }, + { + "number": 4045, + "title": "research: bind joint-child batching to the staged544 native rank interface", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/4045", + "head": "91afbb643f7f4ccf6f34b685ecd959eb790a0f94", + "author": "Clear1nsight", + "scope": "Related phase/interface result; not rerun or claimed here." + }, + { + "number": 4021, + "title": "Verify five rank-four BIT terminals and their fixed-controller cost bound", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/4021", + "head": "c01f97ecfc7fa64847f6abd8f7b231e1df8c7b70", + "author": "RossRichardson", + "scope": "Already published separate BIT/prior lineage; excluded from this new contribution." + }, + { + "number": 3630, + "title": "Bound staged-supplier packing for every replica count", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3630", + "head": "bcac7fe04b9b7f7f5d3c27d620561f96c4ae5608", + "author": "RossRichardson", + "scope": "Already published separate BIT/prior lineage; excluded from this new contribution." + }, + { + "number": 3632, + "title": "Correct the selected P112 scatter covariance and dirty restoration", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3632", + "head": "7e7a889cbf6da2c4461af806fe52a888c621a7e7", + "author": "RossRichardson", + "scope": "Already published separate BIT/prior lineage; excluded from this new contribution." + }, + { + "number": 3645, + "title": "Reduce R438 to 429 helpers with three source snapshots", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3645", + "head": "99b901c9b5ac70cf441b3d7e585cc7b8744b5359", + "author": "RossRichardson", + "scope": "Already published separate BIT/prior lineage; excluded from this new contribution." + }, + { + "number": 3649, + "title": "Classify sharp noncubic ranks of the H6 odd-Gram family", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3649", + "head": "f8768756d8ac4abb263295170a436ba54562fdcd", + "author": "RossRichardson", + "scope": "Already published separate BIT/prior lineage; excluded from this new contribution." + }, + { + "number": 3655, + "title": "Classify H6 dyadic Smith factors and sharp physical-row repair", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3655", + "head": "7bf23e128e58a33c019268f57129629f603547f7", + "author": "RossRichardson", + "scope": "Already published separate BIT/prior lineage; excluded from this new contribution." + } + ] +} diff --git a/research/marked-residual-reflection/SOURCES.json b/research/marked-residual-reflection/SOURCES.json new file mode 100644 index 0000000000..68bddcb9b4 --- /dev/null +++ b/research/marked-residual-reflection/SOURCES.json @@ -0,0 +1,60 @@ +{ + "schema_version": 1, + "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "67f085acd86acd7d4e03922d9cf4b26bca66fed5", + "sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0" + }, + { + "path": "research/kernel92-frame-composition/vendor/pr531/vendor/clifford/clifford_exact.py", + "usage": "provenance", + "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + }, + { + "path": "research/kernel92-frame-composition/NOTICE.md", + "usage": "provenance", + "git_blob": "8d3c3349e13774de4f992591c3a0b9e74029f761", + "sha256": "538e7634331d7e24791be08dedd737bf458f35a3b46ce651e6aacd905f3dee6e" + }, + { + "path": "research/kernel92-frame-composition/PR533-NOTICE.md", + "usage": "provenance", + "git_blob": "6e6d0042d1cf618308e7e57df3e7e8b6958991d0", + "sha256": "2c1961a07b0976e29e8e6f4da14a9aaeb2f961a3a78d842488065aa433fa2f98" + }, + { + "path": "research/kernel92-frame-composition/vendor/pr531/NOTICE.md", + "usage": "provenance", + "git_blob": "f7a8f861be860edd5a78114c5225dec90effa029", + "sha256": "a92f49c5ced455160fbedcc8954e3c9255e3605e88ad12ae5a84f1c4302986f1" + }, + { + "path": "research/kernel92-frame-composition/vendor/pr531/SOURCES.json", + "usage": "provenance", + "git_blob": "78244052aae4866ae9e8e2d2e4c10180870a0fc4", + "sha256": "9e8182e6e659f4671fe0873e324b622cc871df7344157093df40476c8687be5f" + }, + { + "path": "research/kernel92-frame-composition/vendor/pr531/inputs/PR523-ANCESTRY.json", + "usage": "provenance", + "git_blob": "385a202fbc485ceaed1b604d6c21eb3486caa600", + "sha256": "0bfce40d86c849f18e8872ee9e8462b0a69a34ed04e01e942a6614645f686f4b" + }, + { + "path": "LICENSE", + "usage": "provenance", + "git_blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + } + ] +} diff --git a/research/marked-residual-reflection/TASK.json b/research/marked-residual-reflection/TASK.json new file mode 100644 index 0000000000..3c236c0c73 --- /dev/null +++ b/research/marked-residual-reflection/TASK.json @@ -0,0 +1,66 @@ +{ + "schema_version": 1, + "task_id": "supplier-boundary-audit", + "priority_revision": 6, + "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "original_card": { + "id": "supplier-boundary-audit", + "question": "Does one selected supplier obligation follow from its actual source-bound checks?", + "starting_points": [ + "certificates/selected-result.json", + "research/owner-boundary-audit/README.md", + "research/scatter-export-parity-audit/README.md" + ], + "methods": [ + "Trace one hypothesis through the source, checker and complete caller.", + "Construct one semantically invalid but superficially well-formed fixture and test rejection." + ], + "acceptance_gate": "Pin the current sources and one obligation; the historical owner audit is an example, not evidence of a current bug.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read #2977 reported duplicate-scatter counterexample and its opt-in repair. The archive is not a production fix or an independently validated selected-result failure; the selected generator emits unique rows.", + "scope": "Source-binding orientation only; does not replay or validate the reported bug." + }, + "first_experiment": "First check whether the scatter repair has been adopted. If still open, independently reproduce #2977 symbolic-versus-exported parity on the tiny duplicate fixture, compare the selected unique-row positive control, and define either enforced uniqueness or consistent multiplicity semantics. A bounded guard-adoption patch must preserve valid inputs and test the actual exported action. Stop after this obligation; no full historical replay or frontier change follows from the mutant alone.", + "bottleneck_link": "Closing a current acceptance gap or proof obligation strengthens reliability even without changing kappa.", + "allowed_variations": [ + "Audit one named current condition using a new semantic counterexample." + ], + "scope_change_triggers": [ + "Reporting the historical timing-only diagnostic as a new current acceptance bug.", + "Calling a malformed mutant a failure of the selected construction, or importing an opt-in repair without testing the exporter boundary." + ], + "overlap_terms": [ + "owner boundary", + "bridge omission", + "hosting", + "2977", + "scatter export", + "duplicate index", + "parity semantics" + ] + }, + "scope_status": "changed", + "actual_scope": "Prove the full-stock commutator floor in the whole-plane/X-translation/scalar-bank grammar, record its typed half-chunk extension, and exhibit a phase-correct source-specific unpaired reflection outside that grammar together with its native recipes and source-progress tradeoff.", + "scope_change_reason": "Explicit donor-assigned caller investigation and authorized publication of the frozen preceding-run results; this is not a claim to solve the full original card.", + "bottleneck_link": "Complete native caller charge and original-input reader/cleanup obligations. No selected result or new kappa.", + "budget_minutes": 240, + "stop_rule": "Publish only exact complete local identities, scoped proofs or explicitly archived finite screens. Stop favorable-supplier claims at the unresolved full-bill and physical-admission boundaries.", + "outcome": "partial", + "evidence": "README.md; source proof links; BINDINGS.json; explicit normal/optimized VERIFY.json commands.", + "author": "Ross Richardson", + "ai_assistance": "Substantial OpenAI Codex assistance across the original construction, separate mathematical checking contexts, and publication packaging. AI review is not independent human or formal-kernel acceptance.", + "open_questions": [ + { + "question": "Can a caller use this actual unpaired reflection while retaining all original readers and a favorable complete charge?", + "why_it_matters": "This is the remaining constructive gap between the scoped result and a useful complete caller.", + "first_step": "Bind one completed original-column word to the exact reflected source/delivery recipes, including the source-progress loss.", + "blocked_by": "A reflection outside the commutant removes this witness only; it does not supply the missing complete low-cost caller." + } + ] +} diff --git a/research/marked-residual-reflection/VERIFY.json b/research/marked-residual-reflection/VERIFY.json new file mode 100644 index 0000000000..dcd98d89ff --- /dev/null +++ b/research/marked-residual-reflection/VERIFY.json @@ -0,0 +1,28 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 600, + "checks": "Complete listed operator/receipt replays and named rejecting controls; source-bound exact bytes with historical assertions enabled." + }, + { + "argv": [ + "{python}", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 600, + "checks": "Same mathematical coverage under optimized parent Python; historical source assertions deliberately retained by optimize=0 compilation." + } + ] +} diff --git a/research/marked-residual-reflection/original/native-frames/native_model.py b/research/marked-residual-reflection/original/native-frames/native_model.py new file mode 100644 index 0000000000..03925dd36e --- /dev/null +++ b/research/marked-residual-reflection/original/native-frames/native_model.py @@ -0,0 +1,67 @@ +"""Pinned Gaussian Clifford model for common2/fresh2 native bridges. +Apache-2.0; substantial OpenAI Codex assistance. Frozen imports are read only. +""" +from pathlib import Path +import hashlib,importlib.util,sys +sys.dont_write_bytecode=True +BASE=Path('/Users/ross/git/math') +PIN='20ecf2891d80b5acf18d980b2164fb44ea7faa90' +CE_PATH=BASE/'integer-mult-bounds/research/kernel92-frame-composition/vendor/pr531/vendor/clifford/clifford_exact.py' +CE_SHA='2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962' +BOUND_PATH=BASE/'.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/stabilizer-escape/full_stabilizer_bound.py' +BOUND_SHA='f073a00ad4831616e873eb110fd33ad7226010a7c2f6cfa6a6b63167bf58ef75' +def need(ok,why): + if not ok:raise ValueError(why) +def load(name,path,sha): + need(hashlib.sha256(path.read_bytes()).hexdigest()==sha,'source pin '+str(path)) + spec=importlib.util.spec_from_file_location(name,path);mod=importlib.util.module_from_spec(spec);sys.modules[name]=mod;spec.loader.exec_module(mod);return mod +ce=load('native_frames_pinned_clifford',CE_PATH,CE_SHA) +b=load('native_frames_frozen_independent',BOUND_PATH,BOUND_SHA) +def mul(*ops):return b.standard_product(ce,*ops) +def same(a,c,why,phase=True): + need(a.tab==c.tab,why+' signed tableau') + if phase:need(b.sparse_column(a)==b.sparse_column(c),why+' actual Gaussian phase') +def phase(n,p):return ce.Op(n,ce.identity(n),[('phase',p%4)]) +def symplectic_defect_rank(op): + return b.binary_rank(x^y for x,y in zip(b.binary_tableau(op),b.binary_tableau(ce.ident(op.n)))) +def pauli(n,x=0,z=0,p=0): + out=ce.diag(n,[0]*n,[2*((z>>j)&1)for j in range(n)]) + return mul(phase(n,p),ce.xgate(n,x),out) +def conjugated_pauli(op,x=0,z=0,p=0): + triple=ce.apply(op.tab,(x,z,p));return pauli(op.n,*triple),triple +class Model: + def __init__(self,f=1,stages=4): + need(f>=1 and stages>=1,'positive chunk/stages');self.f=f;self.stages=stages;self.n=(2+2*stages)*f;self.I=ce.ident(self.n) + self.N=self.Npair(0,1);self.U=self.Hp(0);self.V=mul(self.N,self.U.adjoint()) + self.P=[self.swap_pair(s+1)for s in range(stages)];self.T=[self.Npair(2+2*s,3+2*s)for s in range(stages)] + self.Q=ce.xgate(self.n,1) + def Hp(self,chunk): + out=self.I + for j in range(self.f): + bit=chunk*self.f+j;alpha=[0]*self.n;alpha[bit]=2 + out=mul(ce.diag(self.n,[0]*self.n,alpha),ce.cgate(self.n,1<=4,'pqqp uses4 stages');gs=[self.I,self.I];controls=[];F=self.I + for s,(kind,W) in enumerate(zip('FGFG',[self.U,self.V,self.V,self.U])): + required=self.phi(gs[1])if kind=='F'else mul(W,self.N.adjoint(),gs[1],self.N,W.adjoint()) + L=mul(required,gs[0].adjoint());controls.append(L);gs[0]=required + if kind=='F':gs=[gs[0],mul(W,self.P[s],gs[1],W.adjoint())] + else:gs=[mul(W.adjoint(),gs[0],W),mul(self.P[s],gs[1])] + F=mul(self.T[s],F) + return gs,controls diff --git a/research/marked-residual-reflection/original/q4-pauli-fusion/MARKED-RESIDUAL-GLOBAL-FLOOR.md b/research/marked-residual-reflection/original/q4-pauli-fusion/MARKED-RESIDUAL-GLOBAL-FLOOR.md new file mode 100644 index 0000000000..b807380df5 --- /dev/null +++ b/research/marked-residual-reflection/original/q4-pauli-fusion/MARKED-RESIDUAL-GLOBAL-FLOOR.md @@ -0,0 +1,170 @@ +# An exact stock floor for whole-plane ADDRESS and X-translation bridges + +This result is about a specified operator grammar. It does not cover +arbitrary Pauli Z, arbitrary linear changes of address bits, or native +queries on unrelated symplectic axes. Those are constructive escape routes, +not consequences of the result below. + +Let there be `L` ordered planes, each containing `2f` address bits, with +actual operators + +``` +N_i = i Hp_f(i) Hq_f(i), N_i^2=-I. +``` + +Different `N_i` commute. A native query on a union `S` of whole planes is, +up to an explicitly paid Gaussian unit and ADDRESS packing, the product +`N_S=prod_(i in S) N_i`. Its recursive rank is `2f |S|`. The admitted free +coefficient algebra is generated by whole ordered-plane permutations, +all actual X translations, and Gaussian dyadic scalars. Arbitrary +invertible bank matrices over this algebra are allowed, with any number +of scalar ADDs, selectors, bank swaps and the associated paid scans. + +For `n` independent banks whose exact final map is the full native +operator `E=prod_(i=0..L-1) N_i`, any word in this grammar satisfies + +``` +sum_native_queries |S| >= n L, +sum_native_queries rank >= 2f n L = n m, m=2fL. (1) +``` + +Arbitrary dirty helpers restored to identity do not weaken (1). The same +bound applies if the target is changed by invertible outer bank words +over the admitted free algebra. In particular, conditional bank routing +`W(Q)` with any admitted X involution is covered. + +## Actual all-f embedding + +On one plane choose `Q=X` on one distinguished bit. The actual `N_f` +anticommutes every single-bit X translation: each `Hp/Hq` factor contains +a Z phase and a function of X. The commuting observables + +``` +R_b=Q X_b, b other than the distinguished bit, +``` + +commute with both `Q` and `N_f`. There are `2^(2f-1)` joint residual +labels. For each label `r`, choose a vector `|+,r>` with `Q=+1` and put + +``` +|-,r> = -i N_f |+,r>. +``` + +Then, exactly including Gaussian phases, + +``` +N_f = i X_virtual, Q=Z_virtual. +``` + +Every physical X translation is diagonal in these virtual/residual +coordinates. This is a change of basis used in a proof; it is not a free +operation granted to a circuit. + +Choose the same two distinct residual labels `u,v` on every plane. They +exist for every `f>=1`. Restrict to tensors with exactly one `v` and all +other labels `u`. The residual basis is `|owner=j>`, `0<=j = (-1)^x_j |x,owner=j>. +``` + +It is an involution. Every admitted X translation is diagonal and +commutes with `C`. Every whole-plane permutation moves `x` and `j` +together and commutes with `C`. Consequently every admitted bank bridge +commutes with the bankwise copy of `C`. + +`N_S` flips precisely the virtual bits in `S` and preserves the owner. +Its commutator with `C` is nonzero precisely on owner sectors in `S`. +Each such sector contributes `2^L` independent rows and columns, so + +``` +rank [N_S,C] = |S| 2^L. (2) +``` + +The full `E` flips the bit at every possible owner. Its commutator is +invertible on `V`, and its `n`-bank target rank is `n L 2^L`. Finally + +``` +[AB,C] = A[B,C] + [A,C]B, +rank[AB,C] <= rank[A,C]+rank[B,C] +``` + +for invertible `A,B`. Applying this to the complete word gives (1). +Query inverses, Gaussian units and conjugation by covered bridges have +the same query commutator rank. Neither arbitrary bank mixing nor a +longer free word evades the argument. + +## Joint debt and the changed caller's terminal block + +The same witness proves that a two-bank diagonal debt on disjoint native +supports `S0,S1` requires total native-plane count at least +`|S0|+|S1|`. Thus the q3 split `(1,2)` cannot use two unary native +queries, and the q4 split `(2,2)` cannot use total native-plane count +three in this grammar. + +The distinct full-pair target +`diag(N0 N1,N0 N1)` has rank16 on its two-bank, two-plane marked block. +Every unary query has rank4. It requires at least four unary queries; +three cannot suffice, including arbitrary `GL2(K[Q,R,P])` bridges. + +For the actual handoff family, write the terminal pivot-input block as +`H=D R J`, where `R` is a scalar bank permutation and the rows of `D` +are actual monomial native/ADDRESS factories. The required pivot +coefficient is `H^-1 N0`; public compensation columns cannot lower the +rank of this submatrix. + +Right multiplying by the displayed factory ADDRESS permutations and a +bank permutation, all commuting with `C`, reduces this coefficient to + +``` +J^-1 diag(N0 E0,N0 E1), +``` + +where `E0,E1` have disjoint external native support, avoid planes0,1,2, +and have total support size `q`. On an external owner sector, `J` +commutes with `C`, so the external contribution is exactly `q 2^L`. +The three core owner sectors contribute `3 2^L`: the exact 48 by48 +core matrix `J^-1 diag(N0,N0)` has rational commutator rank24, with a +displayed nonsingular 24 by24 minor in the JSON certificate. Spectator +virtual bits multiply this by `2^(L-3)`. Hence the fixed-cut tail needs + +``` +total native-plane count >= q+3, +native rank mass >= 2f(q+3). (3) +``` + +The current explicit tail has count `q+4`. Equation (3) is a tail bound +after the stated cut. Cross-cut cancellation has its own complete-word +invoice, while (1) applies directly to every complete word that stays +inside the same grammar. + +## Exact certificate and limits + +Run `python3 -B marked_residual_gate.py`, or add `-O`. The checks use +explicit integer commutator supports for the q3/q4 joint debts, the +two-bank full pair, and an exact rational RREF plus nonsingular minor +for the core matrix. They also bind the changed caller's actual factory +normal forms at q2,3,4,8 to the previously independently replayed word. + +`MARKED-RESIDUAL-GLOBAL-FLOOR.json` contains the tiny matrices and scope. +An actual Pauli-Z example moves the residual label, changes the sign of +`C`, and is explicitly rejected as a commuting bridge. Thus the proof +must not be extended to that larger alphabet. All-f circuit identities +using Z, other address maps, or different native subspaces remain open. + +The parent identified the complete stock-floor consequence. The marked +construction generalizes this lane's earlier two-residual commutator +mechanism; the all-f X-translation embedding, joint-debt and fixed-core +certificates are derived here. No improved kappa or multiplication +theorem is claimed. diff --git a/research/marked-residual-reflection/original/q4-pauli-fusion/marked_residual_gate.py b/research/marked-residual-reflection/original/q4-pauli-fusion/marked_residual_gate.py new file mode 100644 index 0000000000..f76883aba3 --- /dev/null +++ b/research/marked-residual-reflection/original/q4-pauli-fusion/marked_residual_gate.py @@ -0,0 +1,247 @@ +#!/usr/bin/env python3 +"""Exact marked-residual commutator certificates, with the actual all-f scope. + +The operator C is a proof witness, not an available circuit operation. +It commutes whole ordered-plane permutations and X translations, and does +not commute arbitrary Pauli Z or arbitrary bit-linear ADDRESS maps. +Apache-2.0; substantial OpenAI Codex assistance. +""" +from pathlib import Path +from fractions import Fraction +from itertools import permutations +import argparse +import hashlib +import json + +HERE = Path(__file__).resolve().parent + + +def need(x, why): + if not x: + raise ValueError(why) + + +def matmul(a, b): + n = len(a) + out = [[0] * n for _ in range(n)] + for i in range(n): + for h, z in enumerate(a[i]): + if z: + for j, w in enumerate(b[h]): + if w: + out[i][j] += z * w + return out + + +def plus(a, b, sign=1): + return [[x + sign * y for x, y in zip(r, s)] for r, s in zip(a, b)] + + +def exact_rank(matrix): + a = [[Fraction(z) for z in row] for row in matrix] + original_rows = list(range(len(a))) + pivots, pivot_rows = [], [] + row = 0 + for col in range(len(a[0])): + h = next((h for h in range(row, len(a)) if a[h][col]), None) + if h is None: + continue + a[row], a[h] = a[h], a[row] + original_rows[row], original_rows[h] = original_rows[h], original_rows[row] + z = a[row][col] + a[row] = [x / z for x in a[row]] + for h in range(len(a)): + if h != row and a[h][col]: + z = a[h][col] + a[h] = [x - z * y for x, y in zip(a[h], a[row])] + pivots.append(col) + pivot_rows.append(original_rows[row]) + row += 1 + need(all(not any(r) for r in a[row:]), 'rank upper bound has zero remaining rows') + return row, pivots, pivot_rows + + +def signs(L): + return [1 if not (x >> owner & 1) else -1 + for x in range(1 << L) for owner in range(L)] + + +def mapping(L, plane_permutation=None, native_mask=0): + p = list(range(L)) if plane_permutation is None else plane_permutation + out = [] + for x in range(1 << L): + y = x ^ native_mask + z = sum(((y >> i) & 1) << p[i] for i in range(L)) + for owner in range(L): + out.append(z * L + p[owner]) + need(sorted(out) == list(range(len(out))), 'actual virtual/residual action is a permutation') + return out + + +def permutation_matrix(mapping): + a = [[0] * len(mapping) for _ in mapping] + for col, row in enumerate(mapping): + a[row][col] = 1 + return a + + +def commutator_entries(L, native_mask): + c = signs(L) + out = [] + for col, row in enumerate(mapping(L, native_mask=native_mask)): + z = c[col] - c[row] + if z: + out.append([row, col, z]) + need(len({e[0] for e in out}) == len(out) == len({e[1] for e in out}), + 'nonzero commutator entries have distinct rows and columns') + need(len(out) == native_mask.bit_count() * (1 << L), 'exact query commutator rank') + return out + + +def local_fixture(L, bank_masks): + c = signs(L) + for p in permutations(range(L)): + need(all(c[i] == c[j] for i, j in enumerate(mapping(L, p))), + 'every whole-plane permutation commutes the marked C') + # Every Q_i and every actual X translation is diagonal in this basis; + # the latter may have a different sign for the two residual labels. + for i in range(L): + q = [1 if not (x >> i & 1) else -1 for x in range(1 << L) for _ in range(L)] + need(all((a * b) == (b * a) for a, b in zip(c, q)), 'Q_i commutes C') + ranks = {str(mask): len(commutator_entries(L, mask)) for mask in range(1, 1 << L)} + target_rank = sum(len(commutator_entries(L, mask)) for mask in bank_masks) + expected_planes = sum(mask.bit_count() for mask in bank_masks) + need(target_rank == expected_planes * (1 << L), 'joint bank debt ranks add literally') + return dict(planes=L, internal_dimension=L * (1 << L), bank_native_masks=bank_masks, + C_diagonal=c, single_bank_query_commutator_ranks=ranks, + target_commutator_rank=target_rank, + minimum_total_native_plane_count=expected_planes, + target_Gaussian_phase_exponents=[mask.bit_count() % 4 for mask in bank_masks], + phase_note='The displayed native action is i^r times its real permutation. Multiplication by that nonzero Gaussian unit leaves the recorded commutator rank unchanged.') + + +def core_fixture(): + L, d = 3, 24 + I = permutation_matrix(mapping(L)) + X0 = permutation_matrix(mapping(L, native_mask=1)) + P1 = permutation_matrix(mapping(L, [1, 0, 2])) + P2 = permutation_matrix(mapping(L, [2, 1, 0])) + Q1 = matmul(matmul(X0, P1), X0) + QP = matmul(Q1, P2) + J = [[plus(plus(P2, Q1), I, -1), plus(I, P2, -1)], + [plus(Q1, I, -1), I]] + Ji = [[QP, plus(Q1, QP, -1)], + [plus(QP, P2, -1), plus(plus(Q1, P2), QP, -1)]] + def block(a): + return [[a[i // d][j // d][i % d][j % d] for j in range(2 * d)] + for i in range(2 * d)] + ident = [[int(i == j) for j in range(2 * d)] for i in range(2 * d)] + need(matmul(block(J), block(Ji)) == matmul(block(Ji), block(J)) == ident, + 'fixed J and its written inverse are exact') + # N0=i X0, so the common factor i is removed solely for rank arithmetic. + T = block([[matmul(Ji[i][j], X0) for j in range(2)] for i in range(2)]) + c = signs(L) * 2 + R = [[T[i][j] * (c[j] - c[i]) for j in range(2 * d)] for i in range(2 * d)] + rank, columns, rows = exact_rank(R) + need(rank == 24, 'fixed-core exact commutator rank is 24=3*2^3') + minor = [[R[i][j] for j in columns] for i in rows] + need(exact_rank(minor)[0] == 24, 'displayed 24x24 pivot minor is nonsingular') + return dict(internal_dimension=d, total_dimension=2 * d, + J=block(J), J_inverse=block(Ji), correction_without_common_Gaussian_unit=T, + C_diagonal=c, commutator=R, exact_rational_rank=rank, + nonsingular_minor_rows=rows, nonsingular_minor_columns=columns, + normalized_native_plane_lower_bound=3, + meaning='The fixed block is J^-1 diag(N0,N0); Q1=N0^-1 P1 N0=X0 P1 X0 exactly. The omitted common scalar is i, which preserves rank.') + + +def terminal_fixture(q): + from handoff_family_independent import RightAlgebra, event_word, factory_certificate + A = RightAlgebra(2 * q + 2) + M, _ = A.replay(event_word(q), 2 * q + 2) + data = factory_certificate(q, A, M) + normalized = [] + external_union = set() + for item in data['rows']: + p = item['ADDRESS_permutation'] + left = item['native_support_left_normal'] + right = {i for i, j in enumerate(p) if j in left} + inverse_common = p.index(0) + G = right ^ {inverse_common} + need(0 in G and 1 not in G and 2 not in G, 'normalized debt has exactly its common core plane') + external = G - {0} + need(not external_union.intersection(external), 'normalized external debts stay disjoint') + external_union.update(external) + normalized.append(dict(physical_row=item['physical_row'], fixed_J_coordinate=item['fixed_J_coordinate'], + right_native_planes=sorted(right), ADDRESS_inverse_common_plane=inverse_common, + normalized_correction_native_planes=sorted(G), + external_native_planes=sorted(external))) + need(len(external_union) == q, 'actual tail has q distinct external debts after right ADDRESS normalization') + L = 2 * q + 2 + return dict(q=q, ambient_planes=L, normalized_debts=normalized, + external_support_union=sorted(external_union), external_commutator_rank=q * (1 << L), + core_commutator_rank=3 * (1 << L), total_pivot_correction_commutator_rank=(q + 3) * (1 << L), + minimum_tail_native_plane_count=q + 3, minimum_tail_rank_mass_in_units_f=2 * (q + 3), + current_direct_tail_native_plane_count=q + 4, + scope='After this exact prefix cut; any length of whole-plane ADDRESS/X-translation/GL-bank bridge word and native products on whole planes. Public-reader columns can only increase the complete tail commutator rank. Cross-cut cancellation or Pauli Z/other bit-linear ADDRESS is outside this tail-only invoice.') + + +def excluded_Z_control(): + # For f=1 choose residual r=Xp*Xq. In the canonical N=iX_virtual + # basis Zp sends (x,rbit) to (x xor1,rbit xor1), with a nonzero unit. + # Extend C as identity outside the one-mark sector. This extension + # still commutes X and plane permutations but fails to commute Zp. + L = 2 + def c_value(bits, residual): + if residual.bit_count() != 1: + return 1 + owner = (residual & -residual).bit_length() - 1 + return 1 if not (bits >> owner & 1) else -1 + bits, residual, plane = 1, 1, 0 + before = c_value(bits, residual) + after = c_value(bits ^ (1 << plane), residual ^ (1 << plane)) + need(before == -1 and after == 1, 'Pauli Z really escapes the marked-C commutant') + return dict(actual_f=1, virtual_bits=bits, marked_residual_bits=residual, + Pauli_Zp_plane=plane, C_before=before, C_after=after, + result='NONCOMMUTING: the claimed floor must not be extended to full Pauli Z bridges.') + + +def prove(): + fullpair = local_fixture(2, [3, 3]) + need(fullpair['target_commutator_rank'] == 16 and fullpair['single_bank_query_commutator_ranks']['1'] == 4, + 'three unary queries cannot pay the two-bank full pair') + return dict(status='PASS_EXACT_MARKED_RESIDUAL_GLOBAL_FLOOR', no_new_kappa=True, + full_pair_three_query_gate=fullpair, + q3_disjoint_debt_gate=local_fixture(3, [1, 6]), + q4_disjoint_debt_gate=local_fixture(4, [3, 12]), + fixed_core=core_fixture(), + actual_handoff_terminal_gates=[terminal_fixture(q) for q in (2, 3, 4, 8)], + excluded_Pauli_Z_negative_control=excluded_Z_control(), + global_theorem='For L>=1 ordered native planes and n arbitrary target banks, every exact word with target diag(prod_(i=0..L-1) N_i) on those n independent banks, restored arbitrary helpers, native queries on unions of r whole planes, and arbitrary invertible bank bridges over whole-plane ADDRESS permutations and X translations has sum r>=nL. Its native rank mass is at least2f*nL=n*m for m=2fL. Arbitrary Gaussian scalar phases, query inverses and conjugation by covered free bridges do not alter the bound.', + global_proof='On an actual invariant subspace V of dimensionL*2^L let C|x,owner>=(-1)^x_owner |x,owner>. Whole-plane permutations move x andowner together and X translations are diagonal, so every covered bridge commutesC. Product of r native planes flips r virtual bits and leavesownerfixed; its commutator has r*2^L nonzero entries with distinct rows/columns. The n-bank full native target has ranknL2^L. Rank[AB,C]<=rank[A,C]+rank[B,C] for invertible A,B proves the bound.', + actual_all_f_embedding='N_f^2=-I and N_f anticommutes every single X translation on its2f bits. Fix Q=X on one distinguished bit. The2f-1 commuting operators R_b=Q*X_b commuteN andQ. In each joint R eigenlabel choose |+,r> withQ=+1 and define |-,r>=-i*N|+,r>. Then N=iX_virtual, Q=Z_virtual and every X translation is diagonal in (virtual,r). There are2^(2f-1)>=2 residual labels for everyf>=1. Choose the same two labels u,v in every plane and restrict to tensors with exactly one v. Identical plane bases make actual whole-plane ADDRESS permutations the simultaneous virtual/residual permutations used by the certificate. This is an actual invariant subspace, not a faithful-representation assumption or a finite-f interpolation.', + scope_exclusions=['Pauli Z is explicitly excluded: it moves residual labels and fails the exact negative control.', + 'Arbitrary bit-linear ADDRESS maps, p/q role controllers and native axes not unions of the declared ordered planes are excluded unless independently proved to commute this C.', + 'The n*m floor concerns the declared whole-plane native rank mass and complete full-native bank contract. It is not a global circuit, supplier or multiplication-theorem lower bound.'], + attribution=['Marked-residual construction generalizes the earlier q4 two-residual commutator mechanism.', + 'Parent root identified the complete n-bank stock-floor consequence.', + 'The q3/q4 joint debt and actual J-core certificates and all-f X-translation embedding are derived and checked here.'], + producer_sha256=hashlib.sha256(Path(__file__).read_bytes()).hexdigest(), + source_pins=[dict(path=str(HERE / name), sha256=hashlib.sha256((HERE / name).read_bytes()).hexdigest()) + for name in ['handoff_family_independent.py', 'source_handoff_prefix.py']]) + + +def main(): + ap = argparse.ArgumentParser(description=__doc__) + ap.add_argument('--write', action='store_true') + args = ap.parse_args() + out = json.loads(json.dumps(prove())) + path = HERE / 'MARKED-RESIDUAL-GLOBAL-FLOOR.json' + if args.write: + path.write_text(json.dumps(out, indent=2, sort_keys=True) + '\n') + else: + need(json.loads(path.read_text()) == out, 'saved marked-residual certificate differs') + print(out['status'], 'global mass>=n*m in whole-plane/X-only grammar; Pauli Z excluded') + + +if __name__ == '__main__': + main() diff --git a/research/marked-residual-reflection/original/root-chronology/audit_marked_plane_bound.py b/research/marked-residual-reflection/original/root-chronology/audit_marked_plane_bound.py new file mode 100644 index 0000000000..e1960306c9 --- /dev/null +++ b/research/marked-residual-reflection/original/root-chronology/audit_marked_plane_bound.py @@ -0,0 +1,75 @@ +#!/usr/bin/env python3 +"""Independent exact small factors and symbolic counts for a marked-plane cut. +Apache-2.0; substantial OpenAI Codex assistance. Restricted grammar only. +""" +from pathlib import Path +from fractions import Fraction as Q +import argparse,hashlib,json,itertools +from chronology import need +HERE=Path(__file__).resolve().parent +ZERO=(Q(0),Q(0));ONE=(Q(1),Q(0));II=(Q(0),Q(1)) +def plus(a,b):return(a[0]+b[0],a[1]+b[1]) +def neg(a):return(-a[0],-a[1]) +def mul(a,b):return(a[0]*b[0]-a[1]*b[1],a[0]*b[1]+a[1]*b[0]) +def conj(a):return(a[0],-a[1]) +def scale(c,M):return[[mul(c,x)for x in row]for row in M] +def mm(A,B): + out=[] + for row in A: + r=[] + for col in zip(*B): + x=ZERO + for a,b in zip(row,col):x=plus(x,mul(a,b)) + r.append(x) + out.append(r) + return out + +def run(): + I=[[ONE,ZERO],[ZERO,ONE]];X=[[ZERO,ONE],[ONE,ZERO]];Z=[[ONE,ZERO],[ZERO,neg(ONE)]] + a=(Q(1,2),Q(1,2));b=(Q(1,2),Q(-1,2));C=[[a,b],[b,a]];Ci=[[conj(x)for x in row]for row in C] + Hp=mm(Z,Ci);Hq=mm(Z,C) + need(mm(C,X)==mm(X,C),'chirp commutes every X translation on this bit') + need(mm(Hp,Hp)==scale(neg(II),I)and mm(Hq,Hq)==scale(II,I),'exact one-bit square phases') + need(mm(Hp,X)==scale(neg(ONE),mm(X,Hp))and mm(Hq,X)==scale(neg(ONE),mm(X,Hq)),'each typed factor anticommutes X') + need(mm(C,Ci)==I,'exact Gaussian-dyadic chirp inverse') + # All-f scalar proof: N_f=i Hp^tensorf Hq^tensorf has square + # -(-i)^f i^f=-1 and complements every simultaneous X character. + gauge_checks=[] + for f in range(1,6): + for word in range(1<<(2*f)): + x=word&((1<>f;op=(1-x.bit_count()+y.bit_count())%4 + comp=((1<<(2*f))-1)^word;xx=comp&((1<>f;ip=(1-xx.bit_count()+yy.bit_count())%4 + need((op+ip)%4==2,'character pair square is -1') + virtual=word&1;residual=tuple(((word>>j)&1)^virtual for j in range(1,2*f)) + cv=comp&1;cr=tuple(((comp>>j)&1)^cv for j in range(1,2*f)) + need(residual==cr and virtual!=cv,'native flips virtual bit and preserves residual label') + if virtual==0: + # v1=i^(op-1) e_complement makes N v0=i v1 and N v1=i v0. + need(((op-1)+ip)%4==1,'same orbit gauge produces iX on reverse edge') + gauge_checks.append({'f':f,'all_characters':1<<(2*f),'residual_dimension':1<<(2*f-1)}) + cut_checks=[] + for L in range(1,9): + dimension=L*(1<>owner)&1)!=(((x^support)>>owner)&1)) + need(rank==support.bit_count()*(1<>i)&1)!=((x>>(i+1))&1):moved^=(1<>owner)&1)==((moved>>moved_owner)&1),'literal ADDRESS preserves marked cut') + cut_checks.append({'planes':L,'dimension':dimension,'all_native_supports':1<=nL for n full-native output banks and any restored dirty banks. Multiplying by2f gives rankmass>=n*(2Lf).',scope='Actual normalized N_f plane products, arbitrary Gaussian scalar bank operations, whole-plane ADDRESS permutations and X translations; inverses and free conjugates included. No claim for free Pauli Z, general bit-linear ADDRESS, arbitrary native adapters, changed endpoint targets or partial-progress contracts.',limits=['The general proof is written and the listed finite checks are exact; this is not formal-kernel evidence.','A supplier using additional phase or coordinate operations lies outside the obstruction.']) + +def main(): + p=argparse.ArgumentParser();p.add_argument('--write',action='store_true');a=p.parse_args();o=json.loads(json.dumps(run()));f=HERE/'INDEPENDENT-MARKED-PLANE-BOUND.json' + if a.write:f.write_text(json.dumps(o,indent=2,sort_keys=True)+'\n') + else:need(json.loads(f.read_bytes())==o,'saved cut audit differs') + print(o['status'],'character f1..5; all supports L1..8; written all-f/all-L proof') +if __name__=='__main__':main() diff --git a/research/marked-residual-reflection/source/caller/HANDOFF-FAMILY.json b/research/marked-residual-reflection/source/caller/HANDOFF-FAMILY.json new file mode 100644 index 0000000000..e10151cab4 --- /dev/null +++ b/research/marked-residual-reflection/source/caller/HANDOFF-FAMILY.json @@ -0,0 +1,14912 @@ +{ + "all_pair_invariant": { + "continuations": "Only query3 and odd handoffs before the last pair: q-1 total.", + "entrance": "t=u+delta C_r; held=N*u; b1=N*b1raw-v; c_r=-v-N*A_r; c_l=(C_l-C_r)+c_r for l>r; A_r=a+sum_(l>=r)b_l", + "literal_cost": "k=2q+1, n=2q+2, m=4q+4, H2=n*k+q+2 (two input exposures and one final common query included), D_before_tail=2q.", + "next_pair_encoder": "b1+=U; later c_l-=next raw delta C and +=U; swap t with next c; t+=V; continue source N; u_next=V, v_next=-U-N*A_next", + "two_handoff_exit": "U=P_even*u; V=P_odd*(N*v-A_next); public b_r=N*b_rraw, c_r=N*delta C_r; b1=N*(b1raw+A_next)" + }, + "fixtures": [ + { + "D_before_tail": 4, + "H": [ + [ + [ + { + "coefficient": "-1", + "word": [ + "P4", + "P3", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P4", + "P3", + "P1", + "N" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P4", + "P3", + "N" + ] + } + ] + ], + [ + [ + { + "coefficient": "-1", + "word": [ + "P5", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P5", + "N", + "P2" + ] + }, + { + "coefficient": "1", + "word": [ + "P5", + "P1", + "N" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P5", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "P5", + "N", + "P2" + ] + } + ] + ] + ], + "L": [ + [ + [ + { + "coefficient": "-2", + "word": [ + "P4", + "P3" + ] + }, + { + "coefficient": "1", + "word": [ + "P4", + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P4", + "P3" + ] + }, + { + "coefficient": "1", + "word": [ + "P4", + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "-2", + "word": [ + "P4", + "P3" + ] + }, + { + "coefficient": "1", + "word": [ + "P4", + "P3", + "P1" + ] + } + ], + [] + ], + [ + [ + { + "coefficient": "-3", + "word": [ + "P5" + ] + }, + { + "coefficient": "-1", + "word": [ + "P5", + "N", + "P2", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P5", + "P1" + ] + } + ], + [ + { + "coefficient": "-2", + "word": [ + "P5" + ] + }, + { + "coefficient": "-1", + "word": [ + "P5", + "N", + "P2", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P5", + "P1" + ] + } + ], + [ + { + "coefficient": "-2", + "word": [ + "P5" + ] + }, + { + "coefficient": "-1", + "word": [ + "P5", + "N", + "P2", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P5", + "P1" + ] + } + ], + [] + ] + ], + "ambient_arity": 12, + "banks": 6, + "events": [ + { + "coefficient": "1", + "dst": 5, + "kind": "ADD", + "label": "raw c-basis", + "src": 3 + }, + { + "bank": 1, + "kind": "NATIVE", + "label": "shared input N exposure", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "native_arity": 2, + "native_blocks": [ + 0 + ], + "sign": 1 + } + }, + { + "coefficient": "1", + "dst": 2, + "kind": "ADD", + "label": "shared input fanout", + "src": 1 + }, + { + "bank": 1, + "kind": "NATIVE", + "label": "shared input N inverse", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "native_arity": 2, + "native_blocks": [ + 0 + ], + "sign": -1 + } + }, + { + "coefficient": "-1", + "dst": 5, + "kind": "ADD", + "label": "initial nested scalar bridge", + "src": 1 + }, + { + "coefficient": "1", + "dst": 0, + "kind": "ADD", + "label": "initial nested scalar bridge", + "src": 4 + }, + { + "coefficient": "-1", + "dst": 3, + "kind": "ADD", + "label": "initial nested scalar bridge", + "src": 1 + }, + { + "coefficient": "1", + "dst": 0, + "kind": "ADD", + "label": "initial nested scalar bridge", + "src": 2 + }, + { + "coefficient": "-1", + "dst": 2, + "kind": "ADD", + "label": "query1 scalar entrance", + "src": 0 + }, + { + "bank": 0, + "kind": "NATIVE", + "label": "query1 source common", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "native_arity": 2, + "native_blocks": [ + 0 + ], + "sign": 1 + } + }, + { + "coefficient": "1", + "dst": 1, + "kind": "ADD", + "label": "query1 delivery", + "src": 0 + }, + { + "bank": 0, + "kind": "ADDRESS_OR_UNIT", + "label": "query1 source swap", + "operator": { + "block_permutation": [ + 1, + 0, + 2, + 3, + 4, + 5 + ], + "native_arity": 0, + "native_blocks": [], + "sign": 1 + } + }, + { + "bank": 1, + "kind": "NATIVE", + "label": "query1 target fresh", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "native_arity": 2, + "native_blocks": [ + 1 + ], + "sign": 1 + } + }, + { + "bank": 2, + "kind": "NATIVE", + "label": "query1 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "native_arity": 2, + "native_blocks": [ + 1 + ], + "sign": 1 + } + }, + { + "bank": 3, + "kind": "NATIVE", + "label": "query1 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "native_arity": 2, + "native_blocks": [ + 1 + ], + "sign": 1 + } + }, + { + "bank": 4, + "kind": "NATIVE", + "label": "query1 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "native_arity": 2, + "native_blocks": [ + 1 + ], + "sign": 1 + } + }, + { + "bank": 5, + "kind": "NATIVE", + "label": "query1 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "native_arity": 2, + "native_blocks": [ + 1 + ], + "sign": 1 + } + }, + { + "coefficient": "1", + "dst": 2, + "kind": "ADD", + "label": "query1 scalar exit", + "src": 0 + }, + { + "coefficient": "-1", + "dst": 0, + "kind": "ADD", + "label": "initial nested scalar bridge", + "src": 2 + }, + { + "coefficient": "1", + "dst": 1, + "kind": "ADD", + "label": "initial nested scalar bridge", + "src": 3 + }, + { + "coefficient": "-1", + "dst": 3, + "kind": "ADD", + "label": "query2 scalar entrance", + "src": 1 + }, + { + "coefficient": "-1", + "dst": 5, + "kind": "ADD", + "label": "query2 scalar entrance", + "src": 1 + }, + { + "bank": 1, + "kind": "NATIVE", + "label": "query2 source common", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "native_arity": 2, + "native_blocks": [ + 0 + ], + "sign": 1 + } + }, + { + "coefficient": "1", + "dst": 2, + "kind": "ADD", + "label": "query2 delivery", + "src": 1 + }, + { + "bank": 1, + "kind": "ADDRESS_OR_UNIT", + "label": "query2 source swap", + "operator": { + "block_permutation": [ + 2, + 1, + 0, + 3, + 4, + 5 + ], + "native_arity": 0, + "native_blocks": [], + "sign": 1 + } + }, + { + "bank": 0, + "kind": "NATIVE", + "label": "query2 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "native_arity": 2, + "native_blocks": [ + 2 + ], + "sign": 1 + } + }, + { + "bank": 2, + "kind": "NATIVE", + "label": "query2 target fresh", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "native_arity": 2, + "native_blocks": [ + 2 + ], + "sign": 1 + } + }, + { + "bank": 3, + "kind": "NATIVE", + "label": "query2 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "native_arity": 2, + "native_blocks": [ + 2 + ], + "sign": 1 + } + }, + { + "bank": 4, + "kind": "NATIVE", + "label": "query2 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "native_arity": 2, + "native_blocks": [ + 2 + ], + "sign": 1 + } + }, + { + "bank": 5, + "kind": "NATIVE", + "label": "query2 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "native_arity": 2, + "native_blocks": [ + 2 + ], + "sign": 1 + } + }, + { + "coefficient": "1", + "dst": 3, + "kind": "ADD", + "label": "query2 scalar exit", + "src": 1 + }, + { + "coefficient": "1", + "dst": 5, + "kind": "ADD", + "label": "query2 scalar exit", + "src": 1 + }, + { + "coefficient": "-1", + "dst": 1, + "kind": "ADD", + "label": "initial nested scalar bridge", + "src": 3 + }, + { + "bank": 2, + "kind": "NATIVE", + "label": "query3 source common", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "native_arity": 2, + "native_blocks": [ + 0 + ], + "sign": 1 + } + }, + { + "coefficient": "1", + "dst": 5, + "kind": "ADD", + "label": "query3 source fanout", + "src": 2 + }, + { + "coefficient": "1", + "dst": 3, + "kind": "ADD", + "label": "query3 delivery", + "src": 2 + }, + { + "bank": 2, + "kind": "ADDRESS_OR_UNIT", + "label": "query3 source swap", + "operator": { + "block_permutation": [ + 3, + 1, + 2, + 0, + 4, + 5 + ], + "native_arity": 0, + "native_blocks": [], + "sign": 1 + } + }, + { + "bank": 0, + "kind": "NATIVE", + "label": "query3 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "native_arity": 2, + "native_blocks": [ + 3 + ], + "sign": 1 + } + }, + { + "bank": 1, + "kind": "NATIVE", + "label": "query3 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "native_arity": 2, + "native_blocks": [ + 3 + ], + "sign": 1 + } + }, + { + "bank": 3, + "kind": "NATIVE", + "label": "query3 target fresh", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "native_arity": 2, + "native_blocks": [ + 3 + ], + "sign": 1 + } + }, + { + "bank": 4, + "kind": "NATIVE", + "label": "query3 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "native_arity": 2, + "native_blocks": [ + 3 + ], + "sign": 1 + } + }, + { + "bank": 5, + "kind": "NATIVE", + "label": "query3 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "native_arity": 2, + "native_blocks": [ + 3 + ], + "sign": 1 + } + }, + { + "coefficient": "1", + "dst": 5, + "kind": "ADD", + "label": "query3 pre-continuation fanout", + "src": 2 + }, + { + "bank": 2, + "kind": "NATIVE", + "label": "query3 retained source continuation", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "native_arity": 2, + "native_blocks": [ + 0 + ], + "sign": 1 + } + }, + { + "coefficient": "1", + "dst": 2, + "kind": "ADD", + "label": "initial nested scalar bridge", + "src": 0 + }, + { + "coefficient": "1", + "dst": 3, + "kind": "ADD", + "label": "initial nested scalar bridge", + "src": 1 + }, + { + "coefficient": "-1", + "dst": 1, + "kind": "ADD", + "label": "initial nested scalar bridge", + "src": 3 + }, + { + "banks": [ + 2, + 3 + ], + "kind": "BANK_SWAP", + "label": "initial nested permutation" + }, + { + "coefficient": "-1", + "dst": 0, + "kind": "ADD", + "label": "initial nested scalar bridge", + "src": 4 + }, + { + "coefficient": "1", + "dst": 1, + "kind": "ADD", + "label": "initial nested scalar bridge", + "src": 5 + }, + { + "coefficient": "-1", + "dst": 5, + "kind": "ADD", + "label": "query4 scalar source entrance", + "src": 1 + }, + { + "coefficient": "-1", + "dst": 3, + "kind": "ADD", + "label": "held source subtract raw a", + "src": 0 + }, + { + "coefficient": "-1", + "dst": 3, + "kind": "ADD", + "label": "held source subtract future raw b", + "src": 4 + }, + { + "bank": 1, + "kind": "NATIVE", + "label": "query4 source common", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "native_arity": 2, + "native_blocks": [ + 0 + ], + "sign": 1 + } + }, + { + "coefficient": "-1", + "dst": 1, + "kind": "ADD", + "label": "query4 isolate raw c difference", + "src": 3 + }, + { + "banks": [ + 1, + 3 + ], + "kind": "BANK_SWAP", + "label": "query4 source handoff" + }, + { + "bank": 1, + "kind": "ADDRESS_OR_UNIT", + "label": "query4 source swap", + "operator": { + "block_permutation": [ + 4, + 1, + 2, + 3, + 0, + 5 + ], + "native_arity": 0, + "native_blocks": [], + "sign": 1 + } + }, + { + "bank": 0, + "kind": "NATIVE", + "label": "query4 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "native_arity": 2, + "native_blocks": [ + 4 + ], + "sign": 1 + } + }, + { + "bank": 2, + "kind": "NATIVE", + "label": "query4 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "native_arity": 2, + "native_blocks": [ + 4 + ], + "sign": 1 + } + }, + { + "bank": 3, + "kind": "NATIVE", + "label": "query4 target fresh", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "native_arity": 2, + "native_blocks": [ + 4 + ], + "sign": 1 + } + }, + { + "bank": 4, + "kind": "NATIVE", + "label": "query4 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "native_arity": 2, + "native_blocks": [ + 4 + ], + "sign": 1 + } + }, + { + "bank": 5, + "kind": "NATIVE", + "label": "query4 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "native_arity": 2, + "native_blocks": [ + 4 + ], + "sign": 1 + } + }, + { + "banks": [ + 3, + 5 + ], + "kind": "BANK_SWAP", + "label": "query4 move finished c difference" + }, + { + "bank": 4, + "kind": "NATIVE", + "label": "query5 source common", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "native_arity": 2, + "native_blocks": [ + 0 + ], + "sign": 1 + } + }, + { + "coefficient": "1", + "dst": 3, + "kind": "ADD", + "label": "query5 delivery", + "src": 4 + }, + { + "banks": [ + 4, + 3 + ], + "kind": "BANK_SWAP", + "label": "query5 source handoff" + }, + { + "coefficient": "-1", + "dst": 2, + "kind": "ADD", + "label": "query5 finish current b accumulator", + "src": 4 + }, + { + "bank": 4, + "kind": "ADDRESS_OR_UNIT", + "label": "query5 source swap", + "operator": { + "block_permutation": [ + 5, + 1, + 2, + 3, + 4, + 0 + ], + "native_arity": 0, + "native_blocks": [], + "sign": 1 + } + }, + { + "bank": 0, + "kind": "NATIVE", + "label": "query5 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "native_arity": 2, + "native_blocks": [ + 5 + ], + "sign": 1 + } + }, + { + "bank": 1, + "kind": "NATIVE", + "label": "query5 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "native_arity": 2, + "native_blocks": [ + 5 + ], + "sign": 1 + } + }, + { + "bank": 2, + "kind": "NATIVE", + "label": "query5 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "native_arity": 2, + "native_blocks": [ + 5 + ], + "sign": 1 + } + }, + { + "bank": 3, + "kind": "NATIVE", + "label": "query5 target fresh", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "native_arity": 2, + "native_blocks": [ + 5 + ], + "sign": 1 + } + }, + { + "bank": 5, + "kind": "NATIVE", + "label": "query5 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "native_arity": 2, + "native_blocks": [ + 5 + ], + "sign": 1 + } + }, + { + "banks": [ + 4, + 3 + ], + "kind": "BANK_SWAP", + "label": "query5 move finished b to its public slot" + }, + { + "bank": 0, + "kind": "NATIVE", + "label": "final raw a common query", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "native_arity": 2, + "native_blocks": [ + 0 + ], + "sign": 1 + } + }, + { + "coefficient": "-1", + "dst": 2, + "kind": "ADD", + "label": "final b accumulator isolation", + "src": 0 + } + ], + "histogram": { + "2": 34 + }, + "inverse": [ + [ + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + } + ], + [], + [], + [], + [], + [] + ], + [ + [ + { + "coefficient": "1", + "word": [] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P5^-1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N" + ] + } + ], + [] + ], + [ + [], + [], + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + } + ], + [], + [], + [] + ], + [ + [ + { + "coefficient": "1", + "word": [ + "P2^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P2^-1", + "N", + "P3^-1", + "P4^-1" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P2^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P2^-1", + "N", + "P5^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P5^-1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N" + ] + } + ], + [] + ], + [ + [], + [], + [], + [], + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + } + ], + [] + ], + [ + [], + [], + [], + [], + [], + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + } + ] + ] + ], + "matrix": [ + [ + [ + { + "coefficient": "1", + "word": [ + "N" + ] + } + ], + [], + [], + [], + [], + [] + ], + [ + [ + { + "coefficient": "-2", + "word": [ + "P4", + "P3" + ] + }, + { + "coefficient": "1", + "word": [ + "P4", + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P4", + "P3", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P4", + "P3", + "P1", + "N" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P4", + "P3" + ] + }, + { + "coefficient": "1", + "word": [ + "P4", + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P4", + "P3", + "N" + ] + } + ], + [ + { + "coefficient": "-2", + "word": [ + "P4", + "P3" + ] + }, + { + "coefficient": "1", + "word": [ + "P4", + "P3", + "P1" + ] + } + ], + [] + ], + [ + [], + [], + [ + { + "coefficient": "1", + "word": [ + "N" + ] + } + ], + [], + [], + [] + ], + [ + [ + { + "coefficient": "-3", + "word": [ + "P5" + ] + }, + { + "coefficient": "-1", + "word": [ + "P5", + "N", + "P2", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P5", + "P1" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P5", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P5", + "N", + "P2" + ] + }, + { + "coefficient": "1", + "word": [ + "P5", + "P1", + "N" + ] + } + ], + [ + { + "coefficient": "-2", + "word": [ + "P5" + ] + }, + { + "coefficient": "-1", + "word": [ + "P5", + "N", + "P2", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P5", + "P1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P5", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "P5", + "N", + "P2" + ] + } + ], + [ + { + "coefficient": "-2", + "word": [ + "P5" + ] + }, + { + "coefficient": "-1", + "word": [ + "P5", + "N", + "P2", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P5", + "P1" + ] + } + ], + [] + ], + [ + [], + [], + [], + [], + [ + { + "coefficient": "1", + "word": [ + "N" + ] + } + ], + [] + ], + [ + [], + [], + [], + [], + [], + [ + { + "coefficient": "1", + "word": [ + "N" + ] + } + ] + ] + ], + "native_rank_mass": 68, + "physical_inverse": [ + [ + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "1" + } + ], + [], + [], + [], + [], + [] + ], + [ + [ + { + "ADDRESS_plane_permutation": [ + 2, + 0, + 1, + 3, + 4, + 5 + ], + "N_planes": [ + 3, + 4, + 5 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 0, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 4, + 0, + 1, + 2, + 3, + 5 + ], + "N_planes": [ + 3, + 5 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 4, + 0, + 2, + 1, + 3, + 5 + ], + "N_planes": [ + 1, + 2, + 3, + 5 + ], + "coefficient": "-1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 2, + 0, + 1, + 3, + 4, + 5 + ], + "N_planes": [ + 3, + 4, + 5 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "-1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 5, + 0, + 1, + 3, + 4, + 2 + ], + "N_planes": [ + 3, + 4 + ], + "coefficient": "1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 0, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "1" + } + ], + [] + ], + [ + [], + [], + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "1" + } + ], + [], + [], + [] + ], + [ + [ + { + "ADDRESS_plane_permutation": [ + 2, + 0, + 1, + 3, + 4, + 5 + ], + "N_planes": [ + 3, + 4, + 5 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 2, + 1, + 0, + 3, + 4, + 5 + ], + "N_planes": [ + 0, + 1, + 3, + 4, + 5 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 0, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 4, + 0, + 1, + 2, + 3, + 5 + ], + "N_planes": [ + 3, + 5 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 4, + 1, + 0, + 2, + 3, + 5 + ], + "N_planes": [ + 0, + 1, + 3, + 5 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 4, + 0, + 2, + 1, + 3, + 5 + ], + "N_planes": [ + 1, + 2, + 3, + 5 + ], + "coefficient": "-1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 2, + 0, + 1, + 3, + 4, + 5 + ], + "N_planes": [ + 3, + 4, + 5 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 2, + 1, + 0, + 3, + 4, + 5 + ], + "N_planes": [ + 0, + 1, + 3, + 4, + 5 + ], + "coefficient": "-1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 5, + 0, + 1, + 3, + 4, + 2 + ], + "N_planes": [ + 3, + 4 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 5, + 1, + 0, + 3, + 4, + 2 + ], + "N_planes": [ + 0, + 1, + 3, + 4 + ], + "coefficient": "1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 1, + 0, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "1" + } + ], + [] + ], + [ + [], + [], + [], + [], + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "1" + } + ], + [] + ], + [ + [], + [], + [], + [], + [], + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "1" + } + ] + ] + ], + "physical_matrix": [ + [ + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "1" + } + ], + [], + [], + [], + [], + [] + ], + [ + [ + { + "ADDRESS_plane_permutation": [ + 1, + 3, + 2, + 4, + 0, + 5 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 3, + 1, + 2, + 4, + 0, + 5 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "-2" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 3, + 1, + 2, + 4, + 0, + 5 + ], + "N_planes": [ + 1, + 2, + 4, + 5 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 3, + 2, + 4, + 0, + 5 + ], + "N_planes": [ + 2, + 3, + 4, + 5 + ], + "coefficient": "-1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 1, + 3, + 2, + 4, + 0, + 5 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 3, + 1, + 2, + 4, + 0, + 5 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "-1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 3, + 1, + 2, + 4, + 0, + 5 + ], + "N_planes": [ + 1, + 2, + 4, + 5 + ], + "coefficient": "-1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 1, + 3, + 2, + 4, + 0, + 5 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 3, + 1, + 2, + 4, + 0, + 5 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "-2" + } + ], + [] + ], + [ + [], + [], + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "1" + } + ], + [], + [], + [] + ], + [ + [ + { + "ADDRESS_plane_permutation": [ + 2, + 1, + 5, + 3, + 4, + 0 + ], + "N_planes": [ + 1, + 3, + 4 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 5, + 2, + 3, + 4, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 5, + 1, + 2, + 3, + 4, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "-3" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 2, + 1, + 5, + 3, + 4, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 5, + 1, + 2, + 3, + 4, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 5, + 2, + 3, + 4, + 0 + ], + "N_planes": [ + 2, + 3, + 4, + 5 + ], + "coefficient": "-1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 2, + 1, + 5, + 3, + 4, + 0 + ], + "N_planes": [ + 1, + 3, + 4 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 5, + 2, + 3, + 4, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 5, + 1, + 2, + 3, + 4, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "-2" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 2, + 1, + 5, + 3, + 4, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 5, + 1, + 2, + 3, + 4, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4 + ], + "coefficient": "-1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 2, + 1, + 5, + 3, + 4, + 0 + ], + "N_planes": [ + 1, + 3, + 4 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 5, + 2, + 3, + 4, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 5, + 1, + 2, + 3, + 4, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "-2" + } + ], + [] + ], + [ + [], + [], + [], + [], + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "1" + } + ], + [] + ], + [ + [], + [], + [], + [], + [], + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "1" + } + ] + ] + ], + "pivot_rows": [ + 1, + 3 + ], + "public_rows": [ + 0, + 2, + 4, + 5 + ], + "q": 2, + "query_stages": 5 + }, + { + "D_before_tail": 6, + "H": [ + [ + [ + { + "coefficient": "-1", + "word": [ + "P6", + "P5", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P6", + "P5", + "N", + "P2" + ] + }, + { + "coefficient": "1", + "word": [ + "P6", + "P5", + "P1", + "N" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P6", + "P5", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "P6", + "P5", + "N", + "P2" + ] + } + ] + ], + [ + [ + { + "coefficient": "1", + "word": [ + "P7", + "N", + "P4", + "P3", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "P7", + "N", + "P4", + "P3", + "P1", + "N" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P7", + "N", + "P4", + "P3", + "N" + ] + } + ] + ] + ], + "L": [ + [ + [ + { + "coefficient": "-3", + "word": [ + "P6", + "P5" + ] + }, + { + "coefficient": "-1", + "word": [ + "P6", + "P5", + "N", + "P2", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P6", + "P5", + "P1" + ] + } + ], + [ + { + "coefficient": "-2", + "word": [ + "P6", + "P5" + ] + }, + { + "coefficient": "-1", + "word": [ + "P6", + "P5", + "N", + "P2", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P6", + "P5", + "P1" + ] + } + ], + [ + { + "coefficient": "-2", + "word": [ + "P6", + "P5" + ] + }, + { + "coefficient": "-1", + "word": [ + "P6", + "P5", + "N", + "P2", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P6", + "P5", + "P1" + ] + } + ], + [], + [ + { + "coefficient": "-3", + "word": [ + "P6", + "P5" + ] + }, + { + "coefficient": "-1", + "word": [ + "P6", + "P5", + "N", + "P2", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P6", + "P5", + "P1" + ] + } + ], + [] + ], + [ + [ + { + "coefficient": "2", + "word": [ + "P7", + "N", + "P4", + "P3" + ] + }, + { + "coefficient": "-1", + "word": [ + "P7", + "N", + "P4", + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P7", + "N", + "P4", + "P3" + ] + }, + { + "coefficient": "-1", + "word": [ + "P7", + "N", + "P4", + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "2", + "word": [ + "P7", + "N", + "P4", + "P3" + ] + }, + { + "coefficient": "-1", + "word": [ + "P7", + "N", + "P4", + "P3", + "P1" + ] + } + ], + [], + [ + { + "coefficient": "1", + "word": [ + "P7" + ] + }, + { + "coefficient": "2", + "word": [ + "P7", + "N", + "P4", + "P3" + ] + }, + { + "coefficient": "-1", + "word": [ + "P7", + "N", + "P4", + "P3", + "P1" + ] + } + ], + [] + ] + ], + "ambient_arity": 16, + "banks": 8, + "events": [ + { + "coefficient": "1", + "dst": 5, + "kind": "ADD", + "label": "raw c-basis", + "src": 3 + }, + { + "coefficient": "1", + "dst": 7, + "kind": "ADD", + "label": "raw c-basis", + "src": 3 + }, + { + "bank": 1, + "kind": "NATIVE", + "label": "shared input N exposure", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 0 + ], + "sign": 1 + } + }, + { + "coefficient": "1", + "dst": 2, + "kind": "ADD", + "label": "shared input fanout", + "src": 1 + }, + { + "bank": 1, + "kind": "NATIVE", + "label": "shared input N inverse", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 0 + ], + "sign": -1 + } + }, + { + "coefficient": "-1", + "dst": 7, + "kind": "ADD", + "label": "initial nested scalar bridge", + "src": 1 + }, + { + "coefficient": "1", + "dst": 0, + "kind": "ADD", + "label": "initial nested scalar bridge", + "src": 6 + }, + { + "coefficient": "-1", + "dst": 5, + "kind": "ADD", + "label": "initial nested scalar bridge", + "src": 1 + }, + { + "coefficient": "1", + "dst": 0, + "kind": "ADD", + "label": "initial nested scalar bridge", + "src": 4 + }, + { + "coefficient": "-1", + "dst": 3, + "kind": "ADD", + "label": "initial nested scalar bridge", + "src": 1 + }, + { + "coefficient": "1", + "dst": 0, + "kind": "ADD", + "label": "initial nested scalar bridge", + "src": 2 + }, + { + "coefficient": "-1", + "dst": 2, + "kind": "ADD", + "label": "query1 scalar entrance", + "src": 0 + }, + { + "bank": 0, + "kind": "NATIVE", + "label": "query1 source common", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 0 + ], + "sign": 1 + } + }, + { + "coefficient": "1", + "dst": 1, + "kind": "ADD", + "label": "query1 delivery", + "src": 0 + }, + { + "bank": 0, + "kind": "ADDRESS_OR_UNIT", + "label": "query1 source swap", + "operator": { + "block_permutation": [ + 1, + 0, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 0, + "native_blocks": [], + "sign": 1 + } + }, + { + "bank": 1, + "kind": "NATIVE", + "label": "query1 target fresh", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 1 + ], + "sign": 1 + } + }, + { + "bank": 2, + "kind": "NATIVE", + "label": "query1 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 1 + ], + "sign": 1 + } + }, + { + "bank": 3, + "kind": "NATIVE", + "label": "query1 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 1 + ], + "sign": 1 + } + }, + { + "bank": 4, + "kind": "NATIVE", + "label": "query1 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 1 + ], + "sign": 1 + } + }, + { + "bank": 5, + "kind": "NATIVE", + "label": "query1 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 1 + ], + "sign": 1 + } + }, + { + "bank": 6, + "kind": "NATIVE", + "label": "query1 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 1 + ], + "sign": 1 + } + }, + { + "bank": 7, + "kind": "NATIVE", + "label": "query1 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 1 + ], + "sign": 1 + } + }, + { + "coefficient": "1", + "dst": 2, + "kind": "ADD", + "label": "query1 scalar exit", + "src": 0 + }, + { + "coefficient": "-1", + "dst": 0, + "kind": "ADD", + "label": "initial nested scalar bridge", + "src": 2 + }, + { + "coefficient": "1", + "dst": 1, + "kind": "ADD", + "label": "initial nested scalar bridge", + "src": 3 + }, + { + "coefficient": "-1", + "dst": 3, + "kind": "ADD", + "label": "query2 scalar entrance", + "src": 1 + }, + { + "coefficient": "-1", + "dst": 5, + "kind": "ADD", + "label": "query2 scalar entrance", + "src": 1 + }, + { + "coefficient": "-1", + "dst": 7, + "kind": "ADD", + "label": "query2 scalar entrance", + "src": 1 + }, + { + "bank": 1, + "kind": "NATIVE", + "label": "query2 source common", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 0 + ], + "sign": 1 + } + }, + { + "coefficient": "1", + "dst": 2, + "kind": "ADD", + "label": "query2 delivery", + "src": 1 + }, + { + "bank": 1, + "kind": "ADDRESS_OR_UNIT", + "label": "query2 source swap", + "operator": { + "block_permutation": [ + 2, + 1, + 0, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 0, + "native_blocks": [], + "sign": 1 + } + }, + { + "bank": 0, + "kind": "NATIVE", + "label": "query2 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 2 + ], + "sign": 1 + } + }, + { + "bank": 2, + "kind": "NATIVE", + "label": "query2 target fresh", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 2 + ], + "sign": 1 + } + }, + { + "bank": 3, + "kind": "NATIVE", + "label": "query2 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 2 + ], + "sign": 1 + } + }, + { + "bank": 4, + "kind": "NATIVE", + "label": "query2 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 2 + ], + "sign": 1 + } + }, + { + "bank": 5, + "kind": "NATIVE", + "label": "query2 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 2 + ], + "sign": 1 + } + }, + { + "bank": 6, + "kind": "NATIVE", + "label": "query2 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 2 + ], + "sign": 1 + } + }, + { + "bank": 7, + "kind": "NATIVE", + "label": "query2 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 2 + ], + "sign": 1 + } + }, + { + "coefficient": "1", + "dst": 3, + "kind": "ADD", + "label": "query2 scalar exit", + "src": 1 + }, + { + "coefficient": "1", + "dst": 5, + "kind": "ADD", + "label": "query2 scalar exit", + "src": 1 + }, + { + "coefficient": "1", + "dst": 7, + "kind": "ADD", + "label": "query2 scalar exit", + "src": 1 + }, + { + "coefficient": "-1", + "dst": 1, + "kind": "ADD", + "label": "initial nested scalar bridge", + "src": 3 + }, + { + "bank": 2, + "kind": "NATIVE", + "label": "query3 source common", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 0 + ], + "sign": 1 + } + }, + { + "coefficient": "1", + "dst": 5, + "kind": "ADD", + "label": "query3 source fanout", + "src": 2 + }, + { + "coefficient": "1", + "dst": 7, + "kind": "ADD", + "label": "query3 source fanout", + "src": 2 + }, + { + "coefficient": "1", + "dst": 3, + "kind": "ADD", + "label": "query3 delivery", + "src": 2 + }, + { + "bank": 2, + "kind": "ADDRESS_OR_UNIT", + "label": "query3 source swap", + "operator": { + "block_permutation": [ + 3, + 1, + 2, + 0, + 4, + 5, + 6, + 7 + ], + "native_arity": 0, + "native_blocks": [], + "sign": 1 + } + }, + { + "bank": 0, + "kind": "NATIVE", + "label": "query3 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 3 + ], + "sign": 1 + } + }, + { + "bank": 1, + "kind": "NATIVE", + "label": "query3 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 3 + ], + "sign": 1 + } + }, + { + "bank": 3, + "kind": "NATIVE", + "label": "query3 target fresh", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 3 + ], + "sign": 1 + } + }, + { + "bank": 4, + "kind": "NATIVE", + "label": "query3 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 3 + ], + "sign": 1 + } + }, + { + "bank": 5, + "kind": "NATIVE", + "label": "query3 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 3 + ], + "sign": 1 + } + }, + { + "bank": 6, + "kind": "NATIVE", + "label": "query3 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 3 + ], + "sign": 1 + } + }, + { + "bank": 7, + "kind": "NATIVE", + "label": "query3 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 3 + ], + "sign": 1 + } + }, + { + "coefficient": "1", + "dst": 5, + "kind": "ADD", + "label": "query3 pre-continuation fanout", + "src": 2 + }, + { + "coefficient": "1", + "dst": 7, + "kind": "ADD", + "label": "query3 pre-continuation fanout", + "src": 2 + }, + { + "bank": 2, + "kind": "NATIVE", + "label": "query3 retained source continuation", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 0 + ], + "sign": 1 + } + }, + { + "coefficient": "1", + "dst": 2, + "kind": "ADD", + "label": "initial nested scalar bridge", + "src": 0 + }, + { + "coefficient": "1", + "dst": 3, + "kind": "ADD", + "label": "initial nested scalar bridge", + "src": 1 + }, + { + "coefficient": "-1", + "dst": 1, + "kind": "ADD", + "label": "initial nested scalar bridge", + "src": 3 + }, + { + "banks": [ + 2, + 3 + ], + "kind": "BANK_SWAP", + "label": "initial nested permutation" + }, + { + "coefficient": "-1", + "dst": 0, + "kind": "ADD", + "label": "initial nested scalar bridge", + "src": 4 + }, + { + "coefficient": "1", + "dst": 1, + "kind": "ADD", + "label": "initial nested scalar bridge", + "src": 5 + }, + { + "coefficient": "-1", + "dst": 5, + "kind": "ADD", + "label": "query4 scalar source entrance", + "src": 1 + }, + { + "coefficient": "-1", + "dst": 7, + "kind": "ADD", + "label": "query4 scalar source entrance", + "src": 1 + }, + { + "coefficient": "-1", + "dst": 0, + "kind": "ADD", + "label": "restore raw a from deeper response entrance", + "src": 6 + }, + { + "coefficient": "-1", + "dst": 3, + "kind": "ADD", + "label": "held source subtract raw a", + "src": 0 + }, + { + "coefficient": "-1", + "dst": 3, + "kind": "ADD", + "label": "held source subtract future raw b", + "src": 4 + }, + { + "coefficient": "-1", + "dst": 3, + "kind": "ADD", + "label": "held source subtract future raw b", + "src": 6 + }, + { + "bank": 1, + "kind": "NATIVE", + "label": "query4 source common", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 0 + ], + "sign": 1 + } + }, + { + "coefficient": "-1", + "dst": 1, + "kind": "ADD", + "label": "query4 isolate raw c difference", + "src": 3 + }, + { + "banks": [ + 1, + 3 + ], + "kind": "BANK_SWAP", + "label": "query4 source handoff" + }, + { + "bank": 1, + "kind": "ADDRESS_OR_UNIT", + "label": "query4 source swap", + "operator": { + "block_permutation": [ + 4, + 1, + 2, + 3, + 0, + 5, + 6, + 7 + ], + "native_arity": 0, + "native_blocks": [], + "sign": 1 + } + }, + { + "bank": 0, + "kind": "NATIVE", + "label": "query4 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 4 + ], + "sign": 1 + } + }, + { + "bank": 2, + "kind": "NATIVE", + "label": "query4 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 4 + ], + "sign": 1 + } + }, + { + "bank": 3, + "kind": "NATIVE", + "label": "query4 target fresh", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 4 + ], + "sign": 1 + } + }, + { + "bank": 4, + "kind": "NATIVE", + "label": "query4 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 4 + ], + "sign": 1 + } + }, + { + "bank": 5, + "kind": "NATIVE", + "label": "query4 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 4 + ], + "sign": 1 + } + }, + { + "bank": 6, + "kind": "NATIVE", + "label": "query4 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 4 + ], + "sign": 1 + } + }, + { + "bank": 7, + "kind": "NATIVE", + "label": "query4 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 4 + ], + "sign": 1 + } + }, + { + "banks": [ + 3, + 5 + ], + "kind": "BANK_SWAP", + "label": "query4 move finished c difference" + }, + { + "bank": 4, + "kind": "NATIVE", + "label": "query5 source common", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 0 + ], + "sign": 1 + } + }, + { + "coefficient": "1", + "dst": 7, + "kind": "ADD", + "label": "query5 future c first fanout", + "src": 4 + }, + { + "coefficient": "1", + "dst": 3, + "kind": "ADD", + "label": "query5 delivery", + "src": 4 + }, + { + "banks": [ + 4, + 3 + ], + "kind": "BANK_SWAP", + "label": "query5 source handoff" + }, + { + "coefficient": "-1", + "dst": 2, + "kind": "ADD", + "label": "query5 finish current b accumulator", + "src": 4 + }, + { + "coefficient": "-1", + "dst": 7, + "kind": "ADD", + "label": "query5 restore future raw c differences", + "src": 4 + }, + { + "bank": 4, + "kind": "ADDRESS_OR_UNIT", + "label": "query5 source swap", + "operator": { + "block_permutation": [ + 5, + 1, + 2, + 3, + 4, + 0, + 6, + 7 + ], + "native_arity": 0, + "native_blocks": [], + "sign": 1 + } + }, + { + "bank": 0, + "kind": "NATIVE", + "label": "query5 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 5 + ], + "sign": 1 + } + }, + { + "bank": 1, + "kind": "NATIVE", + "label": "query5 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 5 + ], + "sign": 1 + } + }, + { + "bank": 2, + "kind": "NATIVE", + "label": "query5 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 5 + ], + "sign": 1 + } + }, + { + "bank": 3, + "kind": "NATIVE", + "label": "query5 target fresh", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 5 + ], + "sign": 1 + } + }, + { + "bank": 5, + "kind": "NATIVE", + "label": "query5 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 5 + ], + "sign": 1 + } + }, + { + "bank": 6, + "kind": "NATIVE", + "label": "query5 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 5 + ], + "sign": 1 + } + }, + { + "bank": 7, + "kind": "NATIVE", + "label": "query5 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 5 + ], + "sign": 1 + } + }, + { + "coefficient": "1", + "dst": 2, + "kind": "ADD", + "label": "query5 retain other carrier in b accumulator", + "src": 1 + }, + { + "banks": [ + 1, + 7 + ], + "kind": "BANK_SWAP", + "label": "query5 move next raw c into t" + }, + { + "coefficient": "1", + "dst": 1, + "kind": "ADD", + "label": "query5 next source preload", + "src": 4 + }, + { + "bank": 4, + "kind": "NATIVE", + "label": "query5 retained source continuation", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 0 + ], + "sign": 1 + } + }, + { + "banks": [ + 4, + 3 + ], + "kind": "BANK_SWAP", + "label": "query5 move finished b to its public slot" + }, + { + "bank": 1, + "kind": "NATIVE", + "label": "query6 source common", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 0 + ], + "sign": 1 + } + }, + { + "coefficient": "-1", + "dst": 1, + "kind": "ADD", + "label": "query6 isolate raw c difference", + "src": 3 + }, + { + "banks": [ + 1, + 3 + ], + "kind": "BANK_SWAP", + "label": "query6 source handoff" + }, + { + "bank": 1, + "kind": "ADDRESS_OR_UNIT", + "label": "query6 source swap", + "operator": { + "block_permutation": [ + 6, + 1, + 2, + 3, + 4, + 5, + 0, + 7 + ], + "native_arity": 0, + "native_blocks": [], + "sign": 1 + } + }, + { + "bank": 0, + "kind": "NATIVE", + "label": "query6 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 6 + ], + "sign": 1 + } + }, + { + "bank": 2, + "kind": "NATIVE", + "label": "query6 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 6 + ], + "sign": 1 + } + }, + { + "bank": 3, + "kind": "NATIVE", + "label": "query6 target fresh", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 6 + ], + "sign": 1 + } + }, + { + "bank": 4, + "kind": "NATIVE", + "label": "query6 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 6 + ], + "sign": 1 + } + }, + { + "bank": 5, + "kind": "NATIVE", + "label": "query6 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 6 + ], + "sign": 1 + } + }, + { + "bank": 6, + "kind": "NATIVE", + "label": "query6 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 6 + ], + "sign": 1 + } + }, + { + "bank": 7, + "kind": "NATIVE", + "label": "query6 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 6 + ], + "sign": 1 + } + }, + { + "banks": [ + 3, + 7 + ], + "kind": "BANK_SWAP", + "label": "query6 move finished c difference" + }, + { + "bank": 6, + "kind": "NATIVE", + "label": "query7 source common", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 0 + ], + "sign": 1 + } + }, + { + "coefficient": "1", + "dst": 3, + "kind": "ADD", + "label": "query7 delivery", + "src": 6 + }, + { + "banks": [ + 6, + 3 + ], + "kind": "BANK_SWAP", + "label": "query7 source handoff" + }, + { + "coefficient": "-1", + "dst": 2, + "kind": "ADD", + "label": "query7 finish current b accumulator", + "src": 6 + }, + { + "bank": 6, + "kind": "ADDRESS_OR_UNIT", + "label": "query7 source swap", + "operator": { + "block_permutation": [ + 7, + 1, + 2, + 3, + 4, + 5, + 6, + 0 + ], + "native_arity": 0, + "native_blocks": [], + "sign": 1 + } + }, + { + "bank": 0, + "kind": "NATIVE", + "label": "query7 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 7 + ], + "sign": 1 + } + }, + { + "bank": 1, + "kind": "NATIVE", + "label": "query7 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 7 + ], + "sign": 1 + } + }, + { + "bank": 2, + "kind": "NATIVE", + "label": "query7 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 7 + ], + "sign": 1 + } + }, + { + "bank": 3, + "kind": "NATIVE", + "label": "query7 target fresh", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 7 + ], + "sign": 1 + } + }, + { + "bank": 4, + "kind": "NATIVE", + "label": "query7 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 7 + ], + "sign": 1 + } + }, + { + "bank": 5, + "kind": "NATIVE", + "label": "query7 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 7 + ], + "sign": 1 + } + }, + { + "bank": 7, + "kind": "NATIVE", + "label": "query7 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 7 + ], + "sign": 1 + } + }, + { + "banks": [ + 6, + 3 + ], + "kind": "BANK_SWAP", + "label": "query7 move finished b to its public slot" + }, + { + "bank": 0, + "kind": "NATIVE", + "label": "final raw a common query", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 0 + ], + "sign": 1 + } + }, + { + "coefficient": "-1", + "dst": 2, + "kind": "ADD", + "label": "final b accumulator isolation", + "src": 0 + }, + { + "coefficient": "1", + "dst": 7, + "kind": "ADD", + "label": "triangular c difference decode", + "src": 5 + } + ], + "histogram": { + "2": 61 + }, + "inverse": [ + [ + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + } + ], + [], + [], + [], + [], + [], + [], + [] + ], + [ + [ + { + "coefficient": "1", + "word": [] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P5^-1", + "P6^-1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "N", + "P7^-1" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "N", + "P7^-1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N" + ] + } + ], + [], + [ + { + "coefficient": "1", + "word": [] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1" + ] + } + ], + [] + ], + [ + [], + [], + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + } + ], + [], + [], + [], + [], + [] + ], + [ + [ + { + "coefficient": "1", + "word": [ + "P2^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P2^-1", + "N", + "P5^-1", + "P6^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P5^-1", + "P6^-1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P2^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "N", + "P7^-1" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "N", + "P7^-1" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "N", + "P7^-1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N" + ] + } + ], + [], + [ + { + "coefficient": "1", + "word": [ + "P2^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "P2^-1", + "N", + "P3^-1", + "P4^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1" + ] + } + ], + [] + ], + [ + [], + [], + [], + [], + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + } + ], + [], + [], + [] + ], + [ + [], + [], + [], + [], + [], + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + } + ], + [], + [] + ], + [ + [], + [], + [], + [], + [], + [], + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + } + ], + [] + ], + [ + [], + [], + [], + [], + [], + [], + [], + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + } + ] + ] + ], + "matrix": [ + [ + [ + { + "coefficient": "1", + "word": [ + "N" + ] + } + ], + [], + [], + [], + [], + [], + [], + [] + ], + [ + [ + { + "coefficient": "-3", + "word": [ + "P6", + "P5" + ] + }, + { + "coefficient": "-1", + "word": [ + "P6", + "P5", + "N", + "P2", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P6", + "P5", + "P1" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P6", + "P5", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P6", + "P5", + "N", + "P2" + ] + }, + { + "coefficient": "1", + "word": [ + "P6", + "P5", + "P1", + "N" + ] + } + ], + [ + { + "coefficient": "-2", + "word": [ + "P6", + "P5" + ] + }, + { + "coefficient": "-1", + "word": [ + "P6", + "P5", + "N", + "P2", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P6", + "P5", + "P1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P6", + "P5", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "P6", + "P5", + "N", + "P2" + ] + } + ], + [ + { + "coefficient": "-2", + "word": [ + "P6", + "P5" + ] + }, + { + "coefficient": "-1", + "word": [ + "P6", + "P5", + "N", + "P2", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P6", + "P5", + "P1" + ] + } + ], + [], + [ + { + "coefficient": "-3", + "word": [ + "P6", + "P5" + ] + }, + { + "coefficient": "-1", + "word": [ + "P6", + "P5", + "N", + "P2", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P6", + "P5", + "P1" + ] + } + ], + [] + ], + [ + [], + [], + [ + { + "coefficient": "1", + "word": [ + "N" + ] + } + ], + [], + [], + [], + [], + [] + ], + [ + [ + { + "coefficient": "2", + "word": [ + "P7", + "N", + "P4", + "P3" + ] + }, + { + "coefficient": "-1", + "word": [ + "P7", + "N", + "P4", + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P7", + "N", + "P4", + "P3", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "P7", + "N", + "P4", + "P3", + "P1", + "N" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P7", + "N", + "P4", + "P3" + ] + }, + { + "coefficient": "-1", + "word": [ + "P7", + "N", + "P4", + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P7", + "N", + "P4", + "P3", + "N" + ] + } + ], + [ + { + "coefficient": "2", + "word": [ + "P7", + "N", + "P4", + "P3" + ] + }, + { + "coefficient": "-1", + "word": [ + "P7", + "N", + "P4", + "P3", + "P1" + ] + } + ], + [], + [ + { + "coefficient": "1", + "word": [ + "P7" + ] + }, + { + "coefficient": "2", + "word": [ + "P7", + "N", + "P4", + "P3" + ] + }, + { + "coefficient": "-1", + "word": [ + "P7", + "N", + "P4", + "P3", + "P1" + ] + } + ], + [] + ], + [ + [], + [], + [], + [], + [ + { + "coefficient": "1", + "word": [ + "N" + ] + } + ], + [], + [], + [] + ], + [ + [], + [], + [], + [], + [], + [ + { + "coefficient": "1", + "word": [ + "N" + ] + } + ], + [], + [] + ], + [ + [], + [], + [], + [], + [], + [], + [ + { + "coefficient": "1", + "word": [ + "N" + ] + } + ], + [] + ], + [ + [], + [], + [], + [], + [], + [], + [], + [ + { + "coefficient": "1", + "word": [ + "N" + ] + } + ] + ] + ], + "native_rank_mass": 122, + "physical_inverse": [ + [ + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "1" + } + ], + [], + [], + [], + [], + [], + [], + [] + ], + [ + [ + { + "ADDRESS_plane_permutation": [ + 2, + 0, + 1, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 0, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 6, + 0, + 1, + 3, + 4, + 2, + 5, + 7 + ], + "N_planes": [ + 3, + 4, + 5, + 7 + ], + "coefficient": "1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 2, + 0, + 1, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "-1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 7, + 0, + 1, + 2, + 3, + 5, + 6, + 4 + ], + "N_planes": [ + 3, + 5, + 6 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 7, + 0, + 2, + 1, + 3, + 5, + 6, + 4 + ], + "N_planes": [ + 1, + 2, + 3, + 5, + 6 + ], + "coefficient": "1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 0, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "1" + } + ], + [], + [ + { + "ADDRESS_plane_permutation": [ + 4, + 0, + 1, + 2, + 3, + 5, + 6, + 7 + ], + "N_planes": [ + 3, + 5, + 6, + 7 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 4, + 0, + 2, + 1, + 3, + 5, + 6, + 7 + ], + "N_planes": [ + 1, + 2, + 3, + 5, + 6, + 7 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 2, + 0, + 1, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 0, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "1" + } + ], + [] + ], + [ + [], + [], + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "1" + } + ], + [], + [], + [], + [], + [] + ], + [ + [ + { + "ADDRESS_plane_permutation": [ + 2, + 0, + 1, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 2, + 1, + 0, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 0, + 1, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 0, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 6, + 0, + 1, + 3, + 4, + 2, + 5, + 7 + ], + "N_planes": [ + 3, + 4, + 5, + 7 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 6, + 1, + 0, + 3, + 4, + 2, + 5, + 7 + ], + "N_planes": [ + 0, + 1, + 3, + 4, + 5, + 7 + ], + "coefficient": "1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 2, + 0, + 1, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 2, + 1, + 0, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 0, + 1, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "-1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 7, + 0, + 1, + 2, + 3, + 5, + 6, + 4 + ], + "N_planes": [ + 3, + 5, + 6 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 7, + 1, + 0, + 2, + 3, + 5, + 6, + 4 + ], + "N_planes": [ + 0, + 1, + 3, + 5, + 6 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 7, + 0, + 2, + 1, + 3, + 5, + 6, + 4 + ], + "N_planes": [ + 1, + 2, + 3, + 5, + 6 + ], + "coefficient": "1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 1, + 0, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "1" + } + ], + [], + [ + { + "ADDRESS_plane_permutation": [ + 4, + 0, + 1, + 2, + 3, + 5, + 6, + 7 + ], + "N_planes": [ + 3, + 5, + 6, + 7 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 4, + 1, + 0, + 2, + 3, + 5, + 6, + 7 + ], + "N_planes": [ + 0, + 1, + 3, + 5, + 6, + 7 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 4, + 0, + 2, + 1, + 3, + 5, + 6, + 7 + ], + "N_planes": [ + 1, + 2, + 3, + 5, + 6, + 7 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 2, + 0, + 1, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 2, + 1, + 0, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 0, + 1, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 0, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "1" + } + ], + [] + ], + [ + [], + [], + [], + [], + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "1" + } + ], + [], + [], + [] + ], + [ + [], + [], + [], + [], + [], + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "1" + } + ], + [], + [] + ], + [ + [], + [], + [], + [], + [], + [], + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "1" + } + ], + [] + ], + [ + [], + [], + [], + [], + [], + [], + [], + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "1" + } + ] + ] + ], + "physical_matrix": [ + [ + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "1" + } + ], + [], + [], + [], + [], + [], + [], + [] + ], + [ + [ + { + "ADDRESS_plane_permutation": [ + 2, + 1, + 5, + 3, + 4, + 6, + 0, + 7 + ], + "N_planes": [ + 1, + 3, + 4, + 6, + 7 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 5, + 2, + 3, + 4, + 6, + 0, + 7 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 5, + 1, + 2, + 3, + 4, + 6, + 0, + 7 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "-3" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 2, + 1, + 5, + 3, + 4, + 6, + 0, + 7 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 6, + 7 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 5, + 1, + 2, + 3, + 4, + 6, + 0, + 7 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 6, + 7 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 5, + 2, + 3, + 4, + 6, + 0, + 7 + ], + "N_planes": [ + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "-1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 2, + 1, + 5, + 3, + 4, + 6, + 0, + 7 + ], + "N_planes": [ + 1, + 3, + 4, + 6, + 7 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 5, + 2, + 3, + 4, + 6, + 0, + 7 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 5, + 1, + 2, + 3, + 4, + 6, + 0, + 7 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "-2" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 2, + 1, + 5, + 3, + 4, + 6, + 0, + 7 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 6, + 7 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 5, + 1, + 2, + 3, + 4, + 6, + 0, + 7 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 6, + 7 + ], + "coefficient": "-1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 2, + 1, + 5, + 3, + 4, + 6, + 0, + 7 + ], + "N_planes": [ + 1, + 3, + 4, + 6, + 7 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 5, + 2, + 3, + 4, + 6, + 0, + 7 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 5, + 1, + 2, + 3, + 4, + 6, + 0, + 7 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "-2" + } + ], + [], + [ + { + "ADDRESS_plane_permutation": [ + 2, + 1, + 5, + 3, + 4, + 6, + 0, + 7 + ], + "N_planes": [ + 1, + 3, + 4, + 6, + 7 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 5, + 2, + 3, + 4, + 6, + 0, + 7 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 5, + 1, + 2, + 3, + 4, + 6, + 0, + 7 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "-3" + } + ], + [] + ], + [ + [], + [], + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "1" + } + ], + [], + [], + [], + [], + [] + ], + [ + [ + { + "ADDRESS_plane_permutation": [ + 1, + 3, + 2, + 4, + 7, + 5, + 6, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 3, + 1, + 2, + 4, + 7, + 5, + 6, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6 + ], + "coefficient": "-2" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 3, + 1, + 2, + 4, + 7, + 5, + 6, + 0 + ], + "N_planes": [ + 1, + 2, + 4, + 5, + 6 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 3, + 2, + 4, + 7, + 5, + 6, + 0 + ], + "N_planes": [ + 2, + 3, + 4, + 5, + 6 + ], + "coefficient": "-1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 1, + 3, + 2, + 4, + 7, + 5, + 6, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 3, + 1, + 2, + 4, + 7, + 5, + 6, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6 + ], + "coefficient": "-1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 3, + 1, + 2, + 4, + 7, + 5, + 6, + 0 + ], + "N_planes": [ + 1, + 2, + 4, + 5, + 6 + ], + "coefficient": "-1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 1, + 3, + 2, + 4, + 7, + 5, + 6, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 3, + 1, + 2, + 4, + 7, + 5, + 6, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6 + ], + "coefficient": "-2" + } + ], + [], + [ + { + "ADDRESS_plane_permutation": [ + 1, + 3, + 2, + 4, + 7, + 5, + 6, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 3, + 1, + 2, + 4, + 7, + 5, + 6, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6 + ], + "coefficient": "-2" + }, + { + "ADDRESS_plane_permutation": [ + 7, + 1, + 2, + 3, + 4, + 5, + 6, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "1" + } + ], + [] + ], + [ + [], + [], + [], + [], + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "1" + } + ], + [], + [], + [] + ], + [ + [], + [], + [], + [], + [], + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "1" + } + ], + [], + [] + ], + [ + [], + [], + [], + [], + [], + [], + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "1" + } + ], + [] + ], + [ + [], + [], + [], + [], + [], + [], + [], + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "1" + } + ] + ] + ], + "pivot_rows": [ + 1, + 3 + ], + "public_rows": [ + 0, + 2, + 4, + 5, + 6, + 7 + ], + "q": 3, + "query_stages": 7 + }, + { + "D_before_tail": 8, + "H": [ + [ + [ + { + "coefficient": "1", + "word": [ + "P8", + "P7", + "N", + "P4", + "P3", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "P8", + "P7", + "N", + "P4", + "P3", + "P1", + "N" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P8", + "P7", + "N", + "P4", + "P3", + "N" + ] + } + ] + ], + [ + [ + { + "coefficient": "1", + "word": [ + "P9", + "N", + "P6", + "P5", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "P9", + "N", + "P6", + "P5", + "N", + "P2" + ] + }, + { + "coefficient": "-1", + "word": [ + "P9", + "N", + "P6", + "P5", + "P1", + "N" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P9", + "N", + "P6", + "P5", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P9", + "N", + "P6", + "P5", + "N", + "P2" + ] + } + ] + ] + ], + "L": [ + [ + [ + { + "coefficient": "2", + "word": [ + "P8", + "P7", + "N", + "P4", + "P3" + ] + }, + { + "coefficient": "-1", + "word": [ + "P8", + "P7", + "N", + "P4", + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P8", + "P7", + "N", + "P4", + "P3" + ] + }, + { + "coefficient": "-1", + "word": [ + "P8", + "P7", + "N", + "P4", + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "2", + "word": [ + "P8", + "P7", + "N", + "P4", + "P3" + ] + }, + { + "coefficient": "-1", + "word": [ + "P8", + "P7", + "N", + "P4", + "P3", + "P1" + ] + } + ], + [], + [ + { + "coefficient": "1", + "word": [ + "P8", + "P7" + ] + }, + { + "coefficient": "2", + "word": [ + "P8", + "P7", + "N", + "P4", + "P3" + ] + }, + { + "coefficient": "-1", + "word": [ + "P8", + "P7", + "N", + "P4", + "P3", + "P1" + ] + } + ], + [], + [ + { + "coefficient": "2", + "word": [ + "P8", + "P7", + "N", + "P4", + "P3" + ] + }, + { + "coefficient": "-1", + "word": [ + "P8", + "P7", + "N", + "P4", + "P3", + "P1" + ] + } + ], + [] + ], + [ + [ + { + "coefficient": "3", + "word": [ + "P9", + "N", + "P6", + "P5" + ] + }, + { + "coefficient": "1", + "word": [ + "P9", + "N", + "P6", + "P5", + "N", + "P2", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "P9", + "N", + "P6", + "P5", + "P1" + ] + } + ], + [ + { + "coefficient": "2", + "word": [ + "P9", + "N", + "P6", + "P5" + ] + }, + { + "coefficient": "1", + "word": [ + "P9", + "N", + "P6", + "P5", + "N", + "P2", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "P9", + "N", + "P6", + "P5", + "P1" + ] + } + ], + [ + { + "coefficient": "2", + "word": [ + "P9", + "N", + "P6", + "P5" + ] + }, + { + "coefficient": "1", + "word": [ + "P9", + "N", + "P6", + "P5", + "N", + "P2", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "P9", + "N", + "P6", + "P5", + "P1" + ] + } + ], + [], + [ + { + "coefficient": "3", + "word": [ + "P9", + "N", + "P6", + "P5" + ] + }, + { + "coefficient": "1", + "word": [ + "P9", + "N", + "P6", + "P5", + "N", + "P2", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "P9", + "N", + "P6", + "P5", + "P1" + ] + } + ], + [], + [ + { + "coefficient": "1", + "word": [ + "P9" + ] + }, + { + "coefficient": "3", + "word": [ + "P9", + "N", + "P6", + "P5" + ] + }, + { + "coefficient": "1", + "word": [ + "P9", + "N", + "P6", + "P5", + "N", + "P2", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "P9", + "N", + "P6", + "P5", + "P1" + ] + } + ], + [] + ] + ], + "ambient_arity": 20, + "banks": 10, + "events": [ + { + "coefficient": "1", + "dst": 5, + "kind": "ADD", + "label": "raw c-basis", + "src": 3 + }, + { + "coefficient": "1", + "dst": 7, + "kind": "ADD", + "label": "raw c-basis", + "src": 3 + }, + { + "coefficient": "1", + "dst": 9, + "kind": "ADD", + "label": "raw c-basis", + "src": 3 + }, + { + "bank": 1, + "kind": "NATIVE", + "label": "shared input N exposure", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 0 + ], + "sign": 1 + } + }, + { + "coefficient": "1", + "dst": 2, + "kind": "ADD", + "label": "shared input fanout", + "src": 1 + }, + { + "bank": 1, + "kind": "NATIVE", + "label": "shared input N inverse", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 0 + ], + "sign": -1 + } + }, + { + "coefficient": "-1", + "dst": 9, + "kind": "ADD", + "label": "initial nested scalar bridge", + "src": 1 + }, + { + "coefficient": "1", + "dst": 0, + "kind": "ADD", + "label": "initial nested scalar bridge", + "src": 8 + }, + { + "coefficient": "-1", + "dst": 7, + "kind": "ADD", + "label": "initial nested scalar bridge", + "src": 1 + }, + { + "coefficient": "1", + "dst": 0, + "kind": "ADD", + "label": "initial nested scalar bridge", + "src": 6 + }, + { + "coefficient": "-1", + "dst": 5, + "kind": "ADD", + "label": "initial nested scalar bridge", + "src": 1 + }, + { + "coefficient": "1", + "dst": 0, + "kind": "ADD", + "label": "initial nested scalar bridge", + "src": 4 + }, + { + "coefficient": "-1", + "dst": 3, + "kind": "ADD", + "label": "initial nested scalar bridge", + "src": 1 + }, + { + "coefficient": "1", + "dst": 0, + "kind": "ADD", + "label": "initial nested scalar bridge", + "src": 2 + }, + { + "coefficient": "-1", + "dst": 2, + "kind": "ADD", + "label": "query1 scalar entrance", + "src": 0 + }, + { + "bank": 0, + "kind": "NATIVE", + "label": "query1 source common", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 0 + ], + "sign": 1 + } + }, + { + "coefficient": "1", + "dst": 1, + "kind": "ADD", + "label": "query1 delivery", + "src": 0 + }, + { + "bank": 0, + "kind": "ADDRESS_OR_UNIT", + "label": "query1 source swap", + "operator": { + "block_permutation": [ + 1, + 0, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 0, + "native_blocks": [], + "sign": 1 + } + }, + { + "bank": 1, + "kind": "NATIVE", + "label": "query1 target fresh", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 1 + ], + "sign": 1 + } + }, + { + "bank": 2, + "kind": "NATIVE", + "label": "query1 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 1 + ], + "sign": 1 + } + }, + { + "bank": 3, + "kind": "NATIVE", + "label": "query1 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 1 + ], + "sign": 1 + } + }, + { + "bank": 4, + "kind": "NATIVE", + "label": "query1 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 1 + ], + "sign": 1 + } + }, + { + "bank": 5, + "kind": "NATIVE", + "label": "query1 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 1 + ], + "sign": 1 + } + }, + { + "bank": 6, + "kind": "NATIVE", + "label": "query1 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 1 + ], + "sign": 1 + } + }, + { + "bank": 7, + "kind": "NATIVE", + "label": "query1 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 1 + ], + "sign": 1 + } + }, + { + "bank": 8, + "kind": "NATIVE", + "label": "query1 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 1 + ], + "sign": 1 + } + }, + { + "bank": 9, + "kind": "NATIVE", + "label": "query1 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 1 + ], + "sign": 1 + } + }, + { + "coefficient": "1", + "dst": 2, + "kind": "ADD", + "label": "query1 scalar exit", + "src": 0 + }, + { + "coefficient": "-1", + "dst": 0, + "kind": "ADD", + "label": "initial nested scalar bridge", + "src": 2 + }, + { + "coefficient": "1", + "dst": 1, + "kind": "ADD", + "label": "initial nested scalar bridge", + "src": 3 + }, + { + "coefficient": "-1", + "dst": 3, + "kind": "ADD", + "label": "query2 scalar entrance", + "src": 1 + }, + { + "coefficient": "-1", + "dst": 5, + "kind": "ADD", + "label": "query2 scalar entrance", + "src": 1 + }, + { + "coefficient": "-1", + "dst": 7, + "kind": "ADD", + "label": "query2 scalar entrance", + "src": 1 + }, + { + "coefficient": "-1", + "dst": 9, + "kind": "ADD", + "label": "query2 scalar entrance", + "src": 1 + }, + { + "bank": 1, + "kind": "NATIVE", + "label": "query2 source common", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 0 + ], + "sign": 1 + } + }, + { + "coefficient": "1", + "dst": 2, + "kind": "ADD", + "label": "query2 delivery", + "src": 1 + }, + { + "bank": 1, + "kind": "ADDRESS_OR_UNIT", + "label": "query2 source swap", + "operator": { + "block_permutation": [ + 2, + 1, + 0, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 0, + "native_blocks": [], + "sign": 1 + } + }, + { + "bank": 0, + "kind": "NATIVE", + "label": "query2 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 2 + ], + "sign": 1 + } + }, + { + "bank": 2, + "kind": "NATIVE", + "label": "query2 target fresh", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 2 + ], + "sign": 1 + } + }, + { + "bank": 3, + "kind": "NATIVE", + "label": "query2 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 2 + ], + "sign": 1 + } + }, + { + "bank": 4, + "kind": "NATIVE", + "label": "query2 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 2 + ], + "sign": 1 + } + }, + { + "bank": 5, + "kind": "NATIVE", + "label": "query2 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 2 + ], + "sign": 1 + } + }, + { + "bank": 6, + "kind": "NATIVE", + "label": "query2 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 2 + ], + "sign": 1 + } + }, + { + "bank": 7, + "kind": "NATIVE", + "label": "query2 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 2 + ], + "sign": 1 + } + }, + { + "bank": 8, + "kind": "NATIVE", + "label": "query2 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 2 + ], + "sign": 1 + } + }, + { + "bank": 9, + "kind": "NATIVE", + "label": "query2 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 2 + ], + "sign": 1 + } + }, + { + "coefficient": "1", + "dst": 3, + "kind": "ADD", + "label": "query2 scalar exit", + "src": 1 + }, + { + "coefficient": "1", + "dst": 5, + "kind": "ADD", + "label": "query2 scalar exit", + "src": 1 + }, + { + "coefficient": "1", + "dst": 7, + "kind": "ADD", + "label": "query2 scalar exit", + "src": 1 + }, + { + "coefficient": "1", + "dst": 9, + "kind": "ADD", + "label": "query2 scalar exit", + "src": 1 + }, + { + "coefficient": "-1", + "dst": 1, + "kind": "ADD", + "label": "initial nested scalar bridge", + "src": 3 + }, + { + "bank": 2, + "kind": "NATIVE", + "label": "query3 source common", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 0 + ], + "sign": 1 + } + }, + { + "coefficient": "1", + "dst": 5, + "kind": "ADD", + "label": "query3 source fanout", + "src": 2 + }, + { + "coefficient": "1", + "dst": 7, + "kind": "ADD", + "label": "query3 source fanout", + "src": 2 + }, + { + "coefficient": "1", + "dst": 9, + "kind": "ADD", + "label": "query3 source fanout", + "src": 2 + }, + { + "coefficient": "1", + "dst": 3, + "kind": "ADD", + "label": "query3 delivery", + "src": 2 + }, + { + "bank": 2, + "kind": "ADDRESS_OR_UNIT", + "label": "query3 source swap", + "operator": { + "block_permutation": [ + 3, + 1, + 2, + 0, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 0, + "native_blocks": [], + "sign": 1 + } + }, + { + "bank": 0, + "kind": "NATIVE", + "label": "query3 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 3 + ], + "sign": 1 + } + }, + { + "bank": 1, + "kind": "NATIVE", + "label": "query3 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 3 + ], + "sign": 1 + } + }, + { + "bank": 3, + "kind": "NATIVE", + "label": "query3 target fresh", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 3 + ], + "sign": 1 + } + }, + { + "bank": 4, + "kind": "NATIVE", + "label": "query3 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 3 + ], + "sign": 1 + } + }, + { + "bank": 5, + "kind": "NATIVE", + "label": "query3 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 3 + ], + "sign": 1 + } + }, + { + "bank": 6, + "kind": "NATIVE", + "label": "query3 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 3 + ], + "sign": 1 + } + }, + { + "bank": 7, + "kind": "NATIVE", + "label": "query3 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 3 + ], + "sign": 1 + } + }, + { + "bank": 8, + "kind": "NATIVE", + "label": "query3 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 3 + ], + "sign": 1 + } + }, + { + "bank": 9, + "kind": "NATIVE", + "label": "query3 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 3 + ], + "sign": 1 + } + }, + { + "coefficient": "1", + "dst": 5, + "kind": "ADD", + "label": "query3 pre-continuation fanout", + "src": 2 + }, + { + "coefficient": "1", + "dst": 7, + "kind": "ADD", + "label": "query3 pre-continuation fanout", + "src": 2 + }, + { + "coefficient": "1", + "dst": 9, + "kind": "ADD", + "label": "query3 pre-continuation fanout", + "src": 2 + }, + { + "bank": 2, + "kind": "NATIVE", + "label": "query3 retained source continuation", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 0 + ], + "sign": 1 + } + }, + { + "coefficient": "1", + "dst": 2, + "kind": "ADD", + "label": "initial nested scalar bridge", + "src": 0 + }, + { + "coefficient": "1", + "dst": 3, + "kind": "ADD", + "label": "initial nested scalar bridge", + "src": 1 + }, + { + "coefficient": "-1", + "dst": 1, + "kind": "ADD", + "label": "initial nested scalar bridge", + "src": 3 + }, + { + "banks": [ + 2, + 3 + ], + "kind": "BANK_SWAP", + "label": "initial nested permutation" + }, + { + "coefficient": "-1", + "dst": 0, + "kind": "ADD", + "label": "initial nested scalar bridge", + "src": 4 + }, + { + "coefficient": "1", + "dst": 1, + "kind": "ADD", + "label": "initial nested scalar bridge", + "src": 5 + }, + { + "coefficient": "-1", + "dst": 5, + "kind": "ADD", + "label": "query4 scalar source entrance", + "src": 1 + }, + { + "coefficient": "-1", + "dst": 7, + "kind": "ADD", + "label": "query4 scalar source entrance", + "src": 1 + }, + { + "coefficient": "-1", + "dst": 9, + "kind": "ADD", + "label": "query4 scalar source entrance", + "src": 1 + }, + { + "coefficient": "-1", + "dst": 0, + "kind": "ADD", + "label": "restore raw a from deeper response entrance", + "src": 6 + }, + { + "coefficient": "-1", + "dst": 0, + "kind": "ADD", + "label": "restore raw a from deeper response entrance", + "src": 8 + }, + { + "coefficient": "-1", + "dst": 3, + "kind": "ADD", + "label": "held source subtract raw a", + "src": 0 + }, + { + "coefficient": "-1", + "dst": 3, + "kind": "ADD", + "label": "held source subtract future raw b", + "src": 4 + }, + { + "coefficient": "-1", + "dst": 3, + "kind": "ADD", + "label": "held source subtract future raw b", + "src": 6 + }, + { + "coefficient": "-1", + "dst": 3, + "kind": "ADD", + "label": "held source subtract future raw b", + "src": 8 + }, + { + "bank": 1, + "kind": "NATIVE", + "label": "query4 source common", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 0 + ], + "sign": 1 + } + }, + { + "coefficient": "-1", + "dst": 1, + "kind": "ADD", + "label": "query4 isolate raw c difference", + "src": 3 + }, + { + "banks": [ + 1, + 3 + ], + "kind": "BANK_SWAP", + "label": "query4 source handoff" + }, + { + "bank": 1, + "kind": "ADDRESS_OR_UNIT", + "label": "query4 source swap", + "operator": { + "block_permutation": [ + 4, + 1, + 2, + 3, + 0, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 0, + "native_blocks": [], + "sign": 1 + } + }, + { + "bank": 0, + "kind": "NATIVE", + "label": "query4 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 4 + ], + "sign": 1 + } + }, + { + "bank": 2, + "kind": "NATIVE", + "label": "query4 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 4 + ], + "sign": 1 + } + }, + { + "bank": 3, + "kind": "NATIVE", + "label": "query4 target fresh", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 4 + ], + "sign": 1 + } + }, + { + "bank": 4, + "kind": "NATIVE", + "label": "query4 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 4 + ], + "sign": 1 + } + }, + { + "bank": 5, + "kind": "NATIVE", + "label": "query4 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 4 + ], + "sign": 1 + } + }, + { + "bank": 6, + "kind": "NATIVE", + "label": "query4 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 4 + ], + "sign": 1 + } + }, + { + "bank": 7, + "kind": "NATIVE", + "label": "query4 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 4 + ], + "sign": 1 + } + }, + { + "bank": 8, + "kind": "NATIVE", + "label": "query4 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 4 + ], + "sign": 1 + } + }, + { + "bank": 9, + "kind": "NATIVE", + "label": "query4 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 4 + ], + "sign": 1 + } + }, + { + "banks": [ + 3, + 5 + ], + "kind": "BANK_SWAP", + "label": "query4 move finished c difference" + }, + { + "bank": 4, + "kind": "NATIVE", + "label": "query5 source common", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 0 + ], + "sign": 1 + } + }, + { + "coefficient": "1", + "dst": 7, + "kind": "ADD", + "label": "query5 future c first fanout", + "src": 4 + }, + { + "coefficient": "1", + "dst": 9, + "kind": "ADD", + "label": "query5 future c first fanout", + "src": 4 + }, + { + "coefficient": "1", + "dst": 3, + "kind": "ADD", + "label": "query5 delivery", + "src": 4 + }, + { + "banks": [ + 4, + 3 + ], + "kind": "BANK_SWAP", + "label": "query5 source handoff" + }, + { + "coefficient": "-1", + "dst": 2, + "kind": "ADD", + "label": "query5 finish current b accumulator", + "src": 4 + }, + { + "coefficient": "-1", + "dst": 7, + "kind": "ADD", + "label": "query5 restore future raw c differences", + "src": 4 + }, + { + "coefficient": "-1", + "dst": 9, + "kind": "ADD", + "label": "query5 restore future raw c differences", + "src": 4 + }, + { + "bank": 4, + "kind": "ADDRESS_OR_UNIT", + "label": "query5 source swap", + "operator": { + "block_permutation": [ + 5, + 1, + 2, + 3, + 4, + 0, + 6, + 7, + 8, + 9 + ], + "native_arity": 0, + "native_blocks": [], + "sign": 1 + } + }, + { + "bank": 0, + "kind": "NATIVE", + "label": "query5 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 5 + ], + "sign": 1 + } + }, + { + "bank": 1, + "kind": "NATIVE", + "label": "query5 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 5 + ], + "sign": 1 + } + }, + { + "bank": 2, + "kind": "NATIVE", + "label": "query5 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 5 + ], + "sign": 1 + } + }, + { + "bank": 3, + "kind": "NATIVE", + "label": "query5 target fresh", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 5 + ], + "sign": 1 + } + }, + { + "bank": 5, + "kind": "NATIVE", + "label": "query5 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 5 + ], + "sign": 1 + } + }, + { + "bank": 6, + "kind": "NATIVE", + "label": "query5 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 5 + ], + "sign": 1 + } + }, + { + "bank": 7, + "kind": "NATIVE", + "label": "query5 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 5 + ], + "sign": 1 + } + }, + { + "bank": 8, + "kind": "NATIVE", + "label": "query5 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 5 + ], + "sign": 1 + } + }, + { + "bank": 9, + "kind": "NATIVE", + "label": "query5 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 5 + ], + "sign": 1 + } + }, + { + "coefficient": "1", + "dst": 2, + "kind": "ADD", + "label": "query5 retain other carrier in b accumulator", + "src": 1 + }, + { + "coefficient": "-1", + "dst": 9, + "kind": "ADD", + "label": "query5 next c difference", + "src": 7 + }, + { + "coefficient": "1", + "dst": 9, + "kind": "ADD", + "label": "query5 retain other carrier in future c", + "src": 1 + }, + { + "banks": [ + 1, + 7 + ], + "kind": "BANK_SWAP", + "label": "query5 move next raw c into t" + }, + { + "coefficient": "1", + "dst": 1, + "kind": "ADD", + "label": "query5 next source preload", + "src": 4 + }, + { + "bank": 4, + "kind": "NATIVE", + "label": "query5 retained source continuation", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 0 + ], + "sign": 1 + } + }, + { + "banks": [ + 4, + 3 + ], + "kind": "BANK_SWAP", + "label": "query5 move finished b to its public slot" + }, + { + "bank": 1, + "kind": "NATIVE", + "label": "query6 source common", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 0 + ], + "sign": 1 + } + }, + { + "coefficient": "-1", + "dst": 1, + "kind": "ADD", + "label": "query6 isolate raw c difference", + "src": 3 + }, + { + "banks": [ + 1, + 3 + ], + "kind": "BANK_SWAP", + "label": "query6 source handoff" + }, + { + "bank": 1, + "kind": "ADDRESS_OR_UNIT", + "label": "query6 source swap", + "operator": { + "block_permutation": [ + 6, + 1, + 2, + 3, + 4, + 5, + 0, + 7, + 8, + 9 + ], + "native_arity": 0, + "native_blocks": [], + "sign": 1 + } + }, + { + "bank": 0, + "kind": "NATIVE", + "label": "query6 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 6 + ], + "sign": 1 + } + }, + { + "bank": 2, + "kind": "NATIVE", + "label": "query6 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 6 + ], + "sign": 1 + } + }, + { + "bank": 3, + "kind": "NATIVE", + "label": "query6 target fresh", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 6 + ], + "sign": 1 + } + }, + { + "bank": 4, + "kind": "NATIVE", + "label": "query6 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 6 + ], + "sign": 1 + } + }, + { + "bank": 5, + "kind": "NATIVE", + "label": "query6 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 6 + ], + "sign": 1 + } + }, + { + "bank": 6, + "kind": "NATIVE", + "label": "query6 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 6 + ], + "sign": 1 + } + }, + { + "bank": 7, + "kind": "NATIVE", + "label": "query6 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 6 + ], + "sign": 1 + } + }, + { + "bank": 8, + "kind": "NATIVE", + "label": "query6 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 6 + ], + "sign": 1 + } + }, + { + "bank": 9, + "kind": "NATIVE", + "label": "query6 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 6 + ], + "sign": 1 + } + }, + { + "banks": [ + 3, + 7 + ], + "kind": "BANK_SWAP", + "label": "query6 move finished c difference" + }, + { + "bank": 6, + "kind": "NATIVE", + "label": "query7 source common", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 0 + ], + "sign": 1 + } + }, + { + "coefficient": "1", + "dst": 9, + "kind": "ADD", + "label": "query7 future c first fanout", + "src": 6 + }, + { + "coefficient": "1", + "dst": 3, + "kind": "ADD", + "label": "query7 delivery", + "src": 6 + }, + { + "banks": [ + 6, + 3 + ], + "kind": "BANK_SWAP", + "label": "query7 source handoff" + }, + { + "coefficient": "-1", + "dst": 2, + "kind": "ADD", + "label": "query7 finish current b accumulator", + "src": 6 + }, + { + "coefficient": "-1", + "dst": 9, + "kind": "ADD", + "label": "query7 restore future raw c differences", + "src": 6 + }, + { + "bank": 6, + "kind": "ADDRESS_OR_UNIT", + "label": "query7 source swap", + "operator": { + "block_permutation": [ + 7, + 1, + 2, + 3, + 4, + 5, + 6, + 0, + 8, + 9 + ], + "native_arity": 0, + "native_blocks": [], + "sign": 1 + } + }, + { + "bank": 0, + "kind": "NATIVE", + "label": "query7 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 7 + ], + "sign": 1 + } + }, + { + "bank": 1, + "kind": "NATIVE", + "label": "query7 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 7 + ], + "sign": 1 + } + }, + { + "bank": 2, + "kind": "NATIVE", + "label": "query7 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 7 + ], + "sign": 1 + } + }, + { + "bank": 3, + "kind": "NATIVE", + "label": "query7 target fresh", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 7 + ], + "sign": 1 + } + }, + { + "bank": 4, + "kind": "NATIVE", + "label": "query7 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 7 + ], + "sign": 1 + } + }, + { + "bank": 5, + "kind": "NATIVE", + "label": "query7 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 7 + ], + "sign": 1 + } + }, + { + "bank": 7, + "kind": "NATIVE", + "label": "query7 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 7 + ], + "sign": 1 + } + }, + { + "bank": 8, + "kind": "NATIVE", + "label": "query7 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 7 + ], + "sign": 1 + } + }, + { + "bank": 9, + "kind": "NATIVE", + "label": "query7 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 7 + ], + "sign": 1 + } + }, + { + "coefficient": "1", + "dst": 2, + "kind": "ADD", + "label": "query7 retain other carrier in b accumulator", + "src": 1 + }, + { + "banks": [ + 1, + 9 + ], + "kind": "BANK_SWAP", + "label": "query7 move next raw c into t" + }, + { + "coefficient": "1", + "dst": 1, + "kind": "ADD", + "label": "query7 next source preload", + "src": 6 + }, + { + "bank": 6, + "kind": "NATIVE", + "label": "query7 retained source continuation", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 0 + ], + "sign": 1 + } + }, + { + "banks": [ + 6, + 3 + ], + "kind": "BANK_SWAP", + "label": "query7 move finished b to its public slot" + }, + { + "bank": 1, + "kind": "NATIVE", + "label": "query8 source common", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 0 + ], + "sign": 1 + } + }, + { + "coefficient": "-1", + "dst": 1, + "kind": "ADD", + "label": "query8 isolate raw c difference", + "src": 3 + }, + { + "banks": [ + 1, + 3 + ], + "kind": "BANK_SWAP", + "label": "query8 source handoff" + }, + { + "bank": 1, + "kind": "ADDRESS_OR_UNIT", + "label": "query8 source swap", + "operator": { + "block_permutation": [ + 8, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 0, + 9 + ], + "native_arity": 0, + "native_blocks": [], + "sign": 1 + } + }, + { + "bank": 0, + "kind": "NATIVE", + "label": "query8 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 8 + ], + "sign": 1 + } + }, + { + "bank": 2, + "kind": "NATIVE", + "label": "query8 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 8 + ], + "sign": 1 + } + }, + { + "bank": 3, + "kind": "NATIVE", + "label": "query8 target fresh", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 8 + ], + "sign": 1 + } + }, + { + "bank": 4, + "kind": "NATIVE", + "label": "query8 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 8 + ], + "sign": 1 + } + }, + { + "bank": 5, + "kind": "NATIVE", + "label": "query8 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 8 + ], + "sign": 1 + } + }, + { + "bank": 6, + "kind": "NATIVE", + "label": "query8 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 8 + ], + "sign": 1 + } + }, + { + "bank": 7, + "kind": "NATIVE", + "label": "query8 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 8 + ], + "sign": 1 + } + }, + { + "bank": 8, + "kind": "NATIVE", + "label": "query8 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 8 + ], + "sign": 1 + } + }, + { + "bank": 9, + "kind": "NATIVE", + "label": "query8 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 8 + ], + "sign": 1 + } + }, + { + "banks": [ + 3, + 9 + ], + "kind": "BANK_SWAP", + "label": "query8 move finished c difference" + }, + { + "bank": 8, + "kind": "NATIVE", + "label": "query9 source common", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 0 + ], + "sign": 1 + } + }, + { + "coefficient": "1", + "dst": 3, + "kind": "ADD", + "label": "query9 delivery", + "src": 8 + }, + { + "banks": [ + 8, + 3 + ], + "kind": "BANK_SWAP", + "label": "query9 source handoff" + }, + { + "coefficient": "-1", + "dst": 2, + "kind": "ADD", + "label": "query9 finish current b accumulator", + "src": 8 + }, + { + "bank": 8, + "kind": "ADDRESS_OR_UNIT", + "label": "query9 source swap", + "operator": { + "block_permutation": [ + 9, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 0 + ], + "native_arity": 0, + "native_blocks": [], + "sign": 1 + } + }, + { + "bank": 0, + "kind": "NATIVE", + "label": "query9 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 9 + ], + "sign": 1 + } + }, + { + "bank": 1, + "kind": "NATIVE", + "label": "query9 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 9 + ], + "sign": 1 + } + }, + { + "bank": 2, + "kind": "NATIVE", + "label": "query9 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 9 + ], + "sign": 1 + } + }, + { + "bank": 3, + "kind": "NATIVE", + "label": "query9 target fresh", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 9 + ], + "sign": 1 + } + }, + { + "bank": 4, + "kind": "NATIVE", + "label": "query9 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 9 + ], + "sign": 1 + } + }, + { + "bank": 5, + "kind": "NATIVE", + "label": "query9 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 9 + ], + "sign": 1 + } + }, + { + "bank": 6, + "kind": "NATIVE", + "label": "query9 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 9 + ], + "sign": 1 + } + }, + { + "bank": 7, + "kind": "NATIVE", + "label": "query9 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 9 + ], + "sign": 1 + } + }, + { + "bank": 9, + "kind": "NATIVE", + "label": "query9 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 9 + ], + "sign": 1 + } + }, + { + "banks": [ + 8, + 3 + ], + "kind": "BANK_SWAP", + "label": "query9 move finished b to its public slot" + }, + { + "bank": 0, + "kind": "NATIVE", + "label": "final raw a common query", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "native_arity": 2, + "native_blocks": [ + 0 + ], + "sign": 1 + } + }, + { + "coefficient": "-1", + "dst": 2, + "kind": "ADD", + "label": "final b accumulator isolation", + "src": 0 + }, + { + "coefficient": "1", + "dst": 7, + "kind": "ADD", + "label": "triangular c difference decode", + "src": 5 + }, + { + "coefficient": "1", + "dst": 9, + "kind": "ADD", + "label": "triangular c difference decode", + "src": 7 + } + ], + "histogram": { + "2": 96 + }, + "inverse": [ + [ + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + } + ], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ], + [ + [ + { + "coefficient": "1", + "word": [] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "N", + "P7^-1", + "P8^-1" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "N", + "P7^-1", + "P8^-1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P5^-1", + "P6^-1", + "N", + "P9^-1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N" + ] + } + ], + [], + [ + { + "coefficient": "1", + "word": [] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1" + ] + } + ], + [], + [ + { + "coefficient": "1", + "word": [] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P5^-1", + "P6^-1" + ] + } + ], + [] + ], + [ + [], + [], + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + } + ], + [], + [], + [], + [], + [], + [], + [] + ], + [ + [ + { + "coefficient": "1", + "word": [ + "P2^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "N", + "P7^-1", + "P8^-1" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "N", + "P7^-1", + "P8^-1" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "N", + "P7^-1", + "P8^-1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P2^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P2^-1", + "N", + "P5^-1", + "P6^-1", + "N", + "P9^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P5^-1", + "P6^-1", + "N", + "P9^-1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N" + ] + } + ], + [], + [ + { + "coefficient": "1", + "word": [ + "P2^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "P2^-1", + "N", + "P3^-1", + "P4^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1" + ] + } + ], + [], + [ + { + "coefficient": "1", + "word": [ + "P2^-1" + ] + }, + { + "coefficient": "-1", + "word": [ + "P2^-1", + "N", + "P5^-1", + "P6^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P5^-1", + "P6^-1" + ] + } + ], + [] + ], + [ + [], + [], + [], + [], + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + } + ], + [], + [], + [], + [], + [] + ], + [ + [], + [], + [], + [], + [], + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + } + ], + [], + [], + [], + [] + ], + [ + [], + [], + [], + [], + [], + [], + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + } + ], + [], + [], + [] + ], + [ + [], + [], + [], + [], + [], + [], + [], + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + } + ], + [], + [] + ], + [ + [], + [], + [], + [], + [], + [], + [], + [], + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + } + ], + [] + ], + [ + [], + [], + [], + [], + [], + [], + [], + [], + [], + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + } + ] + ] + ], + "matrix": [ + [ + [ + { + "coefficient": "1", + "word": [ + "N" + ] + } + ], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ], + [ + [ + { + "coefficient": "2", + "word": [ + "P8", + "P7", + "N", + "P4", + "P3" + ] + }, + { + "coefficient": "-1", + "word": [ + "P8", + "P7", + "N", + "P4", + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P8", + "P7", + "N", + "P4", + "P3", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "P8", + "P7", + "N", + "P4", + "P3", + "P1", + "N" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P8", + "P7", + "N", + "P4", + "P3" + ] + }, + { + "coefficient": "-1", + "word": [ + "P8", + "P7", + "N", + "P4", + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P8", + "P7", + "N", + "P4", + "P3", + "N" + ] + } + ], + [ + { + "coefficient": "2", + "word": [ + "P8", + "P7", + "N", + "P4", + "P3" + ] + }, + { + "coefficient": "-1", + "word": [ + "P8", + "P7", + "N", + "P4", + "P3", + "P1" + ] + } + ], + [], + [ + { + "coefficient": "1", + "word": [ + "P8", + "P7" + ] + }, + { + "coefficient": "2", + "word": [ + "P8", + "P7", + "N", + "P4", + "P3" + ] + }, + { + "coefficient": "-1", + "word": [ + "P8", + "P7", + "N", + "P4", + "P3", + "P1" + ] + } + ], + [], + [ + { + "coefficient": "2", + "word": [ + "P8", + "P7", + "N", + "P4", + "P3" + ] + }, + { + "coefficient": "-1", + "word": [ + "P8", + "P7", + "N", + "P4", + "P3", + "P1" + ] + } + ], + [] + ], + [ + [], + [], + [ + { + "coefficient": "1", + "word": [ + "N" + ] + } + ], + [], + [], + [], + [], + [], + [], + [] + ], + [ + [ + { + "coefficient": "3", + "word": [ + "P9", + "N", + "P6", + "P5" + ] + }, + { + "coefficient": "1", + "word": [ + "P9", + "N", + "P6", + "P5", + "N", + "P2", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "P9", + "N", + "P6", + "P5", + "P1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P9", + "N", + "P6", + "P5", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "P9", + "N", + "P6", + "P5", + "N", + "P2" + ] + }, + { + "coefficient": "-1", + "word": [ + "P9", + "N", + "P6", + "P5", + "P1", + "N" + ] + } + ], + [ + { + "coefficient": "2", + "word": [ + "P9", + "N", + "P6", + "P5" + ] + }, + { + "coefficient": "1", + "word": [ + "P9", + "N", + "P6", + "P5", + "N", + "P2", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "P9", + "N", + "P6", + "P5", + "P1" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P9", + "N", + "P6", + "P5", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P9", + "N", + "P6", + "P5", + "N", + "P2" + ] + } + ], + [ + { + "coefficient": "2", + "word": [ + "P9", + "N", + "P6", + "P5" + ] + }, + { + "coefficient": "1", + "word": [ + "P9", + "N", + "P6", + "P5", + "N", + "P2", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "P9", + "N", + "P6", + "P5", + "P1" + ] + } + ], + [], + [ + { + "coefficient": "3", + "word": [ + "P9", + "N", + "P6", + "P5" + ] + }, + { + "coefficient": "1", + "word": [ + "P9", + "N", + "P6", + "P5", + "N", + "P2", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "P9", + "N", + "P6", + "P5", + "P1" + ] + } + ], + [], + [ + { + "coefficient": "1", + "word": [ + "P9" + ] + }, + { + "coefficient": "3", + "word": [ + "P9", + "N", + "P6", + "P5" + ] + }, + { + "coefficient": "1", + "word": [ + "P9", + "N", + "P6", + "P5", + "N", + "P2", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "P9", + "N", + "P6", + "P5", + "P1" + ] + } + ], + [] + ], + [ + [], + [], + [], + [], + [ + { + "coefficient": "1", + "word": [ + "N" + ] + } + ], + [], + [], + [], + [], + [] + ], + [ + [], + [], + [], + [], + [], + [ + { + "coefficient": "1", + "word": [ + "N" + ] + } + ], + [], + [], + [], + [] + ], + [ + [], + [], + [], + [], + [], + [], + [ + { + "coefficient": "1", + "word": [ + "N" + ] + } + ], + [], + [], + [] + ], + [ + [], + [], + [], + [], + [], + [], + [], + [ + { + "coefficient": "1", + "word": [ + "N" + ] + } + ], + [], + [] + ], + [ + [], + [], + [], + [], + [], + [], + [], + [], + [ + { + "coefficient": "1", + "word": [ + "N" + ] + } + ], + [] + ], + [ + [], + [], + [], + [], + [], + [], + [], + [], + [], + [ + { + "coefficient": "1", + "word": [ + "N" + ] + } + ] + ] + ], + "native_rank_mass": 192, + "physical_inverse": [ + [ + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "coefficient": "1" + } + ], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ], + [ + [ + { + "ADDRESS_plane_permutation": [ + 2, + 0, + 1, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "N_planes": [ + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 0, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "coefficient": "1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 8, + 0, + 1, + 2, + 3, + 5, + 6, + 4, + 7, + 9 + ], + "N_planes": [ + 3, + 5, + 6, + 7, + 9 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 8, + 0, + 2, + 1, + 3, + 5, + 6, + 4, + 7, + 9 + ], + "N_planes": [ + 1, + 2, + 3, + 5, + 6, + 7, + 9 + ], + "coefficient": "1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 2, + 0, + 1, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "N_planes": [ + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "coefficient": "-1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 9, + 0, + 1, + 3, + 4, + 2, + 5, + 7, + 8, + 6 + ], + "N_planes": [ + 3, + 4, + 5, + 7, + 8 + ], + "coefficient": "-1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 0, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "coefficient": "1" + } + ], + [], + [ + { + "ADDRESS_plane_permutation": [ + 4, + 0, + 1, + 2, + 3, + 5, + 6, + 7, + 8, + 9 + ], + "N_planes": [ + 3, + 5, + 6, + 7, + 8, + 9 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 4, + 0, + 2, + 1, + 3, + 5, + 6, + 7, + 8, + 9 + ], + "N_planes": [ + 1, + 2, + 3, + 5, + 6, + 7, + 8, + 9 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 2, + 0, + 1, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "N_planes": [ + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 0, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "coefficient": "1" + } + ], + [], + [ + { + "ADDRESS_plane_permutation": [ + 6, + 0, + 1, + 3, + 4, + 2, + 5, + 7, + 8, + 9 + ], + "N_planes": [ + 3, + 4, + 5, + 7, + 8, + 9 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 2, + 0, + 1, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "N_planes": [ + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 0, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "coefficient": "1" + } + ], + [] + ], + [ + [], + [], + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "coefficient": "1" + } + ], + [], + [], + [], + [], + [], + [], + [] + ], + [ + [ + { + "ADDRESS_plane_permutation": [ + 2, + 0, + 1, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "N_planes": [ + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 2, + 1, + 0, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "N_planes": [ + 0, + 1, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 0, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "coefficient": "1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 8, + 0, + 1, + 2, + 3, + 5, + 6, + 4, + 7, + 9 + ], + "N_planes": [ + 3, + 5, + 6, + 7, + 9 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 8, + 1, + 0, + 2, + 3, + 5, + 6, + 4, + 7, + 9 + ], + "N_planes": [ + 0, + 1, + 3, + 5, + 6, + 7, + 9 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 8, + 0, + 2, + 1, + 3, + 5, + 6, + 4, + 7, + 9 + ], + "N_planes": [ + 1, + 2, + 3, + 5, + 6, + 7, + 9 + ], + "coefficient": "1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 2, + 0, + 1, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "N_planes": [ + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 2, + 1, + 0, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "N_planes": [ + 0, + 1, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "coefficient": "-1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 9, + 0, + 1, + 3, + 4, + 2, + 5, + 7, + 8, + 6 + ], + "N_planes": [ + 3, + 4, + 5, + 7, + 8 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 9, + 1, + 0, + 3, + 4, + 2, + 5, + 7, + 8, + 6 + ], + "N_planes": [ + 0, + 1, + 3, + 4, + 5, + 7, + 8 + ], + "coefficient": "-1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 1, + 0, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "coefficient": "1" + } + ], + [], + [ + { + "ADDRESS_plane_permutation": [ + 4, + 0, + 1, + 2, + 3, + 5, + 6, + 7, + 8, + 9 + ], + "N_planes": [ + 3, + 5, + 6, + 7, + 8, + 9 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 4, + 1, + 0, + 2, + 3, + 5, + 6, + 7, + 8, + 9 + ], + "N_planes": [ + 0, + 1, + 3, + 5, + 6, + 7, + 8, + 9 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 4, + 0, + 2, + 1, + 3, + 5, + 6, + 7, + 8, + 9 + ], + "N_planes": [ + 1, + 2, + 3, + 5, + 6, + 7, + 8, + 9 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 2, + 0, + 1, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "N_planes": [ + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 2, + 1, + 0, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "N_planes": [ + 0, + 1, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 0, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "coefficient": "1" + } + ], + [], + [ + { + "ADDRESS_plane_permutation": [ + 6, + 0, + 1, + 3, + 4, + 2, + 5, + 7, + 8, + 9 + ], + "N_planes": [ + 3, + 4, + 5, + 7, + 8, + 9 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 6, + 1, + 0, + 3, + 4, + 2, + 5, + 7, + 8, + 9 + ], + "N_planes": [ + 0, + 1, + 3, + 4, + 5, + 7, + 8, + 9 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 2, + 0, + 1, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "N_planes": [ + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 2, + 1, + 0, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "N_planes": [ + 0, + 1, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 0, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "coefficient": "1" + } + ], + [] + ], + [ + [], + [], + [], + [], + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "coefficient": "1" + } + ], + [], + [], + [], + [], + [] + ], + [ + [], + [], + [], + [], + [], + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "coefficient": "1" + } + ], + [], + [], + [], + [] + ], + [ + [], + [], + [], + [], + [], + [], + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "coefficient": "1" + } + ], + [], + [], + [] + ], + [ + [], + [], + [], + [], + [], + [], + [], + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "coefficient": "1" + } + ], + [], + [] + ], + [ + [], + [], + [], + [], + [], + [], + [], + [], + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "coefficient": "1" + } + ], + [] + ], + [ + [], + [], + [], + [], + [], + [], + [], + [], + [], + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "coefficient": "1" + } + ] + ] + ], + "physical_matrix": [ + [ + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "coefficient": "1" + } + ], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ], + [ + [ + { + "ADDRESS_plane_permutation": [ + 1, + 3, + 2, + 4, + 7, + 5, + 6, + 8, + 0, + 9 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 8, + 9 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 3, + 1, + 2, + 4, + 7, + 5, + 6, + 8, + 0, + 9 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 8, + 9 + ], + "coefficient": "-2" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 3, + 1, + 2, + 4, + 7, + 5, + 6, + 8, + 0, + 9 + ], + "N_planes": [ + 1, + 2, + 4, + 5, + 6, + 8, + 9 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 3, + 2, + 4, + 7, + 5, + 6, + 8, + 0, + 9 + ], + "N_planes": [ + 2, + 3, + 4, + 5, + 6, + 8, + 9 + ], + "coefficient": "-1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 1, + 3, + 2, + 4, + 7, + 5, + 6, + 8, + 0, + 9 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 8, + 9 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 3, + 1, + 2, + 4, + 7, + 5, + 6, + 8, + 0, + 9 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 8, + 9 + ], + "coefficient": "-1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 3, + 1, + 2, + 4, + 7, + 5, + 6, + 8, + 0, + 9 + ], + "N_planes": [ + 1, + 2, + 4, + 5, + 6, + 8, + 9 + ], + "coefficient": "-1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 1, + 3, + 2, + 4, + 7, + 5, + 6, + 8, + 0, + 9 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 8, + 9 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 3, + 1, + 2, + 4, + 7, + 5, + 6, + 8, + 0, + 9 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 8, + 9 + ], + "coefficient": "-2" + } + ], + [], + [ + { + "ADDRESS_plane_permutation": [ + 1, + 3, + 2, + 4, + 7, + 5, + 6, + 8, + 0, + 9 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 8, + 9 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 3, + 1, + 2, + 4, + 7, + 5, + 6, + 8, + 0, + 9 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 8, + 9 + ], + "coefficient": "-2" + }, + { + "ADDRESS_plane_permutation": [ + 7, + 1, + 2, + 3, + 4, + 5, + 6, + 8, + 0, + 9 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "coefficient": "1" + } + ], + [], + [ + { + "ADDRESS_plane_permutation": [ + 1, + 3, + 2, + 4, + 7, + 5, + 6, + 8, + 0, + 9 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 8, + 9 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 3, + 1, + 2, + 4, + 7, + 5, + 6, + 8, + 0, + 9 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 8, + 9 + ], + "coefficient": "-2" + } + ], + [] + ], + [ + [], + [], + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "coefficient": "1" + } + ], + [], + [], + [], + [], + [], + [], + [] + ], + [ + [ + { + "ADDRESS_plane_permutation": [ + 2, + 1, + 5, + 3, + 4, + 6, + 9, + 7, + 8, + 0 + ], + "N_planes": [ + 1, + 3, + 4, + 6, + 7, + 8 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 5, + 2, + 3, + 4, + 6, + 9, + 7, + 8, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 5, + 1, + 2, + 3, + 4, + 6, + 9, + 7, + 8, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ], + "coefficient": "-3" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 2, + 1, + 5, + 3, + 4, + 6, + 9, + 7, + 8, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 6, + 7, + 8 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 5, + 1, + 2, + 3, + 4, + 6, + 9, + 7, + 8, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 6, + 7, + 8 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 5, + 2, + 3, + 4, + 6, + 9, + 7, + 8, + 0 + ], + "N_planes": [ + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ], + "coefficient": "-1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 2, + 1, + 5, + 3, + 4, + 6, + 9, + 7, + 8, + 0 + ], + "N_planes": [ + 1, + 3, + 4, + 6, + 7, + 8 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 5, + 2, + 3, + 4, + 6, + 9, + 7, + 8, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 5, + 1, + 2, + 3, + 4, + 6, + 9, + 7, + 8, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ], + "coefficient": "-2" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 2, + 1, + 5, + 3, + 4, + 6, + 9, + 7, + 8, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 6, + 7, + 8 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 5, + 1, + 2, + 3, + 4, + 6, + 9, + 7, + 8, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 6, + 7, + 8 + ], + "coefficient": "-1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 2, + 1, + 5, + 3, + 4, + 6, + 9, + 7, + 8, + 0 + ], + "N_planes": [ + 1, + 3, + 4, + 6, + 7, + 8 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 5, + 2, + 3, + 4, + 6, + 9, + 7, + 8, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 5, + 1, + 2, + 3, + 4, + 6, + 9, + 7, + 8, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ], + "coefficient": "-2" + } + ], + [], + [ + { + "ADDRESS_plane_permutation": [ + 2, + 1, + 5, + 3, + 4, + 6, + 9, + 7, + 8, + 0 + ], + "N_planes": [ + 1, + 3, + 4, + 6, + 7, + 8 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 5, + 2, + 3, + 4, + 6, + 9, + 7, + 8, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 5, + 1, + 2, + 3, + 4, + 6, + 9, + 7, + 8, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ], + "coefficient": "-3" + } + ], + [], + [ + { + "ADDRESS_plane_permutation": [ + 2, + 1, + 5, + 3, + 4, + 6, + 9, + 7, + 8, + 0 + ], + "N_planes": [ + 1, + 3, + 4, + 6, + 7, + 8 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 5, + 2, + 3, + 4, + 6, + 9, + 7, + 8, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 5, + 1, + 2, + 3, + 4, + 6, + 9, + 7, + 8, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ], + "coefficient": "-3" + }, + { + "ADDRESS_plane_permutation": [ + 9, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "coefficient": "1" + } + ], + [] + ], + [ + [], + [], + [], + [], + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "coefficient": "1" + } + ], + [], + [], + [], + [], + [] + ], + [ + [], + [], + [], + [], + [], + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "coefficient": "1" + } + ], + [], + [], + [], + [] + ], + [ + [], + [], + [], + [], + [], + [], + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "coefficient": "1" + } + ], + [], + [], + [] + ], + [ + [], + [], + [], + [], + [], + [], + [], + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "coefficient": "1" + } + ], + [], + [] + ], + [ + [], + [], + [], + [], + [], + [], + [], + [], + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "coefficient": "1" + } + ], + [] + ], + [ + [], + [], + [], + [], + [], + [], + [], + [], + [], + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "coefficient": "1" + } + ] + ] + ], + "pivot_rows": [ + 1, + 3 + ], + "public_rows": [ + 0, + 2, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "q": 4, + "query_stages": 9 + } + ], + "limits": [ + "Two raw terminal carriers retain every source swap and every public reader. Their cleanup is not included.", + "The native cost or moment of the terminal carrier factories is not asserted bounded.", + "The finite all-column checks q2..4 are separate from the written all-pair invariant and are not a formal-kernel proof." + ], + "no_new_kappa": true, + "producer_sha256": "337c5c061f283673fd00057ba16d1cc0b65257cd29b02a3e071eb6c569294fe4", + "scientific_pin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "source_pins": [ + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/caller/nested_family.py", + "sha256": "88f425d12baf8a4f849cccd24605f21680eb8ce8d199054db4b4e7734eca72b6" + }, + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/caller/nested_prefix.py", + "sha256": "9ec10cb0243c0c829475ad7290f4953cdff27cb0f90f70b687c4bbee98af676b" + }, + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/caller/free_ops.py", + "sha256": "5806fe91b9fda162d5986b12e085b14eb3df9a4703f749f61c1f10363138ca77" + }, + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/caller/plane_group.py", + "sha256": "0c54c2e2462390bd0e9a8d47fc765b70e168ced1e0ef5de49e0afed653e26feb" + } + ], + "status": "PASS_ALL_PAIR_SOURCE_HANDOFF_PREFIX" +} diff --git a/research/marked-residual-reflection/source/caller/NESTED-FAMILY.json b/research/marked-residual-reflection/source/caller/NESTED-FAMILY.json new file mode 100644 index 0000000000..d07da85008 --- /dev/null +++ b/research/marked-residual-reflection/source/caller/NESTED-FAMILY.json @@ -0,0 +1,7376 @@ +{ + "affine_cocycle": { + "covered_domain": "Arbitrary independent invertible noncommuting Po,Pe; N^2=-I; literal affine operator identity.", + "independent_columns": [ + "z", + "A_r", + "c_r", + "c_(r+1)", + "b_(r+1)" + ], + "next_even_source": "P_o y_r+c_(r+1)-c_r", + "next_y": "-P_e P_o y_r+b_(r+1)+P_e(c_r-c_(r+1))", + "not_native_admission": "The virtual coordinate is a literal source at the odd cut. Holding its chart through the even cut still requires an explicit invertible bank encoder, all public readers at actual frames, and restoration of the other independent dirty field.", + "source_y": "y_r=N z-A_r+N c_r, A_r=a+sum_(l>r)b_l; c1 means zero public reader" + }, + "all_parameter_proof": "The ideal nested response skeleton gives N on every field after its output isolation. Its two transported pivot columns obey the displayed source-functional/retraction table. Conjugated source-code insertions therefore act by 2x2 updates I+w(Ptilde-I)r. The first two updates multiply to J(P2,Q1); all middle updates are on only the second coordinate and telescope to Ad_(N^-1)(A3), A3=(-1)^(q-1)P_(2q+1)...P3; the last two updates give the first diagonal factor. Left multiplication by the ideal final N yields H=diag(-P_last P_penult,A3 N)J. No source code or public coupling is discarded.", + "finite_checks": "Every free-operator matrix column and both inverse orders for q1..4. Exact transported-plane/source-functional table for q1..8. q2 entire matrix agrees with NESTED-SIX.", + "fixtures": [ + { + "A3": [ + { + "coefficient": "1", + "word": [ + "P3" + ] + } + ], + "D": [ + [ + [ + { + "coefficient": "-1", + "word": [ + "P5", + "P4" + ] + } + ], + [] + ], + [ + [], + [ + { + "coefficient": "1", + "word": [ + "P3", + "N" + ] + } + ] + ] + ], + "H": [ + [ + [ + { + "coefficient": "1", + "word": [ + "P5", + "P4" + ] + }, + { + "coefficient": "1", + "word": [ + "P5", + "P4", + "N", + "P1", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "P5", + "P4", + "P2" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P5", + "P4" + ] + }, + { + "coefficient": "1", + "word": [ + "P5", + "P4", + "P2" + ] + } + ] + ], + [ + [ + { + "coefficient": "-1", + "word": [ + "P3", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P3", + "P1", + "N" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P3", + "N" + ] + } + ] + ] + ], + "J": [ + [ + [ + { + "coefficient": "-1", + "word": [] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P2" + ] + } + ], + [ + { + "coefficient": "1", + "word": [] + }, + { + "coefficient": "-1", + "word": [ + "P2" + ] + } + ] + ], + [ + [ + { + "coefficient": "-1", + "word": [] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1", + "N" + ] + } + ], + [ + { + "coefficient": "1", + "word": [] + } + ] + ] + ], + "L": [ + [ + [ + { + "coefficient": "1", + "word": [ + "P5" + ] + }, + { + "coefficient": "-3", + "word": [ + "P5", + "P4", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P5", + "P4", + "N", + "P1" + ] + }, + { + "coefficient": "1", + "word": [ + "P5", + "P4", + "P2", + "N" + ] + } + ], + [ + { + "coefficient": "-2", + "word": [ + "P5", + "P4", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P5", + "P4", + "N", + "P1" + ] + }, + { + "coefficient": "1", + "word": [ + "P5", + "P4", + "P2", + "N" + ] + } + ] + ], + [ + [ + { + "coefficient": "1", + "word": [] + }, + { + "coefficient": "-2", + "word": [ + "P3" + ] + }, + { + "coefficient": "1", + "word": [ + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P3" + ] + }, + { + "coefficient": "1", + "word": [ + "P3", + "P1" + ] + } + ] + ] + ], + "banks": 4, + "complete_inverse": [ + [ + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + } + ], + [], + [], + [] + ], + [ + [ + { + "coefficient": "1", + "word": [] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "P4^-1", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "N" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "P4^-1", + "P5^-1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "P3^-1" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1" + ] + } + ] + ], + [ + [], + [], + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + } + ], + [] + ], + [ + [ + { + "coefficient": "1", + "word": [ + "P2^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "P2^-1", + "P4^-1", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "P2^-1", + "N", + "P3^-1", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "P4^-1", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "N" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P2^-1", + "P4^-1", + "P5^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "P4^-1", + "P5^-1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P2^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P2^-1", + "N", + "P3^-1" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "P3^-1" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1" + ] + } + ] + ] + ], + "complete_matrix": [ + [ + [ + { + "coefficient": "1", + "word": [ + "N" + ] + } + ], + [], + [], + [] + ], + [ + [ + { + "coefficient": "1", + "word": [ + "P5" + ] + }, + { + "coefficient": "-3", + "word": [ + "P5", + "P4", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P5", + "P4", + "N", + "P1" + ] + }, + { + "coefficient": "1", + "word": [ + "P5", + "P4", + "P2", + "N" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P5", + "P4" + ] + }, + { + "coefficient": "1", + "word": [ + "P5", + "P4", + "N", + "P1", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "P5", + "P4", + "P2" + ] + } + ], + [ + { + "coefficient": "-2", + "word": [ + "P5", + "P4", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P5", + "P4", + "N", + "P1" + ] + }, + { + "coefficient": "1", + "word": [ + "P5", + "P4", + "P2", + "N" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P5", + "P4" + ] + }, + { + "coefficient": "1", + "word": [ + "P5", + "P4", + "P2" + ] + } + ] + ], + [ + [], + [], + [ + { + "coefficient": "1", + "word": [ + "N" + ] + } + ], + [] + ], + [ + [ + { + "coefficient": "1", + "word": [] + }, + { + "coefficient": "-2", + "word": [ + "P3" + ] + }, + { + "coefficient": "1", + "word": [ + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P3", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P3", + "P1", + "N" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P3" + ] + }, + { + "coefficient": "1", + "word": [ + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P3", + "N" + ] + } + ] + ] + ], + "continuations": [ + 4 + ], + "pivot_rows": [ + 1, + 3 + ], + "public_rows": [ + 0, + 2 + ], + "q": 1, + "raw_calls": 5, + "separate_progress_profile": { + "H2": 23, + "ambient": 12, + "rank_deficit_before_tail": 2 + }, + "source_retractions": [ + { + "dst": 1, + "source_code": "P1", + "src": 0, + "stage": 1, + "u": [ + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ] + ] + }, + { + "dst": 2, + "source_code": "P2", + "src": 1, + "stage": 2, + "u": [ + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ] + ] + }, + { + "dst": 3, + "source_code": "P3", + "src": 2, + "stage": 3, + "u": [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ] + ] + }, + { + "dst": 0, + "source_code": "N P4", + "src": 1, + "stage": 4, + "u": [ + [ + "0", + "1" + ], + [ + "1", + "0" + ], + [ + "-1", + "0" + ], + [ + "0", + "0" + ] + ] + }, + { + "dst": 1, + "source_code": "P5", + "src": 0, + "stage": 5, + "u": [ + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "1" + ], + [ + "0", + "0" + ] + ] + } + ] + }, + { + "A3": [ + { + "coefficient": "-1", + "word": [ + "P5", + "P4", + "P3" + ] + } + ], + "D": [ + [ + [ + { + "coefficient": "-1", + "word": [ + "P7", + "P6" + ] + } + ], + [] + ], + [ + [], + [ + { + "coefficient": "-1", + "word": [ + "P5", + "P4", + "P3", + "N" + ] + } + ] + ] + ], + "H": [ + [ + [ + { + "coefficient": "1", + "word": [ + "P7", + "P6" + ] + }, + { + "coefficient": "1", + "word": [ + "P7", + "P6", + "N", + "P1", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "P7", + "P6", + "P2" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P7", + "P6" + ] + }, + { + "coefficient": "1", + "word": [ + "P7", + "P6", + "P2" + ] + } + ] + ], + [ + [ + { + "coefficient": "1", + "word": [ + "P5", + "P4", + "P3", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "P5", + "P4", + "P3", + "P1", + "N" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P5", + "P4", + "P3", + "N" + ] + } + ] + ] + ], + "J": [ + [ + [ + { + "coefficient": "-1", + "word": [] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P2" + ] + } + ], + [ + { + "coefficient": "1", + "word": [] + }, + { + "coefficient": "-1", + "word": [ + "P2" + ] + } + ] + ], + [ + [ + { + "coefficient": "-1", + "word": [] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1", + "N" + ] + } + ], + [ + { + "coefficient": "1", + "word": [] + } + ] + ] + ], + "L": [ + [ + [ + { + "coefficient": "1", + "word": [ + "P7" + ] + }, + { + "coefficient": "-3", + "word": [ + "P7", + "P6", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P7", + "P6", + "N", + "P1" + ] + }, + { + "coefficient": "1", + "word": [ + "P7", + "P6", + "P2", + "N" + ] + } + ], + [ + { + "coefficient": "-2", + "word": [ + "P7", + "P6", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P7", + "P6", + "N", + "P1" + ] + }, + { + "coefficient": "1", + "word": [ + "P7", + "P6", + "P2", + "N" + ] + } + ], + [ + { + "coefficient": "-2", + "word": [ + "P7", + "P6", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P7", + "P6", + "N", + "P1" + ] + }, + { + "coefficient": "1", + "word": [ + "P7", + "P6", + "P2", + "N" + ] + } + ], + [] + ], + [ + [ + { + "coefficient": "1", + "word": [] + }, + { + "coefficient": "2", + "word": [ + "P5", + "P4", + "P3" + ] + }, + { + "coefficient": "-1", + "word": [ + "P5", + "P4", + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P5", + "P4", + "P3" + ] + }, + { + "coefficient": "-1", + "word": [ + "P5", + "P4", + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P5" + ] + }, + { + "coefficient": "2", + "word": [ + "P5", + "P4", + "P3" + ] + }, + { + "coefficient": "-1", + "word": [ + "P5", + "P4", + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "P5", + "P4" + ] + } + ] + ] + ], + "banks": 6, + "complete_inverse": [ + [ + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + } + ], + [], + [], + [], + [], + [] + ], + [ + [ + { + "coefficient": "1", + "word": [] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "P5^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "P6^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1", + "N" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "P6^-1", + "P7^-1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "P5^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "N" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "P5^-1" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "N" + ] + } + ] + ], + [ + [], + [], + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + } + ], + [], + [], + [] + ], + [ + [ + { + "coefficient": "1", + "word": [ + "P2^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "P2^-1", + "P6^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "P5^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "P6^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1", + "N" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P2^-1", + "P6^-1", + "P7^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "P6^-1", + "P7^-1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P2^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "P5^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "N" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1" + ] + }, + { + "coefficient": "-1", + "word": [ + "P2^-1", + "N", + "P3^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "P5^-1" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "N" + ] + } + ] + ], + [ + [], + [], + [], + [], + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + } + ], + [] + ], + [ + [], + [], + [], + [], + [], + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + } + ] + ] + ], + "complete_matrix": [ + [ + [ + { + "coefficient": "1", + "word": [ + "N" + ] + } + ], + [], + [], + [], + [], + [] + ], + [ + [ + { + "coefficient": "1", + "word": [ + "P7" + ] + }, + { + "coefficient": "-3", + "word": [ + "P7", + "P6", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P7", + "P6", + "N", + "P1" + ] + }, + { + "coefficient": "1", + "word": [ + "P7", + "P6", + "P2", + "N" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P7", + "P6" + ] + }, + { + "coefficient": "1", + "word": [ + "P7", + "P6", + "N", + "P1", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "P7", + "P6", + "P2" + ] + } + ], + [ + { + "coefficient": "-2", + "word": [ + "P7", + "P6", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P7", + "P6", + "N", + "P1" + ] + }, + { + "coefficient": "1", + "word": [ + "P7", + "P6", + "P2", + "N" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P7", + "P6" + ] + }, + { + "coefficient": "1", + "word": [ + "P7", + "P6", + "P2" + ] + } + ], + [ + { + "coefficient": "-2", + "word": [ + "P7", + "P6", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P7", + "P6", + "N", + "P1" + ] + }, + { + "coefficient": "1", + "word": [ + "P7", + "P6", + "P2", + "N" + ] + } + ], + [] + ], + [ + [], + [], + [ + { + "coefficient": "1", + "word": [ + "N" + ] + } + ], + [], + [], + [] + ], + [ + [ + { + "coefficient": "1", + "word": [] + }, + { + "coefficient": "2", + "word": [ + "P5", + "P4", + "P3" + ] + }, + { + "coefficient": "-1", + "word": [ + "P5", + "P4", + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P5", + "P4", + "P3", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "P5", + "P4", + "P3", + "P1", + "N" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P5", + "P4", + "P3" + ] + }, + { + "coefficient": "-1", + "word": [ + "P5", + "P4", + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P5", + "P4", + "P3", + "N" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P5" + ] + }, + { + "coefficient": "2", + "word": [ + "P5", + "P4", + "P3" + ] + }, + { + "coefficient": "-1", + "word": [ + "P5", + "P4", + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "P5", + "P4" + ] + } + ] + ], + [ + [], + [], + [], + [], + [ + { + "coefficient": "1", + "word": [ + "N" + ] + } + ], + [] + ], + [ + [], + [], + [], + [], + [], + [ + { + "coefficient": "1", + "word": [ + "N" + ] + } + ] + ] + ], + "continuations": [ + 3, + 4, + 6 + ], + "pivot_rows": [ + 1, + 3 + ], + "public_rows": [ + 0, + 2, + 4, + 5 + ], + "q": 2, + "raw_calls": 7, + "separate_progress_profile": { + "H2": 47, + "ambient": 16, + "rank_deficit_before_tail": 2 + }, + "source_retractions": [ + { + "dst": 1, + "source_code": "P1", + "src": 0, + "stage": 1, + "u": [ + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ] + }, + { + "dst": 2, + "source_code": "P2", + "src": 1, + "stage": 2, + "u": [ + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ] + ] + }, + { + "dst": 3, + "source_code": "N P3", + "src": 2, + "stage": 3, + "u": [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "-1" + ] + ] + }, + { + "dst": 4, + "source_code": "N P4", + "src": 1, + "stage": 4, + "u": [ + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "1" + ], + [ + "0", + "1" + ], + [ + "1", + "0" + ] + ] + }, + { + "dst": 5, + "source_code": "P5", + "src": 4, + "stage": 5, + "u": [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ] + ] + }, + { + "dst": 0, + "source_code": "N P6", + "src": 1, + "stage": 6, + "u": [ + [ + "0", + "1" + ], + [ + "1", + "0" + ], + [ + "-1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ] + }, + { + "dst": 1, + "source_code": "P7", + "src": 0, + "stage": 7, + "u": [ + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "1" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ] + } + ] + }, + { + "A3": [ + { + "coefficient": "1", + "word": [ + "P7", + "P6", + "P5", + "P4", + "P3" + ] + } + ], + "D": [ + [ + [ + { + "coefficient": "-1", + "word": [ + "P9", + "P8" + ] + } + ], + [] + ], + [ + [], + [ + { + "coefficient": "1", + "word": [ + "P7", + "P6", + "P5", + "P4", + "P3", + "N" + ] + } + ] + ] + ], + "H": [ + [ + [ + { + "coefficient": "1", + "word": [ + "P9", + "P8" + ] + }, + { + "coefficient": "1", + "word": [ + "P9", + "P8", + "N", + "P1", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "P9", + "P8", + "P2" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P9", + "P8" + ] + }, + { + "coefficient": "1", + "word": [ + "P9", + "P8", + "P2" + ] + } + ] + ], + [ + [ + { + "coefficient": "-1", + "word": [ + "P7", + "P6", + "P5", + "P4", + "P3", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P7", + "P6", + "P5", + "P4", + "P3", + "P1", + "N" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P7", + "P6", + "P5", + "P4", + "P3", + "N" + ] + } + ] + ] + ], + "J": [ + [ + [ + { + "coefficient": "-1", + "word": [] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P2" + ] + } + ], + [ + { + "coefficient": "1", + "word": [] + }, + { + "coefficient": "-1", + "word": [ + "P2" + ] + } + ] + ], + [ + [ + { + "coefficient": "-1", + "word": [] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1", + "N" + ] + } + ], + [ + { + "coefficient": "1", + "word": [] + } + ] + ] + ], + "L": [ + [ + [ + { + "coefficient": "1", + "word": [ + "P9" + ] + }, + { + "coefficient": "-3", + "word": [ + "P9", + "P8", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P9", + "P8", + "N", + "P1" + ] + }, + { + "coefficient": "1", + "word": [ + "P9", + "P8", + "P2", + "N" + ] + } + ], + [ + { + "coefficient": "-2", + "word": [ + "P9", + "P8", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P9", + "P8", + "N", + "P1" + ] + }, + { + "coefficient": "1", + "word": [ + "P9", + "P8", + "P2", + "N" + ] + } + ], + [ + { + "coefficient": "-2", + "word": [ + "P9", + "P8", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P9", + "P8", + "N", + "P1" + ] + }, + { + "coefficient": "1", + "word": [ + "P9", + "P8", + "P2", + "N" + ] + } + ], + [], + [ + { + "coefficient": "-2", + "word": [ + "P9", + "P8", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P9", + "P8", + "N", + "P1" + ] + }, + { + "coefficient": "1", + "word": [ + "P9", + "P8", + "P2", + "N" + ] + } + ], + [] + ], + [ + [ + { + "coefficient": "1", + "word": [] + }, + { + "coefficient": "-2", + "word": [ + "P7", + "P6", + "P5", + "P4", + "P3" + ] + }, + { + "coefficient": "1", + "word": [ + "P7", + "P6", + "P5", + "P4", + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P7", + "P6", + "P5", + "P4", + "P3" + ] + }, + { + "coefficient": "1", + "word": [ + "P7", + "P6", + "P5", + "P4", + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P7", + "P6", + "P5" + ] + }, + { + "coefficient": "-2", + "word": [ + "P7", + "P6", + "P5", + "P4", + "P3" + ] + }, + { + "coefficient": "1", + "word": [ + "P7", + "P6", + "P5", + "P4", + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P7", + "P6" + ] + }, + { + "coefficient": "1", + "word": [ + "P7", + "P6", + "P5", + "P4" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P7" + ] + }, + { + "coefficient": "-2", + "word": [ + "P7", + "P6", + "P5", + "P4", + "P3" + ] + }, + { + "coefficient": "1", + "word": [ + "P7", + "P6", + "P5", + "P4", + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "P7", + "P6" + ] + } + ] + ] + ], + "banks": 8, + "complete_inverse": [ + [ + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + } + ], + [], + [], + [], + [], + [], + [], + [] + ], + [ + [ + { + "coefficient": "1", + "word": [] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "P7^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "P8^-1", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "P7^-1", + "N" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "P8^-1", + "P9^-1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "P7^-1" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "P7^-1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "N" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "P5^-1", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "N" + ] + } + ], + [ + { + "coefficient": "1", + "word": [] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "N" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "P7^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "P5^-1", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "P7^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1", + "N" + ] + } + ] + ], + [ + [], + [], + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + } + ], + [], + [], + [], + [], + [] + ], + [ + [ + { + "coefficient": "1", + "word": [ + "P2^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "P2^-1", + "P8^-1", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "P7^-1", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "P7^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "P8^-1", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "P7^-1", + "N" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P2^-1", + "P8^-1", + "P9^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "P8^-1", + "P9^-1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P2^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "P7^-1" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "P7^-1" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "P7^-1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "N" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "P2^-1", + "N", + "P3^-1", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "P5^-1", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "N" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "N" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "P7^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "P7^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "P5^-1", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "P7^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1", + "N" + ] + } + ] + ], + [ + [], + [], + [], + [], + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + } + ], + [], + [], + [] + ], + [ + [], + [], + [], + [], + [], + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + } + ], + [], + [] + ], + [ + [], + [], + [], + [], + [], + [], + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + } + ], + [] + ], + [ + [], + [], + [], + [], + [], + [], + [], + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + } + ] + ] + ], + "complete_matrix": [ + [ + [ + { + "coefficient": "1", + "word": [ + "N" + ] + } + ], + [], + [], + [], + [], + [], + [], + [] + ], + [ + [ + { + "coefficient": "1", + "word": [ + "P9" + ] + }, + { + "coefficient": "-3", + "word": [ + "P9", + "P8", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P9", + "P8", + "N", + "P1" + ] + }, + { + "coefficient": "1", + "word": [ + "P9", + "P8", + "P2", + "N" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P9", + "P8" + ] + }, + { + "coefficient": "1", + "word": [ + "P9", + "P8", + "N", + "P1", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "P9", + "P8", + "P2" + ] + } + ], + [ + { + "coefficient": "-2", + "word": [ + "P9", + "P8", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P9", + "P8", + "N", + "P1" + ] + }, + { + "coefficient": "1", + "word": [ + "P9", + "P8", + "P2", + "N" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P9", + "P8" + ] + }, + { + "coefficient": "1", + "word": [ + "P9", + "P8", + "P2" + ] + } + ], + [ + { + "coefficient": "-2", + "word": [ + "P9", + "P8", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P9", + "P8", + "N", + "P1" + ] + }, + { + "coefficient": "1", + "word": [ + "P9", + "P8", + "P2", + "N" + ] + } + ], + [], + [ + { + "coefficient": "-2", + "word": [ + "P9", + "P8", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P9", + "P8", + "N", + "P1" + ] + }, + { + "coefficient": "1", + "word": [ + "P9", + "P8", + "P2", + "N" + ] + } + ], + [] + ], + [ + [], + [], + [ + { + "coefficient": "1", + "word": [ + "N" + ] + } + ], + [], + [], + [], + [], + [] + ], + [ + [ + { + "coefficient": "1", + "word": [] + }, + { + "coefficient": "-2", + "word": [ + "P7", + "P6", + "P5", + "P4", + "P3" + ] + }, + { + "coefficient": "1", + "word": [ + "P7", + "P6", + "P5", + "P4", + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P7", + "P6", + "P5", + "P4", + "P3", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P7", + "P6", + "P5", + "P4", + "P3", + "P1", + "N" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P7", + "P6", + "P5", + "P4", + "P3" + ] + }, + { + "coefficient": "1", + "word": [ + "P7", + "P6", + "P5", + "P4", + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P7", + "P6", + "P5", + "P4", + "P3", + "N" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P7", + "P6", + "P5" + ] + }, + { + "coefficient": "-2", + "word": [ + "P7", + "P6", + "P5", + "P4", + "P3" + ] + }, + { + "coefficient": "1", + "word": [ + "P7", + "P6", + "P5", + "P4", + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P7", + "P6" + ] + }, + { + "coefficient": "1", + "word": [ + "P7", + "P6", + "P5", + "P4" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P7" + ] + }, + { + "coefficient": "-2", + "word": [ + "P7", + "P6", + "P5", + "P4", + "P3" + ] + }, + { + "coefficient": "1", + "word": [ + "P7", + "P6", + "P5", + "P4", + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "P7", + "P6" + ] + } + ] + ], + [ + [], + [], + [], + [], + [ + { + "coefficient": "1", + "word": [ + "N" + ] + } + ], + [], + [], + [] + ], + [ + [], + [], + [], + [], + [], + [ + { + "coefficient": "1", + "word": [ + "N" + ] + } + ], + [], + [] + ], + [ + [], + [], + [], + [], + [], + [], + [ + { + "coefficient": "1", + "word": [ + "N" + ] + } + ], + [] + ], + [ + [], + [], + [], + [], + [], + [], + [], + [ + { + "coefficient": "1", + "word": [ + "N" + ] + } + ] + ] + ], + "continuations": [ + 3, + 4, + 5, + 6, + 8 + ], + "pivot_rows": [ + 1, + 3 + ], + "public_rows": [ + 0, + 2, + 4, + 5, + 6, + 7 + ], + "q": 3, + "raw_calls": 9, + "separate_progress_profile": { + "H2": 79, + "ambient": 20, + "rank_deficit_before_tail": 2 + }, + "source_retractions": [ + { + "dst": 1, + "source_code": "P1", + "src": 0, + "stage": 1, + "u": [ + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ] + }, + { + "dst": 2, + "source_code": "P2", + "src": 1, + "stage": 2, + "u": [ + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ] + ] + }, + { + "dst": 3, + "source_code": "N P3", + "src": 2, + "stage": 3, + "u": [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "-1" + ], + [ + "0", + "0" + ], + [ + "0", + "-1" + ] + ] + }, + { + "dst": 4, + "source_code": "N P4", + "src": 1, + "stage": 4, + "u": [ + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "1" + ], + [ + "0", + "1" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ] + ] + }, + { + "dst": 5, + "source_code": "N P5", + "src": 4, + "stage": 5, + "u": [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "-1" + ] + ] + }, + { + "dst": 6, + "source_code": "N P6", + "src": 1, + "stage": 6, + "u": [ + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "1" + ], + [ + "0", + "0" + ], + [ + "0", + "1" + ], + [ + "0", + "1" + ], + [ + "1", + "0" + ] + ] + }, + { + "dst": 7, + "source_code": "P7", + "src": 6, + "stage": 7, + "u": [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ] + ] + }, + { + "dst": 0, + "source_code": "N P8", + "src": 1, + "stage": 8, + "u": [ + [ + "0", + "1" + ], + [ + "1", + "0" + ], + [ + "-1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ] + }, + { + "dst": 1, + "source_code": "P9", + "src": 0, + "stage": 9, + "u": [ + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "1" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ] + } + ] + }, + { + "A3": [ + { + "coefficient": "-1", + "word": [ + "P9", + "P8", + "P7", + "P6", + "P5", + "P4", + "P3" + ] + } + ], + "D": [ + [ + [ + { + "coefficient": "-1", + "word": [ + "P11", + "P10" + ] + } + ], + [] + ], + [ + [], + [ + { + "coefficient": "-1", + "word": [ + "P9", + "P8", + "P7", + "P6", + "P5", + "P4", + "P3", + "N" + ] + } + ] + ] + ], + "H": [ + [ + [ + { + "coefficient": "1", + "word": [ + "P11", + "P10" + ] + }, + { + "coefficient": "1", + "word": [ + "P11", + "P10", + "N", + "P1", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "P11", + "P10", + "P2" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P11", + "P10" + ] + }, + { + "coefficient": "1", + "word": [ + "P11", + "P10", + "P2" + ] + } + ] + ], + [ + [ + { + "coefficient": "1", + "word": [ + "P9", + "P8", + "P7", + "P6", + "P5", + "P4", + "P3", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "P9", + "P8", + "P7", + "P6", + "P5", + "P4", + "P3", + "P1", + "N" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P9", + "P8", + "P7", + "P6", + "P5", + "P4", + "P3", + "N" + ] + } + ] + ] + ], + "J": [ + [ + [ + { + "coefficient": "-1", + "word": [] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P2" + ] + } + ], + [ + { + "coefficient": "1", + "word": [] + }, + { + "coefficient": "-1", + "word": [ + "P2" + ] + } + ] + ], + [ + [ + { + "coefficient": "-1", + "word": [] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1", + "N" + ] + } + ], + [ + { + "coefficient": "1", + "word": [] + } + ] + ] + ], + "L": [ + [ + [ + { + "coefficient": "1", + "word": [ + "P11" + ] + }, + { + "coefficient": "-3", + "word": [ + "P11", + "P10", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P11", + "P10", + "N", + "P1" + ] + }, + { + "coefficient": "1", + "word": [ + "P11", + "P10", + "P2", + "N" + ] + } + ], + [ + { + "coefficient": "-2", + "word": [ + "P11", + "P10", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P11", + "P10", + "N", + "P1" + ] + }, + { + "coefficient": "1", + "word": [ + "P11", + "P10", + "P2", + "N" + ] + } + ], + [ + { + "coefficient": "-2", + "word": [ + "P11", + "P10", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P11", + "P10", + "N", + "P1" + ] + }, + { + "coefficient": "1", + "word": [ + "P11", + "P10", + "P2", + "N" + ] + } + ], + [], + [ + { + "coefficient": "-2", + "word": [ + "P11", + "P10", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P11", + "P10", + "N", + "P1" + ] + }, + { + "coefficient": "1", + "word": [ + "P11", + "P10", + "P2", + "N" + ] + } + ], + [], + [ + { + "coefficient": "-2", + "word": [ + "P11", + "P10", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P11", + "P10", + "N", + "P1" + ] + }, + { + "coefficient": "1", + "word": [ + "P11", + "P10", + "P2", + "N" + ] + } + ], + [] + ], + [ + [ + { + "coefficient": "1", + "word": [] + }, + { + "coefficient": "2", + "word": [ + "P9", + "P8", + "P7", + "P6", + "P5", + "P4", + "P3" + ] + }, + { + "coefficient": "-1", + "word": [ + "P9", + "P8", + "P7", + "P6", + "P5", + "P4", + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P9", + "P8", + "P7", + "P6", + "P5", + "P4", + "P3" + ] + }, + { + "coefficient": "-1", + "word": [ + "P9", + "P8", + "P7", + "P6", + "P5", + "P4", + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P9", + "P8", + "P7", + "P6", + "P5" + ] + }, + { + "coefficient": "2", + "word": [ + "P9", + "P8", + "P7", + "P6", + "P5", + "P4", + "P3" + ] + }, + { + "coefficient": "-1", + "word": [ + "P9", + "P8", + "P7", + "P6", + "P5", + "P4", + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P9", + "P8", + "P7", + "P6" + ] + }, + { + "coefficient": "-1", + "word": [ + "P9", + "P8", + "P7", + "P6", + "P5", + "P4" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P9", + "P8", + "P7" + ] + }, + { + "coefficient": "2", + "word": [ + "P9", + "P8", + "P7", + "P6", + "P5", + "P4", + "P3" + ] + }, + { + "coefficient": "-1", + "word": [ + "P9", + "P8", + "P7", + "P6", + "P5", + "P4", + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P9", + "P8" + ] + }, + { + "coefficient": "1", + "word": [ + "P9", + "P8", + "P7", + "P6" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P9" + ] + }, + { + "coefficient": "2", + "word": [ + "P9", + "P8", + "P7", + "P6", + "P5", + "P4", + "P3" + ] + }, + { + "coefficient": "-1", + "word": [ + "P9", + "P8", + "P7", + "P6", + "P5", + "P4", + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "P9", + "P8" + ] + } + ] + ] + ], + "banks": 10, + "complete_inverse": [ + [ + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + } + ], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ], + [ + [ + { + "coefficient": "1", + "word": [] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "P7^-1", + "P8^-1", + "P9^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "P10^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "P7^-1", + "P8^-1", + "P9^-1", + "N" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "P10^-1", + "P11^-1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "P7^-1", + "P8^-1", + "P9^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "P7^-1", + "P8^-1", + "P9^-1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "N" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "P5^-1", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "N" + ] + } + ], + [ + { + "coefficient": "1", + "word": [] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "N" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "P7^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "P5^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "P7^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1", + "N" + ] + } + ], + [ + { + "coefficient": "1", + "word": [] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "P7^-1", + "P8^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "P7^-1", + "P8^-1", + "N" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "P7^-1", + "P8^-1", + "P9^-1" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "P7^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "P7^-1", + "P8^-1", + "P9^-1" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "P7^-1", + "N" + ] + } + ] + ], + [ + [], + [], + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + } + ], + [], + [], + [], + [], + [], + [], + [] + ], + [ + [ + { + "coefficient": "1", + "word": [ + "P2^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "P2^-1", + "P10^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "P7^-1", + "P8^-1", + "P9^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "P7^-1", + "P8^-1", + "P9^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "P10^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "P7^-1", + "P8^-1", + "P9^-1", + "N" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P2^-1", + "P10^-1", + "P11^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "P10^-1", + "P11^-1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P2^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "P7^-1", + "P8^-1", + "P9^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "P7^-1", + "P8^-1", + "P9^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "P7^-1", + "P8^-1", + "P9^-1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "N" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "P2^-1", + "N", + "P3^-1", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "P5^-1", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "N" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "N" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "P7^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "P7^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "P5^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "P7^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1", + "N" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "P7^-1", + "P8^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "P7^-1", + "P8^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "P7^-1", + "P8^-1", + "N" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "P7^-1", + "P8^-1", + "P9^-1" + ] + }, + { + "coefficient": "-1", + "word": [ + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "P7^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "P7^-1", + "P8^-1", + "P9^-1" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "P7^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "P7^-1", + "P8^-1", + "P9^-1" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1", + "P6^-1", + "P7^-1", + "N" + ] + } + ] + ], + [ + [], + [], + [], + [], + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + } + ], + [], + [], + [], + [], + [] + ], + [ + [], + [], + [], + [], + [], + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + } + ], + [], + [], + [], + [] + ], + [ + [], + [], + [], + [], + [], + [], + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + } + ], + [], + [], + [] + ], + [ + [], + [], + [], + [], + [], + [], + [], + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + } + ], + [], + [] + ], + [ + [], + [], + [], + [], + [], + [], + [], + [], + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + } + ], + [] + ], + [ + [], + [], + [], + [], + [], + [], + [], + [], + [], + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + } + ] + ] + ], + "complete_matrix": [ + [ + [ + { + "coefficient": "1", + "word": [ + "N" + ] + } + ], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ], + [ + [ + { + "coefficient": "1", + "word": [ + "P11" + ] + }, + { + "coefficient": "-3", + "word": [ + "P11", + "P10", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P11", + "P10", + "N", + "P1" + ] + }, + { + "coefficient": "1", + "word": [ + "P11", + "P10", + "P2", + "N" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P11", + "P10" + ] + }, + { + "coefficient": "1", + "word": [ + "P11", + "P10", + "N", + "P1", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "P11", + "P10", + "P2" + ] + } + ], + [ + { + "coefficient": "-2", + "word": [ + "P11", + "P10", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P11", + "P10", + "N", + "P1" + ] + }, + { + "coefficient": "1", + "word": [ + "P11", + "P10", + "P2", + "N" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P11", + "P10" + ] + }, + { + "coefficient": "1", + "word": [ + "P11", + "P10", + "P2" + ] + } + ], + [ + { + "coefficient": "-2", + "word": [ + "P11", + "P10", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P11", + "P10", + "N", + "P1" + ] + }, + { + "coefficient": "1", + "word": [ + "P11", + "P10", + "P2", + "N" + ] + } + ], + [], + [ + { + "coefficient": "-2", + "word": [ + "P11", + "P10", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P11", + "P10", + "N", + "P1" + ] + }, + { + "coefficient": "1", + "word": [ + "P11", + "P10", + "P2", + "N" + ] + } + ], + [], + [ + { + "coefficient": "-2", + "word": [ + "P11", + "P10", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P11", + "P10", + "N", + "P1" + ] + }, + { + "coefficient": "1", + "word": [ + "P11", + "P10", + "P2", + "N" + ] + } + ], + [] + ], + [ + [], + [], + [ + { + "coefficient": "1", + "word": [ + "N" + ] + } + ], + [], + [], + [], + [], + [], + [], + [] + ], + [ + [ + { + "coefficient": "1", + "word": [] + }, + { + "coefficient": "2", + "word": [ + "P9", + "P8", + "P7", + "P6", + "P5", + "P4", + "P3" + ] + }, + { + "coefficient": "-1", + "word": [ + "P9", + "P8", + "P7", + "P6", + "P5", + "P4", + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P9", + "P8", + "P7", + "P6", + "P5", + "P4", + "P3", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "P9", + "P8", + "P7", + "P6", + "P5", + "P4", + "P3", + "P1", + "N" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P9", + "P8", + "P7", + "P6", + "P5", + "P4", + "P3" + ] + }, + { + "coefficient": "-1", + "word": [ + "P9", + "P8", + "P7", + "P6", + "P5", + "P4", + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P9", + "P8", + "P7", + "P6", + "P5", + "P4", + "P3", + "N" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P9", + "P8", + "P7", + "P6", + "P5" + ] + }, + { + "coefficient": "2", + "word": [ + "P9", + "P8", + "P7", + "P6", + "P5", + "P4", + "P3" + ] + }, + { + "coefficient": "-1", + "word": [ + "P9", + "P8", + "P7", + "P6", + "P5", + "P4", + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P9", + "P8", + "P7", + "P6" + ] + }, + { + "coefficient": "-1", + "word": [ + "P9", + "P8", + "P7", + "P6", + "P5", + "P4" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P9", + "P8", + "P7" + ] + }, + { + "coefficient": "2", + "word": [ + "P9", + "P8", + "P7", + "P6", + "P5", + "P4", + "P3" + ] + }, + { + "coefficient": "-1", + "word": [ + "P9", + "P8", + "P7", + "P6", + "P5", + "P4", + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P9", + "P8" + ] + }, + { + "coefficient": "1", + "word": [ + "P9", + "P8", + "P7", + "P6" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P9" + ] + }, + { + "coefficient": "2", + "word": [ + "P9", + "P8", + "P7", + "P6", + "P5", + "P4", + "P3" + ] + }, + { + "coefficient": "-1", + "word": [ + "P9", + "P8", + "P7", + "P6", + "P5", + "P4", + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "P9", + "P8" + ] + } + ] + ], + [ + [], + [], + [], + [], + [ + { + "coefficient": "1", + "word": [ + "N" + ] + } + ], + [], + [], + [], + [], + [] + ], + [ + [], + [], + [], + [], + [], + [ + { + "coefficient": "1", + "word": [ + "N" + ] + } + ], + [], + [], + [], + [] + ], + [ + [], + [], + [], + [], + [], + [], + [ + { + "coefficient": "1", + "word": [ + "N" + ] + } + ], + [], + [], + [] + ], + [ + [], + [], + [], + [], + [], + [], + [], + [ + { + "coefficient": "1", + "word": [ + "N" + ] + } + ], + [], + [] + ], + [ + [], + [], + [], + [], + [], + [], + [], + [], + [ + { + "coefficient": "1", + "word": [ + "N" + ] + } + ], + [] + ], + [ + [], + [], + [], + [], + [], + [], + [], + [], + [], + [ + { + "coefficient": "1", + "word": [ + "N" + ] + } + ] + ] + ], + "continuations": [ + 3, + 4, + 5, + 6, + 7, + 8, + 10 + ], + "pivot_rows": [ + 1, + 3 + ], + "public_rows": [ + 0, + 2, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "q": 4, + "raw_calls": 11, + "separate_progress_profile": { + "H2": 119, + "ambient": 24, + "rank_deficit_before_tail": 2 + }, + "source_retractions": [ + { + "dst": 1, + "source_code": "P1", + "src": 0, + "stage": 1, + "u": [ + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ] + }, + { + "dst": 2, + "source_code": "P2", + "src": 1, + "stage": 2, + "u": [ + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ] + ] + }, + { + "dst": 3, + "source_code": "N P3", + "src": 2, + "stage": 3, + "u": [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "-1" + ], + [ + "0", + "0" + ], + [ + "0", + "-1" + ], + [ + "0", + "0" + ], + [ + "0", + "-1" + ] + ] + }, + { + "dst": 4, + "source_code": "N P4", + "src": 1, + "stage": 4, + "u": [ + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "1" + ], + [ + "0", + "1" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ] + ] + }, + { + "dst": 5, + "source_code": "N P5", + "src": 4, + "stage": 5, + "u": [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "-1" + ], + [ + "0", + "0" + ], + [ + "0", + "-1" + ] + ] + }, + { + "dst": 6, + "source_code": "N P6", + "src": 1, + "stage": 6, + "u": [ + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "1" + ], + [ + "0", + "0" + ], + [ + "0", + "1" + ], + [ + "0", + "1" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ] + ] + }, + { + "dst": 7, + "source_code": "N P7", + "src": 6, + "stage": 7, + "u": [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "-1" + ] + ] + }, + { + "dst": 8, + "source_code": "N P8", + "src": 1, + "stage": 8, + "u": [ + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "1" + ], + [ + "0", + "0" + ], + [ + "0", + "1" + ], + [ + "0", + "0" + ], + [ + "0", + "1" + ], + [ + "0", + "1" + ], + [ + "1", + "0" + ] + ] + }, + { + "dst": 9, + "source_code": "P9", + "src": 8, + "stage": 9, + "u": [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ] + ] + }, + { + "dst": 0, + "source_code": "N P10", + "src": 1, + "stage": 10, + "u": [ + [ + "0", + "1" + ], + [ + "1", + "0" + ], + [ + "-1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ] + }, + { + "dst": 1, + "source_code": "P11", + "src": 0, + "stage": 11, + "u": [ + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "1" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ] + } + ] + } + ], + "initial_basis": "At raw ZERO, c_r+=c1 for r>=2. One common N/N^-1 exposure fanouts b1+=N*t only. The inverse c-basis is applied after the last query; its other public rows are retained.", + "limits": [ + "H has a bounded five-factory form, but the complete L readers and their native cuts remain part of the contract.", + "The affine ADDRESS cocycle is an algebraic grouping target, not an implemented shared-native controller.", + "The finite checks and written all-parameter recurrence are not a formal-kernel proof." + ], + "native_invoice": "With the current literal compiler c=2q-1 retained N continuations, two shared input N calls and all separate fresh progress: H2=(2q+2)(2q+3)+2q+1, m=4q+8, n=2q+2, D_before_tail=2. Wide batching changes moment pressure, not this mass. No amortized query removal is asserted.", + "no_new_kappa": true, + "producer_sha256": "88f425d12baf8a4f849cccd24605f21680eb8ce8d199054db4b4e7734eca72b6", + "scientific_pin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "source_pins": [ + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/caller/nested_prefix.py", + "sha256": "9ec10cb0243c0c829475ad7290f4953cdff27cb0f90f70b687c4bbee98af676b" + }, + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/caller/nested_six.py", + "sha256": "1719e560816ffa9e5193f6275c44c688fa280bede36a11c307f61783eb995bf0" + }, + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/caller/NESTED-SIX.json", + "sha256": "539a8b44cb46a93c3b7b056d7eff94c4402fba67b8850e03b725b9e2b05952d1" + }, + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/caller/free_ops.py", + "sha256": "5806fe91b9fda162d5986b12e085b14eb3df9a4703f749f61c1f10363138ca77" + } + ], + "status": "PASS_EXPLICIT_NESTED_SOURCE_FAMILY_AND_ONE_COORDINATE_AFFINE_COCYCLE" +} diff --git a/research/marked-residual-reflection/source/caller/NESTED-SIX.json b/research/marked-residual-reflection/source/caller/NESTED-SIX.json new file mode 100644 index 0000000000..d7e80f10b5 --- /dev/null +++ b/research/marked-residual-reflection/source/caller/NESTED-SIX.json @@ -0,0 +1,4910 @@ +{ + "D_before_pivot_tail": 2, + "ambient_arity": 16, + "changed_premise": "Repeated first-query response replacement with coupled source-retraction columns in a fixed two-dimensional E-plane; genuine common-N source continuations are retained at stages3,4,6.", + "complete_inverse": [ + [ + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + } + ], + [], + [], + [], + [], + [] + ], + [ + [ + { + "coefficient": "1", + "word": [] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "P5^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "P6^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1", + "N" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "P6^-1", + "P7^-1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "P5^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "N" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "P5^-1" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "N" + ] + } + ] + ], + [ + [], + [], + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + } + ], + [], + [], + [] + ], + [ + [ + { + "coefficient": "1", + "word": [ + "P2^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "P2^-1", + "P6^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "P5^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "P6^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1", + "N" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P2^-1", + "P6^-1", + "P7^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "P6^-1", + "P7^-1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P2^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "P5^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "N" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1" + ] + }, + { + "coefficient": "-1", + "word": [ + "P2^-1", + "N", + "P3^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1", + "P5^-1" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1", + "P5^-1" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "N" + ] + } + ] + ], + [ + [], + [], + [], + [], + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + } + ], + [] + ], + [ + [], + [], + [], + [], + [], + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + } + ] + ] + ], + "complete_matrix": [ + [ + [ + { + "coefficient": "1", + "word": [ + "N" + ] + } + ], + [], + [], + [], + [], + [] + ], + [ + [ + { + "coefficient": "1", + "word": [ + "P7" + ] + }, + { + "coefficient": "-3", + "word": [ + "P7", + "P6", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P7", + "P6", + "N", + "P1" + ] + }, + { + "coefficient": "1", + "word": [ + "P7", + "P6", + "P2", + "N" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P7", + "P6" + ] + }, + { + "coefficient": "1", + "word": [ + "P7", + "P6", + "N", + "P1", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "P7", + "P6", + "P2" + ] + } + ], + [ + { + "coefficient": "-2", + "word": [ + "P7", + "P6", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P7", + "P6", + "N", + "P1" + ] + }, + { + "coefficient": "1", + "word": [ + "P7", + "P6", + "P2", + "N" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P7", + "P6" + ] + }, + { + "coefficient": "1", + "word": [ + "P7", + "P6", + "P2" + ] + } + ], + [ + { + "coefficient": "-2", + "word": [ + "P7", + "P6", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P7", + "P6", + "N", + "P1" + ] + }, + { + "coefficient": "1", + "word": [ + "P7", + "P6", + "P2", + "N" + ] + } + ], + [] + ], + [ + [], + [], + [ + { + "coefficient": "1", + "word": [ + "N" + ] + } + ], + [], + [], + [] + ], + [ + [ + { + "coefficient": "1", + "word": [] + }, + { + "coefficient": "2", + "word": [ + "P5", + "P4", + "P3" + ] + }, + { + "coefficient": "-1", + "word": [ + "P5", + "P4", + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P5", + "P4", + "P3", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "P5", + "P4", + "P3", + "P1", + "N" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P5", + "P4", + "P3" + ] + }, + { + "coefficient": "-1", + "word": [ + "P5", + "P4", + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P5", + "P4", + "P3", + "N" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P5" + ] + }, + { + "coefficient": "2", + "word": [ + "P5", + "P4", + "P3" + ] + }, + { + "coefficient": "-1", + "word": [ + "P5", + "P4", + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "P5", + "P4" + ] + } + ] + ], + [ + [], + [], + [], + [], + [ + { + "coefficient": "1", + "word": [ + "N" + ] + } + ], + [] + ], + [ + [], + [], + [], + [], + [], + [ + { + "coefficient": "1", + "word": [ + "N" + ] + } + ] + ] + ], + "domain": "Every f>=1 under exact Ni^2=-I, commuting distinct native planes and ADDRESS plane permutations; six arbitrary independent input fields. Free-operator proof allows arbitrary independent invertible Pi.", + "events": [ + { + "coefficient": "1", + "dst": 5, + "kind": "ADD", + "label": "raw c-basis inverse", + "src": 3 + }, + { + "bank": 1, + "kind": "NATIVE", + "label": "shared input N exposure", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 0 + ], + "sign": 1 + } + }, + { + "coefficient": "1", + "dst": 2, + "kind": "ADD", + "label": "shared input fanout b1+=N*t", + "src": 1 + }, + { + "bank": 1, + "kind": "NATIVE", + "label": "shared input N inverse", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 0 + ], + "sign": -1 + } + }, + { + "coefficient": "-1", + "dst": 5, + "kind": "ADD", + "label": "scalar nested response bridge", + "src": 1 + }, + { + "coefficient": "1", + "dst": 0, + "kind": "ADD", + "label": "scalar nested response bridge", + "src": 4 + }, + { + "coefficient": "-1", + "dst": 3, + "kind": "ADD", + "label": "scalar nested response bridge", + "src": 1 + }, + { + "coefficient": "1", + "dst": 0, + "kind": "ADD", + "label": "scalar nested response bridge", + "src": 2 + }, + { + "coefficient": "-1", + "dst": 2, + "kind": "ADD", + "label": "query1 scalar source-retraction entrance", + "src": 0 + }, + { + "bank": 0, + "kind": "NATIVE", + "label": "query1 source common", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 0 + ], + "sign": 1 + } + }, + { + "coefficient": "1", + "dst": 1, + "kind": "ADD", + "label": "query1 delivery", + "src": 0 + }, + { + "bank": 0, + "kind": "ADDRESS_OR_UNIT", + "label": "query1 source swap", + "operator": { + "block_permutation": [ + 1, + 0, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 0, + "native_blocks": [], + "sign": 1 + } + }, + { + "bank": 1, + "kind": "NATIVE", + "label": "query1 target fresh", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 1 + ], + "sign": 1 + } + }, + { + "bank": 2, + "kind": "NATIVE", + "label": "query1 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 1 + ], + "sign": 1 + } + }, + { + "bank": 3, + "kind": "NATIVE", + "label": "query1 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 1 + ], + "sign": 1 + } + }, + { + "bank": 4, + "kind": "NATIVE", + "label": "query1 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 1 + ], + "sign": 1 + } + }, + { + "bank": 5, + "kind": "NATIVE", + "label": "query1 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 1 + ], + "sign": 1 + } + }, + { + "coefficient": "1", + "dst": 2, + "kind": "ADD", + "label": "query1 scalar source-retraction exit", + "src": 0 + }, + { + "coefficient": "-1", + "dst": 0, + "kind": "ADD", + "label": "scalar nested response bridge", + "src": 2 + }, + { + "coefficient": "1", + "dst": 1, + "kind": "ADD", + "label": "scalar nested response bridge", + "src": 3 + }, + { + "coefficient": "-1", + "dst": 3, + "kind": "ADD", + "label": "query2 scalar source-retraction entrance", + "src": 1 + }, + { + "coefficient": "-1", + "dst": 5, + "kind": "ADD", + "label": "query2 scalar source-retraction entrance", + "src": 1 + }, + { + "bank": 1, + "kind": "NATIVE", + "label": "query2 source common", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 0 + ], + "sign": 1 + } + }, + { + "coefficient": "1", + "dst": 2, + "kind": "ADD", + "label": "query2 delivery", + "src": 1 + }, + { + "bank": 1, + "kind": "ADDRESS_OR_UNIT", + "label": "query2 source swap", + "operator": { + "block_permutation": [ + 2, + 1, + 0, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 0, + "native_blocks": [], + "sign": 1 + } + }, + { + "bank": 0, + "kind": "NATIVE", + "label": "query2 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 2 + ], + "sign": 1 + } + }, + { + "bank": 2, + "kind": "NATIVE", + "label": "query2 target fresh", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 2 + ], + "sign": 1 + } + }, + { + "bank": 3, + "kind": "NATIVE", + "label": "query2 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 2 + ], + "sign": 1 + } + }, + { + "bank": 4, + "kind": "NATIVE", + "label": "query2 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 2 + ], + "sign": 1 + } + }, + { + "bank": 5, + "kind": "NATIVE", + "label": "query2 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 2 + ], + "sign": 1 + } + }, + { + "coefficient": "1", + "dst": 3, + "kind": "ADD", + "label": "query2 scalar source-retraction exit", + "src": 1 + }, + { + "coefficient": "1", + "dst": 5, + "kind": "ADD", + "label": "query2 scalar source-retraction exit", + "src": 1 + }, + { + "coefficient": "-1", + "dst": 1, + "kind": "ADD", + "label": "scalar nested response bridge", + "src": 3 + }, + { + "bank": 2, + "kind": "NATIVE", + "label": "query3 source common", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 0 + ], + "sign": 1 + } + }, + { + "coefficient": "1", + "dst": 5, + "kind": "ADD", + "label": "query3 entrance fanout from existing source N", + "src": 2 + }, + { + "coefficient": "1", + "dst": 3, + "kind": "ADD", + "label": "query3 delivery", + "src": 2 + }, + { + "bank": 2, + "kind": "ADDRESS_OR_UNIT", + "label": "query3 source swap", + "operator": { + "block_permutation": [ + 3, + 1, + 2, + 0, + 4, + 5, + 6, + 7 + ], + "native_arity": 0, + "native_blocks": [], + "sign": 1 + } + }, + { + "bank": 0, + "kind": "NATIVE", + "label": "query3 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 3 + ], + "sign": 1 + } + }, + { + "bank": 1, + "kind": "NATIVE", + "label": "query3 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 3 + ], + "sign": 1 + } + }, + { + "bank": 3, + "kind": "NATIVE", + "label": "query3 target fresh", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 3 + ], + "sign": 1 + } + }, + { + "bank": 4, + "kind": "NATIVE", + "label": "query3 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 3 + ], + "sign": 1 + } + }, + { + "bank": 5, + "kind": "NATIVE", + "label": "query3 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 3 + ], + "sign": 1 + } + }, + { + "coefficient": "1", + "dst": 5, + "kind": "ADD", + "label": "query3 pre-continuation fanout", + "src": 2 + }, + { + "bank": 2, + "kind": "NATIVE", + "label": "query3 retained source N continuation", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 0 + ], + "sign": 1 + } + }, + { + "coefficient": "1", + "dst": 2, + "kind": "ADD", + "label": "scalar nested response bridge", + "src": 0 + }, + { + "coefficient": "1", + "dst": 3, + "kind": "ADD", + "label": "scalar nested response bridge", + "src": 1 + }, + { + "coefficient": "-1", + "dst": 1, + "kind": "ADD", + "label": "scalar nested response bridge", + "src": 3 + }, + { + "banks": [ + 2, + 3 + ], + "kind": "BANK_SWAP", + "label": "nested response permutation" + }, + { + "coefficient": "-1", + "dst": 0, + "kind": "ADD", + "label": "scalar nested response bridge", + "src": 4 + }, + { + "coefficient": "1", + "dst": 1, + "kind": "ADD", + "label": "scalar nested response bridge", + "src": 5 + }, + { + "coefficient": "-1", + "dst": 5, + "kind": "ADD", + "label": "query4 scalar source-retraction entrance", + "src": 1 + }, + { + "bank": 1, + "kind": "NATIVE", + "label": "query4 source common", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 0 + ], + "sign": 1 + } + }, + { + "coefficient": "-1", + "dst": 3, + "kind": "ADD", + "label": "query4 entrance fanout from existing source N", + "src": 1 + }, + { + "coefficient": "-1", + "dst": 4, + "kind": "ADD", + "label": "query4 entrance fanout from existing source N", + "src": 1 + }, + { + "coefficient": "1", + "dst": 4, + "kind": "ADD", + "label": "query4 delivery", + "src": 1 + }, + { + "bank": 1, + "kind": "ADDRESS_OR_UNIT", + "label": "query4 source swap", + "operator": { + "block_permutation": [ + 4, + 1, + 2, + 3, + 0, + 5, + 6, + 7 + ], + "native_arity": 0, + "native_blocks": [], + "sign": 1 + } + }, + { + "bank": 0, + "kind": "NATIVE", + "label": "query4 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 4 + ], + "sign": 1 + } + }, + { + "bank": 2, + "kind": "NATIVE", + "label": "query4 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 4 + ], + "sign": 1 + } + }, + { + "bank": 3, + "kind": "NATIVE", + "label": "query4 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 4 + ], + "sign": 1 + } + }, + { + "bank": 4, + "kind": "NATIVE", + "label": "query4 target fresh", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 4 + ], + "sign": 1 + } + }, + { + "bank": 5, + "kind": "NATIVE", + "label": "query4 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 4 + ], + "sign": 1 + } + }, + { + "coefficient": "-1", + "dst": 3, + "kind": "ADD", + "label": "query4 pre-continuation fanout", + "src": 1 + }, + { + "coefficient": "-1", + "dst": 4, + "kind": "ADD", + "label": "query4 pre-continuation fanout", + "src": 1 + }, + { + "bank": 1, + "kind": "NATIVE", + "label": "query4 retained source N continuation", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 0 + ], + "sign": 1 + } + }, + { + "coefficient": "1", + "dst": 5, + "kind": "ADD", + "label": "query4 scalar source-retraction exit", + "src": 1 + }, + { + "coefficient": "-1", + "dst": 1, + "kind": "ADD", + "label": "scalar nested response bridge", + "src": 5 + }, + { + "coefficient": "-1", + "dst": 3, + "kind": "ADD", + "label": "query5 scalar source-retraction entrance", + "src": 4 + }, + { + "bank": 4, + "kind": "NATIVE", + "label": "query5 source common", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 0 + ], + "sign": 1 + } + }, + { + "coefficient": "1", + "dst": 5, + "kind": "ADD", + "label": "query5 delivery", + "src": 4 + }, + { + "bank": 4, + "kind": "ADDRESS_OR_UNIT", + "label": "query5 source swap", + "operator": { + "block_permutation": [ + 5, + 1, + 2, + 3, + 4, + 0, + 6, + 7 + ], + "native_arity": 0, + "native_blocks": [], + "sign": 1 + } + }, + { + "bank": 0, + "kind": "NATIVE", + "label": "query5 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 5 + ], + "sign": 1 + } + }, + { + "bank": 1, + "kind": "NATIVE", + "label": "query5 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 5 + ], + "sign": 1 + } + }, + { + "bank": 2, + "kind": "NATIVE", + "label": "query5 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 5 + ], + "sign": 1 + } + }, + { + "bank": 3, + "kind": "NATIVE", + "label": "query5 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 5 + ], + "sign": 1 + } + }, + { + "bank": 5, + "kind": "NATIVE", + "label": "query5 target fresh", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 5 + ], + "sign": 1 + } + }, + { + "coefficient": "1", + "dst": 3, + "kind": "ADD", + "label": "query5 scalar source-retraction exit", + "src": 4 + }, + { + "coefficient": "1", + "dst": 4, + "kind": "ADD", + "label": "scalar nested response bridge", + "src": 0 + }, + { + "coefficient": "1", + "dst": 5, + "kind": "ADD", + "label": "scalar nested response bridge", + "src": 1 + }, + { + "coefficient": "-1", + "dst": 1, + "kind": "ADD", + "label": "scalar nested response bridge", + "src": 5 + }, + { + "banks": [ + 4, + 5 + ], + "kind": "BANK_SWAP", + "label": "nested response permutation" + }, + { + "coefficient": "1", + "dst": 2, + "kind": "ADD", + "label": "query6 scalar source-retraction entrance", + "src": 1 + }, + { + "bank": 1, + "kind": "NATIVE", + "label": "query6 source common", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 0 + ], + "sign": 1 + } + }, + { + "coefficient": "-1", + "dst": 0, + "kind": "ADD", + "label": "query6 entrance fanout from existing source N", + "src": 1 + }, + { + "coefficient": "1", + "dst": 0, + "kind": "ADD", + "label": "query6 delivery", + "src": 1 + }, + { + "bank": 1, + "kind": "ADDRESS_OR_UNIT", + "label": "query6 source swap", + "operator": { + "block_permutation": [ + 6, + 1, + 2, + 3, + 4, + 5, + 0, + 7 + ], + "native_arity": 0, + "native_blocks": [], + "sign": 1 + } + }, + { + "bank": 0, + "kind": "NATIVE", + "label": "query6 target fresh", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 6 + ], + "sign": 1 + } + }, + { + "bank": 2, + "kind": "NATIVE", + "label": "query6 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 6 + ], + "sign": 1 + } + }, + { + "bank": 3, + "kind": "NATIVE", + "label": "query6 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 6 + ], + "sign": 1 + } + }, + { + "bank": 4, + "kind": "NATIVE", + "label": "query6 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 6 + ], + "sign": 1 + } + }, + { + "bank": 5, + "kind": "NATIVE", + "label": "query6 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 6 + ], + "sign": 1 + } + }, + { + "coefficient": "-1", + "dst": 0, + "kind": "ADD", + "label": "query6 pre-continuation fanout", + "src": 1 + }, + { + "bank": 1, + "kind": "NATIVE", + "label": "query6 retained source N continuation", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 0 + ], + "sign": 1 + } + }, + { + "coefficient": "-1", + "dst": 2, + "kind": "ADD", + "label": "query6 scalar source-retraction exit", + "src": 1 + }, + { + "bank": 0, + "kind": "NATIVE", + "label": "query7 source common", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 0 + ], + "sign": 1 + } + }, + { + "coefficient": "-1", + "dst": 2, + "kind": "ADD", + "label": "query7 entrance fanout from existing source N", + "src": 0 + }, + { + "coefficient": "1", + "dst": 1, + "kind": "ADD", + "label": "query7 delivery", + "src": 0 + }, + { + "bank": 0, + "kind": "ADDRESS_OR_UNIT", + "label": "query7 source swap", + "operator": { + "block_permutation": [ + 7, + 1, + 2, + 3, + 4, + 5, + 6, + 0 + ], + "native_arity": 0, + "native_blocks": [], + "sign": 1 + } + }, + { + "bank": 1, + "kind": "NATIVE", + "label": "query7 target fresh", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 7 + ], + "sign": 1 + } + }, + { + "bank": 2, + "kind": "NATIVE", + "label": "query7 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 7 + ], + "sign": 1 + } + }, + { + "bank": 3, + "kind": "NATIVE", + "label": "query7 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 7 + ], + "sign": 1 + } + }, + { + "bank": 4, + "kind": "NATIVE", + "label": "query7 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 7 + ], + "sign": 1 + } + }, + { + "bank": 5, + "kind": "NATIVE", + "label": "query7 inactive fresh progress", + "operator": { + "block_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "native_arity": 2, + "native_blocks": [ + 7 + ], + "sign": 1 + } + }, + { + "banks": [ + 0, + 1 + ], + "kind": "BANK_SWAP", + "label": "nested response permutation" + }, + { + "coefficient": "-1", + "dst": 5, + "kind": "ADD", + "label": "final c-basis change", + "src": 3 + } + ], + "folds": [ + "All pre-N retraction fanouts use the already-paid source N query.", + "At a retained continuation, N(NP)=-P makes every N-valued exit a scalar fanout before the continuation.", + "Final post-N b1 fanout cancels the shared output isolation after the final bank swap." + ], + "histogram": { + "2": 47 + }, + "inverse": "Reverse every physical event; negate ADDs, invert each signed native/ADDRESS operator, reverse swaps. Checked both matrix orders without any initialized field.", + "limits": [ + "This is a six-bank PREFIX. H and L have not been cleared or given the five-factory tail schema.", + "The complete invoice is not the optimistic two-continuation planning case: stages3,4,6 are all explicitly paid.", + "No source exposure sharing or three-stage public touch window is assumed.", + "The exact signed group algebra proves positive identities for every f; it is not a formal-kernel certificate." + ], + "mandatory_nondeferred_touches": { + "0": [ + 5, + 7, + 8, + 9, + 10, + 11, + 17, + 18, + 44, + 48, + 76, + 82, + 83, + 90, + 93, + 94, + 95, + 96, + 102 + ], + "1": [ + 1, + 2, + 3, + 4, + 6, + 10, + 19, + 20, + 21, + 22, + 23, + 24, + 30, + 31, + 32, + 45, + 46, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 61, + 62, + 63, + 64, + 65, + 77, + 78, + 80, + 81, + 82, + 83, + 84, + 90, + 91, + 92, + 95, + 102 + ], + "2": [ + 2, + 7, + 8, + 17, + 18, + 23, + 33, + 34, + 35, + 36, + 42, + 43, + 44, + 47, + 80, + 92, + 94 + ], + "3": [ + 0, + 6, + 19, + 20, + 30, + 32, + 35, + 45, + 46, + 47, + 52, + 61, + 66, + 75, + 103 + ], + "4": [ + 5, + 48, + 53, + 54, + 62, + 66, + 67, + 68, + 69, + 75, + 76, + 79 + ], + "5": [ + 0, + 4, + 21, + 31, + 34, + 42, + 49, + 50, + 64, + 65, + 68, + 77, + 78, + 79, + 103 + ] + }, + "native_rank_mass": 94, + "negative_control": "Wrong pre-continuation fanout sign changes the actual all-column matrix.", + "no_new_kappa": true, + "physical_inverse": [ + [ + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "1" + } + ], + [], + [], + [], + [], + [] + ], + [ + [ + { + "ADDRESS_plane_permutation": [ + 2, + 0, + 1, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 5, + 0, + 1, + 2, + 3, + 4, + 6, + 7 + ], + "N_planes": [ + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 6, + 0, + 1, + 3, + 4, + 5, + 2, + 7 + ], + "N_planes": [ + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 0, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 5, + 0, + 2, + 1, + 3, + 4, + 6, + 7 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 7, + 0, + 1, + 3, + 4, + 5, + 2, + 6 + ], + "N_planes": [ + 2, + 3, + 4, + 5, + 6 + ], + "coefficient": "-1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 2, + 0, + 1, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "-1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 5, + 0, + 1, + 2, + 3, + 4, + 6, + 7 + ], + "N_planes": [ + 3, + 4, + 6, + 7 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 5, + 0, + 2, + 1, + 3, + 4, + 6, + 7 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 6, + 7 + ], + "coefficient": "1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 4, + 0, + 1, + 2, + 3, + 5, + 6, + 7 + ], + "N_planes": [ + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 0, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 4, + 0, + 2, + 1, + 3, + 5, + 6, + 7 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 5, + 0, + 1, + 2, + 3, + 4, + 6, + 7 + ], + "N_planes": [ + 3, + 4, + 6, + 7 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 5, + 0, + 2, + 1, + 3, + 4, + 6, + 7 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 6, + 7 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 3, + 0, + 1, + 2, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 3, + 0, + 2, + 1, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "-1" + } + ] + ], + [ + [], + [], + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "1" + } + ], + [], + [], + [] + ], + [ + [ + { + "ADDRESS_plane_permutation": [ + 2, + 0, + 1, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 5, + 0, + 1, + 2, + 3, + 4, + 6, + 7 + ], + "N_planes": [ + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 2, + 1, + 0, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 0, + 1, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 5, + 1, + 0, + 2, + 3, + 4, + 6, + 7 + ], + "N_planes": [ + 0, + 1, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 6, + 0, + 1, + 3, + 4, + 5, + 2, + 7 + ], + "N_planes": [ + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 0, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 5, + 0, + 2, + 1, + 3, + 4, + 6, + 7 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 6, + 1, + 0, + 3, + 4, + 5, + 2, + 7 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "-1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 7, + 0, + 1, + 3, + 4, + 5, + 2, + 6 + ], + "N_planes": [ + 2, + 3, + 4, + 5, + 6 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 7, + 1, + 0, + 3, + 4, + 5, + 2, + 6 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6 + ], + "coefficient": "-1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 2, + 0, + 1, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 2, + 1, + 0, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 0, + 1, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "-1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 5, + 0, + 1, + 2, + 3, + 4, + 6, + 7 + ], + "N_planes": [ + 3, + 4, + 6, + 7 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 5, + 1, + 0, + 2, + 3, + 4, + 6, + 7 + ], + "N_planes": [ + 0, + 1, + 3, + 4, + 6, + 7 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 5, + 0, + 2, + 1, + 3, + 4, + 6, + 7 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 6, + 7 + ], + "coefficient": "1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 4, + 0, + 1, + 2, + 3, + 5, + 6, + 7 + ], + "N_planes": [ + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 4, + 1, + 0, + 2, + 3, + 5, + 6, + 7 + ], + "N_planes": [ + 0, + 1, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 0, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 4, + 0, + 2, + 1, + 3, + 5, + 6, + 7 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 5, + 0, + 1, + 2, + 3, + 4, + 6, + 7 + ], + "N_planes": [ + 3, + 4, + 6, + 7 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 5, + 1, + 0, + 2, + 3, + 4, + 6, + 7 + ], + "N_planes": [ + 0, + 1, + 3, + 4, + 6, + 7 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 5, + 0, + 2, + 1, + 3, + 4, + 6, + 7 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 6, + 7 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 3, + 0, + 1, + 2, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 3, + 1, + 0, + 2, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 0, + 1, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 3, + 0, + 2, + 1, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "-1" + } + ] + ], + [ + [], + [], + [], + [], + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "1" + } + ], + [] + ], + [ + [], + [], + [], + [], + [], + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "1" + } + ] + ] + ], + "physical_matrix": [ + [ + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "1" + } + ], + [], + [], + [], + [], + [] + ], + [ + [ + { + "ADDRESS_plane_permutation": [ + 1, + 6, + 2, + 3, + 4, + 5, + 7, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 7 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 6, + 1, + 2, + 3, + 4, + 5, + 7, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 7 + ], + "coefficient": "3" + }, + { + "ADDRESS_plane_permutation": [ + 2, + 1, + 6, + 3, + 4, + 5, + 7, + 0 + ], + "N_planes": [ + 1, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 7, + 1, + 2, + 3, + 4, + 5, + 6, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 1, + 6, + 2, + 3, + 4, + 5, + 7, + 0 + ], + "N_planes": [ + 2, + 3, + 4, + 5, + 7 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 2, + 1, + 6, + 3, + 4, + 5, + 7, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 6, + 1, + 2, + 3, + 4, + 5, + 7, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 1, + 6, + 2, + 3, + 4, + 5, + 7, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 7 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 6, + 1, + 2, + 3, + 4, + 5, + 7, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 7 + ], + "coefficient": "2" + }, + { + "ADDRESS_plane_permutation": [ + 2, + 1, + 6, + 3, + 4, + 5, + 7, + 0 + ], + "N_planes": [ + 1, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "-1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 2, + 1, + 6, + 3, + 4, + 5, + 7, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 6, + 1, + 2, + 3, + 4, + 5, + 7, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "-1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 1, + 6, + 2, + 3, + 4, + 5, + 7, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 7 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 6, + 1, + 2, + 3, + 4, + 5, + 7, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 7 + ], + "coefficient": "2" + }, + { + "ADDRESS_plane_permutation": [ + 2, + 1, + 6, + 3, + 4, + 5, + 7, + 0 + ], + "N_planes": [ + 1, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "-1" + } + ], + [] + ], + [ + [], + [], + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "1" + } + ], + [], + [], + [] + ], + [ + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 3, + 2, + 4, + 5, + 0, + 6, + 7 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 3, + 1, + 2, + 4, + 5, + 0, + 6, + 7 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "2" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 3, + 1, + 2, + 4, + 5, + 0, + 6, + 7 + ], + "N_planes": [ + 1, + 2, + 4, + 5, + 6, + 7 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 3, + 2, + 4, + 5, + 0, + 6, + 7 + ], + "N_planes": [ + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 1, + 3, + 2, + 4, + 5, + 0, + 6, + 7 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 3, + 1, + 2, + 4, + 5, + 0, + 6, + 7 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 3, + 1, + 2, + 4, + 5, + 0, + 6, + 7 + ], + "N_planes": [ + 1, + 2, + 4, + 5, + 6, + 7 + ], + "coefficient": "1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 1, + 3, + 2, + 4, + 5, + 0, + 6, + 7 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 3, + 1, + 2, + 4, + 5, + 0, + 6, + 7 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "2" + }, + { + "ADDRESS_plane_permutation": [ + 5, + 1, + 2, + 3, + 4, + 0, + 6, + 7 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 4, + 1, + 2, + 3, + 5, + 0, + 6, + 7 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "-1" + } + ] + ], + [ + [], + [], + [], + [], + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "1" + } + ], + [] + ], + [ + [], + [], + [], + [], + [], + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "coefficient": "1" + } + ] + ] + ], + "pivot_H": [ + [ + [ + { + "coefficient": "1", + "word": [ + "P7", + "P6" + ] + }, + { + "coefficient": "1", + "word": [ + "P7", + "P6", + "N", + "P1", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "P7", + "P6", + "P2" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P7", + "P6" + ] + }, + { + "coefficient": "1", + "word": [ + "P7", + "P6", + "P2" + ] + } + ] + ], + [ + [ + { + "coefficient": "1", + "word": [ + "P5", + "P4", + "P3", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "P5", + "P4", + "P3", + "P1", + "N" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P5", + "P4", + "P3", + "N" + ] + } + ] + ] + ], + "pivot_rows": [ + 1, + 3 + ], + "producer_sha256": "1719e560816ffa9e5193f6275c44c688fa280bede36a11c307f61783eb995bf0", + "public_L": [ + [ + [ + { + "coefficient": "1", + "word": [ + "P7" + ] + }, + { + "coefficient": "-3", + "word": [ + "P7", + "P6", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P7", + "P6", + "N", + "P1" + ] + }, + { + "coefficient": "1", + "word": [ + "P7", + "P6", + "P2", + "N" + ] + } + ], + [ + { + "coefficient": "-2", + "word": [ + "P7", + "P6", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P7", + "P6", + "N", + "P1" + ] + }, + { + "coefficient": "1", + "word": [ + "P7", + "P6", + "P2", + "N" + ] + } + ], + [ + { + "coefficient": "-2", + "word": [ + "P7", + "P6", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P7", + "P6", + "N", + "P1" + ] + }, + { + "coefficient": "1", + "word": [ + "P7", + "P6", + "P2", + "N" + ] + } + ], + [] + ], + [ + [ + { + "coefficient": "1", + "word": [] + }, + { + "coefficient": "2", + "word": [ + "P5", + "P4", + "P3" + ] + }, + { + "coefficient": "-1", + "word": [ + "P5", + "P4", + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P5", + "P4", + "P3" + ] + }, + { + "coefficient": "-1", + "word": [ + "P5", + "P4", + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P5" + ] + }, + { + "coefficient": "2", + "word": [ + "P5", + "P4", + "P3" + ] + }, + { + "coefficient": "-1", + "word": [ + "P5", + "P4", + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "P5", + "P4" + ] + } + ] + ] + ], + "public_banks_including_pivots": 6, + "public_rows": [ + 0, + 2, + 4, + 5 + ], + "query_count": 7, + "scientific_pin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "shared_input_N_calls": 2, + "source_continuation_count": 3, + "source_pins": [ + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/caller/nested_prefix.py", + "sha256": "9ec10cb0243c0c829475ad7290f4953cdff27cb0f90f70b687c4bbee98af676b" + }, + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/caller/free_ops.py", + "sha256": "5806fe91b9fda162d5986b12e085b14eb3df9a4703f749f61c1f10363138ca77" + }, + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/caller/plane_group.py", + "sha256": "0c54c2e2462390bd0e9a8d47fc765b70e168ced1e0ef5de49e0afed653e26feb" + } + ], + "source_retractions": [ + { + "continued": false, + "dst": 1, + "source_code": "P1", + "src": 0, + "stage": 1, + "u": [ + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ] + }, + { + "continued": false, + "dst": 2, + "source_code": "P2", + "src": 1, + "stage": 2, + "u": [ + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ] + ] + }, + { + "continued": true, + "dst": 3, + "source_code": "N P3", + "src": 2, + "stage": 3, + "u": [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "-1" + ] + ] + }, + { + "continued": true, + "dst": 4, + "source_code": "N P4", + "src": 1, + "stage": 4, + "u": [ + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "1" + ], + [ + "0", + "1" + ], + [ + "1", + "0" + ] + ] + }, + { + "continued": false, + "dst": 5, + "source_code": "P5", + "src": 4, + "stage": 5, + "u": [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ] + ] + }, + { + "continued": true, + "dst": 0, + "source_code": "N P6", + "src": 1, + "stage": 6, + "u": [ + [ + "0", + "1" + ], + [ + "1", + "0" + ], + [ + "-1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ] + }, + { + "continued": false, + "dst": 1, + "source_code": "P7", + "src": 0, + "stage": 7, + "u": [ + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "1" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ] + } + ], + "source_sequence": [ + 0, + 1, + 2, + 1, + 4, + 1, + 0 + ], + "status": "PASS_EXACT_NESTED_SIX_BANK_PREFIX_FOUR_PUBLIC_TWO_PIVOTS", + "stock_if_pivots_finish": 96, + "target_sequence": [ + 1, + 2, + 3, + 4, + 5, + 0, + 1 + ] +} diff --git a/research/marked-residual-reflection/source/caller/PIVOT-PLANE-PROBE.json b/research/marked-residual-reflection/source/caller/PIVOT-PLANE-PROBE.json new file mode 100644 index 0000000000..9f5bfe890e --- /dev/null +++ b/research/marked-residual-reflection/source/caller/PIVOT-PLANE-PROBE.json @@ -0,0 +1,13 @@ +{ + "candidate_pairs": 729, + "dimension_failures": 0, + "native_invoice_if_admitted": "Same five raw carriers plus full global fresh progress; constant bank GL source changes only. Any N-dependent initial plane encoder and terminal correction remain paid/open.", + "scope": "Old n4 five-shear ideal topology only; arbitrary real source-retraction columns allowed at later queries. Source-code algebra, native encoder and actual correction are not inferred.", + "solutions": [], + "source_tail_alphabet": [ + -1, + 0, + 1 + ], + "status": "BOUNDED_EXACT_SOURCE_RETRACTION_SCREEN" +} diff --git a/research/marked-residual-reflection/source/caller/free_ops.py b/research/marked-residual-reflection/source/caller/free_ops.py new file mode 100644 index 0000000000..327bcb37aa --- /dev/null +++ b/research/marked-residual-reflection/source/caller/free_ops.py @@ -0,0 +1,108 @@ +"""Exact free operators N^2=-I and arbitrary invertible noncommuting P_j. + +Apache-2.0; substantial OpenAI Codex assistance. Derived from this lane's +frozen coded caller verifier; no native admission is inferred here. +""" +from fractions import Fraction + + +def need(x, why): + if not x: + raise ValueError(why) + + +def reduce_word(w): + a, sign = [], 1 + for x in w: + if a and x == a[-1] == 0: + a.pop() + sign = -sign + elif a and x != 0 and x == -a[-1]: + a.pop() + else: + a.append(x) + return tuple(a), sign + + +def mono(w=(), c=1): + w, sign = reduce_word(w) + return {w: Fraction(c) * sign} if c else {} + + +Z, I, N = {}, mono(), mono((0,)) + + +def add(a, b): + c = dict(a) + for w, v in b.items(): + c[w] = c.get(w, 0) + v + if not c[w]: + del c[w] + return c + + +def neg(a): + return {w: -v for w, v in a.items()} + + +def mul(a, b): + c = {} + for w, x in a.items(): + for v, y in b.items(): + c = add(c, mono(w + v, x * y)) + return c + + +def prod(*args): + a = I + for b in args: + a = mul(a, b) + return a + + +def inv(a): + need(len(a) == 1, 'invert one literal word') + (w, c), = a.items() + b = mono((), 1 / c) + for x in reversed(w): + b = mul(b, neg(N) if x == 0 else mono((-x,))) + need(mul(a, b) == mul(b, a) == I, 'literal phase inverse') + return b + + +def summ(args): + a = Z + for b in args: + a = add(a, b) + return a + + +def eye(n): + return [[I if i == j else Z for j in range(n)] for i in range(n)] + + +def mm(a, b): + return [[summ(mul(x, y) for x, y in zip(r, c)) for c in zip(*b)] for r in a] + + +def es(n, dst, src, coefficient): + a = eye(n) + a[dst][src] = add(a[dst][src], coefficient) + return a + + +def unary(n, b, coefficient): + a = eye(n) + a[b][b] = coefficient + return a + + +def serial(a): + return [{'coefficient': str(c), + 'word': ['N' if x == 0 else 'P' + str(abs(x)) + ('^-1' if x < 0 else '') for x in w]} + for w, c in sorted(a.items())] + + +def sm(a): + return [[serial(x) for x in r] for r in a] + diff --git a/research/marked-residual-reflection/source/caller/handoff_family.py b/research/marked-residual-reflection/source/caller/handoff_family.py new file mode 100644 index 0000000000..ddfa5041b9 --- /dev/null +++ b/research/marked-residual-reflection/source/caller/handoff_family.py @@ -0,0 +1,196 @@ +#!/usr/bin/env python3 +"""All-pair source handoffs with one continuation per nonfinal pair. + +The two terminal carrier words are retained exactly. This is a prefix, +not a claim that their native cleanup has bounded cost. +Apache-2.0; substantial OpenAI Codex assistance. +""" +from pathlib import Path +from fractions import Fraction +from collections import Counter +import argparse, hashlib, json, sys +sys.dont_write_bytecode=True +import free_ops as F +from plane_group import Algebra +from nested_prefix import skeleton +from nested_family import retraction, ec +HERE=Path(__file__).resolve().parent + + +def build(q,physical=False): + F.need(q>=2,'handoff family starts with two new pairs') + n,k=2*q+2,2*q+1 + A=Algebra(k+1)if physical else None + I=A.I if physical else F.I + Z=A.Z if physical else F.Z + eye=A.eye if physical else F.eye + mm=A.mm if physical else F.mm + inv=A.inv if physical else F.inv + es=A.es if physical else F.es + mul=A.mul if physical else F.mul + N=A.n(0)if physical else F.N + M=eye(n);Mi=eye(n);events=[];stage=0 + def app(B,Bi,e): + nonlocal M,Mi + F.need(mm(B,Bi)==mm(Bi,B)==eye(n),'every literal event has its full inverse') + M=mm(B,M);Mi=mm(Mi,Bi);events.append(e) + def add(d,s,c,label): + if not c:return + op=A.mono(coefficient=c)if physical else F.mono((),c) + nop=A.mono(coefficient=-c)if physical else F.mono((),-c) + app(es(n,d,s,op),es(n,d,s,nop),{'kind':'ADD','dst':d,'src':s,'coefficient':str(c),'label':label}) + def opadd(d,s,c,label): + F.need(not physical,'operator ADD belongs only to the retarded formal proof') + app(es(n,d,s,c),es(n,d,s,F.neg(c)),{'kind':'FORMAL_ADD','dst':d,'src':s,'label':label}) + def unary(b,g,label,native=False): + B=eye(n);Bi=eye(n);B[b][b]=g;Bi[b][b]=inv(g) + if physical: + ((bits,p),c),=g.items() + op={'sign':int(c),'native_blocks':[j for j in range(k+1)if bits>>j&1], + 'block_permutation':list(p),'native_arity':A.native_arity(g)} + e={'kind':'NATIVE'if native else'ADDRESS_OR_UNIT','bank':b,'operator':op,'label':label} + else:e={'kind':'FORMAL_UNARY','bank':b,'operator':F.serial(g),'label':label} + app(B,Bi,e) + def swap(b,c,label): + B=eye(n);B[b],B[c]=B[c],B[b] + app(B,B,{'kind':'BANK_SWAP','banks':[b,c],'label':label}) + def progress(src,s,dst=None): + if physical: + for b in range(n): + if b!=src:unary(b,A.n(s),f'query{s} target fresh'if b==dst else f'query{s} inactive fresh progress',True) + # Initial direct prefix through the scalar entrance of query4. Its + # three source retractions are the independently pinned direct ones. + for r in range(2,q+1):add(2*r+1,3,1,'raw c-basis') + if physical: + unary(1,N,'shared input N exposure',True);add(2,1,1,'shared input fanout');unary(1,inv(N),'shared input N inverse',True) + _,ops=skeleton(q,[1]+[0]*(q-1)) + for typ,d,s,z in ops: + if typ=='a': + if physical: + if z[1]: + F.need(stage==0 and d==2 and s==1 and z[1]==1,'shared input is the only early N ADD') + else:add(d,s,z[0],'initial nested scalar bridge') + else:opadd(d,s,ec(z),'initial nested bridge') + elif typ=='s':swap(d,s,'initial nested permutation') + else: + stage+=1;u=retraction(q,stage) + if stage==4: + for b,(aa,bb)in enumerate(u): + if b!=s:add(b,s,-aa,'query4 scalar source entrance') + break + if physical: + for b,(aa,bb)in enumerate(u): + if b!=s:add(b,s,-aa,f'query{stage} scalar entrance') + unary(s,N,f'query{stage} source common',True) + for b,(aa,bb)in enumerate(u): + if b!=s:add(b,s,-bb,f'query{stage} source fanout') + add(d,s,1,f'query{stage} delivery') + unary(s,A.swap(0,stage),f'query{stage} source swap') + progress(s,stage,d) + if stage==3: + for b,(aa,bb)in enumerate(u): + if b!=s:add(b,s,-bb,'query3 pre-continuation fanout') + unary(s,N,'query3 retained source continuation',True) + for b,(aa,bb)in enumerate(u): + if b!=s:add(b,s,aa,f'query{stage} scalar exit') + else: + for b,z in enumerate(u): + if b!=s:opadd(b,s,F.neg(ec(z)),f'query{stage} source entrance') + P=F.mono((stage,));P=F.mul(N,P)if stage==3 else P + opadd(d,s,N,f'query{stage} cross');unary(s,P,f'query{stage} source code') + for b,z in enumerate(u): + if b!=s:opadd(b,s,ec(z),f'query{stage} source exit') + # The deeper response entrances left future raw b fields on a. + # Remove them before using a as the independent raw public input. + for r in range(3,q+1):add(0,2*r,-1,'restore raw a from deeper response entrance') + # Hold N*u without the raw A_r part. All its input fields are kept. + add(3,0,-1,'held source subtract raw a') + for r in range(2,q+1):add(3,2*r,-1,'held source subtract future raw b') + for r in range(2,q+1): + even,odd=2*r,2*r+1;b=2*r;c=2*r+1 + unary(1,N,f'query{even} source common',physical) + add(1,3,-1,f'query{even} isolate raw c difference') + swap(1,3,f'query{even} source handoff') + if physical:unary(1,A.swap(0,even),f'query{even} source swap') + else:unary(1,F.prod(F.mono((even,)),inv(N)),f'query{even} retarded source post') + progress(1,even,3) + swap(3,c,f'query{even} move finished c difference') + unary(b,N,f'query{odd} source common',physical) + for ell in range(r+1,q+1):add(2*ell+1,b,1,f'query{odd} future c first fanout') + add(3,b,1,f'query{odd} delivery') + swap(b,3,f'query{odd} source handoff') + add(2,b,-1,f'query{odd} finish current b accumulator') + for ell in range(r+1,q+1):add(2*ell+1,b,-1,f'query{odd} restore future raw c differences') + if physical:unary(b,A.swap(0,odd),f'query{odd} source swap') + else:unary(b,F.prod(F.mono((odd,)),inv(N)),f'query{odd} retarded source post') + progress(b,odd,3) + if rr; A_r=a+sum_(l>=r)b_l', + 'two_handoff_exit':'U=P_even*u; V=P_odd*(N*v-A_next); public b_r=N*b_rraw, c_r=N*delta C_r; b1=N*(b1raw+A_next)', + 'next_pair_encoder':'b1+=U; later c_l-=next raw delta C and +=U; swap t with next c; t+=V; continue source N; u_next=V, v_next=-U-N*A_next', + 'continuations':'Only query3 and odd handoffs before the last pair: q-1 total.', + 'literal_cost':'k=2q+1, n=2q+2, m=4q+4, H2=n*k+q+2 (two input exposures and one final common query included), D_before_tail=2q.'}, + 'limits':['Two raw terminal carriers retain every source swap and every public reader. Their cleanup is not included.', + 'The native cost or moment of the terminal carrier factories is not asserted bounded.', + 'The finite all-column checks q2..4 are separate from the written all-pair invariant and are not a formal-kernel proof.'], + 'source_pins':[{'path':str(HERE/p),'sha256':hashlib.sha256((HERE/p).read_bytes()).hexdigest()}for p in('nested_family.py','nested_prefix.py','free_ops.py','plane_group.py')], + 'no_new_kappa':True} + + +def main(): + ap=argparse.ArgumentParser(description=__doc__);ap.add_argument('--write',action='store_true');args=ap.parse_args() + out=prove();out['producer_sha256']=hashlib.sha256(Path(__file__).read_bytes()).hexdigest();out=json.loads(json.dumps(out));p=HERE/'HANDOFF-FAMILY.json' + if args.write:p.write_text(json.dumps(out,indent=2,sort_keys=True)+'\n') + else:F.need(json.loads(p.read_text())==out,'saved handoff family receipt differs') + print(out['status']) +if __name__=='__main__':main() diff --git a/research/marked-residual-reflection/source/caller/nested_family.py b/research/marked-residual-reflection/source/caller/nested_family.py new file mode 100644 index 0000000000..76e5827c61 --- /dev/null +++ b/research/marked-residual-reflection/source/caller/nested_family.py @@ -0,0 +1,181 @@ +#!/usr/bin/env python3 +"""Explicit nested source-retraction family and its one-coordinate cocycle. + +The native implementation still pays 2q-1 continuations. Algebraic +telescoping alone is not permission to remove these queries. +Apache-2.0; substantial OpenAI Codex assistance. +""" +from pathlib import Path +import argparse +import hashlib +import json +import sys +sys.dont_write_bytecode=True +from fractions import Fraction +import free_ops as F +from nested_prefix import skeleton, prefixes, Z, I, N, add, neg, mul, mm + +HERE=Path(__file__).resolve().parent + + +def ec(z):return F.add(F.mono((),z[0]),F.mono((0,),z[1])) + + +def retraction(q,s): + n=2*q+2;u=[Z]*n + if s==1: + u[0]=I;u[2]=I + elif s==2: + u[1]=I + for r in range(1,q+1):u[2*r+1]=I + elif s==2*q+2: + u[1]=I;u[0]=N;u[2]=neg(I) + elif s==2*q+3: + u[0]=I;u[2]=N + elif s%2: + r=(s-1)//2;u[2*r]=I + for j in range(1,r):u[2*j+1]=I + for j in range(r+1,q+1):u[2*j+1]=neg(N) + else: + r=(s-2)//2;u[1]=I;u[2*(r+1)]=N + for j in range(1,r+1):u[2*j+1]=N + for j in range(r+1,q+1):u[2*j+1]=I + return u + + +def coordinates(q,s): + if s==1:return(neg(N),neg(N)),(N,Z) + if s==2:return(neg(I),Z),(neg(I),I) + if s==2*q+2:return(I,Z),(I,Z) + if s==2*q+3:return(neg(N),Z),(N,Z) + if s%2:return(Z,neg(N)),(Z,N) + return(Z,I),(Z,I) + + +def continued(q,s): + return (3<=s<=2*q and s!=2)or s==2*q+2 + + +def formal(q): + n,ops=skeleton(q,[1]+[0]*(q-1));M=F.eye(n);Mi=F.eye(n);s=0;sources=[] + def app(A,Ai): + nonlocal M,Mi + F.need(F.mm(A,Ai)==F.mm(Ai,A)==F.eye(n),'each event has its full inverse') + M=F.mm(A,M);Mi=F.mm(Mi,Ai) + def a(d,src,c):app(F.es(n,d,src,c),F.es(n,d,src,F.neg(c))) + for r in range(2,q+1):a(2*r+1,3,F.I) + for typ,d,src,z in ops: + if typ=='a':a(d,src,ec(z)) + elif typ=='s': + B=F.eye(n);B[d],B[src]=B[src],B[d];app(B,B) + else: + s+=1;u=retraction(q,s) + F.need(u[src]==I,'source normalization') + for j,z in enumerate(u): + if j!=src and z!=Z:a(j,src,F.neg(ec(z))) + P=F.mono((s,));P=F.mul(F.N,P)if continued(q,s)else P + A=F.mm(F.unary(n,src,P),F.es(n,d,src,F.N)) + Ai=F.mm(F.es(n,d,src,F.neg(F.N)),F.unary(n,src,F.inv(P))) + app(A,Ai) + for j,z in enumerate(u): + if j!=src and z!=Z:a(j,src,ec(z)) + sources.append({'stage':s,'src':src,'dst':d,'u':[[str(a),str(b)]for a,b in u], + 'source_code':('N P'if continued(q,s)else'P')+str(s)}) + for r in range(2,q+1):a(2*r+1,3,F.neg(F.I)) + F.need(F.mm(M,Mi)==F.mm(Mi,M)==F.eye(n),'all-column literal inverse in both orders') + public=[i for i in range(n)if i not in(1,3)] + F.need(all(M[i]==[F.N if j==i else F.Z for j in range(n)]for i in public), + 'all n-2 public outputs are exactly N times independent inputs') + H=[[M[i][j]for j in(1,3)]for i in(1,3)];L=[[M[i][j]for j in public]for i in(1,3)] + P={j:F.mono((j,))for j in range(1,2*q+4)} + A3=F.prod(*(P[j]for j in range(2*q+1,2,-1))) + if(q-1)%2:A3=F.neg(A3) + Q1=F.prod(F.inv(F.N),P[1],F.N) + J=[[F.add(F.add(P[2],Q1),F.neg(F.I)),F.add(F.I,F.neg(P[2]))], + [F.add(Q1,F.neg(F.I)),F.I]] + D=[[F.neg(F.mul(P[2*q+3],P[2*q+2])),F.Z],[F.Z,F.mul(A3,F.N)]] + F.need(H==F.mm(D,J),'five-factory H factor for the explicit family') + # Independently rebuild H using only the two-dimensional source-coordinate updates. + B=F.eye(2) + for s in range(1,2*q+4): + w,r=coordinates(q,s);w=list(map(ec,w));r=list(map(ec,r)) + Ptilde=F.mul(F.N,P[s])if continued(q,s)else P[s] + T=[[F.add(F.I if i==j else F.Z,F.prod(w[i],F.add(Ptilde,F.neg(F.I)),r[j]))for j in range(2)]for i in range(2)] + B=F.mm(T,B) + F.need(H==[[F.mul(F.N,x)for x in row]for row in B], + 'two-coordinate update proof independently reconstructs H') + return {'q':q,'banks':n,'raw_calls':2*q+3,'public_rows':public,'pivot_rows':[1,3], + 'source_retractions':sources,'complete_matrix':F.sm(M),'complete_inverse':F.sm(Mi), + 'H':F.sm(H),'L':F.sm(L),'D':F.sm(D),'J':F.sm(J),'A3':F.serial(A3), + 'continuations':[s for s in range(1,2*q+4)if continued(q,s)], + 'separate_progress_profile':{'H2':n*(2*q+3)+2*q+1,'ambient':4*q+8, + 'rank_deficit_before_tail':2}} + + +def prefix_coordinates(q): + n=2*q+2;_,pre=prefixes(q,[1]+[0]*(q-1)) + V=[[I if i==1 else Z,I if i>=3 and i%2 else Z]for i in range(n)] + for s,(M,src,dst)in enumerate(pre,1): + B=mm(M,V);w,r=coordinates(q,s) + F.need([add(mul(row[0],w[0]),mul(row[1],w[1]))for row in B]==retraction(q,s), + 'displayed normalized source column lies in the transported fixed plane') + F.need(tuple(B[src])==r,'displayed source functional on both pivot coordinates') + + +def cocycle(): + # Columns(z,A,c,d,b) are independent fields. Po and Pe do not commute. + ZR=[F.I,F.Z,F.Z,F.Z,F.Z];AR=[F.Z,F.I,F.Z,F.Z,F.Z] + CR=[F.Z,F.Z,F.I,F.Z,F.Z];DR=[F.Z,F.Z,F.Z,F.I,F.Z];BR=[F.Z,F.Z,F.Z,F.Z,F.I] + def plus(*rows):return[F.summ(row[j]for row in rows)for j in range(5)] + def left(a,row):return[F.mul(a,x)for x in row] + Po,Pe=F.mono((1,)),F.mono((2,)) + y=plus(left(F.N,ZR),left(F.neg(F.I),AR),left(F.N,CR)) + fodd=plus(left(F.neg(F.I),AR),left(F.N,CR)) + zodd=plus(left(F.mul(Po,F.N),ZR),left(F.add(Po,F.N),fodd)) + even_source=plus(zodd,left(F.N,AR),DR) + F.need(even_source==plus(left(Po,y),DR,left(F.neg(F.I),CR)), + 'next source is the old source through one ADDRESS plus the raw c difference') + feven=plus(left(F.N,AR),DR) + zeven=plus(left(F.mul(F.N,Pe),zodd),left(F.add(F.mul(F.N,Pe),F.neg(F.I)),feven)) + ynext=plus(left(F.N,zeven),left(F.N,DR),left(F.neg(F.I),AR),BR) + rhs=plus(left(F.neg(F.mul(Pe,Po)),y),BR,left(Pe,CR),left(F.neg(Pe),DR)) + F.need(ynext==rhs,'middle two-call affine ADDRESS cocycle on every independent public/pivot column') + return {'source_y':'y_r=N z-A_r+N c_r, A_r=a+sum_(l>r)b_l; c1 means zero public reader', + 'next_even_source':'P_o y_r+c_(r+1)-c_r', + 'next_y':'-P_e P_o y_r+b_(r+1)+P_e(c_r-c_(r+1))', + 'independent_columns':['z','A_r','c_r','c_(r+1)','b_(r+1)'], + 'covered_domain':'Arbitrary independent invertible noncommuting Po,Pe; N^2=-I; literal affine operator identity.', + 'not_native_admission':'The virtual coordinate is a literal source at the odd cut. Holding its chart through the even cut still requires an explicit invertible bank encoder, all public readers at actual frames, and restoration of the other independent dirty field.'} + + +def prove(): + for q in range(1,9):prefix_coordinates(q) + fixtures=[formal(q)for q in(1,2,3,4)] + from nested_six import formal_word + M,Mi,_,_,_=formal_word() + F.need(fixtures[1]['complete_matrix']==F.sm(M)and fixtures[1]['complete_inverse']==F.sm(Mi), + 'q2 direct family agrees exactly with independently compiled NESTED-SIX') + return {'status':'PASS_EXPLICIT_NESTED_SOURCE_FAMILY_AND_ONE_COORDINATE_AFFINE_COCYCLE', + 'scientific_pin':'20ecf2891d80b5acf18d980b2164fb44ea7faa90','fixtures':fixtures,'affine_cocycle':cocycle(), + 'all_parameter_proof':'The ideal nested response skeleton gives N on every field after its output isolation. Its two transported pivot columns obey the displayed source-functional/retraction table. Conjugated source-code insertions therefore act by 2x2 updates I+w(Ptilde-I)r. The first two updates multiply to J(P2,Q1); all middle updates are on only the second coordinate and telescope to Ad_(N^-1)(A3), A3=(-1)^(q-1)P_(2q+1)...P3; the last two updates give the first diagonal factor. Left multiplication by the ideal final N yields H=diag(-P_last P_penult,A3 N)J. No source code or public coupling is discarded.', + 'initial_basis':'At raw ZERO, c_r+=c1 for r>=2. One common N/N^-1 exposure fanouts b1+=N*t only. The inverse c-basis is applied after the last query; its other public rows are retained.', + 'finite_checks':'Every free-operator matrix column and both inverse orders for q1..4. Exact transported-plane/source-functional table for q1..8. q2 entire matrix agrees with NESTED-SIX.', + 'native_invoice':'With the current literal compiler c=2q-1 retained N continuations, two shared input N calls and all separate fresh progress: H2=(2q+2)(2q+3)+2q+1, m=4q+8, n=2q+2, D_before_tail=2. Wide batching changes moment pressure, not this mass. No amortized query removal is asserted.', + 'limits':['H has a bounded five-factory form, but the complete L readers and their native cuts remain part of the contract.', + 'The affine ADDRESS cocycle is an algebraic grouping target, not an implemented shared-native controller.', + 'The finite checks and written all-parameter recurrence are not a formal-kernel proof.'], + 'source_pins':[{'path':str(HERE/p),'sha256':hashlib.sha256((HERE/p).read_bytes()).hexdigest()} + for p in('nested_prefix.py','nested_six.py','NESTED-SIX.json','free_ops.py')], + 'no_new_kappa':True} + + +def main(): + ap=argparse.ArgumentParser(description=__doc__);ap.add_argument('--write',action='store_true');args=ap.parse_args() + out=prove();out['producer_sha256']=hashlib.sha256(Path(__file__).read_bytes()).hexdigest();path=HERE/'NESTED-FAMILY.json' + out=json.loads(json.dumps(out)) + if args.write:path.write_text(json.dumps(out,indent=2,sort_keys=True)+'\n') + else:F.need(json.loads(path.read_text())==out,'saved nested-family receipt differs') + print(out['status']) + + +if __name__=='__main__':main() diff --git a/research/marked-residual-reflection/source/caller/nested_prefix.py b/research/marked-residual-reflection/source/caller/nested_prefix.py new file mode 100644 index 0000000000..d7e424e224 --- /dev/null +++ b/research/marked-residual-reflection/source/caller/nested_prefix.py @@ -0,0 +1,113 @@ +"""Exact ideal prefixes for nested three-response replacements. + +This is a construction helper, not a native admission or a receipt. +Apache-2.0; substantial OpenAI Codex assistance. +""" +from fractions import Fraction as F +from itertools import combinations +from pivot_plane_probe import Z, I, N, add, neg, mul, inv, eye, mm, es, null, summ + + +def skeleton(q, betas=None): + n = 2*q+2 + out = [] + def a(d,s,c=I): out.append(('a',d,s,c)) + def query(d,s,depth): + if depth == 0: + out.append(('q',d,s,N)) + return + b,c = 2*depth, 2*depth+1 + a(c,d,neg(I));a(s,b) + query(d,s,depth-1) + a(s,b,neg(I));a(d,c) + out.append(('q',b,d,N)) + a(d,c,neg(I)) + out.append(('q',c,b,N)) + a(b,s);a(c,d);a(d,c,neg(I)) + out.append(('s',b,c,I)) + # All independent incoming b fields use the same paid input exposure. + betas=[F(1)]*q if betas is None else list(map(F,betas)) + for j in range(1,q+1):a(2*j,1,(F(0),betas[j-1])) + query(1,0,q) + out.append(('q',0,1,N));out.append(('q',1,0,N)) + out.append(('s',0,1,I)) + for j in range(1,q+1):a(2*j,1,(F(0),-betas[j-1])) + return n,out + + +def prefixes(q,betas=None): + n,ops=skeleton(q,betas) + M=eye(n);out=[] + for typ,d,s,c in ops: + if typ=='s': + M=[list(row) for row in M] + M[d],M[s]=M[s],M[d] + else: + M=mm(es(n,d,s,c),M) + if typ=='q':out.append((M,s,d)) + target=[[N if i==j else Z for j in range(n)]for i in range(n)] + if M!=target:raise ValueError('nested ideal skeleton not full N') + return ops,out + + +def rref_null(A): + return null(A) + + +def source_choice(B,src,prefer_real=True): + """Choose E-column coefficients with source1, minimizing N-row support. + + B has two E-columns. The search is only the finitely many possible + active constraints of its at-most-two-dimensional affine solution. + """ + n=len(B) + # c_j=a_j+N*b_j. Source normalization is exact (real1,N0). + realrows=[];imagrows=[] + for row in B: + realrows.append([z for x in row for z in (x[0],-x[1])]) + imagrows.append([z for x in row for z in (x[1],x[0])]) + def solve(A,b): + m=len(A);k=4;A=[list(row)+[rhs]for row,rhs in zip(A,b)];r=0;p=[] + for j in range(k): + h=next((h for h in range(r,m)if A[h][j]),None) + if h is None:continue + A[r],A[h]=A[h],A[r];v=A[r][j];A[r]=[x/v for x in A[r]] + for h in range(m): + if h!=r and A[h][j]: + v=A[h][j];A[h]=[x-v*y for x,y in zip(A[h],A[r])] + p.append(j);r+=1 + if any(not any(row[:k]) and row[k]for row in A):return None + x=[F(0)]*k + for h,j in enumerate(p):x[j]=A[h][k] + return x + candidates=[] + # Two normalization constraints leave at most two independent choices. + for count in range(3): + for chosen in combinations(range(n),count): + A=[realrows[src],imagrows[src]]+[imagrows[i]for i in chosen] + x=solve(A,[F(1),F(0)]+[F(0)]*count) + if x is None:continue + u=[summ(mul(z,(x[2*j],x[2*j+1]))for j,z in enumerate(row))for row in B] + if u[src]!=I:raise ValueError('source normalization') + key=(sum(z[1]!=0 for z in u),sum(z!=Z for z in u),sum(abs(z[0])+abs(z[1])for z in u)) + candidates.append((key,u,x)) + if not candidates:return None + return min(candidates,key=lambda t:t[0]) + + +def probe(q,c_weights=None,betas=None): + n=2*q+2;ops,pre=prefixes(q,betas) + weights=[1]*q if c_weights is None else c_weights + V=[[I if i==1 else Z, (F(weights[(i-3)//2]),F(0))if i>=3 and i%2 else Z]for i in range(n)] + rows=[] + for M,src,dst in pre: + answer=source_choice(mm(M,V),src) + rows.append((src,dst,answer)) + return rows + + +if __name__=='__main__': + for q in(1,2,3): + print('q',q) + for src,dst,res in probe(q): + print(src,'->',dst, None if res is None else (res[0],res[1])) diff --git a/research/marked-residual-reflection/source/caller/nested_six.py b/research/marked-residual-reflection/source/caller/nested_six.py new file mode 100644 index 0000000000..56d90d15b0 --- /dev/null +++ b/research/marked-residual-reflection/source/caller/nested_six.py @@ -0,0 +1,207 @@ +#!/usr/bin/env python3 +"""Literal six-bank nested caller prefix with its paid source continuations. + +All six input columns are independent. Four public rows finish; two pivot +rows retain the displayed H/L. This is an expensive first recursive prefix, +not a claimed complete supplier or a promised constant terminal tail. +Apache-2.0; substantial OpenAI Codex assistance. +""" +from pathlib import Path +from fractions import Fraction +from collections import Counter +import argparse +import hashlib +import json +import sys +sys.dont_write_bytecode = True +import free_ops as F +from plane_group import Algebra +from nested_prefix import skeleton, probe + +HERE = Path(__file__).resolve().parent + + +def ec(z): + return F.add(F.mono((), z[0]), F.mono((0,), z[1])) + + +def formal_word(): + q,n=2,6 + _,ops=skeleton(q,(1,0)) + choices=probe(q,(1,1),(1,0)) + F.need(all(c is not None for _,_,c in choices), 'every normalized source retraction exists') + M=F.eye(n);Mi=F.eye(n);s=0 + def app(A,Ai): + nonlocal M,Mi + F.need(F.mm(A,Ai)==F.mm(Ai,A)==F.eye(n),'formal event inverse') + M=F.mm(A,M);Mi=F.mm(Mi,Ai) + def a(d,src,c):app(F.es(n,d,src,c),F.es(n,d,src,F.neg(c))) + a(5,3,F.I) # inverse of the final constant c-basis change + source_rows=[] + for typ,d,src,z in ops: + if typ=='a':a(d,src,ec(z)) + elif typ=='s': + P=F.eye(n);P[d],P[src]=P[src],P[d];app(P,P) + else: + s+=1;u=choices[s-1][2][1] + cont=(s!=7 and any(v[1] for v in u)) + # G E(N) G^-1=E(N), because source functional is fixed, + # target differs from source, and every coefficient lies in E. + for j,v in enumerate(u): + if j!=src and v!=(0,0):a(j,src,F.neg(ec(v))) + P=F.mono((s,)) + if cont:P=F.mul(F.N,P) + A=F.mm(F.unary(n,src,P),F.es(n,d,src,F.N)) + Ai=F.mm(F.es(n,d,src,F.neg(F.N)),F.unary(n,src,F.inv(P))) + app(A,Ai) + for j,v in enumerate(u): + if j!=src and v!=(0,0):a(j,src,ec(v)) + source_rows.append({'stage':s,'src':src,'dst':d, + 'u':[[str(x),str(y)]for x,y in u], + 'source_code':('N P'if cont else'P')+str(s), + 'continued':cont}) + a(5,3,F.neg(F.I)) + F.need(F.mm(M,Mi)==F.mm(Mi,M)==F.eye(n),'formal literal inverse both orders') + public=(0,2,4,5);pivots=(1,3) + for i in public: + F.need(M[i]==[F.N if j==i else F.Z for j in range(n)], + 'every independent finished public row is exactly N times its own input') + H=[[M[i][j]for j in pivots]for i in pivots] + L=[[M[i][j]for j in public]for i in pivots] + return M,Mi,source_rows,H,L + + +def evaluate(q,A): + out=A.Z + for w,c in q.items(): + term=A.mono(coefficient=c) + for k in w: + op=A.n(0)if k==0 else A.swap(0,abs(k)) + term=A.mul(term,A.inv(op)if k<0 else op) + out=A.add(out,term) + return out + + +def physical_word(wrong_continuation_sign=False): + banks,planes=6,8 + A=Algebra(planes);M=A.eye(banks);Mi=A.eye(banks);events=[];s=0 + _,ops=skeleton(2,(1,0));choices=probe(2,(1,1),(1,0)) + def app(B,Bi,e): + nonlocal M,Mi + F.need(A.mm(B,Bi)==A.mm(Bi,B)==A.eye(banks),'physical event inverse') + M=A.mm(B,M);Mi=A.mm(Mi,Bi);events.append(e) + def add(d,src,c,label): + if not c:return + app(A.es(banks,d,src,A.mono(coefficient=c)), + A.es(banks,d,src,A.mono(coefficient=-c)), + {'kind':'ADD','dst':d,'src':src,'coefficient':str(c),'label':label}) + def unary(i,g,kind,label): + B=A.eye(banks);B[i][i]=g;Bi=A.eye(banks);Bi[i][i]=A.inv(g) + ((bits,p),c),=g.items() + F.need(c in(-1,1),'native/ADDRESS operator is a Gaussian unit word') + op={'sign':int(c),'native_blocks':[j for j in range(planes)if bits>>j&1], + 'block_permutation':list(p),'native_arity':A.native_arity(g)} + app(B,Bi,{'kind':kind,'bank':i,'operator':op,'label':label}) + add(5,3,Fraction(1),'raw c-basis inverse') + unary(1,A.n(0),'NATIVE','shared input N exposure') + add(2,1,Fraction(1),'shared input fanout b1+=N*t') + unary(1,A.inv(A.n(0)),'NATIVE','shared input N inverse') + for typ,d,src,z in ops: + if typ=='a': + if z[1]: + F.need(z[0]==0 and ((s==0 and d==2 and src==1)or(s==7 and d==2 and src==1)), + 'only the explicitly compiled shared input/output N-ADDs occur') + continue + add(d,src,z[0],'scalar nested response bridge') + elif typ=='s': + B=A.eye(banks);B[d],B[src]=B[src],B[d] + app(B,B,{'kind':'BANK_SWAP','banks':[d,src],'label':'nested response permutation'}) + else: + s+=1;u=choices[s-1][2][1];cont=s!=7 and any(v[1]for v in u) + for j,(a,b)in enumerate(u): + if j!=src:add(j,src,-a,f'query{s} scalar source-retraction entrance') + unary(src,A.n(0),'NATIVE',f'query{s} source common') + for j,(a,b)in enumerate(u): + if j!=src:add(j,src,-b,f'query{s} entrance fanout from existing source N') + add(d,src,Fraction(1),f'query{s} delivery') + unary(src,A.swap(0,s),'ADDRESS_OR_UNIT',f'query{s} source swap') + for j in range(banks): + if j!=src: + unary(j,A.n(s),'NATIVE',f'query{s} target fresh'if j==d else f'query{s} inactive fresh progress') + if cont: + for j,(a,b)in enumerate(u): + if j!=src: + coefficient=b if wrong_continuation_sign else -b + add(j,src,coefficient,f'query{s} pre-continuation fanout') + unary(src,A.n(0),'NATIVE',f'query{s} retained source N continuation') + for j,(a,b)in enumerate(u): + if j!=src:add(j,src,a,f'query{s} scalar source-retraction exit') + if not cont and any(v[1]for v in u): + F.need(s==7 and u[2][1]==1 and all(not v[1]for j,v in enumerate(u)if j!=2), + 'last post-N fanout cancels exactly the final shared output isolation') + add(5,3,Fraction(-1),'final c-basis change') + F.need(A.mm(M,Mi)==A.mm(Mi,M)==A.eye(banks),'all six physical columns, literal inverse in both orders') + return A,M,Mi,events + + +def prove(): + M,Mi,sources,H,L=formal_word() + A,physical,physical_inverse,events=physical_word() + fullfresh=A.prod(*(A.n(j)for j in range(1,8))) + expected=[[A.mul(fullfresh,evaluate(x,A))for x in row]for row in M] + F.need(physical==expected,'actual N-plane/ADDRESS event list binds every free-operator coefficient and its phase') + E=A.mul(fullfresh,A.n(0));public=[0,2,4,5] + for i in public: + F.need(physical[i]==[E if j==i else A.Z for j in range(6)],'physical full native public endpoints') + _,mutant,_,_=physical_word(True) + F.need(mutant!=physical,'wrong continuation sign is detected on the complete matrix') + Hhist=Counter(e['operator']['native_arity']for e in events if e['kind']=='NATIVE') + F.need(Hhist=={2:47},'complete prefix histogram') + touches={i:[]for i in range(6)} + for index,e in enumerate(events): + if e['kind']=='ADD':active=(e['dst'],e['src']) + elif e['kind']=='BANK_SWAP':active=e['banks'] + else:active=(e['bank'],) + # Every fresh progress is paid; its label lets an independent + # scheduler delay it only across an exact commutation contract. + if e['kind']=='NATIVE'and('target fresh'in e['label']or'inactive fresh progress'in e['label']):continue + for i in active:touches[i].append(index) + return { + 'status':'PASS_EXACT_NESTED_SIX_BANK_PREFIX_FOUR_PUBLIC_TWO_PIVOTS', + 'scientific_pin':'20ecf2891d80b5acf18d980b2164fb44ea7faa90', + 'domain':'Every f>=1 under exact Ni^2=-I, commuting distinct native planes and ADDRESS plane permutations; six arbitrary independent input fields. Free-operator proof allows arbitrary independent invertible Pi.', + 'changed_premise':'Repeated first-query response replacement with coupled source-retraction columns in a fixed two-dimensional E-plane; genuine common-N source continuations are retained at stages3,4,6.', + 'source_sequence':[e['src']for e in sources],'target_sequence':[e['dst']for e in sources], + 'source_retractions':sources,'events':events, + 'complete_matrix':F.sm(M),'complete_inverse':F.sm(Mi), + 'public_rows':public,'pivot_rows':[1,3], 'pivot_H':F.sm(H),'public_L':F.sm(L), + 'physical_matrix':[[A.serial(x)for x in row]for row in physical], + 'physical_inverse':[[A.serial(x)for x in row]for row in physical_inverse], + 'histogram':dict(Hhist),'native_rank_mass':94,'ambient_arity':16,'public_banks_including_pivots':6, + 'stock_if_pivots_finish':96,'D_before_pivot_tail':2, + 'query_count':7,'source_continuation_count':3,'shared_input_N_calls':2, + 'mandatory_nondeferred_touches':touches, + 'inverse':'Reverse every physical event; negate ADDs, invert each signed native/ADDRESS operator, reverse swaps. Checked both matrix orders without any initialized field.', + 'folds':['All pre-N retraction fanouts use the already-paid source N query.', + 'At a retained continuation, N(NP)=-P makes every N-valued exit a scalar fanout before the continuation.', + 'Final post-N b1 fanout cancels the shared output isolation after the final bank swap.'], + 'limits':['This is a six-bank PREFIX. H and L have not been cleared or given the five-factory tail schema.', + 'The complete invoice is not the optimistic two-continuation planning case: stages3,4,6 are all explicitly paid.', + 'No source exposure sharing or three-stage public touch window is assumed.', + 'The exact signed group algebra proves positive identities for every f; it is not a formal-kernel certificate.'], + 'source_pins':[{'path':str(HERE/p),'sha256':hashlib.sha256((HERE/p).read_bytes()).hexdigest()} + for p in('nested_prefix.py','free_ops.py','plane_group.py')], + 'negative_control':'Wrong pre-continuation fanout sign changes the actual all-column matrix.', + 'no_new_kappa':True} + + +def main(): + ap=argparse.ArgumentParser(description=__doc__);ap.add_argument('--write',action='store_true');args=ap.parse_args() + out=prove();out['producer_sha256']=hashlib.sha256(Path(__file__).read_bytes()).hexdigest() + out=json.loads(json.dumps(out));path=HERE/'NESTED-SIX.json' + if args.write:path.write_text(json.dumps(out,indent=2,sort_keys=True)+'\n') + else:F.need(json.loads(path.read_text())==out,'saved nested-six receipt differs') + print(out['status'],out['histogram'],'prefix only') + + +if __name__=='__main__':main() diff --git a/research/marked-residual-reflection/source/caller/pivot_plane_probe.py b/research/marked-residual-reflection/source/caller/pivot_plane_probe.py new file mode 100644 index 0000000000..fd793eba19 --- /dev/null +++ b/research/marked-residual-reflection/source/caller/pivot_plane_probe.py @@ -0,0 +1,92 @@ +#!/usr/bin/env python3 +"""Bounded n4 source-retraction screen; actual code/native closure not inferred.""" +from fractions import Fraction as F +from itertools import product +from pathlib import Path +import json, sys +sys.dont_write_bytecode=True +Z=(F(0),F(0));I=(F(1),F(0));N=(F(0),F(1)) +def add(a,b):return(a[0]+b[0],a[1]+b[1]) +def neg(a):return(-a[0],-a[1]) +def mul(a,b):return(a[0]*b[0]-a[1]*b[1],a[0]*b[1]+a[1]*b[0]) +def inv(a): + d=a[0]*a[0]+a[1]*a[1] + if not d:raise ValueError('nonunit') + return(a[0]/d,-a[1]/d) +def eye(n):return [[I if i==j else Z for j in range(n)] for i in range(n)] +def mm(A,B):return [[summ(mul(x,y) for x,y in zip(r,c)) for c in zip(*B)] for r in A] +def summ(xs): + a=Z + for b in xs:a=add(a,b) + return a +def es(n,d,s,c): + A=eye(n);A[d][s]=c;return A +def null(A): + A=[list(r) for r in A];m=len(A);n=len(A[0]);p=[];r=0 + for c in range(n): + k=next((k for k in range(r,m) if A[k][c]),None) + if k is None:continue + A[r],A[k]=A[k],A[r];v=A[r][c];A[r]=[x/v for x in A[r]] + for j in range(m): + if j!=r and A[j][c]: + v=A[j][c];A[j]=[x-v*y for x,y in zip(A[j],A[r])] + p.append(c);r+=1 + if r==m:break + out=[] + for c in range(n): + if c in p:continue + v=[F(0)]*n;v[c]=F(1) + for j,d in enumerate(p):v[d]=-A[j][c] + out.append(v) + return out + +def rank(A): + A=[list(r) for r in A];m=len(A);n=len(A[0]);r=0 + for c in range(n): + k=next((k for k in range(r,m) if A[k][c]!=Z),None) + if k is None:continue + A[r],A[k]=A[k],A[r];v=inv(A[r][c]);A[r]=[mul(x,v) for x in A[r]] + for j in range(m): + if j!=r and A[j][c]!=Z: + v=A[j][c];A[j]=[add(x,neg(mul(v,y))) for x,y in zip(A[j],A[r])] + r+=1 + if r==m:break + return r + +def prefixes(n=4): + ops=[('q',0,1,N),('a',0,2,I),('q',1,0,N),('a',0,2,neg(I)),('a',1,3,I),('q',2,1,N),('a',1,3,neg(I)),('q',3,2,N),('a',1,3,I),('a',2,0,I),('q',0,3,neg(N)),('a',2,0,neg(I))] + M=eye(n);Mi=eye(n);out=[] + for typ,d,s,c in ops: + M=mm(es(n,d,s,c),M);Mi=mm(Mi,es(n,d,s,neg(c))) + if typ=='q':out.append((M,Mi,s,d)) + return out + +def real_source(B,src): + ns=null([[z for x in r for z in (x[1],x[0])] for r in B]) + for v in ns: + u=[summ(mul(x,(v[2*j],v[2*j+1])) for j,x in enumerate(r)) for r in B] + if any(x[1] for x in u):raise ValueError('nonreal null witness') + if u[src][0]:return [x[0]/u[src][0] for x in u] + return None + +def serial(A):return [[[str(x),str(y)] for x,y in r] for r in A] +def run(): + pre=prefixes();found=[];count=0;dimension_fail=0 + for tail1 in product((-1,0,1),repeat=3): + u1=list(map(F,tail1));u1.insert(pre[0][2],F(1)) + v1=mm(pre[0][1],[[(x,F(0))] for x in u1]) + for tail2 in product((-1,0,1),repeat=3): + count+=1;u2=list(map(F,tail2));u2.insert(pre[1][2],F(1)) + v2=mm(pre[1][1],[[(x,F(0))] for x in u2]) + V=[[v1[i][0],v2[i][0]] for i in range(4)] + if rank(V)!=2:dimension_fail+=1;continue + choices=[] + for M,Mi,src,dst in pre: + u=real_source(mm(M,V),src) + if u is None:break + choices.append([str(x) for x in u]) + else:found.append({'first_source':list(map(str,u1)),'second_source':list(map(str,u2)),'input_plane':serial(V),'source_retractions':choices}) + return {'status':'BOUNDED_EXACT_SOURCE_RETRACTION_SCREEN','candidate_pairs':count,'source_tail_alphabet':[-1,0,1],'dimension_failures':dimension_fail,'solutions':found,'scope':'Old n4 five-shear ideal topology only; arbitrary real source-retraction columns allowed at later queries. Source-code algebra, native encoder and actual correction are not inferred.','native_invoice_if_admitted':'Same five raw carriers plus full global fresh progress; constant bank GL source changes only. Any N-dependent initial plane encoder and terminal correction remain paid/open.'} +if __name__=='__main__': + out=run();Path(__file__).with_name('PIVOT-PLANE-PROBE.json').write_text(json.dumps(out,indent=2,sort_keys=True)+'\n');print(out['status'],out['candidate_pairs'],'pairs',len(out['solutions']),'solutions') + if out['solutions']:print(json.dumps(out['solutions'][0])) diff --git a/research/marked-residual-reflection/source/caller/plane_group.py b/research/marked-residual-reflection/source/caller/plane_group.py new file mode 100644 index 0000000000..fddd6b0761 --- /dev/null +++ b/research/marked-residual-reflection/source/caller/plane_group.py @@ -0,0 +1,103 @@ +"""Exact all-chunk operator algebra for the minimal plane carrier. + +N_i^2=-I, N_i commute, and plane ADDRESS permutations permute the N_i. +All operations are literal Gaussian-unit identities, not binary tableaux. +Apache-2.0; substantial OpenAI Codex assistance. +""" +from fractions import Fraction + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +class Algebra: + def __init__(self, planes): + self.p = planes + self.idperm = tuple(range(planes)) + self.I = {(0, self.idperm): Fraction(1)} + self.Z = {} + + def mono(self, bits=0, perm=None, coefficient=1): + if not coefficient: + return {} + return {(bits, self.idperm if perm is None else tuple(perm)): Fraction(coefficient)} + + def n(self, i): + return self.mono(1 << i) + + def swap(self, i, j): + p = list(self.idperm) + p[i], p[j] = p[j], p[i] + return self.mono(perm=p) + + def add(self, a, b): + c = dict(a) + for g, v in b.items(): + c[g] = c.get(g, 0) + v + if not c[g]: + del c[g] + return c + + @staticmethod + def neg(a): + return {g: -v for g, v in a.items()} + + def mul(self, a, b): + c = {} + for (x, p), v in a.items(): + for (y, q), w in b.items(): + py = sum(1 << p[i] for i in range(self.p) if y >> i & 1) + sign = -1 if (x & py).bit_count() % 2 else 1 + r = tuple(p[q[i]] for i in range(self.p)) + c = self.add(c, self.mono(x ^ py, r, sign * v * w)) + return c + + def prod(self, *args): + c = self.I + for a in args: + c = self.mul(c, a) + return c + + def inv(self, a): + need(len(a) == 1, 'literal inverse requires one group word') + ((x, p), v), = a.items() + pi = [0] * self.p + for i, j in enumerate(p): + pi[j] = i + y = sum(1 << pi[i] for i in range(self.p) if x >> i & 1) + sign = -1 if x.bit_count() % 2 else 1 + b = self.mono(y, pi, sign / v) + need(self.mul(a, b) == self.mul(b, a) == self.I, 'exact phase inverse') + return b + + def ad(self, a, b): + return self.prod(a, b, self.inv(a)) + + def native_arity(self, a): + need(len(a) == 1, 'native arity only for a single actual operator') + ((bits, _), _), = a.items() + return 2 * bits.bit_count() + + def eye(self, n): + return [[self.I if i == j else self.Z for j in range(n)] for i in range(n)] + + def mm(self, a, b): + return [[self.sum(self.mul(x, y) for x, y in zip(r, c)) for c in zip(*b)] for r in a] + + def sum(self, terms): + a = self.Z + for b in terms: + a = self.add(a, b) + return a + + def es(self, n, dst, src, a): + m = self.eye(n) + m[dst][src] = self.add(m[dst][src], a) + return m + + def serial(self, a): + return [{'coefficient': str(c), 'N_planes': [i for i in range(self.p) if x >> i & 1], + 'ADDRESS_plane_permutation': list(p)} for (x, p), c in sorted(a.items())] + diff --git a/research/marked-residual-reflection/source/native-frames/CONJUGATED-FACTORY.json b/research/marked-residual-reflection/source/native-frames/CONJUGATED-FACTORY.json new file mode 100644 index 0000000000..a53882c953 --- /dev/null +++ b/research/marked-residual-reflection/source/native-frames/CONJUGATED-FACTORY.json @@ -0,0 +1,140 @@ +{ + "COPY_precision_tape_obligations": "Native lowering is a Fourier/supplier query with arbitrary input. Any source COPY to a fanout, all bank reads, the two monomial ADDRESS/phase adapters, their reversible scans, precision/rounding propagation, source-bound block norms, and physical tape return remain paid caller obligations. No endpoint, all-size recursion, stock or exponent follows from this unary identity.", + "actual_checks": [ + { + "actual_native_recipe_phase": true, + "f": 1, + "inverse": "same operator", + "ranks_P2_RP2_P2R_RP2R": [ + 4, + 4, + 4, + 2 + ] + }, + { + "actual_native_recipe_phase": true, + "f": 2, + "inverse": "same operator", + "ranks_P2_RP2_P2R_RP2R": [ + 8, + 8, + 8, + 4 + ] + }, + { + "actual_native_recipe_phase": true, + "f": 3, + "inverse": "same operator", + "ranks_P2_RP2_P2R_RP2R": [ + 12, + 12, + 12, + 6 + ] + } + ], + "all_f_proof": "P2_f and R_f are bitwise tensors. Global N_f phases cancel in conjugation, so B_f=B_1^tensor f. The explicit actual one-bit equality B_1=L C_2 R_adapter tensor-lifts with fixed bitwise ADDRESS/quadratic-phase controllers to one selected native2f query. B_1 has B-rank2, so B_f has exact B-rank2f, including all f-dependent adapter phase powers.", + "caller_obligation": "This bill applies only to the literal B shown. An outgoing source P2 is not replaced for free. R uses the stage2-future plane2, so supplying both R sides at a legal caller cut with all source/target columns and fresh coverage is a separate obligation. A global chart change also transports N and cannot be used to claim this saving while holding N fixed.", + "complete_unary_invoice": { + "ADDRESS_scans_at_most": 2, + "Gaussian_quadratic_phase_scans_at_most": 2, + "monomial_adapters": 2, + "native_H2": 1, + "native_rank_mass": 2, + "ordinary_helpers": 0, + "private_fields": 0 + }, + "evidence_domain": "Written exact all-f tensor proof, actual Gaussian recipe and phase checks f1/f2/f3, and one-sided negative controls. No finite-f extrapolation and no formal-kernel claim.", + "exact_operator": "B=N0 R P2 R N0^-1, P2=SWAP(plane0,plane2), R=ADDRESS(I+vv^T), v=(p0,q0,p1,p2).", + "no_new_kappa": true, + "one_bit_selected_native_recipe": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 4, + 9, + 16, + 32, + 1, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 0, + 2, + 0, + 3, + 3, + 0, + 0 + ], + "matrix_rows": [ + 37, + 48, + 2, + 36, + 8, + 52, + 64, + 128 + ], + "offset": 3, + "phase": 1, + "quadratic_rows": [ + 48, + 0, + 48, + 0, + 21, + 37, + 0, + 0 + ] + } + }, + "producer_sha256": "81a75479e21d70181e4aa70746be3a4a31bcb3ddd1bd00a4a1b812bf126d7caf", + "scientific_pin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "source_pins": [ + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/native_model.py", + "sha256": "6397a86bd3d1461be182fcfa8602b0c70c489964a8c14f12436ba2506e11d9e3" + }, + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/orthogonal_source_normalizer.py", + "sha256": "c6373762bd15763625cc9237bb280a5e26ab8e53d6bfb034474f068b1525e6fa" + }, + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/conjugated_reflection.py", + "sha256": "6b68a4a60b160fe28227c31909ed86bd7f80b1f3e07591032cd001dbeb242f6f" + } + ], + "status": "PASS_ALL_F_TWO_SIDED_REFLECTION_FACTORY_SINGLE_CHILD" +} diff --git a/research/marked-residual-reflection/source/native-frames/CONJUGATED-REFLECTION.json b/research/marked-residual-reflection/source/native-frames/CONJUGATED-REFLECTION.json new file mode 100644 index 0000000000..ea17f03e16 --- /dev/null +++ b/research/marked-residual-reflection/source/native-frames/CONJUGATED-REFLECTION.json @@ -0,0 +1,387 @@ +{ + "actual_operator": "R=P_(I+vv^T), v=(1,1,1,0,1,0) on completed(p0,q0,p1,q1,p2,q2); A=N0 R N0^-1.", + "actual_tensor_recipe_checks": [ + { + "conjugating_old_plane": 0, + "f": 1, + "inverse": "same A", + "native_arity": 2, + "tensor_recipe_actual_Gaussian_phase": true + }, + { + "conjugating_old_plane": 1, + "f": 1, + "inverse": "same A", + "native_arity": 2, + "tensor_recipe_actual_Gaussian_phase": true + }, + { + "conjugating_old_plane": 2, + "f": 1, + "inverse": "same A", + "native_arity": 2, + "tensor_recipe_actual_Gaussian_phase": true + }, + { + "conjugating_old_plane": 0, + "f": 2, + "inverse": "same A", + "native_arity": 4, + "tensor_recipe_actual_Gaussian_phase": true + }, + { + "conjugating_old_plane": 1, + "f": 2, + "inverse": "same A", + "native_arity": 4, + "tensor_recipe_actual_Gaussian_phase": true + }, + { + "conjugating_old_plane": 2, + "f": 2, + "inverse": "same A", + "native_arity": 4, + "tensor_recipe_actual_Gaussian_phase": true + }, + { + "conjugating_old_plane": 0, + "f": 3, + "inverse": "same A", + "native_arity": 6, + "tensor_recipe_actual_Gaussian_phase": true + }, + { + "conjugating_old_plane": 1, + "f": 3, + "inverse": "same A", + "native_arity": 6, + "tensor_recipe_actual_Gaussian_phase": true + }, + { + "conjugating_old_plane": 2, + "f": 3, + "inverse": "same A", + "native_arity": 6, + "tensor_recipe_actual_Gaussian_phase": true + } + ], + "all_f_tensor_identity": "R_f is the bitwise tensor product of R_1. N_f=i^(1-f) N_1^tensor f after regrouping address coordinates. Its global unit cancels in conjugation, so A_f=A_1^tensor f literally, including phase. Tensoring the explicit one-bit monomial/native/monomial equality therefore gives A_f=L_f C_(2f) R_f_adapter. All three factors have fixed bitwise controllers; no f1 tableau-only inference is used.", + "evidence_domain": "Written all-f exact tensor proof and native B-rank proof; independent actual Gaussian compiled checks at f1/f2/f3; all-f two-bank polynomial coefficients checked in the phase-sensitive tensor algebra.", + "limits": [ + "This is a changed legal local bridge, not a completed caller or shared-debt cancellation.", + "The source-kernel N0R is not assumed quadratic, and no old scalar caller is imported by that assumption.", + "All bank ADD, ADDRESS and phase scans are paid; no source access, owner, precision, all-size or tape gate is discharged." + ], + "native_model_sha256": "6397a86bd3d1461be182fcfa8602b0c70c489964a8c14f12436ba2506e11d9e3", + "native_rank_proof": "The binary B block of A_1 has rank2. Direct sums under bitwise tensor regrouping have rank2f, so A_f and its inverse have exact native arity2f for every f>=1. A_f^2=I by conjugation of R_f^2=I.", + "no_new_kappa": true, + "old_plane_extension": "The same exact single-child admission holds for A_i=N_i R N_i^-1 on each i=0,1,2, with the three explicit recipes retained. Since N_i=i H_i and H_i=Hp_i Hq_i is involutive, this is also H_i R H_i without any external i. The tensor proof and all adapter phase powers apply separately to each saved recipe.", + "one_bit_selected_native_recipe": { + "left": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 2, + 9, + 16, + 1, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0 + ], + "matrix_rows": [ + 21, + 7, + 3, + 20, + 8, + 32, + 64, + 128 + ], + "offset": 2, + "phase": 0, + "quadratic_rows": [ + 0, + 18, + 0, + 0, + 18, + 0, + 0, + 0 + ] + } + }, + "one_bit_selected_native_recipes_by_old_plane": [ + { + "left": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 2, + 9, + 16, + 1, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0 + ], + "matrix_rows": [ + 21, + 7, + 3, + 20, + 8, + 32, + 64, + 128 + ], + "offset": 2, + "phase": 0, + "quadratic_rows": [ + 0, + 18, + 0, + 0, + 18, + 0, + 0, + 0 + ] + } + }, + { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 10, + 1, + 16, + 2, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 19, + 7, + 17, + 18, + 8, + 32, + 64, + 128 + ], + "offset": 3, + "phase": 1, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 10, + 2, + 16, + 1, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 7, + 19, + 5, + 6, + 8, + 32, + 64, + 128 + ], + "offset": 3, + "phase": 1, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + } + ], + "producer_sha256": "6b68a4a60b160fe28227c31909ed86bd7f80b1f3e07591032cd001dbeb242f6f", + "reflection_source_sha256": "c6373762bd15763625cc9237bb280a5e26ab8e53d6bfb034474f068b1525e6fa", + "scientific_pin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "single_unary_invoice": { + "ADDRESS_scans_at_most": 2, + "Gaussian_quadratic_phase_scans_at_most": 2, + "monomial_adapters": 2, + "native_H2": 1, + "native_rank_mass": 2, + "ordinary_helpers": 0, + "private_fields": 0 + }, + "status": "PASS_ALL_F_SINGLE_CHILD_CONJUGATED_UNPAIRED_REFLECTION", + "two_bank_identity": "For E12=I+e1e2^T and B_R=E12 diag(I,R) E12^-1, Ad_(diag(N,N))(B_R)=E12 diag(I,A) E12^-1. Both independent inputs are retained. Its literal inverse reverses the shears and applies A^-1=A; the entire displayed conjugated word is itself involutive.", + "two_bank_invoice": { + "monomial_adapters": 2, + "native_H2": 1, + "native_rank_mass": 2, + "ordinary_helpers": 0, + "private_fields": 0, + "scalar_ADD_scans": 2 + } +} diff --git a/research/marked-residual-reflection/source/native-frames/HALF-CHUNK-COMMUTANT-AUDIT.md b/research/marked-residual-reflection/source/native-frames/HALF-CHUNK-COMMUTANT-AUDIT.md new file mode 100644 index 0000000000..6f1ccaca14 --- /dev/null +++ b/research/marked-residual-reflection/source/native-frames/HALF-CHUNK-COMMUTANT-AUDIT.md @@ -0,0 +1,77 @@ +# Typed half-chunk queries in the restricted bridge grammar + +Scientific source: canonical `20ecf2891d80b5acf18d980b2164fb44ea7faa90`. +This independently audits the scope of the marked-residual argument. It does +not extend the argument to arbitrary ADDRESS or Pauli adapters. + +Let a chunk contain f address bits. The actual operators are +`Hp_f=(Z C^-1)^tensor f`, `Hq_f=(Z C)^tensor f`, where +`C=((1+i)I+(1-i)X)/2`. In the simultaneous physical-X character basis, + + Hp_f |x>_X = (-i)^|x| |x xor 1^f>_X, + Hq_f |x>_X = i^|x| |x xor 1^f>_X, + Hq_f = Hp_f X_all. + +These formulas follow by diagonalizing each literal C and letting Z exchange +the two X characters. They include the actual global phases. + +Write `b=x_1`, `r_j=x_j xor x_1`, so `r_1=0`. Each Hp or Hq preserves r and +flips b. There are `2^(f-1)` residual labels. Choose any complex square root +`lambda_f^2=(-i)^f`; in the pair with residual r use basis multiplier +`g_0=1`, `g_1=(-i)^|r|/lambda_f`. Hp is then exactly `lambda_f X_virtual`. +This is only a basis for a rank proof. It introduces no physical scalar, +Gaussian normalization, or allowed operation. In particular the proof works +for odd f as well as even f. Hq is Hp times the actual diagonal X_all, and +has the same virtual-bit flip. + +Fix L physical chunks and f>=2. Choose distinct residuals r0=0 and r1. +Let V be spanned by all character configurations having r1 at exactly one +chunk (the owner), r0 elsewhere, and arbitrary virtual bits. Then +`dim V = L*2^L`. Define C on this space by + + C |owner,b_1,...,b_L> = (-1)^b_owner |owner,b_1,...,b_L>. + +Every whole-chunk permutation preserves V and commutes with C: it moves +the owner and the virtual bits by the same permutation. The above gauge +is uniform on all chunks, so this assertion has no omitted gauge phase. +Every physical ADDRESS X translation is diagonal in these characters, +with coefficient `(-1)^(a.r + b|a|)`, hence also preserves V and commutes +with C. Scalar Gaussian coefficients commute as well. Any invertible bank +matrix over the algebra generated by these operations has those properties. +There is no restriction on its word length or on the sizes of its scalar +coefficients. + +A paid unary native product on a set S of r distinct chunks, using one Hp +or Hq (or inverse) on each selected chunk, has + + rank_V [C,U_S] = r*2^L. + +Indeed it anticommutes on each owner block belonging to S and commutes on +the other owner blocks; every nonzero phase is invertible. Monomial +adapters from the stated commuting algebra preserve this rank. Arbitrary +monomial adapters are not included by that sentence. + +On n independent data banks, the full target applying one selected Hp/Hq +on every chunk has commutator rank `n L 2^L`. Arbitrary additional dirty +banks restored literally to I contribute zero. Since + + rank[C,AB] <= rank[C,A] + rank[C,B], + +every exact complete word in this grammar satisfies `sum r >= nL`, or +native rank mass at least `n L f`, the full native stock. The result is +unchanged by entrance/exit adapters within the same commuting algebra. +It holds for every f>=2, so restricting an all-size construction to odd f +does not evade it. + +The claim is restricted to the displayed physical typed-query alphabet and +whole-chunk-permutation/X-translation bridges. A general bit-linear ADDRESS +map, a Pauli Z, a controlled chart not preserving V, an arbitrary monomial +native adapter, a changed datatype, or a target not equivalent through the +stated commuting algebra requires a new proof. In particular this is not a +lower bound for every native operator of the same Bruhat rank. The unpaired +reflection in `ORTHOGONAL-REFLECTION-PROOF.md` is an explicit legal operation +outside this argument. + +The underlying one-chunk phases and selected-native identity are checked by +`one_chunk_phase.py` / `ONE-CHUNK-PHASE.json`; the present all-parameter +argument is a written proof, not a formal-kernel proof or a finite census. diff --git a/research/marked-residual-reflection/source/native-frames/ONE-CHUNK-PHASE.json b/research/marked-residual-reflection/source/native-frames/ONE-CHUNK-PHASE.json new file mode 100644 index 0000000000..8c71eeb1dc --- /dev/null +++ b/research/marked-residual-reflection/source/native-frames/ONE-CHUNK-PHASE.json @@ -0,0 +1,186 @@ +{ + "actual_checks": [ + { + "Gaussian_scalar_normalization_to_minus_I": false, + "f": 1, + "native_arity": 1, + "square_of_iH_as_i_exponent": 1, + "type": "Hp" + }, + { + "Gaussian_scalar_normalization_to_minus_I": false, + "f": 1, + "native_arity": 1, + "square_of_iH_as_i_exponent": 3, + "type": "Hq" + }, + { + "extra_ADDRESS_bit": 1, + "f": 1, + "native_arity": 1, + "selected_native_recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 1, + 0, + 0 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8 + ], + "offset": 3, + "phase": 3, + "quadratic_rows": [ + 0, + 2, + 0, + 0 + ] + } + }, + "square": "-I", + "tag_diagonal_phase_exponent": 3, + "type": "Hp_with_separate_tag_bit" + }, + { + "Gaussian_scalar_normalization_to_minus_I": true, + "f": 2, + "native_arity": 2, + "square_of_iH_as_i_exponent": 0, + "type": "Hp" + }, + { + "Gaussian_scalar_normalization_to_minus_I": true, + "f": 2, + "native_arity": 2, + "square_of_iH_as_i_exponent": 0, + "type": "Hq" + }, + { + "extra_ADDRESS_bit": 2, + "f": 2, + "native_arity": 2, + "selected_native_recipe": null, + "square": "-I", + "tag_diagonal_phase_exponent": 0, + "type": "Hp_with_separate_tag_bit" + }, + { + "Gaussian_scalar_normalization_to_minus_I": false, + "f": 3, + "native_arity": 3, + "square_of_iH_as_i_exponent": 3, + "type": "Hp" + }, + { + "Gaussian_scalar_normalization_to_minus_I": false, + "f": 3, + "native_arity": 3, + "square_of_iH_as_i_exponent": 1, + "type": "Hq" + }, + { + "extra_ADDRESS_bit": 3, + "f": 3, + "native_arity": 3, + "selected_native_recipe": null, + "square": "-I", + "tag_diagonal_phase_exponent": 1, + "type": "Hp_with_separate_tag_bit" + }, + { + "Gaussian_scalar_normalization_to_minus_I": true, + "f": 4, + "native_arity": 4, + "square_of_iH_as_i_exponent": 2, + "type": "Hp" + }, + { + "Gaussian_scalar_normalization_to_minus_I": true, + "f": 4, + "native_arity": 4, + "square_of_iH_as_i_exponent": 2, + "type": "Hq" + }, + { + "extra_ADDRESS_bit": 4, + "f": 4, + "native_arity": 4, + "selected_native_recipe": null, + "square": "-I", + "tag_diagonal_phase_exponent": 2, + "type": "Hp_with_separate_tag_bit" + }, + { + "Gaussian_scalar_normalization_to_minus_I": false, + "f": 5, + "native_arity": 5, + "square_of_iH_as_i_exponent": 1, + "type": "Hp" + }, + { + "Gaussian_scalar_normalization_to_minus_I": false, + "f": 5, + "native_arity": 5, + "square_of_iH_as_i_exponent": 3, + "type": "Hq" + }, + { + "extra_ADDRESS_bit": 5, + "f": 5, + "native_arity": 5, + "selected_native_recipe": null, + "square": "-I", + "tag_diagonal_phase_exponent": 3, + "type": "Hp_with_separate_tag_bit" + } + ], + "all_f_identity": "Hp_f^2=(-i)^f I and Hq_f^2=i^f I, so (i Hp_f)^2=-(-i)^f I and (i Hq_f)^2=-i^f I. Literal iH squares to-I only when f=0 mod4.", + "even_f_normalization": "For even f, gamma_p=i^(f/2+1), gamma_q=i^(1-f/2) are Gaussian units and (gamma_p Hp_f)^2=(gamma_q Hq_f)^2=-I.", + "evidence_domain": "Written all-f scalar/flat-unitary proofs; actual exact Gaussian phase and arity checks for f1..5; one-bit selected-native lowering plus the explicit Hp tensor/native query and monomial tag implementation. No tableau-only extrapolation. Higher-f dense recipe expansion is unnecessary and is not claimed.", + "flat_unitary_obstruction_scope": "More generally, a unitary B acting fully and flatly on exactly f address bits with B^2=-I is skew-Hermitian. Every diagonal is nonzero pure imaginary of magnitude2^(-f/2). Gaussian-dyadic entries cannot have that imaginary value for odd f. This covers unitary monomial left/right gauges of a full one-chunk native Fourier operator; it does not cover an enlarged ambient operator with zero diagonal, nonunitary gauges, arbitrary operators of rankf acting on more thanf bits, or a changed recursive datatype.", + "native_model_sha256": "6397a86bd3d1461be182fcfa8602b0c70c489964a8c14f12436ba2506e11d9e3", + "no_new_kappa": true, + "odd_f_scalar_obstruction": "For odd f a scalar normalization requires gamma^2=+i or-i. If gamma=a+bi is Gaussian rational then a^2=b^2 and2ab=+1 or-1, forcing a^2=1/2, impossible rational. Thus no Gaussian-dyadic scalar, unit or nonunit, normalizes the odd-f typed chunk to square-I.", + "producer_sha256": "d1490bed667bcae939bdb74002471bfa221c22df5a527d3726ec2bf038ee17a0", + "scientific_pin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "status": "PASS_ONE_CHUNK_PHASE_DOMAIN_AND_SEPARATE_TAG_RESOURCE", + "tag_invoice": { + "extra_address_coordinates": 1, + "native_arity": "f", + "native_monomial_adapter_scans_at_most": 2, + "ordinary_helpers": 0, + "private_fields": 0, + "tag_ADDRESS_X_scans": 1, + "tag_phase_scans": 1 + }, + "tag_resource": "A separate tag bit admits M_f=[[0,1],[-i^f,0]], an actual ADDRESS X plus Gaussian-unit phase, with M_f^2=-i^f I. Since it is disjoint from Hp_f, B_f=Hp_f tensor M_f has B_f^2=-I and exact nativearityf for every f. This is a changed f+1-bit domain, not a scalar normalization onf bits.", + "tag_terminal_obligation": "The extra tag bit remains monomial under this resource. A supplier requiring full native rank on its entire ambient address space must supply its missing tag Fourier progress, or prove a separately charged sector/dispatcher contract. That cost is not waived here. Sharing the tag among planes also changes their product and must be checked literally." +} diff --git a/research/marked-residual-reflection/source/native-frames/ORTHOGONAL-REFLECTION-PROOF.md b/research/marked-residual-reflection/source/native-frames/ORTHOGONAL-REFLECTION-PROOF.md new file mode 100644 index 0000000000..d6c9c0c46e --- /dev/null +++ b/research/marked-residual-reflection/source/native-frames/ORTHOGONAL-REFLECTION-PROOF.md @@ -0,0 +1,105 @@ +# An unpaired exact ADDRESS normalizer and its common conjugate + +Source pin: `20ecf2891d80b5acf18d980b2164fb44ea7faa90`. The scripts +`orthogonal_source_normalizer.py` and `conjugated_reflection.py` preserve +their native source/compiler hashes in their JSON receipts. + +Credit and overlap: the generic even-linear lift/cocycle warning belongs +to Chris R / Clear1nsight's [PR3987](https://github.com/CrocSwap/integer-mult-bounds/pull/3987), +head `fc536202fdaa924158789a5ef59ac079bbe21922`. ToikY's +[PR4002](https://github.com/CrocSwap/integer-mult-bounds/pull/4002), head +`d593941ea0a4926021cba9d01fe60500579e464f`, gives exact normalized lifts, +signed words and mandatory anticommuting-C phase tags. The typed +`P_A Z_z` specialization here is not claimed as a new generic +normalization theorem. The distinct local obligation is its actual typed +source cut, full independent columns and inverse, native-cut rank, +fresh-progress tradeoff, and fully paid caller resource. The overlap was +read from the root's saved 10:32 board intake; no scientific pin is moved. + +For j completed old planes, with p/q chunks of length f in each plane, +let D multiply an address by `i^(sum p bits - sum q bits)`. The actual +old native product is exactly + + G_old = product_(l=0..j-1) N_l = i^j D^-1 H_all D. + +Here H_all is ordinary normalized Walsh. On one bit, +`Hp=e^(-i pi/4) S^-1 H S` and `Hq=e^(+i pi/4) S H S^-1`. +The non-Gaussian scalars cancel within every p/q pair; each N_l retains +its one literal i. Thus the displayed identity has no missing f phase. + +For any binary orthogonal A (`A^T A=I`), its literal ADDRESS operator P_A +commutes with Walsh, as follows directly from the kernel `(-1)^(x.y)`. +Consequently `R_A=D^-1 P_A D` is an exact monomial normalizer of G_old +for every f. This establishes native admission with explicit Gaussian +phases, without relying on a finite tableau to certify a tensor family. + +The useful choice needs three complete old planes. Order their six chunks +as `(p0,q0,p1,q1,p2,q2)`, and put + + v=(1,1,1,0,1,0), A=I+v v^T. + +Its weight is four, so `v^T v=0`, `A^2=A^T A=I`. The same binary map is +applied separately at every bit position. Write d(x) for the typed p-minus-q +weight and d_v for its restriction to the support of v. If `v.x=1`, then + + d(x)-d(Ax)=2 d_v(x)-2 = 0 mod 4; + +if `v.x=0`, the difference is zero. Therefore the useful normalizer is +**literally bare ADDRESS**: `R_A=P_A`. No Gaussian phase scan is needed. +It is involutive and uses only completed old coordinates. + +At stage j>=3, put Fpast equal to the completed fresh product and Fnew to +the product after the new fresh plane. Starting with two arbitrary fields +in the common Fpast chart, the literal word is + + source=N0 source; source=R source; target+=source; + source=R^-1 source; source=Pj source; target=Tj target. + +Because `[R,N0 Fpast]=0`, its full two-column matrix is exactly + + Fnew * [[Pj,0],[N0 R,I]]. + +The source code Pj, raw target coefficient, source cross coefficient, and +fresh coverage are retained, with phase. The inverse reverses the word, +uses target subtraction, and inverts each unary operator; it requires no +zero field or helper. Its bill is the original two native-2f queries, one +delivery ADD and one source ADDRESS, plus two ADDRESS R scans. Both new +scans are paid. This is a changed cross kernel, not a completed caller. + +This R escapes the old whole-plane marked-residual proof. In the physical +X-character basis it takes the character with all q0 bits set to the +character with all p0,p1,p2 bits set. Thus a configuration with one marked +plane residual is sent to three marked residuals, for every f. The actual +64-point character sum at f=1 gives coefficient exactly +1, and the written +bitwise identity gives the all-f lift. Pair-gauge phases cannot remove +nonzero leakage. + +By contrast the balanced support `(p0,q0,p1,q1)` is a negative control. +Its typed R is `Z_v P_A`; on characters it maps +`w -> w+(v.w+1)v`. With the residual mark `(p=0,q=1^f)`, it fixes an owner +inside its support and flips only unmarked virtual bits when the owner is +outside. It commutes with the marked C. The balanced reflection must not +be promoted as an escape. Its quartic kernel check is distinct from the +unpaired kernel; no claim `(N0 R)^2=-I` is made for the useful R. + +There is a further cheaper conjugation resource. Let `A_f=N0 R N0^-1`. +The global factor in `N_f=i^(1-f) N_1^tensor f` cancels in conjugation, +so `A_f=A_1^tensor f` after bitwise regrouping. The one-bit A has native +B-rank two. Its exact selected-native lowering is saved in +`CONJUGATED-REFLECTION.json`; tensoring the literal monomial/native/ +monomial equality implements A_f with one native-2f child and two fixed +bitwise monomial adapters, not two N queries. Its B-rank is exactly 2f, +and `A_f^2=I`. ADDRESS and quadratic Gaussian phase scans for both adapters +remain paid. The direct actual recipe checks cover f=1,2,3, including +global phase, while the tensor proof covers every f>=1. + +In particular, with scalar bank shear E12 and +`B_R=E12 diag(I,R) E12^-1`, + + Ad_diag(N,N)(B_R) = E12 diag(I,A_f) E12^-1. + +The right side costs one H2, two scalar ADD scans and the two monomial +adapters. Both independent bank columns and the literal inverse are +checked in the phase-sensitive tensor algebra. This does not itself +cancel a persistent factory or establish a supplier, stock surplus, +all-size transfer, precision bound, owner allocation, or tape bound. diff --git a/research/marked-residual-reflection/source/native-frames/ORTHOGONAL-SOURCE-NORMALIZER.json b/research/marked-residual-reflection/source/native-frames/ORTHOGONAL-SOURCE-NORMALIZER.json new file mode 100644 index 0000000000..6bb64c44d0 --- /dev/null +++ b/research/marked-residual-reflection/source/native-frames/ORTHOGONAL-SOURCE-NORMALIZER.json @@ -0,0 +1,164 @@ +{ + "all_parameter_schema": "For j old native planes (2j chunks), put D=diag phasei on everyoldp bit and-i on everyoldq bit. Exact G_old=product(N_i)=i^j D^-1 H_all D. If binaryA is orthogonal,A^T A=I, then its literal ADDRESS permutation P_A commutes ordinary WalshH_all. Hence R_A=D^-1 P_A D is monomial and commutesG_old, including all global phases, for every f>=1.", + "evidence_domain": "Written all-j/all-f orthogonal conjugation proof and explicit all-f bare-phase/leakage proof; actual Gaussian phase/source-column checks for pairedj2 f1/f2/f3 and unpairedj3 f1/f2; independent64-point actual Fourier-character sums. The paired candidate is correctly rejected as a marked-C escape. No f1-only native admission is extrapolated.", + "explicit_unpaired_reflection": "On three complete oldplanes ordered(p0,q0,p1,q1,p2,q2), take v=(1,1,1,0,1,0), A=I+vv^T. Its support has three p chunks and one q. v^Tv=0, so A^2=A^T A=I. Apply it bitwise at all f positions. Writing d(x)=sum pbits-sum qbits, if v.x is odd then d(x)-d(Ax)=2 d_v(x)-2=0 mod4; otherwise zero. Thus R_A=D^-1 P_A D=P_A literally, with no extra Gaussian phase.", + "limits": [ + "A complete caller must retain the changed noncommuting kernelsN0R and their independent-input sourcecodes, all public couplings and the literal inverse.", + "The old scalar quadratic caller cannot be reused by pretendingK^2=-I.", + "No full exponent, stock/owner, all-size, precision or tape claim is made." + ], + "literal_gaussian_chart": "Ononebit Hp=e^(-i pi/4) S^-1 H S and Hq=e^(+i pi/4) S H S^-1, S=diag(1,i). Their scalar factors cancel within each actual pairN=i Hp Hq, giving the exact i^j formula above. This is a conjugation identity in Gaussian operators; no irrational phase is introduced by the implementedR, which usesonly D/P_A/D^-1 with Gaussian-unit entries.", + "marked_character_checks": { + "paired_negative_control": { + "all_f_lift": "The map is bitwise. With one residual mark r=(p0,q1^f), its owner inside the balanced support makes v.w=1 at every position and R fixes the character. An owner outside makes R complement only unmarked virtual bits. The marked owner bit is unchanged.", + "marked_C_commutes": true, + "one_mark_characters_checked": 24 + }, + "unpaired_escape": { + "actual_character_matrix_coefficient": [ + "1", + "0" + ], + "all_f_lift": "Put ones on all f q0 positions and zeros elsewhere. Bare bitwise ADDRESS sends this X character to ones on all p0,p1,p2 positions, changing exactly one residual mark into three for every f>=1. No diagonal pair gauge can remove this nonzero leakage.", + "input_X_character": 2, + "input_residual_marks": [ + 1, + 0, + 0 + ], + "output_X_character": 21, + "output_residual_marks": [ + 1, + 1, + 1 + ] + } + }, + "native_model_sha256": "6397a86bd3d1461be182fcfa8602b0c70c489964a8c14f12436ba2506e11d9e3", + "native_zero_lowering": "The useful unpaired R is the explicit bitwise binary ADDRESS map A=I+vv^T itself. Its inverse is the same literal scan. Both new scans use only completed old chunks. The fixed binary controller and all address/source work remain paid.", + "no_new_kappa": true, + "paired_actual_checks": [ + { + "f": 1, + "kernel_fourth_power": "I", + "kernel_power_native_arities": [ + 2, + 2, + 2, + 0 + ], + "native_R": 0, + "new_fresh_plane": 2, + "source_frame_commutes_actual_phase": true, + "source_old_native_planes": [ + 0, + 1 + ] + }, + { + "f": 2, + "kernel_fourth_power": "I", + "kernel_power_native_arities": [ + 4, + 4, + 4, + 0 + ], + "native_R": 0, + "new_fresh_plane": 2, + "source_frame_commutes_actual_phase": true, + "source_old_native_planes": [ + 0, + 1 + ] + }, + { + "f": 3, + "kernel_fourth_power": "I", + "kernel_power_native_arities": [ + 6, + 6, + 6, + 0 + ], + "native_R": 0, + "new_fresh_plane": 2, + "source_frame_commutes_actual_phase": true, + "source_old_native_planes": [ + 0, + 1 + ] + } + ], + "paired_one_bit_monomial_recipe": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 14, + 13, + 11, + 7, + 16, + 32 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "paired_reflection_negative_control": "On two complete oldplanes v=1111 gives a legal typed R, but it COMMUTES with the marked-residual C. It is not an escape from that grammar floor. Its kernel K=N0R has exact K^4=I and nativearities2f,2f,2f,0 for its first four powers.", + "per_pair_invoice": { + "delivery_ADD_scans": 1, + "existing_source_ADDRESS_scans": 1, + "native_H2": 2, + "native_rank_mass": 4, + "new_R_ADDRESS_scans": 2, + "new_R_diagonal_phase_scans": 0, + "ordinary_helpers": 0, + "private_fields": 0 + }, + "producer_sha256": "c6373762bd15763625cc9237bb280a5e26ab8e53d6bfb034474f068b1525e6fa", + "scientific_pin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "source_cut_binding": "At stagej with oldF=productfresh1..j-1, source N0oldF is full G_old. Insert R before the source delivery and R^-1 immediately after. Then sourcePj and targetNj give boundary Fnew[[Pj,0],[N0R,I]]. The sourceoriginal column, targetoriginal column, arbitrary source crosscolumn and literal inverse all retain their phases. This doesnot assert(N0R)^2=-I.", + "status": "PASS_ALL_F_ORTHOGONAL_TYPED_SOURCE_NORMALIZER", + "unpaired_actual_checks": [ + { + "actual_typed_R_equals_bare_ADDRESS": true, + "f": 1, + "kernel_native_arity": 2, + "native_R": 0, + "new_fresh_plane": 3, + "old_native_planes": [ + 0, + 1, + 2 + ], + "source_and_cross_columns_actual_phase": true + }, + { + "actual_typed_R_equals_bare_ADDRESS": true, + "f": 2, + "kernel_native_arity": 4, + "native_R": 0, + "new_fresh_plane": 3, + "old_native_planes": [ + 0, + 1, + 2 + ], + "source_and_cross_columns_actual_phase": true + } + ] +} diff --git a/research/marked-residual-reflection/source/native-frames/SOURCE-PROGRESS-TRADEOFF.json b/research/marked-residual-reflection/source/native-frames/SOURCE-PROGRESS-TRADEOFF.json new file mode 100644 index 0000000000..f772201387 --- /dev/null +++ b/research/marked-residual-reflection/source/native-frames/SOURCE-PROGRESS-TRADEOFF.json @@ -0,0 +1,72 @@ +{ + "actual_checks": [ + { + "actual_Gaussian_minus_sign_verified": true, + "exact_standard_target_completion_arity": 4, + "f": 1, + "native_arities": { + "N_T_prime": 2, + "P_prime": 0, + "T_prime": 2, + "conjugated_factory": 2, + "standard_N_N2": 4 + }, + "old_N1_frame_commutator_arity": 2 + }, + { + "actual_Gaussian_minus_sign_verified": true, + "exact_standard_target_completion_arity": 8, + "f": 2, + "native_arities": { + "N_T_prime": 4, + "P_prime": 0, + "T_prime": 4, + "conjugated_factory": 4, + "standard_N_N2": 8 + }, + "old_N1_frame_commutator_arity": 4 + }, + { + "actual_Gaussian_minus_sign_verified": true, + "exact_standard_target_completion_arity": 12, + "f": 3, + "native_arities": { + "N_T_prime": 6, + "P_prime": 0, + "T_prime": 6, + "conjugated_factory": 6, + "standard_N_N2": 12 + }, + "old_N1_frame_commutator_arity": 6 + } + ], + "all_f_lift": "The reflection and P2 are bitwise tensor families, and N_f^2=-I is already an exact all-f identity with one global i per plane. The rank equality and compensation inequality are written dimension-independent proofs. The displayed specific ranks follow by tensor-direct-sum B rank; the actual sign is checked independently at f1/f2/f3. No claim N_f*T_prime,f=(N_1*T_prime,1)^tensor f is made without its global phase.", + "all_parameter_identity": "For any invertible monomial Clifford P and actual N with N^2=-I, define T=P N P^-1. Then (N P N^-1) P^-1=-N T. This is a literal operator equality, including the global minus sign, for every ambient dimension and f.", + "all_parameter_rank_equality": "Native Clifford arity is the rank of its binary B block. Right or left multiplication by an invertible monomial Clifford and a global scalar preserves that rank. Therefore arity(Ad_N(P))=arity(N T) exactly. In particular a cheap2f factory conjugate cannot simultaneously supply independent common+new progress of arity4f through this same P and T.", + "local_compensation_lower_bound": "For Clifford operators A,B, B_(AB)=A_A B_B+B_A D_B, so rank B_(AB)<=rank B_A+rank B_B. Any unary compensation word, with arbitrary monomial Clifford adapters between its native children, increasing a2f operator to actual nativearity4f needs sum additional native arities>=2f. This is a single-field endpoint statement and does not assume the marked-residual bridge grammar.", + "no_new_kappa": true, + "producer_sha256": "847a7654eddf538745416d48dbd4394beda8d0b13b1e3e46164e5e41b6475f52", + "scientific_pin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "scope": [ + "The two-sided reflection factory lowering remains a legitimate local native resource.", + "A different source/delivery map or a bank-coupled word may change the pair P,T and is not excluded.", + "A sum of paths, borrowed inputs, dirty helpers and source reads requires its complete independent-column analysis; the unary rank inequality does not replace that.", + "No supplier, stock surplus, precision, all-size or tape conclusion follows." + ], + "source_pins": [ + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/native_model.py", + "sha256": "6397a86bd3d1461be182fcfa8602b0c70c489964a8c14f12436ba2506e11d9e3" + }, + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/orthogonal_source_normalizer.py", + "sha256": "c6373762bd15763625cc9237bb280a5e26ab8e53d6bfb034474f068b1525e6fa" + }, + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/conjugated_factory.py", + "sha256": "81a75479e21d70181e4aa70746be3a4a31bcb3ddd1bd00a4a1b812bf126d7caf" + } + ], + "specific_two_sided_factory": "P_prime=R P2 R, R=ADDRESS(I+vv^T), v=(p0,q0,p1,p2); T_prime=P_prime N0 P_prime^-1. The cheap conjugate of CONJUGATED-FACTORY.json is valid, but N0*T_prime has arity2f, while N0*N2 has arity4f. The literal standard-target correction (N0*N2)(N0*T_prime)^-1 has arity4f. P_prime also changes the oldN1 chart: its commutator with N1 has arity2f.", + "status": "PASS_ALL_F_LOCAL_FACTORY_PROGRESS_TRADEOFF" +} diff --git a/research/marked-residual-reflection/source/native-frames/conjugated_factory.py b/research/marked-residual-reflection/source/native-frames/conjugated_factory.py new file mode 100644 index 0000000000..16db14187d --- /dev/null +++ b/research/marked-residual-reflection/source/native-frames/conjugated_factory.py @@ -0,0 +1,69 @@ +#!/usr/bin/env python3 +"""A one-child lowering for the genuinely two-sided R P2 R factory. +Apache-2.0; substantial OpenAI Codex assistance. No free source substitution. +""" +from pathlib import Path +import argparse +import hashlib +import json +from native_model import * +from orthogonal_source_normalizer import reflection +from conjugated_reflection import tensor_monomial + +HERE = Path(__file__).resolve().parent + + +def run(): + z1 = Model(1, 3) + R1, _ = reflection(z1, 3, (0, 1, 2, 4)) + M1 = mul(R1, z1.P[1], R1) + B1 = mul(z1.N, M1, z1.N.adjoint()) + recipe, compiled = ce.lower_child(B1) + need(recipe['rank'] == 2, 'two-sided factory conjugate native2') + same(B1, compiled, 'literal one-bit factory lowering phase') + checks = [] + for f in (1, 2, 3): + z = Model(f, 3) + R, _ = reflection(z, 3, (0, 1, 2, 4)) + M = mul(R, z.P[1], R) + B = mul(z.N, M, z.N.adjoint()) + literal = mul(tensor_monomial(recipe['left'], f), + ce.fourier(z.n, range(2 * f)), tensor_monomial(recipe['right'], f)) + same(B, literal, 'two-sided factory all-f tensor recipe phase') + same(mul(B, B), z.I, 'two-sided factory literal involution') + ranks = [b.native_rank(mul(z.N, X, z.N.adjoint())) + for X in (z.P[1], mul(R, z.P[1]), mul(z.P[1], R), M)] + need(ranks == [4 * f, 4 * f, 4 * f, 2 * f], 'both R sides are required for this saving') + checks.append({'f': f, 'ranks_P2_RP2_P2R_RP2R': ranks, + 'actual_native_recipe_phase': True, 'inverse': 'same operator'}) + return {'status': 'PASS_ALL_F_TWO_SIDED_REFLECTION_FACTORY_SINGLE_CHILD', + 'scientific_pin': PIN, + 'producer_sha256': hashlib.sha256(Path(__file__).read_bytes()).hexdigest(), + 'source_pins': [{'path': str(HERE/name), 'sha256': hashlib.sha256((HERE/name).read_bytes()).hexdigest()} + for name in ('native_model.py', 'orthogonal_source_normalizer.py', 'conjugated_reflection.py')], + 'exact_operator': 'B=N0 R P2 R N0^-1, P2=SWAP(plane0,plane2), R=ADDRESS(I+vv^T), v=(p0,q0,p1,p2).', + 'all_f_proof': 'P2_f and R_f are bitwise tensors. Global N_f phases cancel in conjugation, so B_f=B_1^tensor f. The explicit actual one-bit equality B_1=L C_2 R_adapter tensor-lifts with fixed bitwise ADDRESS/quadratic-phase controllers to one selected native2f query. B_1 has B-rank2, so B_f has exact B-rank2f, including all f-dependent adapter phase powers.', + 'one_bit_selected_native_recipe': recipe, + 'complete_unary_invoice': {'native_H2': 1, 'native_rank_mass': 2, + 'monomial_adapters': 2, 'ADDRESS_scans_at_most': 2, + 'Gaussian_quadratic_phase_scans_at_most': 2, + 'ordinary_helpers': 0, 'private_fields': 0}, + 'actual_checks': checks, + 'caller_obligation': 'This bill applies only to the literal B shown. An outgoing source P2 is not replaced for free. R uses the stage2-future plane2, so supplying both R sides at a legal caller cut with all source/target columns and fresh coverage is a separate obligation. A global chart change also transports N and cannot be used to claim this saving while holding N fixed.', + 'COPY_precision_tape_obligations': 'Native lowering is a Fourier/supplier query with arbitrary input. Any source COPY to a fanout, all bank reads, the two monomial ADDRESS/phase adapters, their reversible scans, precision/rounding propagation, source-bound block norms, and physical tape return remain paid caller obligations. No endpoint, all-size recursion, stock or exponent follows from this unary identity.', + 'evidence_domain': 'Written exact all-f tensor proof, actual Gaussian recipe and phase checks f1/f2/f3, and one-sided negative controls. No finite-f extrapolation and no formal-kernel claim.', + 'no_new_kappa': True} + + +if __name__ == '__main__': + p = argparse.ArgumentParser(description=__doc__) + p.add_argument('--write', action='store_true') + args = p.parse_args() + out = json.loads(json.dumps(run())) + path = HERE/'CONJUGATED-FACTORY.json' + if args.write: + path.write_text(json.dumps(out, indent=2, sort_keys=True)+'\n') + else: + need(json.loads(path.read_text()) == out, 'saved conjugated factory differs') + print(out['status']) + print(out['complete_unary_invoice']) diff --git a/research/marked-residual-reflection/source/native-frames/conjugated_reflection.py b/research/marked-residual-reflection/source/native-frames/conjugated_reflection.py new file mode 100644 index 0000000000..341df23adc --- /dev/null +++ b/research/marked-residual-reflection/source/native-frames/conjugated_reflection.py @@ -0,0 +1,111 @@ +#!/usr/bin/env python3 +"""One native child for the common conjugate of an unpaired ADDRESS reflection. +Apache-2.0; substantial OpenAI Codex assistance. This is a local resource. +""" +from pathlib import Path +import argparse +import hashlib +import json +from native_model import * +from orthogonal_source_normalizer import reflection +from lifted_algebra import Algebra + +HERE = Path(__file__).resolve().parent + + +def tensor_monomial(recipe, f): + """Lift every one-bit wire and phase bitwise, retaining its actual phase.""" + chunks = len(recipe['matrix_rows']) + n = chunks * f + def bitlift(mask, k): + return sum(1 << (chunk * f + k) for chunk in range(chunks) if (mask >> chunk) & 1) + rows = [bitlift(recipe['matrix_rows'][chunk], k) for chunk in range(chunks) for k in range(f)] + quadratic = [bitlift(recipe['quadratic_rows'][chunk], k) for chunk in range(chunks) for k in range(f)] + alpha = [recipe['linear_Z4'][chunk] for chunk in range(chunks) for k in range(f)] + offset = sum(bitlift(recipe['offset'], k) for k in range(f)) + return mul(phase(n, f * recipe['phase']), ce.xgate(n, offset), + ce.perm(n, rows), ce.diag(n, quadratic, alpha)) + + +def run(): + z1 = Model(1, 3) + R1, _ = reflection(z1, 3, (0, 1, 2, 4)) + base_native = [z1.N, z1.T[0], z1.T[1]] + onebit_conjugates = [mul(Ni, R1, Ni.adjoint()) for Ni in base_native] + recipes = [] + for A in onebit_conjugates: + rec, compiled = ce.lower_child(A) + need(rec['rank'] == 2, 'one-bit conjugate has native rank2') + same(compiled, A, 'actual selected-native one-bit lowering') + recipes.append(rec) + A1, recipe = onebit_conjugates[0], recipes[0] + checks = [] + for f in (1, 2, 3): + z = Model(f, 3) + R, _ = reflection(z, 3, (0, 1, 2, 4)) + for plane, (Ni, rec) in enumerate(zip([z.N, z.T[0], z.T[1]], recipes)): + A = mul(Ni, R, Ni.adjoint()) + left = tensor_monomial(rec['left'], f) + right = tensor_monomial(rec['right'], f) + literal = mul(left, ce.fourier(z.n, range(2 * f)), right) + same(literal, A, 'tensor-lifted native child actual phase') + same(mul(A, A), z.I, 'conjugated reflection literal involution') + need(b.native_rank(A) == 2 * f, 'conjugated reflection rank2f') + need(b.native_rank(left) == b.native_rank(right) == 0, 'literal adapters monomial') + checks.append({'f': f, 'conjugating_old_plane': plane, + 'native_arity': 2 * f, 'inverse': 'same A', + 'tensor_recipe_actual_Gaussian_phase': True}) + + # Independently retain both bank columns over the exact all-f tensor algebra. + a = Algebra(3) + R, A = a.lift(R1), a.lift(A1) + def shear(sign): + out = a.mat_identity(2) + out[0][1] = a.scale(a.one, sign) + return out + E, Ei = shear(1), shear(-1) + BR = a.mat_product(a.mat_product(E, a.diagonal(2, 1, R)), Ei) + conjugated = a.mat_product(a.mat_product(a.diagonal(2, 0, a.N), a.diagonal(2, 1, a.N)), BR) + conjugated = a.mat_product(conjugated, a.mat_product(a.diagonal(2, 0, a.adjoint(a.N)), a.diagonal(2, 1, a.adjoint(a.N)))) + expected = a.mat_product(a.mat_product(E, a.diagonal(2, 1, A)), Ei) + need(conjugated == expected, 'two independent bank-column conjugation identity') + need(a.mat_product(expected, expected) == a.mat_identity(2), 'literal bank word inverse') + return {'status': 'PASS_ALL_F_SINGLE_CHILD_CONJUGATED_UNPAIRED_REFLECTION', + 'scientific_pin': PIN, + 'producer_sha256': hashlib.sha256(Path(__file__).read_bytes()).hexdigest(), + 'reflection_source_sha256': hashlib.sha256((HERE/'orthogonal_source_normalizer.py').read_bytes()).hexdigest(), + 'native_model_sha256': hashlib.sha256((HERE/'native_model.py').read_bytes()).hexdigest(), + 'actual_operator': 'R=P_(I+vv^T), v=(1,1,1,0,1,0) on completed(p0,q0,p1,q1,p2,q2); A=N0 R N0^-1.', + 'all_f_tensor_identity': 'R_f is the bitwise tensor product of R_1. N_f=i^(1-f) N_1^tensor f after regrouping address coordinates. Its global unit cancels in conjugation, so A_f=A_1^tensor f literally, including phase. Tensoring the explicit one-bit monomial/native/monomial equality therefore gives A_f=L_f C_(2f) R_f_adapter. All three factors have fixed bitwise controllers; no f1 tableau-only inference is used.', + 'native_rank_proof': 'The binary B block of A_1 has rank2. Direct sums under bitwise tensor regrouping have rank2f, so A_f and its inverse have exact native arity2f for every f>=1. A_f^2=I by conjugation of R_f^2=I.', + 'one_bit_selected_native_recipe': recipe, + 'one_bit_selected_native_recipes_by_old_plane': recipes, + 'actual_tensor_recipe_checks': checks, + 'old_plane_extension': 'The same exact single-child admission holds for A_i=N_i R N_i^-1 on each i=0,1,2, with the three explicit recipes retained. Since N_i=i H_i and H_i=Hp_i Hq_i is involutive, this is also H_i R H_i without any external i. The tensor proof and all adapter phase powers apply separately to each saved recipe.', + 'single_unary_invoice': {'native_H2': 1, 'native_rank_mass': 2, + 'monomial_adapters': 2, 'ADDRESS_scans_at_most': 2, + 'Gaussian_quadratic_phase_scans_at_most': 2, + 'ordinary_helpers': 0, 'private_fields': 0}, + 'two_bank_identity': 'For E12=I+e1e2^T and B_R=E12 diag(I,R) E12^-1, Ad_(diag(N,N))(B_R)=E12 diag(I,A) E12^-1. Both independent inputs are retained. Its literal inverse reverses the shears and applies A^-1=A; the entire displayed conjugated word is itself involutive.', + 'two_bank_invoice': {'native_H2': 1, 'native_rank_mass': 2, + 'scalar_ADD_scans': 2, 'monomial_adapters': 2, + 'ordinary_helpers': 0, 'private_fields': 0}, + 'evidence_domain': 'Written all-f exact tensor proof and native B-rank proof; independent actual Gaussian compiled checks at f1/f2/f3; all-f two-bank polynomial coefficients checked in the phase-sensitive tensor algebra.', + 'limits': ['This is a changed legal local bridge, not a completed caller or shared-debt cancellation.', + 'The source-kernel N0R is not assumed quadratic, and no old scalar caller is imported by that assumption.', + 'All bank ADD, ADDRESS and phase scans are paid; no source access, owner, precision, all-size or tape gate is discharged.'], + 'no_new_kappa': True} + + +if __name__ == '__main__': + p = argparse.ArgumentParser(description=__doc__) + p.add_argument('--write', action='store_true') + args = p.parse_args() + out = json.loads(json.dumps(run())) + path = HERE/'CONJUGATED-REFLECTION.json' + if args.write: + path.write_text(json.dumps(out, indent=2, sort_keys=True)+'\n') + else: + need(json.loads(path.read_text()) == out, 'saved conjugated reflection differs') + print(out['status']) + print(out['single_unary_invoice']) diff --git a/research/marked-residual-reflection/source/native-frames/lifted_algebra.py b/research/marked-residual-reflection/source/native-frames/lifted_algebra.py new file mode 100644 index 0000000000..a63509e504 --- /dev/null +++ b/research/marked-residual-reflection/source/native-frames/lifted_algebra.py @@ -0,0 +1,123 @@ +"""Exact all-f tensor algebra with one distinguished Pauli-controlled coordinate. +Apache-2.0; substantial OpenAI Codex assistance. No finite-f extrapolation. +""" +from dataclasses import dataclass +from fractions import Fraction as F +from native_model import * +@dataclass(frozen=True) +class G: + a:F=F(0);b:F=F(0) + def __add__(s,t): + if not isinstance(t,G):t=G(F(t)) + return G(s.a+t.a,s.b+t.b) + def __neg__(s):return G(-s.a,-s.b) + def __sub__(s,t):return s+-t + def __mul__(s,t): + if not isinstance(t,G):t=G(F(t)) + return G(s.a*t.a-s.b*t.b,s.a*t.b+s.b*t.a) + def conj(s):return G(s.a,-s.b) + def __truediv__(s,t): + if not isinstance(t,G):t=G(F(t)) + d=t.a*t.a+t.b*t.b;need(bool(d),'nonzero Gaussian divisor');return s*t.conj()*G(1/d) + def __bool__(s):return bool(s.a or s.b) + def encode(s):return[str(s.a),str(s.b)] +ZERO=G();ONE=G(F(1));I=G(F(0),F(1));UNITS=(ONE,I,-ONE,-I) +def phasevec(q):return tuple(UNITS[(q if isinstance(q,int)else q(r))%4]for r in range(4)) +def cadd(a,c):return tuple(x+y for x,y in zip(a,c)) +def cmul(a,c):return tuple(x*y for x,y in zip(a,c)) +def cconj(a):return tuple(x.conj()for x in a) +def czero(a):return not any(a) +class Algebra: + def __init__(self,stages=4): + self.stages=stages;self.m=2+2*stages;self.rep={};self.products={};self.inverses={};self.phase_cache={};self.model=Model(1,stages);self.idkey=self.canonical(ce.ident(self.m))[0] + self.one={(self.idkey,self.idkey):(ONE,)*4};self.N=self.lift(self.model.N,exponent=1);self.U=self.lift(self.model.U);self.V=self.product(self.N,self.adjoint(self.U));self.P=[self.lift(x)for x in self.model.P];self.T=[self.lift(x,exponent=1)for x in self.model.T];self.Q=[] + for s in range(stages+1):self.Q.append(self.lift(ce.xgate(self.m,1<<(2*s)),ce.ident(self.m))) + def canonical(self,op): + key=op.tab + # Same signed tableau means the representative differs by exactly a Gaussian unit. + state,depth=b.sparse_column(op);first=state[min(state)];q=None + for j in range(4): + a,c=b.gaussian_unit(first,-j) + if a>0 and c>=0:q=j;break + need(q is not None,'canonical Gaussian amplitude phase') + if key not in self.rep:self.rep[key]=op.then(phase(op.n,-q)) + return key,q + def multiply_keys(self,a,c): + if(a,c)not in self.products:self.products[(a,c)]=self.canonical(mul(self.rep[a],self.rep[c])) + return self.products[(a,c)] + def adjoint_key(self,a): + if a not in self.inverses:self.inverses[a]=self.canonical(self.rep[a].adjoint()) + return self.inverses[a] + def lift(self,dist,bulk=None,exponent=0): + if bulk is None:bulk=dist + kd,qd=self.canonical(dist);kb,qb=self.canonical(bulk) + need(b.binary_tableau(dist)==b.binary_tableau(bulk),'distinguished difference must be Pauli only') + return{(kd,kb):phasevec(lambda r:exponent*(1-r)+qd+qb*(r-1))} + def add(self,a,c): + out=dict(a) + for k,v in c.items(): + w=cadd(out.get(k,(ZERO,)*4),v) + if czero(w):out.pop(k,None) + else:out[k]=w + return out + def scale(self,a,c): + if not isinstance(c,G):c=G(F(c)) + return{k:tuple(c*x for x in v)for k,v in a.items()if c} + def product(self,a,c): + out={} + for(ad,ab),av in a.items(): + for(cd,cb),cv in c.items(): + kd,qd=self.multiply_keys(ad,cd);kb,qb=self.multiply_keys(ab,cb);phase=phasevec(lambda r:qd+qb*(r-1));value=cmul(cmul(av,cv),phase);key=(kd,kb);value=cadd(out.get(key,(ZERO,)*4),value) + if czero(value):out.pop(key,None) + else:out[key]=value + return out + def adjoint(self,a): + out={} + for(ad,ab),av in a.items(): + kd,qd=self.adjoint_key(ad);kb,qb=self.adjoint_key(ab);value=cmul(cconj(av),phasevec(lambda r:qd+qb*(r-1)));out=self.add(out,{(kd,kb):value}) + return out + def mat_identity(self,n):return[[dict(self.one)if i==j else{}for j in range(n)]for i in range(n)] + def mat_product(self,a,c): + n=len(a);out=[[{}for j in range(n)]for i in range(n)] + for i in range(n): + for k in range(n): + if not a[i][k]:continue + for j in range(n): + if c[k][j]:out[i][j]=self.add(out[i][j],self.product(a[i][k],c[k][j])) + return out + def router(self,n,a,c,selector=0,sign=1): + out=self.mat_identity(n);Q=self.scale(self.Q[selector],sign);ep=self.scale(self.add(self.one,Q),F(1,2));em=self.scale(self.add(self.one,self.scale(Q,-1)),F(1,2));out[a][a]=out[c][c]=ep;out[a][c]=out[c][a]=em;return out + def diagonal(self,n,bank,op):out=self.mat_identity(n);out[bank][bank]=op;return out + def continuation(self,choice): + if choice=='U':return self.U + if choice=='V':return self.V + # alpha_f=(-i)^(f+1), selected completed fresh1 p-bit. Conditional + # continuation is directly admitted by the R diag(U,I) R word. + need(choice in('C+','C-'),'known role') + Q=self.Q[1];ep=self.scale(self.add(self.one,Q),F(1,2));em=self.scale(self.add(self.one,self.scale(Q,-1)),F(1,2));alpha=phasevec(lambda r:-r-1);av={k:cmul(v,alpha)for k,v in self.V.items()} + return self.add(self.product(ep if choice=='C+'else em,self.U),self.product(em if choice=='C+'else ep,av)) + def box(self,n,stage,kind,target,source,role='U',c=1,target_P=False): + out=self.mat_identity(n);W=self.continuation(role);P=self.P[stage] + if kind=='F':out[source][source]=self.product(W,P);out[target][source]=self.scale(self.N,c) + elif kind=='G': + Wi=self.adjoint(W);out[source][source]=Wi;out[target][target]=P;out[target][source]=self.scale(self.product(self.product(P,self.N),Wi),c) + else:raise ValueError(kind) + if target_P: + need(kind=='F','only forward postdelivery/pre-T target P admitted') + out=self.mat_product(self.diagonal(n,target,P),out) + return out + def allf_target_residual(self,a): + # Right-normalize the desired full native common N. A positive result + # has entries in the fixed distinguished Pauli algebra, bulk identity. + Ni=self.adjoint(self.N);res=[] + for row in a: + rr=[] + for entry in row: + v=self.product(entry,Ni) + if any(kb!=self.idkey for kd,kb in v):return None + if any(b.binary_tableau(self.rep[kd])!=b.binary_tableau(ce.ident(self.m))for kd,kb in v):return None + rr.append(v) + res.append(rr) + return res + def fingerprint(self,a): + return tuple(tuple(tuple(sorted((str(k),tuple((v.a,v.b)for v in vec))for k,vec in entry.items()))for entry in row)for row in a) diff --git a/research/marked-residual-reflection/source/native-frames/native_model.py b/research/marked-residual-reflection/source/native-frames/native_model.py new file mode 100644 index 0000000000..0ab770f491 --- /dev/null +++ b/research/marked-residual-reflection/source/native-frames/native_model.py @@ -0,0 +1,67 @@ +"""Pinned Gaussian Clifford model for common2/fresh2 native bridges. +Apache-2.0; substantial OpenAI Codex assistance. Frozen imports are read only. +""" +from pathlib import Path +import hashlib,importlib.util,sys +sys.dont_write_bytecode=True +BASE=Path(__file__).resolve().parents[1] +PIN='20ecf2891d80b5acf18d980b2164fb44ea7faa90' +CE_PATH=BASE/'vendor/clifford_exact.py' +CE_SHA='2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962' +BOUND_PATH=BASE/'vendor/full_stabilizer_bound.py' +BOUND_SHA='f073a00ad4831616e873eb110fd33ad7226010a7c2f6cfa6a6b63167bf58ef75' +def need(ok,why): + if not ok:raise ValueError(why) +def load(name,path,sha): + need(hashlib.sha256(path.read_bytes()).hexdigest()==sha,'source pin '+str(path)) + spec=importlib.util.spec_from_file_location(name,path);mod=importlib.util.module_from_spec(spec);sys.modules[name]=mod;spec.loader.exec_module(mod);return mod +ce=load('native_frames_pinned_clifford',CE_PATH,CE_SHA) +b=load('native_frames_frozen_independent',BOUND_PATH,BOUND_SHA) +def mul(*ops):return b.standard_product(ce,*ops) +def same(a,c,why,phase=True): + need(a.tab==c.tab,why+' signed tableau') + if phase:need(b.sparse_column(a)==b.sparse_column(c),why+' actual Gaussian phase') +def phase(n,p):return ce.Op(n,ce.identity(n),[('phase',p%4)]) +def symplectic_defect_rank(op): + return b.binary_rank(x^y for x,y in zip(b.binary_tableau(op),b.binary_tableau(ce.ident(op.n)))) +def pauli(n,x=0,z=0,p=0): + out=ce.diag(n,[0]*n,[2*((z>>j)&1)for j in range(n)]) + return mul(phase(n,p),ce.xgate(n,x),out) +def conjugated_pauli(op,x=0,z=0,p=0): + triple=ce.apply(op.tab,(x,z,p));return pauli(op.n,*triple),triple +class Model: + def __init__(self,f=1,stages=4): + need(f>=1 and stages>=1,'positive chunk/stages');self.f=f;self.stages=stages;self.n=(2+2*stages)*f;self.I=ce.ident(self.n) + self.N=self.Npair(0,1);self.U=self.Hp(0);self.V=mul(self.N,self.U.adjoint()) + self.P=[self.swap_pair(s+1)for s in range(stages)];self.T=[self.Npair(2+2*s,3+2*s)for s in range(stages)] + self.Q=ce.xgate(self.n,1) + def Hp(self,chunk): + out=self.I + for j in range(self.f): + bit=chunk*self.f+j;alpha=[0]*self.n;alpha[bit]=2 + out=mul(ce.diag(self.n,[0]*self.n,alpha),ce.cgate(self.n,1<=4,'pqqp uses4 stages');gs=[self.I,self.I];controls=[];F=self.I + for s,(kind,W) in enumerate(zip('FGFG',[self.U,self.V,self.V,self.U])): + required=self.phi(gs[1])if kind=='F'else mul(W,self.N.adjoint(),gs[1],self.N,W.adjoint()) + L=mul(required,gs[0].adjoint());controls.append(L);gs[0]=required + if kind=='F':gs=[gs[0],mul(W,self.P[s],gs[1],W.adjoint())] + else:gs=[mul(W.adjoint(),gs[0],W),mul(self.P[s],gs[1])] + F=mul(self.T[s],F) + return gs,controls diff --git a/research/marked-residual-reflection/source/native-frames/one_chunk_phase.py b/research/marked-residual-reflection/source/native-frames/one_chunk_phase.py new file mode 100644 index 0000000000..fa0d81c267 --- /dev/null +++ b/research/marked-residual-reflection/source/native-frames/one_chunk_phase.py @@ -0,0 +1,78 @@ +#!/usr/bin/env python3 +"""Exact phase limits of a one-typed-chunk order-four native operator. +Apache-2.0; substantial OpenAI Codex assistance. Tag extension is separate. +""" +from pathlib import Path +import argparse +import hashlib +import json +from native_model import * + +HERE = Path(__file__).resolve().parent + + +def run(): + checks = [] + for f in range(1, 6): + z = Model(f, 1) + for name, base, square in [('Hp', z.Hp(0), -f), ('Hq', z.Hq(0), f)]: + B = mul(phase(z.n, 1), base) + same(mul(B, B), phase(z.n, 2 + square), 'literal i typedchunk square') + need(b.native_rank(B) == f, 'typedchunk native arity') + if f % 2 == 0: + gamma = f // 2 + 1 if name == 'Hp' else 1 - f // 2 + normalized = mul(phase(z.n, gamma), base) + same(mul(normalized, normalized), phase(z.n, 2), 'even chunk Gaussian-unit normalization') + checks.append({'f': f, 'type': name, 'native_arity': f, + 'square_of_iH_as_i_exponent': (2 + square) % 4, + 'Gaussian_scalar_normalization_to_minus_I': f % 2 == 0}) + # One tag BIT is an explicit extra coordinate. It is not part of + # the claimed flat f-bit one-chunk domain. + tag = f + alpha = [0] * z.n + alpha[tag] = (f + 2) % 4 # c=-i^f; M=[[0,1],[c,0]], M^2=cI. + quadratic = [0] * z.n + quadratic[tag] = (1 << tag) if alpha[tag] % 2 else 0 + M = mul(ce.diag(z.n, quadratic, alpha), ce.xgate(z.n, 1 << tag)) + same(mul(M, M), phase(z.n, f + 2), 'actual Gaussian ADDRESS-tag phase') + tagged = mul(z.Hp(0), M) + same(mul(tagged, tagged), phase(z.n, 2), 'tagged operator squares to minus identity') + need(b.native_rank(tagged) == f, 'tag extension remains rankf') + recipe = None + if f == 1: + recipe, compiled = ce.lower_child(tagged) + same(tagged, compiled, 'literal tagged selected-native lowering') + checks.append({'f': f, 'type': 'Hp_with_separate_tag_bit', 'native_arity': f, + 'extra_ADDRESS_bit': tag, 'square': '-I', + 'tag_diagonal_phase_exponent': (f + 2) % 4, + 'selected_native_recipe': recipe}) + return {'status': 'PASS_ONE_CHUNK_PHASE_DOMAIN_AND_SEPARATE_TAG_RESOURCE', + 'scientific_pin': PIN, + 'producer_sha256': hashlib.sha256(Path(__file__).read_bytes()).hexdigest(), + 'native_model_sha256': hashlib.sha256((HERE/'native_model.py').read_bytes()).hexdigest(), + 'all_f_identity': 'Hp_f^2=(-i)^f I and Hq_f^2=i^f I, so (i Hp_f)^2=-(-i)^f I and (i Hq_f)^2=-i^f I. Literal iH squares to-I only when f=0 mod4.', + 'even_f_normalization': 'For even f, gamma_p=i^(f/2+1), gamma_q=i^(1-f/2) are Gaussian units and (gamma_p Hp_f)^2=(gamma_q Hq_f)^2=-I.', + 'odd_f_scalar_obstruction': 'For odd f a scalar normalization requires gamma^2=+i or-i. If gamma=a+bi is Gaussian rational then a^2=b^2 and2ab=+1 or-1, forcing a^2=1/2, impossible rational. Thus no Gaussian-dyadic scalar, unit or nonunit, normalizes the odd-f typed chunk to square-I.', + 'flat_unitary_obstruction_scope': 'More generally, a unitary B acting fully and flatly on exactly f address bits with B^2=-I is skew-Hermitian. Every diagonal is nonzero pure imaginary of magnitude2^(-f/2). Gaussian-dyadic entries cannot have that imaginary value for odd f. This covers unitary monomial left/right gauges of a full one-chunk native Fourier operator; it does not cover an enlarged ambient operator with zero diagonal, nonunitary gauges, arbitrary operators of rankf acting on more thanf bits, or a changed recursive datatype.', + 'tag_resource': 'A separate tag bit admits M_f=[[0,1],[-i^f,0]], an actual ADDRESS X plus Gaussian-unit phase, with M_f^2=-i^f I. Since it is disjoint from Hp_f, B_f=Hp_f tensor M_f has B_f^2=-I and exact nativearityf for every f. This is a changed f+1-bit domain, not a scalar normalization onf bits.', + 'tag_invoice': {'native_arity': 'f', 'extra_address_coordinates': 1, + 'tag_ADDRESS_X_scans': 1, 'tag_phase_scans': 1, + 'native_monomial_adapter_scans_at_most': 2, + 'ordinary_helpers': 0, 'private_fields': 0}, + 'tag_terminal_obligation': 'The extra tag bit remains monomial under this resource. A supplier requiring full native rank on its entire ambient address space must supply its missing tag Fourier progress, or prove a separately charged sector/dispatcher contract. That cost is not waived here. Sharing the tag among planes also changes their product and must be checked literally.', + 'actual_checks': checks, + 'evidence_domain': 'Written all-f scalar/flat-unitary proofs; actual exact Gaussian phase and arity checks for f1..5; one-bit selected-native lowering plus the explicit Hp tensor/native query and monomial tag implementation. No tableau-only extrapolation. Higher-f dense recipe expansion is unnecessary and is not claimed.', + 'no_new_kappa': True} + + +if __name__ == '__main__': + p = argparse.ArgumentParser(description=__doc__) + p.add_argument('--write', action='store_true') + args = p.parse_args() + out = json.loads(json.dumps(run())) + path = HERE/'ONE-CHUNK-PHASE.json' + if args.write: + path.write_text(json.dumps(out, indent=2, sort_keys=True)+'\n') + else: + need(json.loads(path.read_text()) == out, 'stored one-chunk phase receipt differs') + print(out['status']) diff --git a/research/marked-residual-reflection/source/native-frames/orthogonal_source_normalizer.py b/research/marked-residual-reflection/source/native-frames/orthogonal_source_normalizer.py new file mode 100644 index 0000000000..9ffbd4da72 --- /dev/null +++ b/research/marked-residual-reflection/source/native-frames/orthogonal_source_normalizer.py @@ -0,0 +1,182 @@ +#!/usr/bin/env python3 +"""Gaussian-typed binary orthogonal normalizers at a full source cut. + +This is a genuine bit-linear ADDRESS extension beyond plane permutations +and X translations. It is not itself a completed caller construction. +Apache-2.0; substantial OpenAI Codex assistance. +""" +from pathlib import Path +from fractions import Fraction +import argparse +import hashlib +import json +from native_model import * + +HERE = Path(__file__).resolve().parent + + +def typed_D(model, oldplanes): + alpha, quadratic = [0] * model.n, [0] * model.n + for chunk in range(2 * oldplanes): + for bit in range(model.f): + k = chunk * model.f + bit + alpha[k] = 1 if chunk % 2 == 0 else 3 + quadratic[k] = 1 << k + return ce.diag(model.n, quadratic, alpha) + + +def reflection(model, oldplanes=2, support=(0, 1, 2, 3)): + need(len(support) % 2 == 0 and len(support) > 0, 'even nonempty reflection support') + need(max(support) < 2 * oldplanes, 'reflection uses only completed old chunks') + rows = [1 << j for j in range(model.n)] + for out in support: + for bit in range(model.f): + rows[out * model.f + bit] ^= sum(1 << (src * model.f + bit) + for src in support) + D = typed_D(model, oldplanes) + P = ce.perm(model.n, rows) + return mul(D.adjoint(), P, D), rows + + +def gaussian_add(a, c): + return a[0] + c[0], a[1] + c[1] + + +def unit(power): + return ((1, 0), (0, 1), (-1, 0), (0, -1))[power % 4] + + +def marked_character_checks(): + # Actual 64-point Fourier character sum, independent of Clifford tableaux. + def residual(w): + return tuple(((w >> (2 * k)) ^ (w >> (2 * k + 1))) & 1 for k in range(3)) + + def character_coefficient(w, wp, support): + v = sum(1 << k for k in support) + coefficient = (0, 0) + for x in range(64): + Ax = x ^ (v if (x & v).bit_count() % 2 else 0) + dx = sum((1 if k % 2 == 0 else -1) * ((x >> k) & 1) for k in range(6)) + dAx = sum((1 if k % 2 == 0 else -1) * ((Ax >> k) & 1) for k in range(6)) + sign = 2 * (((w & x).bit_count() + (wp & Ax).bit_count()) % 2) + coefficient = gaussian_add(coefficient, unit(dx - dAx + sign)) + return [Fraction(a, 64) for a in coefficient] + + # The initially proposed balanced reflection is NOT an escape. It maps + # w to w+(v.w+1)v and preserves both the unique mark and its virtual bit. + v = 15 + paired_checked = 0 + for w in range(64): + marks = residual(w) + if sum(marks) != 1: + continue + wp = w ^ (v if ((w & v).bit_count() + 1) % 2 else 0) + owner = marks.index(1) + need(character_coefficient(w, wp, (0, 1, 2, 3)) == [1, 0], 'paired exact character map') + need(residual(wp) == marks and ((w >> (2 * owner)) & 1) == ((wp >> (2 * owner)) & 1), 'paired reflection commutes marked C') + paired_checked += 1 + # Unpaired three-p/one-q reflection is bare ADDRESS, sending q0 to p0+p1+p2. + w, wp = 2, 21 + coefficient = character_coefficient(w, wp, (0, 1, 2, 4)) + need(coefficient == [1, 0], 'unpaired actual character coefficient') + need(residual(w) == (1, 0, 0) and residual(wp) == (1, 1, 1), 'genuine marked-subspace leakage') + return {'paired_negative_control': {'one_mark_characters_checked': paired_checked, + 'marked_C_commutes': True, + 'all_f_lift': 'The map is bitwise. With one residual mark r=(p0,q1^f), its owner inside the balanced support makes v.w=1 at every position and R fixes the character. An owner outside makes R complement only unmarked virtual bits. The marked owner bit is unchanged.'}, + 'unpaired_escape': {'input_X_character': w, 'input_residual_marks': residual(w), + 'output_X_character': wp, 'output_residual_marks': residual(wp), + 'actual_character_matrix_coefficient': [str(x) for x in coefficient], + 'all_f_lift': 'Put ones on all f q0 positions and zeros elsewhere. Bare bitwise ADDRESS sends this X character to ones on all p0,p1,p2 positions, changing exactly one residual mark into three for every f>=1. No diagonal pair gauge can remove this nonzero leakage.'}} + + +def run(): + checks = [] + onebit_recipe = None + for f in (1, 2, 3): + z = Model(f, 2) + R, rows = reflection(z) + oldG = mul(z.N, z.T[0]) + same(mul(R, R), z.I, 'actual orthogonal normalizer involution') + same(mul(R, oldG), mul(oldG, R), 'actual full-source normalizer phase') + need(b.native_rank(R) == 0, 'orthogonal typed reflection is monomial') + # Literal two-bank source insertion, with oldfresh=N1 and newfresh=N2. + actual_source = mul(z.P[1], R.adjoint(), R, z.N, z.T[0]) + actual_cross = mul(z.T[1], R, z.N, z.T[0]) + desired_source = mul(z.T[1], z.T[0], z.P[1]) + desired_cross = mul(z.T[1], z.T[0], z.N, R) + same(actual_source, desired_source, 'unchanged sourcecode and fresh coverage') + same(actual_cross, desired_cross, 'changed delivery N0R on arbitrary source column') + # The raw target coefficient is N2 N1 and is independent of source. + K = mul(z.N, R) + power = z.I + ranks = [] + for exponent in range(1, 5): + power = mul(K, power) + ranks.append(b.native_rank(power)) + same(power, z.I, 'exact quartic phase of this reflection kernel') + need(ranks == [2 * f, 2 * f, 2 * f, 0], 'kernel power is not an unproved full-native completion') + if f == 1: + compiled, onebit_recipe = ce.monomial(R) + same(R, compiled, 'actual literal Gaussian monomial recipe') + checks.append({'f': f, 'native_R': 0, 'source_old_native_planes': [0, 1], + 'new_fresh_plane': 2, 'source_frame_commutes_actual_phase': True, + 'kernel_power_native_arities': ranks, 'kernel_fourth_power': 'I'}) + unpaired_checks = [] + for f in (1, 2): + z = Model(f, 3) + R, rows = reflection(z, 3, (0, 1, 2, 4)) + bare = ce.perm(z.n, rows) + oldG = mul(z.N, z.T[0], z.T[1]) + same(R, bare, 'unpaired typed normalizer is literally bare ADDRESS') + same(mul(R, R), z.I, 'unpaired reflection literal involution') + same(mul(R, oldG), mul(oldG, R), 'unpaired full-source Gaussian phase') + need(b.native_rank(R) == 0, 'unpaired ADDRESS is nativezero') + actual_source = mul(z.P[2], R.adjoint(), R, z.N, z.T[0], z.T[1]) + actual_cross = mul(z.T[2], R, z.N, z.T[0], z.T[1]) + same(actual_source, mul(z.T[2], z.T[0], z.T[1], z.P[2]), 'unpaired unchanged source column') + same(actual_cross, mul(z.T[2], z.T[0], z.T[1], z.N, R), 'unpaired changed cross column phase') + need(b.native_rank(mul(z.N, R)) == 2 * f, 'changed cross native arity') + unpaired_checks.append({'f': f, 'old_native_planes': [0, 1, 2], 'new_fresh_plane': 3, + 'actual_typed_R_equals_bare_ADDRESS': True, 'native_R': 0, + 'source_and_cross_columns_actual_phase': True, + 'kernel_native_arity': 2 * f}) + characters = marked_character_checks() + return {'status': 'PASS_ALL_F_ORTHOGONAL_TYPED_SOURCE_NORMALIZER', + 'scientific_pin': PIN, + 'producer_sha256': hashlib.sha256(Path(__file__).read_bytes()).hexdigest(), + 'native_model_sha256': hashlib.sha256((HERE/'native_model.py').read_bytes()).hexdigest(), + 'all_parameter_schema': 'For j old native planes (2j chunks), put D=diag phasei on everyoldp bit and-i on everyoldq bit. Exact G_old=product(N_i)=i^j D^-1 H_all D. If binaryA is orthogonal,A^T A=I, then its literal ADDRESS permutation P_A commutes ordinary WalshH_all. Hence R_A=D^-1 P_A D is monomial and commutesG_old, including all global phases, for every f>=1.', + 'paired_reflection_negative_control': 'On two complete oldplanes v=1111 gives a legal typed R, but it COMMUTES with the marked-residual C. It is not an escape from that grammar floor. Its kernel K=N0R has exact K^4=I and nativearities2f,2f,2f,0 for its first four powers.', + 'explicit_unpaired_reflection': 'On three complete oldplanes ordered(p0,q0,p1,q1,p2,q2), take v=(1,1,1,0,1,0), A=I+vv^T. Its support has three p chunks and one q. v^Tv=0, so A^2=A^T A=I. Apply it bitwise at all f positions. Writing d(x)=sum pbits-sum qbits, if v.x is odd then d(x)-d(Ax)=2 d_v(x)-2=0 mod4; otherwise zero. Thus R_A=D^-1 P_A D=P_A literally, with no extra Gaussian phase.', + 'literal_gaussian_chart': 'Ononebit Hp=e^(-i pi/4) S^-1 H S and Hq=e^(+i pi/4) S H S^-1, S=diag(1,i). Their scalar factors cancel within each actual pairN=i Hp Hq, giving the exact i^j formula above. This is a conjugation identity in Gaussian operators; no irrational phase is introduced by the implementedR, which usesonly D/P_A/D^-1 with Gaussian-unit entries.', + 'source_cut_binding': 'At stagej with oldF=productfresh1..j-1, source N0oldF is full G_old. Insert R before the source delivery and R^-1 immediately after. Then sourcePj and targetNj give boundary Fnew[[Pj,0],[N0R,I]]. The sourceoriginal column, targetoriginal column, arbitrary source crosscolumn and literal inverse all retain their phases. This doesnot assert(N0R)^2=-I.', + 'per_pair_invoice': {'native_H2': 2, 'native_rank_mass': 4, + 'delivery_ADD_scans': 1, + 'existing_source_ADDRESS_scans': 1, + 'new_R_ADDRESS_scans': 2, + 'new_R_diagonal_phase_scans': 0, + 'ordinary_helpers': 0, 'private_fields': 0}, + 'native_zero_lowering': 'The useful unpaired R is the explicit bitwise binary ADDRESS map A=I+vv^T itself. Its inverse is the same literal scan. Both new scans use only completed old chunks. The fixed binary controller and all address/source work remain paid.', + 'paired_one_bit_monomial_recipe': onebit_recipe, + 'paired_actual_checks': checks, + 'unpaired_actual_checks': unpaired_checks, + 'marked_character_checks': characters, + 'evidence_domain': 'Written all-j/all-f orthogonal conjugation proof and explicit all-f bare-phase/leakage proof; actual Gaussian phase/source-column checks for pairedj2 f1/f2/f3 and unpairedj3 f1/f2; independent64-point actual Fourier-character sums. The paired candidate is correctly rejected as a marked-C escape. No f1-only native admission is extrapolated.', + 'limits': ['A complete caller must retain the changed noncommuting kernelsN0R and their independent-input sourcecodes, all public couplings and the literal inverse.', + 'The old scalar quadratic caller cannot be reused by pretendingK^2=-I.', + 'No full exponent, stock/owner, all-size, precision or tape claim is made.'], + 'no_new_kappa': True} + + +if __name__ == '__main__': + p = argparse.ArgumentParser(description=__doc__) + p.add_argument('--write', action='store_true') + args = p.parse_args() + out = json.loads(json.dumps(run())) + path = HERE/'ORTHOGONAL-SOURCE-NORMALIZER.json' + if args.write: + path.write_text(json.dumps(out, indent=2, sort_keys=True)+'\n') + else: + need(json.loads(path.read_text()) == out, 'saved orthogonal normalizer differs') + print(out['status']) + print(out['marked_character_checks']['unpaired_escape']) diff --git a/research/marked-residual-reflection/source/native-frames/source_progress_tradeoff.py b/research/marked-residual-reflection/source/native-frames/source_progress_tradeoff.py new file mode 100644 index 0000000000..6664002f03 --- /dev/null +++ b/research/marked-residual-reflection/source/native-frames/source_progress_tradeoff.py @@ -0,0 +1,60 @@ +#!/usr/bin/env python3 +"""Exact local equality between conjugated factory rank and new progress. +Apache-2.0; substantial OpenAI Codex assistance. Not a bank-network no-go. +""" +from pathlib import Path +import argparse +import hashlib +import json +from native_model import * +from orthogonal_source_normalizer import reflection + +HERE=Path(__file__).resolve().parent + + +def run(): + checks=[] + for f in(1,2,3): + z=Model(f,3) + R,_=reflection(z,3,(0,1,2,4)) + P=mul(R,z.P[1],R) + T=mul(P,z.N,P.adjoint()) + B=mul(z.N,P,z.N.adjoint()) + progress=mul(z.N,T) + same(mul(B,P.adjoint()),mul(phase(z.n,2),progress),'actual all-f minus sign in local tradeoff') + ranks={'P_prime':b.native_rank(P),'T_prime':b.native_rank(T), + 'conjugated_factory':b.native_rank(B),'N_T_prime':b.native_rank(progress), + 'standard_N_N2':b.native_rank(mul(z.N,z.T[1]))} + need(ranks=={'P_prime':0,'T_prime':2*f,'conjugated_factory':2*f, + 'N_T_prime':2*f,'standard_N_N2':4*f},'local factory-progress ranks') + completion=mul(z.N,z.T[1],progress.adjoint()) + old_commutator=mul(P,z.T[0],P.adjoint(),z.T[0].adjoint()) + need(b.native_rank(completion)==4*f,'literal standard-target compensation rank') + need(b.native_rank(old_commutator)==2*f,'old fresh chart is not preserved') + checks.append({'f':f,'native_arities':ranks, + 'exact_standard_target_completion_arity':4*f, + 'old_N1_frame_commutator_arity':2*f, + 'actual_Gaussian_minus_sign_verified':True}) + return {'status':'PASS_ALL_F_LOCAL_FACTORY_PROGRESS_TRADEOFF', + 'scientific_pin':PIN,'producer_sha256':hashlib.sha256(Path(__file__).read_bytes()).hexdigest(), + 'source_pins':[{'path':str(HERE/p),'sha256':hashlib.sha256((HERE/p).read_bytes()).hexdigest()} + for p in('native_model.py','orthogonal_source_normalizer.py','conjugated_factory.py')], + 'all_parameter_identity':'For any invertible monomial Clifford P and actual N with N^2=-I, define T=P N P^-1. Then (N P N^-1) P^-1=-N T. This is a literal operator equality, including the global minus sign, for every ambient dimension and f.', + 'all_parameter_rank_equality':'Native Clifford arity is the rank of its binary B block. Right or left multiplication by an invertible monomial Clifford and a global scalar preserves that rank. Therefore arity(Ad_N(P))=arity(N T) exactly. In particular a cheap2f factory conjugate cannot simultaneously supply independent common+new progress of arity4f through this same P and T.', + 'local_compensation_lower_bound':'For Clifford operators A,B, B_(AB)=A_A B_B+B_A D_B, so rank B_(AB)<=rank B_A+rank B_B. Any unary compensation word, with arbitrary monomial Clifford adapters between its native children, increasing a2f operator to actual nativearity4f needs sum additional native arities>=2f. This is a single-field endpoint statement and does not assume the marked-residual bridge grammar.', + 'specific_two_sided_factory':'P_prime=R P2 R, R=ADDRESS(I+vv^T), v=(p0,q0,p1,p2); T_prime=P_prime N0 P_prime^-1. The cheap conjugate of CONJUGATED-FACTORY.json is valid, but N0*T_prime has arity2f, while N0*N2 has arity4f. The literal standard-target correction (N0*N2)(N0*T_prime)^-1 has arity4f. P_prime also changes the oldN1 chart: its commutator with N1 has arity2f.', + 'all_f_lift':'The reflection and P2 are bitwise tensor families, and N_f^2=-I is already an exact all-f identity with one global i per plane. The rank equality and compensation inequality are written dimension-independent proofs. The displayed specific ranks follow by tensor-direct-sum B rank; the actual sign is checked independently at f1/f2/f3. No claim N_f*T_prime,f=(N_1*T_prime,1)^tensor f is made without its global phase.', + 'actual_checks':checks, + 'scope':['The two-sided reflection factory lowering remains a legitimate local native resource.', + 'A different source/delivery map or a bank-coupled word may change the pair P,T and is not excluded.', + 'A sum of paths, borrowed inputs, dirty helpers and source reads requires its complete independent-column analysis; the unary rank inequality does not replace that.', + 'No supplier, stock surplus, precision, all-size or tape conclusion follows.'], + 'no_new_kappa':True} + + +if __name__=='__main__': + p=argparse.ArgumentParser(description=__doc__);p.add_argument('--write',action='store_true');args=p.parse_args() + out=json.loads(json.dumps(run()));path=HERE/'SOURCE-PROGRESS-TRADEOFF.json' + if args.write:path.write_text(json.dumps(out,indent=2,sort_keys=True)+'\n') + else:need(json.loads(path.read_text())==out,'saved source progress tradeoff differs') + print(out['status']) diff --git a/research/marked-residual-reflection/source/q4-pauli-fusion/MARKED-RESIDUAL-GLOBAL-FLOOR.json b/research/marked-residual-reflection/source/q4-pauli-fusion/MARKED-RESIDUAL-GLOBAL-FLOOR.json new file mode 100644 index 0000000000..3e685f2eab --- /dev/null +++ b/research/marked-residual-reflection/source/q4-pauli-fusion/MARKED-RESIDUAL-GLOBAL-FLOOR.json @@ -0,0 +1,10158 @@ +{ + "actual_all_f_embedding": "N_f^2=-I and N_f anticommutes every single X translation on its2f bits. Fix Q=X on one distinguished bit. The2f-1 commuting operators R_b=Q*X_b commuteN andQ. In each joint R eigenlabel choose |+,r> withQ=+1 and define |-,r>=-i*N|+,r>. Then N=iX_virtual, Q=Z_virtual and every X translation is diagonal in (virtual,r). There are2^(2f-1)>=2 residual labels for everyf>=1. Choose the same two labels u,v in every plane and restrict to tensors with exactly one v. Identical plane bases make actual whole-plane ADDRESS permutations the simultaneous virtual/residual permutations used by the certificate. This is an actual invariant subspace, not a faithful-representation assumption or a finite-f interpolation.", + "actual_handoff_terminal_gates": [ + { + "ambient_planes": 6, + "core_commutator_rank": 192, + "current_direct_tail_native_plane_count": 6, + "external_commutator_rank": 128, + "external_support_union": [ + 4, + 5 + ], + "minimum_tail_native_plane_count": 5, + "minimum_tail_rank_mass_in_units_f": 10, + "normalized_debts": [ + { + "ADDRESS_inverse_common_plane": 4, + "external_native_planes": [ + 4 + ], + "fixed_J_coordinate": 1, + "normalized_correction_native_planes": [ + 0, + 4 + ], + "physical_row": 1, + "right_native_planes": [ + 0 + ] + }, + { + "ADDRESS_inverse_common_plane": 5, + "external_native_planes": [ + 5 + ], + "fixed_J_coordinate": 0, + "normalized_correction_native_planes": [ + 0, + 5 + ], + "physical_row": 3, + "right_native_planes": [ + 0 + ] + } + ], + "q": 2, + "scope": "After this exact prefix cut; any length of whole-plane ADDRESS/X-translation/GL-bank bridge word and native products on whole planes. Public-reader columns can only increase the complete tail commutator rank. Cross-cut cancellation or Pauli Z/other bit-linear ADDRESS is outside this tail-only invoice.", + "total_pivot_correction_commutator_rank": 320 + }, + { + "ambient_planes": 8, + "core_commutator_rank": 768, + "current_direct_tail_native_plane_count": 7, + "external_commutator_rank": 768, + "external_support_union": [ + 4, + 6, + 7 + ], + "minimum_tail_native_plane_count": 6, + "minimum_tail_rank_mass_in_units_f": 12, + "normalized_debts": [ + { + "ADDRESS_inverse_common_plane": 6, + "external_native_planes": [ + 6 + ], + "fixed_J_coordinate": 0, + "normalized_correction_native_planes": [ + 0, + 6 + ], + "physical_row": 1, + "right_native_planes": [ + 0 + ] + }, + { + "ADDRESS_inverse_common_plane": 7, + "external_native_planes": [ + 4, + 7 + ], + "fixed_J_coordinate": 1, + "normalized_correction_native_planes": [ + 0, + 4, + 7 + ], + "physical_row": 3, + "right_native_planes": [ + 0, + 4 + ] + } + ], + "q": 3, + "scope": "After this exact prefix cut; any length of whole-plane ADDRESS/X-translation/GL-bank bridge word and native products on whole planes. Public-reader columns can only increase the complete tail commutator rank. Cross-cut cancellation or Pauli Z/other bit-linear ADDRESS is outside this tail-only invoice.", + "total_pivot_correction_commutator_rank": 1536 + }, + { + "ambient_planes": 10, + "core_commutator_rank": 3072, + "current_direct_tail_native_plane_count": 8, + "external_commutator_rank": 4096, + "external_support_union": [ + 4, + 6, + 8, + 9 + ], + "minimum_tail_native_plane_count": 7, + "minimum_tail_rank_mass_in_units_f": 14, + "normalized_debts": [ + { + "ADDRESS_inverse_common_plane": 8, + "external_native_planes": [ + 4, + 8 + ], + "fixed_J_coordinate": 1, + "normalized_correction_native_planes": [ + 0, + 4, + 8 + ], + "physical_row": 1, + "right_native_planes": [ + 0, + 4 + ] + }, + { + "ADDRESS_inverse_common_plane": 9, + "external_native_planes": [ + 6, + 9 + ], + "fixed_J_coordinate": 0, + "normalized_correction_native_planes": [ + 0, + 6, + 9 + ], + "physical_row": 3, + "right_native_planes": [ + 0, + 6 + ] + } + ], + "q": 4, + "scope": "After this exact prefix cut; any length of whole-plane ADDRESS/X-translation/GL-bank bridge word and native products on whole planes. Public-reader columns can only increase the complete tail commutator rank. Cross-cut cancellation or Pauli Z/other bit-linear ADDRESS is outside this tail-only invoice.", + "total_pivot_correction_commutator_rank": 7168 + }, + { + "ambient_planes": 18, + "core_commutator_rank": 786432, + "current_direct_tail_native_plane_count": 12, + "external_commutator_rank": 2097152, + "external_support_union": [ + 4, + 6, + 8, + 10, + 12, + 14, + 16, + 17 + ], + "minimum_tail_native_plane_count": 11, + "minimum_tail_rank_mass_in_units_f": 22, + "normalized_debts": [ + { + "ADDRESS_inverse_common_plane": 16, + "external_native_planes": [ + 4, + 8, + 12, + 16 + ], + "fixed_J_coordinate": 1, + "normalized_correction_native_planes": [ + 0, + 4, + 8, + 12, + 16 + ], + "physical_row": 1, + "right_native_planes": [ + 0, + 4, + 8, + 12 + ] + }, + { + "ADDRESS_inverse_common_plane": 17, + "external_native_planes": [ + 6, + 10, + 14, + 17 + ], + "fixed_J_coordinate": 0, + "normalized_correction_native_planes": [ + 0, + 6, + 10, + 14, + 17 + ], + "physical_row": 3, + "right_native_planes": [ + 0, + 6, + 10, + 14 + ] + } + ], + "q": 8, + "scope": "After this exact prefix cut; any length of whole-plane ADDRESS/X-translation/GL-bank bridge word and native products on whole planes. Public-reader columns can only increase the complete tail commutator rank. Cross-cut cancellation or Pauli Z/other bit-linear ADDRESS is outside this tail-only invoice.", + "total_pivot_correction_commutator_rank": 2883584 + } + ], + "attribution": [ + "Marked-residual construction generalizes the earlier q4 two-residual commutator mechanism.", + "Parent root identified the complete n-bank stock-floor consequence.", + "The q3/q4 joint debt and actual J-core certificates and all-f X-translation embedding are derived and checked here." + ], + "excluded_Pauli_Z_negative_control": { + "C_after": 1, + "C_before": -1, + "Pauli_Zp_plane": 0, + "actual_f": 1, + "marked_residual_bits": 1, + "result": "NONCOMMUTING: the claimed floor must not be extended to full Pauli Z bridges.", + "virtual_bits": 1 + }, + "fixed_core": { + "C_diagonal": [ + 1, + 1, + 1, + -1, + 1, + 1, + 1, + -1, + 1, + -1, + -1, + 1, + 1, + 1, + -1, + -1, + 1, + -1, + 1, + -1, + -1, + -1, + -1, + -1, + 1, + 1, + 1, + -1, + 1, + 1, + 1, + -1, + 1, + -1, + -1, + 1, + 1, + 1, + -1, + -1, + 1, + -1, + 1, + -1, + -1, + -1, + -1, + -1 + ], + "J": [ + [ + -1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + -1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + -1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ] + ], + "J_inverse": [ + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0 + ], + [ + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0 + ], + [ + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0 + ], + [ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0 + ] + ], + "commutator": [ + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2 + ], + [ + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 0, + 0, + 0, + 0, + 0, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0 + ], + [ + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 0, + 0, + 0, + 0, + 0, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0 + ] + ], + "correction_without_common_Gaussian_unit": [ + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 1, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0 + ], + [ + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0 + ], + [ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0 + ], + [ + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 1, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0 + ], + [ + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0 + ] + ], + "exact_rational_rank": 24, + "internal_dimension": 24, + "meaning": "The fixed block is J^-1 diag(N0,N0); Q1=N0^-1 P1 N0=X0 P1 X0 exactly. The omitted common scalar is i, which preserves rank.", + "nonsingular_minor_columns": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23 + ], + "nonsingular_minor_rows": [ + 23, + 21, + 22, + 11, + 9, + 10, + 20, + 18, + 19, + 8, + 6, + 7, + 17, + 15, + 16, + 5, + 3, + 4, + 14, + 12, + 13, + 2, + 0, + 1 + ], + "normalized_native_plane_lower_bound": 3, + "total_dimension": 48 + }, + "full_pair_three_query_gate": { + "C_diagonal": [ + 1, + 1, + -1, + 1, + 1, + -1, + -1, + -1 + ], + "bank_native_masks": [ + 3, + 3 + ], + "internal_dimension": 8, + "minimum_total_native_plane_count": 4, + "phase_note": "The displayed native action is i^r times its real permutation. Multiplication by that nonzero Gaussian unit leaves the recorded commutator rank unchanged.", + "planes": 2, + "single_bank_query_commutator_ranks": { + "1": 4, + "2": 4, + "3": 8 + }, + "target_Gaussian_phase_exponents": [ + 2, + 2 + ], + "target_commutator_rank": 16 + }, + "global_proof": "On an actual invariant subspace V of dimensionL*2^L let C|x,owner>=(-1)^x_owner |x,owner>. Whole-plane permutations move x andowner together and X translations are diagonal, so every covered bridge commutesC. Product of r native planes flips r virtual bits and leavesownerfixed; its commutator has r*2^L nonzero entries with distinct rows/columns. The n-bank full native target has ranknL2^L. Rank[AB,C]<=rank[A,C]+rank[B,C] for invertible A,B proves the bound.", + "global_theorem": "For L>=1 ordered native planes and n arbitrary target banks, every exact word with target diag(prod_(i=0..L-1) N_i) on those n independent banks, restored arbitrary helpers, native queries on unions of r whole planes, and arbitrary invertible bank bridges over whole-plane ADDRESS permutations and X translations has sum r>=nL. Its native rank mass is at least2f*nL=n*m for m=2fL. Arbitrary Gaussian scalar phases, query inverses and conjugation by covered free bridges do not alter the bound.", + "no_new_kappa": true, + "producer_sha256": "0110b774289bd52284a8605dab44ffe88a225c64790a43025b60d1eb33295061", + "q3_disjoint_debt_gate": { + "C_diagonal": [ + 1, + 1, + 1, + -1, + 1, + 1, + 1, + -1, + 1, + -1, + -1, + 1, + 1, + 1, + -1, + -1, + 1, + -1, + 1, + -1, + -1, + -1, + -1, + -1 + ], + "bank_native_masks": [ + 1, + 6 + ], + "internal_dimension": 24, + "minimum_total_native_plane_count": 3, + "phase_note": "The displayed native action is i^r times its real permutation. Multiplication by that nonzero Gaussian unit leaves the recorded commutator rank unchanged.", + "planes": 3, + "single_bank_query_commutator_ranks": { + "1": 8, + "2": 8, + "3": 16, + "4": 8, + "5": 16, + "6": 16, + "7": 24 + }, + "target_Gaussian_phase_exponents": [ + 1, + 2 + ], + "target_commutator_rank": 24 + }, + "q4_disjoint_debt_gate": { + "C_diagonal": [ + 1, + 1, + 1, + 1, + -1, + 1, + 1, + 1, + 1, + -1, + 1, + 1, + -1, + -1, + 1, + 1, + 1, + 1, + -1, + 1, + -1, + 1, + -1, + 1, + 1, + -1, + -1, + 1, + -1, + -1, + -1, + 1, + 1, + 1, + 1, + -1, + -1, + 1, + 1, + -1, + 1, + -1, + 1, + -1, + -1, + -1, + 1, + -1, + 1, + 1, + -1, + -1, + -1, + 1, + -1, + -1, + 1, + -1, + -1, + -1, + -1, + -1, + -1, + -1 + ], + "bank_native_masks": [ + 3, + 12 + ], + "internal_dimension": 64, + "minimum_total_native_plane_count": 4, + "phase_note": "The displayed native action is i^r times its real permutation. Multiplication by that nonzero Gaussian unit leaves the recorded commutator rank unchanged.", + "planes": 4, + "single_bank_query_commutator_ranks": { + "1": 16, + "10": 32, + "11": 48, + "12": 32, + "13": 48, + "14": 48, + "15": 64, + "2": 16, + "3": 32, + "4": 16, + "5": 32, + "6": 32, + "7": 48, + "8": 16, + "9": 32 + }, + "target_Gaussian_phase_exponents": [ + 2, + 2 + ], + "target_commutator_rank": 64 + }, + "scope_exclusions": [ + "Pauli Z is explicitly excluded: it moves residual labels and fails the exact negative control.", + "Arbitrary bit-linear ADDRESS maps, p/q role controllers and native axes not unions of the declared ordered planes are excluded unless independently proved to commute this C.", + "The n*m floor concerns the declared whole-plane native rank mass and complete full-native bank contract. It is not a global circuit, supplier or multiplication-theorem lower bound." + ], + "source_pins": [ + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/q4-pauli-fusion/handoff_family_independent.py", + "sha256": "8d3137072860b1e7d85307fac79f8349d6a41f26786f7f42bf6a8a667b769718" + }, + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/q4-pauli-fusion/source_handoff_prefix.py", + "sha256": "d9169c729610e4346c56ab28f498c4f2d37dd5c34bc027309372f9d7f50ed06f" + } + ], + "status": "PASS_EXACT_MARKED_RESIDUAL_GLOBAL_FLOOR" +} diff --git a/research/marked-residual-reflection/source/q4-pauli-fusion/MARKED-RESIDUAL-GLOBAL-FLOOR.md b/research/marked-residual-reflection/source/q4-pauli-fusion/MARKED-RESIDUAL-GLOBAL-FLOOR.md new file mode 100644 index 0000000000..293357e51e --- /dev/null +++ b/research/marked-residual-reflection/source/q4-pauli-fusion/MARKED-RESIDUAL-GLOBAL-FLOOR.md @@ -0,0 +1,179 @@ +# An exact stock floor for whole-plane ADDRESS and X-translation bridges + +This result is about a specified operator grammar. It does not cover +arbitrary Pauli Z, arbitrary linear changes of address bits, or native +queries on unrelated symplectic axes. Those are constructive escape routes, +not consequences of the result below. + +Let there be `L` ordered planes, each containing `2f` address bits, with +actual operators + +``` +N_i = i Hp_f(i) Hq_f(i), N_i^2=-I. +``` + +Different `N_i` commute. A native query on a union `S` of whole planes is, +up to an explicitly paid Gaussian unit and ADDRESS packing, the product +`N_S=prod_(i in S) N_i`. Its recursive rank is `2f |S|`. The admitted free +coefficient algebra is generated by whole ordered-plane permutations, +all actual X translations, and Gaussian dyadic scalars. Arbitrary +invertible bank matrices over this algebra are allowed, with any number +of scalar ADDs, selectors, bank swaps and the associated paid scans. + +For `n` independent banks whose exact final map is the full native +operator `E=prod_(i=0..L-1) N_i`, any word in this grammar satisfies + +``` +sum_native_queries |S| >= n L, +sum_native_queries rank >= 2f n L = n m, m=2fL. (1) +``` + +Arbitrary dirty helpers restored to identity do not weaken (1). The same +bound applies if the target is changed by invertible outer bank words +over the admitted free algebra. In particular, conditional bank routing +`W(Q)` with any admitted X involution is covered. + +## Actual all-f embedding + +On one plane choose `Q=X` on one distinguished bit. The actual `N_f` +anticommutes every single-bit X translation: each `Hp/Hq` factor contains +a Z phase and a function of X. The commuting observables + +``` +R_b=Q X_b, b other than the distinguished bit, +``` + +commute with both `Q` and `N_f`. There are `2^(2f-1)` joint residual +labels. For each label `r`, choose a vector `|+,r>` with `Q=+1` and put + +``` +|-,r> = -i N_f |+,r>. +``` + +Then, exactly including Gaussian phases, + +``` +N_f = i X_virtual, Q=Z_virtual. +``` + +Every physical X translation is diagonal in these virtual/residual +coordinates. This is a change of basis used in a proof; it is not a free +operation granted to a circuit. + +Choose the same two distinct residual labels `u,v` on every plane. They +exist for every `f>=1`. Restrict to tensors with exactly one `v` and all +other labels `u`. The residual basis is `|owner=j>`, `0<=j = (-1)^x_j |x,owner=j>. +``` + +It is an involution. Every admitted X translation is diagonal and +commutes with `C`. Every whole-plane permutation moves `x` and `j` +together and commutes with `C`. Consequently every admitted bank bridge +commutes with the bankwise copy of `C`. + +`N_S` flips precisely the virtual bits in `S` and preserves the owner. +Its commutator with `C` is nonzero precisely on owner sectors in `S`. +Each such sector contributes `2^L` independent rows and columns, so + +``` +rank [N_S,C] = |S| 2^L. (2) +``` + +The full `E` flips the bit at every possible owner. Its commutator is +invertible on `V`, and its `n`-bank target rank is `n L 2^L`. Finally + +``` +[AB,C] = A[B,C] + [A,C]B, +rank[AB,C] <= rank[A,C]+rank[B,C] +``` + +for invertible `A,B`. Applying this to the complete word gives (1). +Query inverses, Gaussian units and conjugation by covered bridges have +the same query commutator rank. Neither arbitrary bank mixing nor a +longer free word evades the argument. + +## Joint debt and the changed caller's terminal block + +The same witness proves that a two-bank diagonal debt on disjoint native +supports `S0,S1` requires total native-plane count at least +`|S0|+|S1|`. Thus the q3 split `(1,2)` cannot use two single-plane +native queries (each of recursive rank `2f`), and the q4 split `(2,2)` +cannot use total native-plane count three in this grammar. The q3 target +`diag(N0,N1 N2)` does use two unary bank queries when their supports have +sizes one and two; it still pays three native planes. + +The distinct full-pair target +`diag(N0 N1,N0 N1)` has rank16 on its two-bank, two-plane marked block. +Every single-plane query has commutator rank4, so at least four such +queries are required; three cannot suffice, including arbitrary +`GL2(K[Q,R,P])` bridges. A unary bank query is not necessarily single-plane: +applying `N0 N1` once to each bank realizes this target in two queries, +each of commutator rank8 and recursive rank `4f`. Splitting the first +bank's query into `N0` then `N1` also gives a three-query realization. +Both words pay four native planes, or total rank mass `8f`, exactly the +two-bank stock floor. The general bound is on plane count/rank mass, +not on the number of arbitrary-support unary queries. + +For the actual handoff family, write the terminal pivot-input block as +`H=D R J`, where `R` is a scalar bank permutation and the rows of `D` +are actual monomial native/ADDRESS factories. The required pivot +coefficient is `H^-1 N0`; public compensation columns cannot lower the +rank of this submatrix. + +Right multiplying by the displayed factory ADDRESS permutations and a +bank permutation, all commuting with `C`, reduces this coefficient to + +``` +J^-1 diag(N0 E0,N0 E1), +``` + +where `E0,E1` have disjoint external native support, avoid planes0,1,2, +and have total support size `q`. On an external owner sector, `J` +commutes with `C`, so the external contribution is exactly `q 2^L`. +The three core owner sectors contribute `3 2^L`: the exact 48 by48 +core matrix `J^-1 diag(N0,N0)` has rational commutator rank24, with a +displayed nonsingular 24 by24 minor in the JSON certificate. Spectator +virtual bits multiply this by `2^(L-3)`. Hence the fixed-cut tail needs + +``` +total native-plane count >= q+3, +native rank mass >= 2f(q+3). (3) +``` + +The current explicit tail has count `q+4`. Equation (3) is a tail bound +after the stated cut. Cross-cut cancellation has its own complete-word +invoice, while (1) applies directly to every complete word that stays +inside the same grammar. + +## Exact certificate and limits + +Run `python3 -B marked_residual_gate.py`, or add `-O`. The checks use +explicit integer commutator supports for the q3/q4 joint debts, the +two-bank full pair, and an exact rational RREF plus nonsingular minor +for the core matrix. They also bind the changed caller's actual factory +normal forms at q2,3,4,8 to the previously independently replayed word. + +`MARKED-RESIDUAL-GLOBAL-FLOOR.json` contains the tiny matrices and scope. +An actual Pauli-Z example moves the residual label, changes the sign of +`C`, and is explicitly rejected as a commuting bridge. Thus the proof +must not be extended to that larger alphabet. All-f circuit identities +using Z, other address maps, or different native subspaces remain open. + +The parent identified the complete stock-floor consequence. The marked +construction generalizes this lane's earlier two-residual commutator +mechanism; the all-f X-translation embedding, joint-debt and fixed-core +certificates are derived here. No improved kappa or multiplication +theorem is claimed. diff --git a/research/marked-residual-reflection/source/q4-pauli-fusion/SOURCE-HANDOFF-PREFIX.json b/research/marked-residual-reflection/source/q4-pauli-fusion/SOURCE-HANDOFF-PREFIX.json new file mode 100644 index 0000000000..9d08816664 --- /dev/null +++ b/research/marked-residual-reflection/source/q4-pauli-fusion/SOURCE-HANDOFF-PREFIX.json @@ -0,0 +1,4360 @@ +{ + "D_before_pivot_tail_in_units_f": 4, + "actual_native_planes": 6, + "all_f_phase": "N_f=i^(1-f) N1^tensor(f)=i Hp_f Hq_f, so N_f^2=-I. Disjoint planes commute and the literal ADDRESS swap satisfies P_i N_0=N_i P_i. These exact relations prove the serialized identity for every f>=1, including Gaussian global phases.", + "ambient_arity_in_units_f": 12, + "attribution": [ + "First-three-query nested-response entrance and its cut: mixed_carrier_caller_1019/caller/nested_prefix.py and nested_six.py.", + "Mid-query source handoff: root/root-chronology/source_handoff.py.", + "Second handoff and pre-P5 current-source fanout: independently derived by q4_pauli_fusion and stabilizer_escape_1019; final standalone N(a) closure proposed by root.", + "This file composes these mechanisms into the complete changed five-stage arbitrary-column prefix." + ], + "banks": [ + "a", + "t", + "b1", + "c1", + "b2", + "c2" + ], + "complete_formal_inverse": [ + [ + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + } + ], + [], + [], + [], + [], + [] + ], + [ + [ + { + "coefficient": "1", + "word": [] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P5^-1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N" + ] + } + ], + [] + ], + [ + [], + [], + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + } + ], + [], + [], + [] + ], + [ + [ + { + "coefficient": "1", + "word": [ + "P2^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P2^-1", + "N", + "P3^-1", + "P4^-1" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "P3^-1", + "P4^-1" + ] + }, + { + "coefficient": "-1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P3^-1", + "P4^-1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P2^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P2^-1", + "N", + "P5^-1" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N", + "P2^-1", + "N", + "P5^-1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "N", + "P1^-1", + "N" + ] + } + ], + [] + ], + [ + [], + [], + [], + [], + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + } + ], + [] + ], + [ + [], + [], + [], + [], + [], + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + } + ] + ] + ], + "complete_formal_matrix": [ + [ + [ + { + "coefficient": "1", + "word": [ + "N" + ] + } + ], + [], + [], + [], + [], + [] + ], + [ + [ + { + "coefficient": "-2", + "word": [ + "P4", + "P3" + ] + }, + { + "coefficient": "1", + "word": [ + "P4", + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P4", + "P3", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P4", + "P3", + "P1", + "N" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P4", + "P3" + ] + }, + { + "coefficient": "1", + "word": [ + "P4", + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P4", + "P3", + "N" + ] + } + ], + [ + { + "coefficient": "-2", + "word": [ + "P4", + "P3" + ] + }, + { + "coefficient": "1", + "word": [ + "P4", + "P3", + "P1" + ] + } + ], + [] + ], + [ + [], + [], + [ + { + "coefficient": "1", + "word": [ + "N" + ] + } + ], + [], + [], + [] + ], + [ + [ + { + "coefficient": "-3", + "word": [ + "P5" + ] + }, + { + "coefficient": "-1", + "word": [ + "P5", + "N", + "P2", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P5", + "P1" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P5", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P5", + "N", + "P2" + ] + }, + { + "coefficient": "1", + "word": [ + "P5", + "P1", + "N" + ] + } + ], + [ + { + "coefficient": "-2", + "word": [ + "P5" + ] + }, + { + "coefficient": "-1", + "word": [ + "P5", + "N", + "P2", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P5", + "P1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P5", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "P5", + "N", + "P2" + ] + } + ], + [ + { + "coefficient": "-2", + "word": [ + "P5" + ] + }, + { + "coefficient": "-1", + "word": [ + "P5", + "N", + "P2", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P5", + "P1" + ] + } + ], + [] + ], + [ + [], + [], + [], + [], + [ + { + "coefficient": "1", + "word": [ + "N" + ] + } + ], + [] + ], + [ + [], + [], + [], + [], + [], + [ + { + "coefficient": "1", + "word": [ + "N" + ] + } + ] + ] + ], + "complete_physical_inverse": [ + [ + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "1" + } + ], + [], + [], + [], + [], + [] + ], + [ + [ + { + "ADDRESS_plane_permutation": [ + 2, + 0, + 1, + 3, + 4, + 5 + ], + "N_planes": [ + 3, + 4, + 5 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 0, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 4, + 0, + 1, + 2, + 3, + 5 + ], + "N_planes": [ + 3, + 5 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 4, + 0, + 2, + 1, + 3, + 5 + ], + "N_planes": [ + 1, + 2, + 3, + 5 + ], + "coefficient": "-1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 2, + 0, + 1, + 3, + 4, + 5 + ], + "N_planes": [ + 3, + 4, + 5 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "-1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 5, + 0, + 1, + 3, + 4, + 2 + ], + "N_planes": [ + 3, + 4 + ], + "coefficient": "1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 0, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "1" + } + ], + [] + ], + [ + [], + [], + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "1" + } + ], + [], + [], + [] + ], + [ + [ + { + "ADDRESS_plane_permutation": [ + 2, + 0, + 1, + 3, + 4, + 5 + ], + "N_planes": [ + 3, + 4, + 5 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 2, + 1, + 0, + 3, + 4, + 5 + ], + "N_planes": [ + 0, + 1, + 3, + 4, + 5 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 0, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 4, + 0, + 1, + 2, + 3, + 5 + ], + "N_planes": [ + 3, + 5 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 4, + 1, + 0, + 2, + 3, + 5 + ], + "N_planes": [ + 0, + 1, + 3, + 5 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 4, + 0, + 2, + 1, + 3, + 5 + ], + "N_planes": [ + 1, + 2, + 3, + 5 + ], + "coefficient": "-1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 2, + 0, + 1, + 3, + 4, + 5 + ], + "N_planes": [ + 3, + 4, + 5 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 2, + 1, + 0, + 3, + 4, + 5 + ], + "N_planes": [ + 0, + 1, + 3, + 4, + 5 + ], + "coefficient": "-1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 5, + 0, + 1, + 3, + 4, + 2 + ], + "N_planes": [ + 3, + 4 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 5, + 1, + 0, + 3, + 4, + 2 + ], + "N_planes": [ + 0, + 1, + 3, + 4 + ], + "coefficient": "1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 1, + 0, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "1" + } + ], + [] + ], + [ + [], + [], + [], + [], + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "1" + } + ], + [] + ], + [ + [], + [], + [], + [], + [], + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "1" + } + ] + ] + ], + "complete_physical_matrix": [ + [ + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "1" + } + ], + [], + [], + [], + [], + [] + ], + [ + [ + { + "ADDRESS_plane_permutation": [ + 1, + 3, + 2, + 4, + 0, + 5 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 3, + 1, + 2, + 4, + 0, + 5 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "-2" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 3, + 1, + 2, + 4, + 0, + 5 + ], + "N_planes": [ + 1, + 2, + 4, + 5 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 3, + 2, + 4, + 0, + 5 + ], + "N_planes": [ + 2, + 3, + 4, + 5 + ], + "coefficient": "-1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 1, + 3, + 2, + 4, + 0, + 5 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 3, + 1, + 2, + 4, + 0, + 5 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "-1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 3, + 1, + 2, + 4, + 0, + 5 + ], + "N_planes": [ + 1, + 2, + 4, + 5 + ], + "coefficient": "-1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 1, + 3, + 2, + 4, + 0, + 5 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 3, + 1, + 2, + 4, + 0, + 5 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "-2" + } + ], + [] + ], + [ + [], + [], + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "1" + } + ], + [], + [], + [] + ], + [ + [ + { + "ADDRESS_plane_permutation": [ + 2, + 1, + 5, + 3, + 4, + 0 + ], + "N_planes": [ + 1, + 3, + 4 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 5, + 2, + 3, + 4, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 5, + 1, + 2, + 3, + 4, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "-3" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 2, + 1, + 5, + 3, + 4, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 5, + 1, + 2, + 3, + 4, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 5, + 2, + 3, + 4, + 0 + ], + "N_planes": [ + 2, + 3, + 4, + 5 + ], + "coefficient": "-1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 2, + 1, + 5, + 3, + 4, + 0 + ], + "N_planes": [ + 1, + 3, + 4 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 5, + 2, + 3, + 4, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 5, + 1, + 2, + 3, + 4, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "-2" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 2, + 1, + 5, + 3, + 4, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 5, + 1, + 2, + 3, + 4, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4 + ], + "coefficient": "-1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 2, + 1, + 5, + 3, + 4, + 0 + ], + "N_planes": [ + 1, + 3, + 4 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 5, + 2, + 3, + 4, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 5, + 1, + 2, + 3, + 4, + 0 + ], + "N_planes": [ + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "-2" + } + ], + [] + ], + [ + [], + [], + [], + [], + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "1" + } + ], + [] + ], + [ + [], + [], + [], + [], + [], + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "coefficient": "1" + } + ] + ] + ], + "current_cut_formal_matrix": [ + [ + [ + { + "coefficient": "1", + "word": [] + } + ], + [], + [], + [], + [], + [] + ], + [ + [ + { + "coefficient": "-2", + "word": [ + "P3" + ] + }, + { + "coefficient": "1", + "word": [ + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P3", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P3", + "P1", + "N" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P3" + ] + }, + { + "coefficient": "1", + "word": [ + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P3", + "N" + ] + } + ], + [ + { + "coefficient": "-2", + "word": [ + "P3" + ] + }, + { + "coefficient": "1", + "word": [ + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [] + } + ] + ], + [ + [ + { + "coefficient": "-2", + "word": [ + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1" + ] + }, + { + "coefficient": "1", + "word": [ + "P2", + "N" + ] + } + ], + [ + { + "coefficient": "1", + "word": [] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "P2" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1" + ] + }, + { + "coefficient": "1", + "word": [ + "P2", + "N" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [] + }, + { + "coefficient": "1", + "word": [ + "P2" + ] + } + ], + [ + { + "coefficient": "-2", + "word": [ + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1" + ] + }, + { + "coefficient": "1", + "word": [ + "P2", + "N" + ] + } + ], + [] + ], + [ + [ + { + "coefficient": "1", + "word": [] + }, + { + "coefficient": "-2", + "word": [ + "N", + "P3" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "N", + "P3", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P3", + "P1", + "N" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "N", + "P3" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "N", + "P3", + "N" + ] + } + ], + [ + { + "coefficient": "1", + "word": [] + }, + { + "coefficient": "-2", + "word": [ + "N", + "P3" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P3", + "P1" + ] + } + ], + [] + ], + [ + [], + [], + [], + [], + [ + { + "coefficient": "1", + "word": [] + } + ], + [] + ], + [ + [ + { + "coefficient": "-3", + "word": [ + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1" + ] + }, + { + "coefficient": "1", + "word": [ + "P2", + "N" + ] + } + ], + [ + { + "coefficient": "1", + "word": [] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "P2" + ] + } + ], + [ + { + "coefficient": "-2", + "word": [ + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1" + ] + }, + { + "coefficient": "1", + "word": [ + "P2", + "N" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [] + }, + { + "coefficient": "1", + "word": [ + "P2" + ] + } + ], + [ + { + "coefficient": "-3", + "word": [ + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "N", + "P1" + ] + }, + { + "coefficient": "1", + "word": [ + "P2", + "N" + ] + } + ], + [] + ] + ], + "current_cut_physical_matrix": [ + [ + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 1, + 2, + 3 + ], + "coefficient": "1" + } + ], + [], + [], + [], + [], + [] + ], + [ + [ + { + "ADDRESS_plane_permutation": [ + 1, + 3, + 2, + 0, + 4, + 5 + ], + "N_planes": [ + 1, + 2, + 3 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 3, + 1, + 2, + 0, + 4, + 5 + ], + "N_planes": [ + 1, + 2, + 3 + ], + "coefficient": "-2" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 3, + 1, + 2, + 0, + 4, + 5 + ], + "N_planes": [ + 1, + 2 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 3, + 2, + 0, + 4, + 5 + ], + "N_planes": [ + 2, + 3 + ], + "coefficient": "-1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 1, + 3, + 2, + 0, + 4, + 5 + ], + "N_planes": [ + 1, + 2, + 3 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 3, + 1, + 2, + 0, + 4, + 5 + ], + "N_planes": [ + 1, + 2, + 3 + ], + "coefficient": "-1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 3, + 1, + 2, + 0, + 4, + 5 + ], + "N_planes": [ + 1, + 2 + ], + "coefficient": "-1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 1, + 3, + 2, + 0, + 4, + 5 + ], + "N_planes": [ + 1, + 2, + 3 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 3, + 1, + 2, + 0, + 4, + 5 + ], + "N_planes": [ + 1, + 2, + 3 + ], + "coefficient": "-2" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 1, + 2, + 3 + ], + "coefficient": "1" + } + ] + ], + [ + [ + { + "ADDRESS_plane_permutation": [ + 2, + 1, + 0, + 3, + 4, + 5 + ], + "N_planes": [ + 1, + 3 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 0, + 1, + 2, + 3 + ], + "coefficient": "-2" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 0, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 0, + 1, + 2, + 3 + ], + "coefficient": "1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 1, + 0, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 0, + 2, + 3 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 1, + 2, + 3 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 2, + 1, + 0, + 3, + 4, + 5 + ], + "N_planes": [ + 1, + 2, + 3 + ], + "coefficient": "-1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 2, + 1, + 0, + 3, + 4, + 5 + ], + "N_planes": [ + 1, + 3 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 0, + 1, + 2, + 3 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 0, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 0, + 1, + 2, + 3 + ], + "coefficient": "1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 1, + 2, + 3 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 2, + 1, + 0, + 3, + 4, + 5 + ], + "N_planes": [ + 1, + 2, + 3 + ], + "coefficient": "1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 2, + 1, + 0, + 3, + 4, + 5 + ], + "N_planes": [ + 1, + 3 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 0, + 1, + 2, + 3 + ], + "coefficient": "-2" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 0, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 0, + 1, + 2, + 3 + ], + "coefficient": "1" + } + ], + [] + ], + [ + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 1, + 2, + 3 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 3, + 2, + 0, + 4, + 5 + ], + "N_planes": [ + 0, + 1, + 2, + 3 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 3, + 1, + 2, + 0, + 4, + 5 + ], + "N_planes": [ + 0, + 1, + 2, + 3 + ], + "coefficient": "-2" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 3, + 1, + 2, + 0, + 4, + 5 + ], + "N_planes": [ + 0, + 1, + 2 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 3, + 2, + 0, + 4, + 5 + ], + "N_planes": [ + 0, + 2, + 3 + ], + "coefficient": "-1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 1, + 3, + 2, + 0, + 4, + 5 + ], + "N_planes": [ + 0, + 1, + 2, + 3 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 3, + 1, + 2, + 0, + 4, + 5 + ], + "N_planes": [ + 0, + 1, + 2, + 3 + ], + "coefficient": "-1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 3, + 1, + 2, + 0, + 4, + 5 + ], + "N_planes": [ + 0, + 1, + 2 + ], + "coefficient": "-1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 1, + 2, + 3 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 3, + 2, + 0, + 4, + 5 + ], + "N_planes": [ + 0, + 1, + 2, + 3 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 3, + 1, + 2, + 0, + 4, + 5 + ], + "N_planes": [ + 0, + 1, + 2, + 3 + ], + "coefficient": "-2" + } + ], + [] + ], + [ + [], + [], + [], + [], + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 1, + 2, + 3 + ], + "coefficient": "1" + } + ], + [] + ], + [ + [ + { + "ADDRESS_plane_permutation": [ + 2, + 1, + 0, + 3, + 4, + 5 + ], + "N_planes": [ + 1, + 3 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 0, + 1, + 2, + 3 + ], + "coefficient": "-3" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 0, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 0, + 1, + 2, + 3 + ], + "coefficient": "1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 1, + 0, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 0, + 2, + 3 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 1, + 2, + 3 + ], + "coefficient": "1" + }, + { + "ADDRESS_plane_permutation": [ + 2, + 1, + 0, + 3, + 4, + 5 + ], + "N_planes": [ + 1, + 2, + 3 + ], + "coefficient": "-1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 2, + 1, + 0, + 3, + 4, + 5 + ], + "N_planes": [ + 1, + 3 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 0, + 1, + 2, + 3 + ], + "coefficient": "-2" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 0, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 0, + 1, + 2, + 3 + ], + "coefficient": "1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 1, + 2, + 3 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 2, + 1, + 0, + 3, + 4, + 5 + ], + "N_planes": [ + 1, + 2, + 3 + ], + "coefficient": "1" + } + ], + [ + { + "ADDRESS_plane_permutation": [ + 2, + 1, + 0, + 3, + 4, + 5 + ], + "N_planes": [ + 1, + 3 + ], + "coefficient": "-1" + }, + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 0, + 1, + 2, + 3 + ], + "coefficient": "-3" + }, + { + "ADDRESS_plane_permutation": [ + 1, + 0, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 0, + 1, + 2, + 3 + ], + "coefficient": "1" + } + ], + [] + ] + ], + "cut_contract": "In the retarded F3 frame (a,t,b1,c1,b2,c2)=(a,u+C,N*x-v,N*u+a+B,B,-v-N*(a+B)); all six coordinates (a,x,B,C,u,v) are independent. They are derived from the full current word, not initialized helpers.", + "domain": "Every f>=1; six arbitrary independent fields; actual common/fresh native planes N_i with N_i^2=-I and exact plane-permutation covariance. Formal retarded proof allows arbitrary invertible noncommuting P1,...,P5.", + "events": [ + { + "coefficient": "1", + "dst": 5, + "kind": "ADD", + "label": "input c-basis inverse", + "src": 3 + }, + { + "bank": 1, + "kind": "NATIVE", + "label": "shared entrance N exposure", + "native_arity": 2, + "operator": [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 0 + ], + "coefficient": "1" + } + ] + }, + { + "coefficient": "1", + "dst": 2, + "kind": "ADD", + "label": "shared entrance b1 += N t", + "src": 1 + }, + { + "bank": 1, + "kind": "NATIVE", + "label": "shared entrance N inverse", + "native_arity": 2, + "operator": [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 0 + ], + "coefficient": "-1" + } + ] + }, + { + "coefficient": "-1", + "dst": 5, + "kind": "ADD", + "label": "scalar nested response bridge", + "src": 1 + }, + { + "coefficient": "1", + "dst": 0, + "kind": "ADD", + "label": "scalar nested response bridge", + "src": 4 + }, + { + "coefficient": "-1", + "dst": 3, + "kind": "ADD", + "label": "scalar nested response bridge", + "src": 1 + }, + { + "coefficient": "1", + "dst": 0, + "kind": "ADD", + "label": "scalar nested response bridge", + "src": 2 + }, + { + "coefficient": "-1", + "dst": 2, + "kind": "ADD", + "label": "query1 scalar entrance", + "src": 0 + }, + { + "bank": 0, + "kind": "NATIVE", + "label": "query1 existing source N", + "native_arity": 2, + "operator": [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 0 + ], + "coefficient": "1" + } + ] + }, + { + "coefficient": "1", + "dst": 1, + "kind": "ADD", + "label": "query1 raw delivery", + "src": 0 + }, + { + "bank": 0, + "kind": "ADDRESS", + "label": "query1 source plane swap", + "native_arity": 0, + "operator": [ + { + "ADDRESS_plane_permutation": [ + 1, + 0, + 2, + 3, + 4, + 5 + ], + "N_planes": [], + "coefficient": "1" + } + ] + }, + { + "bank": 1, + "kind": "NATIVE", + "label": "query1 paid fresh progress bank1", + "native_arity": 2, + "operator": [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 1 + ], + "coefficient": "1" + } + ] + }, + { + "bank": 2, + "kind": "NATIVE", + "label": "query1 paid fresh progress bank2", + "native_arity": 2, + "operator": [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 1 + ], + "coefficient": "1" + } + ] + }, + { + "bank": 3, + "kind": "NATIVE", + "label": "query1 paid fresh progress bank3", + "native_arity": 2, + "operator": [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 1 + ], + "coefficient": "1" + } + ] + }, + { + "bank": 4, + "kind": "NATIVE", + "label": "query1 paid fresh progress bank4", + "native_arity": 2, + "operator": [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 1 + ], + "coefficient": "1" + } + ] + }, + { + "bank": 5, + "kind": "NATIVE", + "label": "query1 paid fresh progress bank5", + "native_arity": 2, + "operator": [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 1 + ], + "coefficient": "1" + } + ] + }, + { + "coefficient": "1", + "dst": 2, + "kind": "ADD", + "label": "query1 scalar exit", + "src": 0 + }, + { + "coefficient": "-1", + "dst": 0, + "kind": "ADD", + "label": "scalar nested response bridge", + "src": 2 + }, + { + "coefficient": "1", + "dst": 1, + "kind": "ADD", + "label": "scalar nested response bridge", + "src": 3 + }, + { + "coefficient": "-1", + "dst": 3, + "kind": "ADD", + "label": "query2 scalar entrance", + "src": 1 + }, + { + "coefficient": "-1", + "dst": 5, + "kind": "ADD", + "label": "query2 scalar entrance", + "src": 1 + }, + { + "bank": 1, + "kind": "NATIVE", + "label": "query2 existing source N", + "native_arity": 2, + "operator": [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 0 + ], + "coefficient": "1" + } + ] + }, + { + "coefficient": "1", + "dst": 2, + "kind": "ADD", + "label": "query2 raw delivery", + "src": 1 + }, + { + "bank": 1, + "kind": "ADDRESS", + "label": "query2 source plane swap", + "native_arity": 0, + "operator": [ + { + "ADDRESS_plane_permutation": [ + 2, + 1, + 0, + 3, + 4, + 5 + ], + "N_planes": [], + "coefficient": "1" + } + ] + }, + { + "bank": 0, + "kind": "NATIVE", + "label": "query2 paid fresh progress bank0", + "native_arity": 2, + "operator": [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 2 + ], + "coefficient": "1" + } + ] + }, + { + "bank": 2, + "kind": "NATIVE", + "label": "query2 paid fresh progress bank2", + "native_arity": 2, + "operator": [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 2 + ], + "coefficient": "1" + } + ] + }, + { + "bank": 3, + "kind": "NATIVE", + "label": "query2 paid fresh progress bank3", + "native_arity": 2, + "operator": [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 2 + ], + "coefficient": "1" + } + ] + }, + { + "bank": 4, + "kind": "NATIVE", + "label": "query2 paid fresh progress bank4", + "native_arity": 2, + "operator": [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 2 + ], + "coefficient": "1" + } + ] + }, + { + "bank": 5, + "kind": "NATIVE", + "label": "query2 paid fresh progress bank5", + "native_arity": 2, + "operator": [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 2 + ], + "coefficient": "1" + } + ] + }, + { + "coefficient": "1", + "dst": 3, + "kind": "ADD", + "label": "query2 scalar exit", + "src": 1 + }, + { + "coefficient": "1", + "dst": 5, + "kind": "ADD", + "label": "query2 scalar exit", + "src": 1 + }, + { + "coefficient": "-1", + "dst": 1, + "kind": "ADD", + "label": "scalar nested response bridge", + "src": 3 + }, + { + "bank": 2, + "kind": "NATIVE", + "label": "query3 existing source N", + "native_arity": 2, + "operator": [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 0 + ], + "coefficient": "1" + } + ] + }, + { + "coefficient": "1", + "dst": 5, + "kind": "ADD", + "label": "query3 entrance from source N exposure", + "src": 2 + }, + { + "coefficient": "1", + "dst": 3, + "kind": "ADD", + "label": "query3 raw delivery", + "src": 2 + }, + { + "bank": 2, + "kind": "ADDRESS", + "label": "query3 source plane swap", + "native_arity": 0, + "operator": [ + { + "ADDRESS_plane_permutation": [ + 3, + 1, + 2, + 0, + 4, + 5 + ], + "N_planes": [], + "coefficient": "1" + } + ] + }, + { + "bank": 0, + "kind": "NATIVE", + "label": "query3 paid fresh progress bank0", + "native_arity": 2, + "operator": [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 3 + ], + "coefficient": "1" + } + ] + }, + { + "bank": 1, + "kind": "NATIVE", + "label": "query3 paid fresh progress bank1", + "native_arity": 2, + "operator": [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 3 + ], + "coefficient": "1" + } + ] + }, + { + "bank": 3, + "kind": "NATIVE", + "label": "query3 paid fresh progress bank3", + "native_arity": 2, + "operator": [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 3 + ], + "coefficient": "1" + } + ] + }, + { + "bank": 4, + "kind": "NATIVE", + "label": "query3 paid fresh progress bank4", + "native_arity": 2, + "operator": [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 3 + ], + "coefficient": "1" + } + ] + }, + { + "bank": 5, + "kind": "NATIVE", + "label": "query3 paid fresh progress bank5", + "native_arity": 2, + "operator": [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 3 + ], + "coefficient": "1" + } + ] + }, + { + "coefficient": "1", + "dst": 5, + "kind": "ADD", + "label": "query3 pre-continuation fanout", + "src": 2 + }, + { + "bank": 2, + "kind": "NATIVE", + "label": "query3 paid source continuation", + "native_arity": 2, + "operator": [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 0 + ], + "coefficient": "1" + } + ] + }, + { + "coefficient": "1", + "dst": 2, + "kind": "ADD", + "label": "scalar nested response bridge", + "src": 0 + }, + { + "coefficient": "1", + "dst": 3, + "kind": "ADD", + "label": "scalar nested response bridge", + "src": 1 + }, + { + "coefficient": "-1", + "dst": 1, + "kind": "ADD", + "label": "scalar nested response bridge", + "src": 3 + }, + { + "banks": [ + 2, + 3 + ], + "kind": "BANK_SWAP", + "label": "nested response bank permutation" + }, + { + "coefficient": "-1", + "dst": 0, + "kind": "ADD", + "label": "scalar nested response bridge", + "src": 4 + }, + { + "coefficient": "1", + "dst": 1, + "kind": "ADD", + "label": "scalar nested response bridge", + "src": 5 + }, + { + "coefficient": "-1", + "dst": 5, + "kind": "ADD", + "label": "query4 scalar entrance before changed source identity", + "src": 1 + }, + { + "coefficient": "-1", + "dst": 3, + "kind": "ADD", + "label": "query4 current encoder c1 -= a", + "src": 0 + }, + { + "coefficient": "-1", + "dst": 3, + "kind": "ADD", + "label": "query4 current encoder c1 -= b2", + "src": 4 + }, + { + "bank": 1, + "kind": "NATIVE", + "label": "query4 existing source N on u+c2", + "native_arity": 2, + "operator": [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 0 + ], + "coefficient": "1" + } + ] + }, + { + "coefficient": "-1", + "dst": 1, + "kind": "ADD", + "label": "query4 isolate N c2 from held N u", + "src": 3 + }, + { + "banks": [ + 1, + 3 + ], + "kind": "BANK_SWAP", + "label": "query4 source handoff BEFORE source ADDRESS" + }, + { + "bank": 1, + "kind": "ADDRESS", + "label": "query4 ADDRESS on changed source", + "native_arity": 0, + "operator": [ + { + "ADDRESS_plane_permutation": [ + 4, + 1, + 2, + 3, + 0, + 5 + ], + "N_planes": [], + "coefficient": "1" + } + ] + }, + { + "bank": 0, + "kind": "NATIVE", + "label": "query4 paid fresh progress bank0", + "native_arity": 2, + "operator": [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 4 + ], + "coefficient": "1" + } + ] + }, + { + "bank": 2, + "kind": "NATIVE", + "label": "query4 paid fresh progress bank2", + "native_arity": 2, + "operator": [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 4 + ], + "coefficient": "1" + } + ] + }, + { + "bank": 3, + "kind": "NATIVE", + "label": "query4 paid fresh progress bank3", + "native_arity": 2, + "operator": [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 4 + ], + "coefficient": "1" + } + ] + }, + { + "bank": 4, + "kind": "NATIVE", + "label": "query4 paid fresh progress bank4", + "native_arity": 2, + "operator": [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 4 + ], + "coefficient": "1" + } + ] + }, + { + "bank": 5, + "kind": "NATIVE", + "label": "query4 paid fresh progress bank5", + "native_arity": 2, + "operator": [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 4 + ], + "coefficient": "1" + } + ] + }, + { + "banks": [ + 3, + 5 + ], + "kind": "BANK_SWAP", + "label": "query4 put completed public c2 into slot5" + }, + { + "bank": 4, + "kind": "NATIVE", + "label": "query5 existing source N on raw b2", + "native_arity": 2, + "operator": [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 0 + ], + "coefficient": "1" + } + ] + }, + { + "coefficient": "1", + "dst": 3, + "kind": "ADD", + "label": "query5 cancel b2 from the dirty first-pivot field", + "src": 4 + }, + { + "banks": [ + 4, + 3 + ], + "kind": "BANK_SWAP", + "label": "query5 source handoff BEFORE source ADDRESS" + }, + { + "coefficient": "-1", + "dst": 2, + "kind": "ADD", + "label": "query5 current-source fanout b1 -= (-v-N a) BEFORE source ADDRESS", + "src": 4 + }, + { + "bank": 4, + "kind": "ADDRESS", + "label": "query5 ADDRESS on changed source", + "native_arity": 0, + "operator": [ + { + "ADDRESS_plane_permutation": [ + 5, + 1, + 2, + 3, + 4, + 0 + ], + "N_planes": [], + "coefficient": "1" + } + ] + }, + { + "bank": 0, + "kind": "NATIVE", + "label": "query5 paid fresh progress bank0", + "native_arity": 2, + "operator": [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 5 + ], + "coefficient": "1" + } + ] + }, + { + "bank": 1, + "kind": "NATIVE", + "label": "query5 paid fresh progress bank1", + "native_arity": 2, + "operator": [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 5 + ], + "coefficient": "1" + } + ] + }, + { + "bank": 2, + "kind": "NATIVE", + "label": "query5 paid fresh progress bank2", + "native_arity": 2, + "operator": [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 5 + ], + "coefficient": "1" + } + ] + }, + { + "bank": 3, + "kind": "NATIVE", + "label": "query5 paid fresh progress bank3", + "native_arity": 2, + "operator": [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 5 + ], + "coefficient": "1" + } + ] + }, + { + "bank": 5, + "kind": "NATIVE", + "label": "query5 paid fresh progress bank5", + "native_arity": 2, + "operator": [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 5 + ], + "coefficient": "1" + } + ] + }, + { + "banks": [ + 4, + 3 + ], + "kind": "BANK_SWAP", + "label": "query5 restore pivot3 and completed public b2 slot4" + }, + { + "bank": 0, + "kind": "NATIVE", + "label": "final paid N exposure on raw a", + "native_arity": 2, + "operator": [ + { + "ADDRESS_plane_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "N_planes": [ + 0 + ], + "coefficient": "1" + } + ] + }, + { + "coefficient": "-1", + "dst": 2, + "kind": "ADD", + "label": "finish b1 using the current completed public a", + "src": 0 + } + ], + "exact_inverse": "Reverse every serialized event; negate ADD coefficients, invert every Gaussian native/ADDRESS word, keep each bank SWAP. Both orders are checked on all six independent columns.", + "final_standalone_N_calls": 1, + "handoff_endpoint_before_final_N": "In F5 coordinates (a,P4*u,N*(x+a),P5*(N*v-a),N*B,N*C). Then N(a); b1-=a completes all four public rows.", + "limits": [ + "The two pivot rows have not been compensated here. The 34-query invoice is a prefix invoice; an H/L tail must be added.", + "This six-bank construction is exact; a recursive all-size response-sharing stage and bounded terminal cocycle are separate obligations.", + "All scalar ADDs, bank SWAPs, ADDRESS permutations and native source/fresh scans are explicit. Native adapter and physical tape/precision/owner costs must be imported only under the actual caller interface.", + "No whole multiplication theorem, formal-kernel result, or improved kappa is claimed." + ], + "native_histogram_in_units_f": { + "2": 34 + }, + "native_rank_mass_in_units_f": 68, + "negative_controls": [ + "Wrong pre-P5 current-source fanout sign", + "Omit fresh N4 progress on the new public c2", + "Omit the last inverse ADD" + ], + "no_new_kappa": true, + "nonrecursive_event_counts": { + "ADD": 32, + "ADDRESS": 5, + "BANK_SWAP": 5, + "NATIVE": 34 + }, + "pivot_H": [ + [ + [ + { + "coefficient": "-1", + "word": [ + "P4", + "P3", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P4", + "P3", + "P1", + "N" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P4", + "P3", + "N" + ] + } + ] + ], + [ + [ + { + "coefficient": "-1", + "word": [ + "P5", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P5", + "N", + "P2" + ] + }, + { + "coefficient": "1", + "word": [ + "P5", + "P1", + "N" + ] + } + ], + [ + { + "coefficient": "1", + "word": [ + "P5", + "N" + ] + }, + { + "coefficient": "-1", + "word": [ + "P5", + "N", + "P2" + ] + } + ] + ] + ], + "pivot_rows": [ + 1, + 3 + ], + "prefix_only": true, + "producer_sha256": "d9169c729610e4346c56ab28f498c4f2d37dd5c34bc027309372f9d7f50ed06f", + "public_L": [ + [ + [ + { + "coefficient": "-2", + "word": [ + "P4", + "P3" + ] + }, + { + "coefficient": "1", + "word": [ + "P4", + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "-1", + "word": [ + "P4", + "P3" + ] + }, + { + "coefficient": "1", + "word": [ + "P4", + "P3", + "P1" + ] + } + ], + [ + { + "coefficient": "-2", + "word": [ + "P4", + "P3" + ] + }, + { + "coefficient": "1", + "word": [ + "P4", + "P3", + "P1" + ] + } + ], + [] + ], + [ + [ + { + "coefficient": "-3", + "word": [ + "P5" + ] + }, + { + "coefficient": "-1", + "word": [ + "P5", + "N", + "P2", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P5", + "P1" + ] + } + ], + [ + { + "coefficient": "-2", + "word": [ + "P5" + ] + }, + { + "coefficient": "-1", + "word": [ + "P5", + "N", + "P2", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P5", + "P1" + ] + } + ], + [ + { + "coefficient": "-2", + "word": [ + "P5" + ] + }, + { + "coefficient": "-1", + "word": [ + "P5", + "N", + "P2", + "N" + ] + }, + { + "coefficient": "1", + "word": [ + "P5", + "P1" + ] + } + ], + [] + ] + ], + "public_rows": [ + 0, + 2, + 4, + 5 + ], + "query_stages": 5, + "scientific_pin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "shared_entrance_N_calls": 2, + "source_continuation_stages": [ + 3 + ], + "source_pins": [ + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/caller/free_ops.py", + "sha256": "5806fe91b9fda162d5986b12e085b14eb3df9a4703f749f61c1f10363138ca77" + }, + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/caller/plane_group.py", + "sha256": "0c54c2e2462390bd0e9a8d47fc765b70e168ced1e0ef5de49e0afed653e26feb" + }, + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/caller/nested_prefix.py", + "sha256": "9ec10cb0243c0c829475ad7290f4953cdff27cb0f90f70b687c4bbee98af676b" + }, + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/caller/nested_six.py", + "sha256": "1719e560816ffa9e5193f6275c44c688fa280bede36a11c307f61783eb995bf0" + } + ], + "source_retractions_first_three": [ + { + "continued": false, + "source": 0, + "source_retraction": [ + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + "stage": 1, + "target": 1 + }, + { + "continued": false, + "source": 1, + "source_retraction": [ + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ] + ], + "stage": 2, + "target": 2 + }, + { + "continued": true, + "source": 2, + "source_retraction": [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "-1" + ] + ], + "stage": 3, + "target": 3 + } + ], + "status": "PASS_EXACT_FIVE_STAGE_MID_QUERY_HANDOFF_PREFIX", + "stock_if_two_pivots_finish_in_units_f": 72 +} diff --git a/research/marked-residual-reflection/source/q4-pauli-fusion/handoff_family_independent.py b/research/marked-residual-reflection/source/q4-pauli-fusion/handoff_family_independent.py new file mode 100644 index 0000000000..76629fefaa --- /dev/null +++ b/research/marked-residual-reflection/source/q4-pauli-fusion/handoff_family_independent.py @@ -0,0 +1,472 @@ +#!/usr/bin/env python3 +"""Independent right-normal replay and paid fresh-progress intervals. + +This reconstructs the source-handoff family as one explicit word. Its +operator normal form is P_perm * N_mask, opposite to caller/plane_group.py. +All integer coefficients and Gaussian signs are exact. No assert is used. +Apache-2.0; substantial OpenAI Codex assistance. +""" +from pathlib import Path +from collections import Counter +import argparse +import hashlib +import json +import sys + +sys.dont_write_bytecode = True +HERE = Path(__file__).resolve().parent +CALLER = HERE.parent / 'caller' + + +def need(x, why): + if not x: + raise ValueError(why) + + +class RightAlgebra: + """P_p N_x, where N_i^2=-I and permutations act on plane labels.""" + def __init__(self, planes): + self.planes = planes + self.id = tuple(range(planes)) + self.one = (self.id, 0) + + def product(self, a, b): + p, x = a + q, y = b + # N_x P_q = P_q N_(q^-1 x), in right normal form. + z = sum(1 << i for i in range(self.planes) if x >> q[i] & 1) + sign = -1 if (z & y).bit_count() & 1 else 1 + return (tuple(p[q[i]] for i in range(self.planes)), z ^ y), sign + + def inverse(self, a): + p, x = a + pi = [None] * self.planes + for i, j in enumerate(p): + pi[j] = i + y = sum(1 << p[i] for i in range(self.planes) if x >> i & 1) + op = tuple(pi), y + sign = -1 if x.bit_count() & 1 else 1 + need(self.product(a, op) == self.product(op, a) == (self.one, sign), + 'right-normal Gaussian inverse') + return op, sign + + def plus(self, a, b, scale=1): + c = dict(a) + for op, z in b.items(): + c[op] = c.get(op, 0) + scale * z + if not c[op]: + del c[op] + return c + + def times(self, a, b): + c = {} + for op, z in a.items(): + for oq, w in b.items(): + r, sign = self.product(op, oq) + c[r] = c.get(r, 0) + sign * z * w + if not c[r]: + del c[r] + return c + + def eye(self, n): + return [[{self.one: 1} if i == j else {} for j in range(n)] for i in range(n)] + + def mm(self, a, b): + n = len(a) + out = [[{} for _ in range(n)] for _ in range(n)] + for i in range(n): + for h in range(n): + if a[i][h]: + for j in range(n): + if b[h][j]: + out[i][j] = self.plus(out[i][j], self.times(a[i][h], b[h][j])) + return out + + def op(self, event): + data = event['operator'] + p = tuple(data['block_permutation']) + leftmask = sum(1 << i for i in data['native_blocks']) + rightmask = sum(1 << i for i in range(self.planes) if leftmask >> p[i] & 1) + return (p, rightmask), data['sign'] + + def commute(self, event, mask): + op, sign = self.op(event) + return self.product(op, (self.id, mask)) == self.product((self.id, mask), op) + + def replay(self, events, n, return_inverse=True): + M, Mi = self.eye(n), self.eye(n) + for event in events: + typ = event['kind'] + if typ == 'ADD': + d, s, z = event['dst'], event['src'], int(event['coefficient']) + M[d] = [self.plus(a, b, z) for a, b in zip(M[d], M[s])] + if return_inverse: + # Right multiplication by the inverse shear changes col s. + for row in Mi: + row[s] = self.plus(row[s], row[d], -z) + elif typ == 'BANK_SWAP': + a, b = event['banks'] + M[a], M[b] = M[b], M[a] + if return_inverse: + for row in Mi: + row[a], row[b] = row[b], row[a] + else: + op, sign = self.op(event) + bank = event['bank'] + M[bank] = [self.times({op: sign}, a) for a in M[bank]] + if return_inverse: + oi, si = self.inverse(op) + for row in Mi: + row[bank] = self.times(row[bank], {oi: sign * si}) + return M, Mi + + def serial(self, M): + return [[[[list(p), x, c] for (p, x), c in sorted(a.items())] for a in row] for row in M] + + +def event_word(q, omit_raw_a_repair=False): + """One explicit word; no transported-source search is called.""" + need(q >= 2, 'the handoff family starts at q=2') + n, planes = 2 * q + 2, 2 * q + 2 + events = [] + def add(d, s, c, label): + if c: + events.append(dict(kind='ADD', dst=d, src=s, coefficient=str(c), label=label)) + def unary(bank, blocks, permutation=None, sign=1, label='', native=True): + p = list(range(planes)) if permutation is None else permutation + events.append(dict(kind='NATIVE' if native else 'ADDRESS_OR_UNIT', bank=bank, + operator=dict(sign=sign, native_blocks=list(blocks), + block_permutation=p, native_arity=2 * len(blocks)), label=label)) + def common(bank, label, inverse=False): + unary(bank, [0], sign=-1 if inverse else 1, label=label) + def swap(a, b, label): + events.append(dict(kind='BANK_SWAP', banks=[a, b], label=label)) + def source_swap(bank, stage): + p = list(range(planes)) + p[0], p[stage] = p[stage], p[0] + unary(bank, [], p, label=f'query{stage} source swap', native=False) + def fresh(source, stage, target): + for bank in range(n): + if bank != source: + unary(bank, [stage], label=f'query{stage} target fresh' if bank == target + else f'query{stage} inactive fresh progress') + for r in range(2, q + 1): + add(2 * r + 1, 3, 1, 'raw c-basis') + common(1, 'shared input N exposure') + add(2, 1, 1, 'shared input fanout') + common(1, 'shared input N inverse', True) + for r in range(q, 0, -1): + add(2 * r + 1, 1, -1, 'initial nested scalar bridge') + add(0, 2 * r, 1, 'initial nested scalar bridge') + add(2, 0, -1, 'query1 scalar entrance') + common(0, 'query1 source common') + add(1, 0, 1, 'query1 delivery') + source_swap(0, 1) + fresh(0, 1, 1) + add(2, 0, 1, 'query1 scalar exit') + add(0, 2, -1, 'initial nested scalar bridge') + add(1, 3, 1, 'initial nested scalar bridge') + for r in range(1, q + 1): + add(2 * r + 1, 1, -1, 'query2 scalar entrance') + common(1, 'query2 source common') + add(2, 1, 1, 'query2 delivery') + source_swap(1, 2) + fresh(1, 2, 2) + for r in range(1, q + 1): + add(2 * r + 1, 1, 1, 'query2 scalar exit') + add(1, 3, -1, 'initial nested scalar bridge') + common(2, 'query3 source common') + for r in range(2, q + 1): + add(2 * r + 1, 2, 1, 'query3 source fanout') + add(3, 2, 1, 'query3 delivery') + source_swap(2, 3) + fresh(2, 3, 3) + for r in range(2, q + 1): + add(2 * r + 1, 2, 1, 'query3 pre-continuation fanout') + common(2, 'query3 retained source continuation') + add(2, 0, 1, 'initial nested scalar bridge') + add(3, 1, 1, 'initial nested scalar bridge') + add(1, 3, -1, 'initial nested scalar bridge') + swap(2, 3, 'initial nested permutation') + add(0, 4, -1, 'initial nested scalar bridge') + add(1, 5, 1, 'initial nested scalar bridge') + for r in range(2, q + 1): + add(2 * r + 1, 1, -1, 'query4 scalar source entrance') + if not omit_raw_a_repair: + for r in range(3, q + 1): + add(0, 2 * r, -1, 'restore raw a from deeper response entrance') + add(3, 0, -1, 'held source subtract raw a') + for r in range(2, q + 1): + add(3, 2 * r, -1, 'held source subtract future raw b') + for r in range(2, q + 1): + even, odd, b, c = 2 * r, 2 * r + 1, 2 * r, 2 * r + 1 + common(1, f'query{even} source common') + add(1, 3, -1, f'query{even} isolate raw c difference') + swap(1, 3, f'query{even} source handoff') + source_swap(1, even) + fresh(1, even, 3) + swap(3, c, f'query{even} move finished c difference') + common(b, f'query{odd} source common') + for ell in range(r + 1, q + 1): + add(2 * ell + 1, b, 1, f'query{odd} future c first fanout') + add(3, b, 1, f'query{odd} delivery') + swap(b, 3, f'query{odd} source handoff') + add(2, b, -1, f'query{odd} finish current b accumulator') + for ell in range(r + 1, q + 1): + add(2 * ell + 1, b, -1, f'query{odd} restore future raw c differences') + source_swap(b, odd) + fresh(b, odd, 3) + if r < q: + add(2, 1, 1, f'query{odd} retain other carrier in b accumulator') + nextc = 2 * r + 3 + for ell in range(r + 2, q + 1): + add(2 * ell + 1, nextc, -1, f'query{odd} next c difference') + add(2 * ell + 1, 1, 1, f'query{odd} retain other carrier in future c') + swap(1, nextc, f'query{odd} move next raw c into t') + add(1, b, 1, f'query{odd} next source preload') + common(b, f'query{odd} retained source continuation') + swap(b, 3, f'query{odd} move finished b to its public slot') + common(0, 'final raw a common query') + add(2, 0, -1, 'final b accumulator isolation') + for r in range(3, q + 1): + add(2 * r + 1, 2 * r - 1, 1, 'triangular c difference decode') + return events + + +def canonical_event(event): + typ = event['kind'] + if typ == 'ADD': + return typ, event['dst'], event['src'], int(event['coefficient']) + if typ == 'BANK_SWAP': + return typ, tuple(event['banks']) + x = event['operator'] + return typ, event['bank'], x['sign'], tuple(x['native_blocks']), tuple(x['block_permutation']) + + +def histogram(events): + return Counter(event['operator']['native_arity'] for event in events if event['kind'] == 'NATIVE') + + +def defer_fresh(events, n, planes, flush_swaps=False): + """Pay each postponed fresh factor at its actual first incompatible cut.""" + A = RightAlgebra(planes) + pending = [[] for _ in range(n)] + out, batches, transports = [], [], [] + def flush(bank, deadline, reason): + if not pending[bank]: + return + requests = pending[bank] + blocks = [e['operator']['native_blocks'][0] for _, e in requests] + need(len(set(blocks)) == len(blocks), 'no repeated native plane is silently cancelled') + event = dict(kind='NATIVE', bank=bank, + operator=dict(sign=1, native_blocks=sorted(blocks), + block_permutation=list(range(planes)), native_arity=2 * len(blocks)), + label='paid deferred fresh-progress batch') + batches.append(dict(bank=bank, original_request_indices=[i for i, _ in requests], + original_request_banks=[e['bank'] for _, e in requests], + native_planes=sorted(blocks), deadline_before_original_event=deadline, + reason=reason, output_event_index=len(out), arity_in_units_f=2 * len(blocks))) + out.append(event) + pending[bank] = [] + for index, event in enumerate(events): + fresh = event['kind'] == 'NATIVE' and ('target fresh' in event['label'] or 'inactive fresh progress' in event['label']) + if fresh: + need(len(event['operator']['native_blocks']) == 1 and event['operator']['sign'] == 1, + 'a fresh request is an actual single signed native plane') + pending[event['bank']].append((index, event)) + continue + typ = event['kind'] + if typ == 'ADD': + for bank in sorted({event['dst'], event['src']}): + flush(bank, index, 'next scalar ADD touches this field') + elif typ == 'BANK_SWAP': + a, b = event['banks'] + if flush_swaps: + flush(a, index, 'bank SWAP conservative deadline') + flush(b, index, 'bank SWAP conservative deadline') + else: + transports.append(dict(original_event_index=index, banks=[a, b], + pending_request_indices=[[i for i, _ in pending[a]], [i for i, _ in pending[b]]])) + pending[a], pending[b] = pending[b], pending[a] + else: + bank = event['bank'] + mask = sum(1 << e['operator']['native_blocks'][0] for _, e in pending[bank]) + if mask and not A.commute(event, mask): + flush(bank, index, 'next unary fails exact native-plane commutation') + out.append(event) + for bank in range(n): + flush(bank, len(events), 'declared prefix endpoint') + need(sum(k * v for k, v in histogram(out).items()) == sum(k * v for k, v in histogram(events).items()), + 'all postponed native rank mass remains paid') + return out, batches, transports + + +def reverse_events(events): + out = [] + for event in reversed(events): + e = json.loads(json.dumps(event)) + if e['kind'] == 'ADD': + e['coefficient'] = str(-int(e['coefficient'])) + elif e['kind'] != 'BANK_SWAP': + p = e['operator']['block_permutation'] + pi = [None] * len(p) + for i, j in enumerate(p): + pi[j] = i + # Invert left-normal N_x P_p independently from right replay. + mask = sum(1 << j for j in e['operator']['native_blocks']) + invmask = sum(1 << pi[i] for i in range(len(p)) if mask >> i & 1) + e['operator']['block_permutation'] = pi + e['operator']['native_blocks'] = [i for i in range(len(p)) if invmask >> i & 1] + if mask.bit_count() & 1: + e['operator']['sign'] *= -1 + out.append(e) + return out + + +def matrix_digest(A, M): + raw = json.dumps(A.serial(M), separators=(',', ':')).encode() + return hashlib.sha256(raw).hexdigest() + + +def factory_certificate(q, A, M): + """Separate the exact alternating carrier factories from the fixed J.""" + def P(stage): + p = list(A.id) + p[0], p[stage] = p[stage], p[0] + return {(tuple(p), 0): 1} + N, I = {(A.id, 1): 1}, {A.one: 1} + Ni = {(A.id, 1): -1} + Q1 = A.times(A.times(Ni, P(1)), N) + J = [[A.plus(A.plus(P(2), Q1), I, -1), A.plus(I, P(2), -1)], + [A.plus(Q1, I, -1), I]] + u, v = (1, A.times(P(3), N)), (0, I) + for r in range(2, q + 1): + U = u[0], A.times(P(2 * r), u[1]) + V = v[0], A.times(A.times(P(2 * r + 1), N), v[1]) + if r < q: + u, v = V, (U[0], {op: -c for op, c in U[1].items()}) + factories = [U, V] + Ffresh = {(A.id, ((1 << A.planes) - 1) ^ 1): 1} + rows = [] + support_union = set() + for physical_row, (coordinate, factory) in zip((1, 3), factories): + need(len(factory) == 1, 'each terminal factory is a single actual native/ADDRESS word') + (perm, rightmask), sign = next(iter(factory.items())) + leftsupport = [perm[i] for i in range(A.planes) if rightmask >> i & 1] + need(0 not in leftsupport and not support_union.intersection(leftsupport), + 'terminal factories have disjoint fresh native supports') + support_union.update(leftsupport) + expected = [A.times(A.times(Ffresh, factory), J[coordinate][j]) for j in range(2)] + need([M[physical_row][j] for j in (1, 3)] == expected, + 'all actual pivot-input columns factor through the exact fixed J') + rows.append(dict(physical_row=physical_row, fixed_J_coordinate=coordinate, + ADDRESS_permutation=list(perm), native_support_left_normal=sorted(leftsupport), + native_block_count=len(leftsupport), exact_Gaussian_unit=sign, + one_direct_inverse_factory_child_arity_in_units_f=2 * len(leftsupport))) + need(support_union == set(range(3, 2 * q + 2, 2)), + 'factory native supports are exactly the q odd fresh planes 3,5,...,2q+1') + return dict(rows=rows, total_native_blocks=q, + exact_support_union=sorted(support_union), + direct_inverse_factory_rank_mass_in_units_f=2 * q, + scope='Exact factorization and invoice for direct diagonal inverse-factory cleanup. This is not a lower bound on arbitrary joint H/L compensation words.') + + +def check_q(q, source_compare=False, full_intervals=False): + n, planes = 2 * q + 2, 2 * q + 2 + events = event_word(q) + if source_compare: + sys.path.insert(0, str(CALLER)) + import handoff_family + _, _, _, supplied = handoff_family.build(q, True) + need(list(map(canonical_event, events)) == list(map(canonical_event, supplied)), + f'q{q} independently reconstructed trace differs from the supplied literal word') + A = RightAlgebra(planes) + M, Mi = A.replay(events, n) + need(A.mm(M, Mi) == A.mm(Mi, M) == A.eye(n), 'both complete inverse matrix orders') + rev, _ = A.replay(reverse_events(events), n, False) + need(rev == Mi, 'serialized reverse/inverse word binds independently') + E = {(A.id, (1 << planes) - 1): 1} + public = [i for i in range(n) if i not in (1, 3)] + need(all(M[i] == [E if j == i else {} for j in range(n)] for i in public), + f'q{q} all independent actual public columns') + expected = n * (2 * q + 1) + q + 2 + need(histogram(events) == {2: expected}, 'separate-progress prefix histogram') + batched, batches, transports = defer_fresh(events, n, planes) + Mb, Mbi = A.replay(batched, n) + need(Mb == M and Mbi == Mi, 'paid batched word equals the complete original word and inverse') + need(A.replay(reverse_events(batched), n, False)[0] == Mi, + 'actual reversed batched event list restores every raw input') + if q >= 3: + mutant, _ = A.replay(event_word(q, True), n, False) + need(any(mutant[i] != M[i] for i in public), 'omitted raw-a repair must change a public raw-input column') + # A defect control changes a real pending progress batch, not a promise. + bad = json.loads(json.dumps(batched)) + chosen = next(e for e in bad if e['label'] == 'paid deferred fresh-progress batch') + chosen['operator']['sign'] *= -1 + need(A.replay(bad, n, False)[0] != M, 'wrong deferred Gaussian batch phase is detected') + phase_adapters = sum((len(b['native_planes']) - 1) % 4 != 0 for b in batches) + result = dict(q=q, banks=n, stages=2 * q + 1, ambient_arity_in_units_f=2 * planes, + independent_source_trace_match=source_compare, + separate_histogram=dict(histogram(events)), batched_histogram=dict(histogram(batched)), + rank_mass_in_units_f=2 * expected, stock_in_units_f=2 * n * planes, + D_prefix_in_units_f=2 * q, public_rows=public, + original_event_count=len(events), batched_event_count=len(batched), + batch_count=len(batches), transported_pending_intervals=len(transports), + largest_batch_arity_in_units_f=max(b['arity_in_units_f'] for b in batches), + batch_Gaussian_UNIT_scan_count=phase_adapters, + batch_selected_plane_packing_ADDRESS_scan_upper_bound=2 * len(batches), + batch_native_lowering='Product of r disjoint N_f planes equals i^(r-1) times the actual native N_(r*f) after the displayed plane packing. Pay the Gaussian UNIT scan when r-1 is nonzero modulo4 and the two packing/unpacking ADDRESS scans unless a separate literal layout removes them.', + terminal_factory_diagnostic=factory_certificate(q, A, M), + complete_matrix_sha256=matrix_digest(A, M), + complete_inverse_sha256=matrix_digest(A, Mi), + all_actual_columns_and_both_inverse_orders='PASS', + all_batched_columns_and_literal_reverse='PASS') + if full_intervals: + result.update(original_events=events, batched_events=batched, + fresh_progress_intervals=batches, pending_bank_transports=transports) + return result + + +def main(): + ap = argparse.ArgumentParser(description=__doc__) + ap.add_argument('--write', action='store_true') + ap.add_argument('--quick', action='store_true', help='check q2..5 rather than the saved full receipt') + args = ap.parse_args() + qs = [2, 3, 4, 5] if args.quick else [2, 3, 4, 5, 6, 8, 12, 16] + fixtures = [] + for q in qs: + fixtures.append(check_q(q, q <= 5, q in (2, 3, 4, 8, 16))) + print('PASS_RIGHT_NORMAL_HANDOFF_AND_PAID_PROGRESS', 'q', q, + 'hist', fixtures[-1]['batched_histogram'], flush=True) + out = dict(status='PASS_INDEPENDENT_ACTUAL_HANDOFF_FAMILY_AND_PAID_PROGRESS', + no_new_kappa=True, prefix_only=True, + scientific_pin='20ecf2891d80b5acf18d980b2164fb44ea7faa90', + fixtures=fixtures, + exact_arithmetic='Integer linear combinations of P_perm N_mask; the product rule is derived in right normal form, independently of caller/plane_group.py left normal form. N_i^2=-I Gaussian signs are retained.', + all_q_retiming_proof='At each processed cut original_prefix=D_pending*retimed_prefix. Each pending fresh N_i commutes through a unary only after exact group multiplication verifies commutation. Pending factors are transported through an actual bank SWAP by conjugation. Before each ADD all pending factors on both participating banks are paid. Pending factors on other banks commute with the ADD. Endpoint pays every remaining factor. Hence the complete changed word equals the original for every finite q, with all native rank mass retained.', + covered_domain='Finite independent full-column replay q2,3,4,5,6,8,12,16, plus the written all-q local commutation invariant for the displayed event generator. The source all-pair affine induction remains a separate written construction; neither is a formal-kernel result.', + negative_controls=['Omitting the q>=3 raw-a repair changes an actual public input column.', + 'Wrong sign on a paid deferred fresh batch changes the complete operator.'], + limits=['The terminal two-pivot H/L compensation is not part of this prefix receipt.', + 'The batching schedule is valid and fully paid; no global optimality of its moment is claimed.', + 'Each wide native batch is an actual product of distinct disjoint native planes, arity 2f times its displayed plane count. Native ADDRESS/adapters, scalar ADD/SWAP scans, ownership, precision and outer assembly retain their independent costs.'], + attribution=['Source handoff and final raw-a closure: root.', + 'Scalable pair encoder and raw-a repair: mixed_carrier_caller_1019/caller/handoff_family.py.', + 'Second source handoff/current-source fanout: q4_pauli_fusion and stabilizer_escape_1019.', + 'Independent explicit trace reconstruction, right-normal all-column replay and legal paid progress intervals: q4_pauli_fusion.'], + source_pins=[dict(path=str(CALLER / name), sha256=hashlib.sha256((CALLER / name).read_bytes()).hexdigest()) + for name in ['handoff_family.py', 'nested_family.py', 'nested_prefix.py', 'plane_group.py']], + producer_sha256=hashlib.sha256(Path(__file__).read_bytes()).hexdigest()) + out = json.loads(json.dumps(out)) + if args.quick: + return + path = HERE / 'INDEPENDENT-HANDOFF-FAMILY.json' + if args.write: + path.write_text(json.dumps(out, sort_keys=True, indent=2) + '\n') + else: + need(json.loads(path.read_text()) == out, 'saved independent family receipt differs') + print(out['status'], 'prefix only; no new kappa') + + +if __name__ == '__main__': + main() diff --git a/research/marked-residual-reflection/source/q4-pauli-fusion/marked_residual_gate.py b/research/marked-residual-reflection/source/q4-pauli-fusion/marked_residual_gate.py new file mode 100644 index 0000000000..d930d6d157 --- /dev/null +++ b/research/marked-residual-reflection/source/q4-pauli-fusion/marked_residual_gate.py @@ -0,0 +1,247 @@ +#!/usr/bin/env python3 +"""Exact marked-residual commutator certificates, with the actual all-f scope. + +The operator C is a proof witness, not an available circuit operation. +It commutes whole ordered-plane permutations and X translations, and does +not commute arbitrary Pauli Z or arbitrary bit-linear ADDRESS maps. +Apache-2.0; substantial OpenAI Codex assistance. +""" +from pathlib import Path +from fractions import Fraction +from itertools import permutations +import argparse +import hashlib +import json + +HERE = Path(__file__).resolve().parent + + +def need(x, why): + if not x: + raise ValueError(why) + + +def matmul(a, b): + n = len(a) + out = [[0] * n for _ in range(n)] + for i in range(n): + for h, z in enumerate(a[i]): + if z: + for j, w in enumerate(b[h]): + if w: + out[i][j] += z * w + return out + + +def plus(a, b, sign=1): + return [[x + sign * y for x, y in zip(r, s)] for r, s in zip(a, b)] + + +def exact_rank(matrix): + a = [[Fraction(z) for z in row] for row in matrix] + original_rows = list(range(len(a))) + pivots, pivot_rows = [], [] + row = 0 + for col in range(len(a[0])): + h = next((h for h in range(row, len(a)) if a[h][col]), None) + if h is None: + continue + a[row], a[h] = a[h], a[row] + original_rows[row], original_rows[h] = original_rows[h], original_rows[row] + z = a[row][col] + a[row] = [x / z for x in a[row]] + for h in range(len(a)): + if h != row and a[h][col]: + z = a[h][col] + a[h] = [x - z * y for x, y in zip(a[h], a[row])] + pivots.append(col) + pivot_rows.append(original_rows[row]) + row += 1 + need(all(not any(r) for r in a[row:]), 'rank upper bound has zero remaining rows') + return row, pivots, pivot_rows + + +def signs(L): + return [1 if not (x >> owner & 1) else -1 + for x in range(1 << L) for owner in range(L)] + + +def mapping(L, plane_permutation=None, native_mask=0): + p = list(range(L)) if plane_permutation is None else plane_permutation + out = [] + for x in range(1 << L): + y = x ^ native_mask + z = sum(((y >> i) & 1) << p[i] for i in range(L)) + for owner in range(L): + out.append(z * L + p[owner]) + need(sorted(out) == list(range(len(out))), 'actual virtual/residual action is a permutation') + return out + + +def permutation_matrix(mapping): + a = [[0] * len(mapping) for _ in mapping] + for col, row in enumerate(mapping): + a[row][col] = 1 + return a + + +def commutator_entries(L, native_mask): + c = signs(L) + out = [] + for col, row in enumerate(mapping(L, native_mask=native_mask)): + z = c[col] - c[row] + if z: + out.append([row, col, z]) + need(len({e[0] for e in out}) == len(out) == len({e[1] for e in out}), + 'nonzero commutator entries have distinct rows and columns') + need(len(out) == native_mask.bit_count() * (1 << L), 'exact query commutator rank') + return out + + +def local_fixture(L, bank_masks): + c = signs(L) + for p in permutations(range(L)): + need(all(c[i] == c[j] for i, j in enumerate(mapping(L, p))), + 'every whole-plane permutation commutes the marked C') + # Every Q_i and every actual X translation is diagonal in this basis; + # the latter may have a different sign for the two residual labels. + for i in range(L): + q = [1 if not (x >> i & 1) else -1 for x in range(1 << L) for _ in range(L)] + need(all((a * b) == (b * a) for a, b in zip(c, q)), 'Q_i commutes C') + ranks = {str(mask): len(commutator_entries(L, mask)) for mask in range(1, 1 << L)} + target_rank = sum(len(commutator_entries(L, mask)) for mask in bank_masks) + expected_planes = sum(mask.bit_count() for mask in bank_masks) + need(target_rank == expected_planes * (1 << L), 'joint bank debt ranks add literally') + return dict(planes=L, internal_dimension=L * (1 << L), bank_native_masks=bank_masks, + C_diagonal=c, single_bank_query_commutator_ranks=ranks, + target_commutator_rank=target_rank, + minimum_total_native_plane_count=expected_planes, + target_Gaussian_phase_exponents=[mask.bit_count() % 4 for mask in bank_masks], + phase_note='The displayed native action is i^r times its real permutation. Multiplication by that nonzero Gaussian unit leaves the recorded commutator rank unchanged.') + + +def core_fixture(): + L, d = 3, 24 + I = permutation_matrix(mapping(L)) + X0 = permutation_matrix(mapping(L, native_mask=1)) + P1 = permutation_matrix(mapping(L, [1, 0, 2])) + P2 = permutation_matrix(mapping(L, [2, 1, 0])) + Q1 = matmul(matmul(X0, P1), X0) + QP = matmul(Q1, P2) + J = [[plus(plus(P2, Q1), I, -1), plus(I, P2, -1)], + [plus(Q1, I, -1), I]] + Ji = [[QP, plus(Q1, QP, -1)], + [plus(QP, P2, -1), plus(plus(Q1, P2), QP, -1)]] + def block(a): + return [[a[i // d][j // d][i % d][j % d] for j in range(2 * d)] + for i in range(2 * d)] + ident = [[int(i == j) for j in range(2 * d)] for i in range(2 * d)] + need(matmul(block(J), block(Ji)) == matmul(block(Ji), block(J)) == ident, + 'fixed J and its written inverse are exact') + # N0=i X0, so the common factor i is removed solely for rank arithmetic. + T = block([[matmul(Ji[i][j], X0) for j in range(2)] for i in range(2)]) + c = signs(L) * 2 + R = [[T[i][j] * (c[j] - c[i]) for j in range(2 * d)] for i in range(2 * d)] + rank, columns, rows = exact_rank(R) + need(rank == 24, 'fixed-core exact commutator rank is 24=3*2^3') + minor = [[R[i][j] for j in columns] for i in rows] + need(exact_rank(minor)[0] == 24, 'displayed 24x24 pivot minor is nonsingular') + return dict(internal_dimension=d, total_dimension=2 * d, + J=block(J), J_inverse=block(Ji), correction_without_common_Gaussian_unit=T, + C_diagonal=c, commutator=R, exact_rational_rank=rank, + nonsingular_minor_rows=rows, nonsingular_minor_columns=columns, + normalized_native_plane_lower_bound=3, + meaning='The fixed block is J^-1 diag(N0,N0); Q1=N0^-1 P1 N0=X0 P1 X0 exactly. The omitted common scalar is i, which preserves rank.') + + +def terminal_fixture(q): + from handoff_family_independent import RightAlgebra, event_word, factory_certificate + A = RightAlgebra(2 * q + 2) + M, _ = A.replay(event_word(q), 2 * q + 2) + data = factory_certificate(q, A, M) + normalized = [] + external_union = set() + for item in data['rows']: + p = item['ADDRESS_permutation'] + left = item['native_support_left_normal'] + right = {i for i, j in enumerate(p) if j in left} + inverse_common = p.index(0) + G = right ^ {inverse_common} + need(0 in G and 1 not in G and 2 not in G, 'normalized debt has exactly its common core plane') + external = G - {0} + need(not external_union.intersection(external), 'normalized external debts stay disjoint') + external_union.update(external) + normalized.append(dict(physical_row=item['physical_row'], fixed_J_coordinate=item['fixed_J_coordinate'], + right_native_planes=sorted(right), ADDRESS_inverse_common_plane=inverse_common, + normalized_correction_native_planes=sorted(G), + external_native_planes=sorted(external))) + need(len(external_union) == q, 'actual tail has q distinct external debts after right ADDRESS normalization') + L = 2 * q + 2 + return dict(q=q, ambient_planes=L, normalized_debts=normalized, + external_support_union=sorted(external_union), external_commutator_rank=q * (1 << L), + core_commutator_rank=3 * (1 << L), total_pivot_correction_commutator_rank=(q + 3) * (1 << L), + minimum_tail_native_plane_count=q + 3, minimum_tail_rank_mass_in_units_f=2 * (q + 3), + current_direct_tail_native_plane_count=q + 4, + scope='After this exact prefix cut; any length of whole-plane ADDRESS/X-translation/GL-bank bridge word and native products on whole planes. Public-reader columns can only increase the complete tail commutator rank. Cross-cut cancellation or Pauli Z/other bit-linear ADDRESS is outside this tail-only invoice.') + + +def excluded_Z_control(): + # For f=1 choose residual r=Xp*Xq. In the canonical N=iX_virtual + # basis Zp sends (x,rbit) to (x xor1,rbit xor1), with a nonzero unit. + # Extend C as identity outside the one-mark sector. This extension + # still commutes X and plane permutations but fails to commute Zp. + L = 2 + def c_value(bits, residual): + if residual.bit_count() != 1: + return 1 + owner = (residual & -residual).bit_length() - 1 + return 1 if not (bits >> owner & 1) else -1 + bits, residual, plane = 1, 1, 0 + before = c_value(bits, residual) + after = c_value(bits ^ (1 << plane), residual ^ (1 << plane)) + need(before == -1 and after == 1, 'Pauli Z really escapes the marked-C commutant') + return dict(actual_f=1, virtual_bits=bits, marked_residual_bits=residual, + Pauli_Zp_plane=plane, C_before=before, C_after=after, + result='NONCOMMUTING: the claimed floor must not be extended to full Pauli Z bridges.') + + +def prove(): + fullpair = local_fixture(2, [3, 3]) + need(fullpair['target_commutator_rank'] == 16 and fullpair['single_bank_query_commutator_ranks']['1'] == 4, + 'three single-plane (rank-2f) queries cannot pay the two-bank full pair') + return dict(status='PASS_EXACT_MARKED_RESIDUAL_GLOBAL_FLOOR', no_new_kappa=True, + full_pair_three_query_gate=fullpair, + q3_disjoint_debt_gate=local_fixture(3, [1, 6]), + q4_disjoint_debt_gate=local_fixture(4, [3, 12]), + fixed_core=core_fixture(), + actual_handoff_terminal_gates=[terminal_fixture(q) for q in (2, 3, 4, 8)], + excluded_Pauli_Z_negative_control=excluded_Z_control(), + global_theorem='For L>=1 ordered native planes and n arbitrary target banks, every exact word with target diag(prod_(i=0..L-1) N_i) on those n independent banks, restored arbitrary helpers, native queries on unions of r whole planes, and arbitrary invertible bank bridges over whole-plane ADDRESS permutations and X translations has sum r>=nL. Its native rank mass is at least2f*nL=n*m for m=2fL. Arbitrary Gaussian scalar phases, query inverses and conjugation by covered free bridges do not alter the bound.', + global_proof='On an actual invariant subspace V of dimensionL*2^L let C|x,owner>=(-1)^x_owner |x,owner>. Whole-plane permutations move x andowner together and X translations are diagonal, so every covered bridge commutesC. Product of r native planes flips r virtual bits and leavesownerfixed; its commutator has r*2^L nonzero entries with distinct rows/columns. The n-bank full native target has ranknL2^L. Rank[AB,C]<=rank[A,C]+rank[B,C] for invertible A,B proves the bound.', + actual_all_f_embedding='N_f^2=-I and N_f anticommutes every single X translation on its2f bits. Fix Q=X on one distinguished bit. The2f-1 commuting operators R_b=Q*X_b commuteN andQ. In each joint R eigenlabel choose |+,r> withQ=+1 and define |-,r>=-i*N|+,r>. Then N=iX_virtual, Q=Z_virtual and every X translation is diagonal in (virtual,r). There are2^(2f-1)>=2 residual labels for everyf>=1. Choose the same two labels u,v in every plane and restrict to tensors with exactly one v. Identical plane bases make actual whole-plane ADDRESS permutations the simultaneous virtual/residual permutations used by the certificate. This is an actual invariant subspace, not a faithful-representation assumption or a finite-f interpolation.', + scope_exclusions=['Pauli Z is explicitly excluded: it moves residual labels and fails the exact negative control.', + 'Arbitrary bit-linear ADDRESS maps, p/q role controllers and native axes not unions of the declared ordered planes are excluded unless independently proved to commute this C.', + 'The n*m floor concerns the declared whole-plane native rank mass and complete full-native bank contract. It is not a global circuit, supplier or multiplication-theorem lower bound.'], + attribution=['Marked-residual construction generalizes the earlier q4 two-residual commutator mechanism.', + 'Parent root identified the complete n-bank stock-floor consequence.', + 'The q3/q4 joint debt and actual J-core certificates and all-f X-translation embedding are derived and checked here.'], + producer_sha256=hashlib.sha256(Path(__file__).read_bytes()).hexdigest(), + source_pins=[dict(path=str(HERE / name), sha256=hashlib.sha256((HERE / name).read_bytes()).hexdigest()) + for name in ['handoff_family_independent.py', 'source_handoff_prefix.py']]) + + +def main(): + ap = argparse.ArgumentParser(description=__doc__) + ap.add_argument('--write', action='store_true') + args = ap.parse_args() + out = json.loads(json.dumps(prove())) + path = HERE / 'MARKED-RESIDUAL-GLOBAL-FLOOR.json' + if args.write: + path.write_text(json.dumps(out, indent=2, sort_keys=True) + '\n') + else: + need(json.loads(path.read_text()) == out, 'saved marked-residual certificate differs') + print(out['status'], 'global mass>=n*m in whole-plane/X-only grammar; Pauli Z excluded') + + +if __name__ == '__main__': + main() diff --git a/research/marked-residual-reflection/source/q4-pauli-fusion/source_handoff_prefix.py b/research/marked-residual-reflection/source/q4-pauli-fusion/source_handoff_prefix.py new file mode 100644 index 0000000000..76e0068415 --- /dev/null +++ b/research/marked-residual-reflection/source/q4-pauli-fusion/source_handoff_prefix.py @@ -0,0 +1,328 @@ +#!/usr/bin/env python3 +"""Exact five-stage six-bank prefix with two mid-query source handoffs. + +The first three stages are the pinned nested-response construction. The +last two stages change the physical source before its plane ADDRESS swap. +All six input columns are arbitrary. No ordinary or private helper occurs. +Apache-2.0; substantial OpenAI Codex assistance. +""" +from pathlib import Path +from fractions import Fraction +from collections import Counter +import argparse +import hashlib +import json +import sys + +sys.dont_write_bytecode = True +HERE = Path(__file__).resolve().parent +CALLER = HERE.parent / 'caller' +sys.path.insert(0, str(CALLER)) +import free_ops as F +from plane_group import Algebra +from nested_prefix import skeleton, probe + + +def need(x, message): + if not x: + raise ValueError(message) + + +class Physical: + def __init__(self, skip_progress=False): + self.A = Algebra(6) + self.M = self.A.eye(6) + self.Mi = self.A.eye(6) + self.events = [] + self.skip_progress = skip_progress + + def app(self, B, Bi, event): + A = self.A + need(A.mm(B, Bi) == A.mm(Bi, B) == A.eye(6), 'each actual event is invertible') + self.M = A.mm(B, self.M) + self.Mi = A.mm(self.Mi, Bi) + self.events.append(event) + + def add(self, dst, src, c, label): + if not c: + return + A = self.A + self.app(A.es(6, dst, src, A.mono(coefficient=c)), + A.es(6, dst, src, A.mono(coefficient=-c)), + dict(kind='ADD', dst=dst, src=src, coefficient=str(c), label=label)) + + def unary(self, bank, op, kind, label): + A = self.A + B, Bi = A.eye(6), A.eye(6) + B[bank][bank], Bi[bank][bank] = op, A.inv(op) + self.app(B, Bi, dict(kind=kind, bank=bank, operator=A.serial(op), + native_arity=A.native_arity(op), label=label)) + + def swap(self, i, j, label): + B = self.A.eye(6) + B[i], B[j] = B[j], B[i] + self.app(B, B, dict(kind='BANK_SWAP', banks=[i, j], label=label)) + + def fresh(self, stage, source): + for bank in range(6): + if bank == source: + continue + if self.skip_progress and stage == 4 and bank == 3: + continue + self.unary(bank, self.A.n(stage), 'NATIVE', + f'query{stage} paid fresh progress bank{bank}') + + +class Formal: + def __init__(self): + self.M, self.Mi = F.eye(6), F.eye(6) + + def app(self, B, Bi): + need(F.mm(B, Bi) == F.mm(Bi, B) == F.eye(6), 'each formal event is invertible') + self.M = F.mm(B, self.M) + self.Mi = F.mm(self.Mi, Bi) + + def add(self, dst, src, c): + if c: + self.app(F.es(6, dst, src, c), F.es(6, dst, src, F.neg(c))) + + def scalar(self, dst, src, c): + self.add(dst, src, F.mono((), c)) + + def unary(self, bank, op): + self.app(F.unary(6, bank, op), F.unary(6, bank, F.inv(op))) + + def swap(self, i, j): + B = F.eye(6) + B[i], B[j] = B[j], B[i] + self.app(B, B) + + +def evaluate(x, A): + out = A.Z + for word, c in x.items(): + term = A.mono(coefficient=c) + for letter in word: + op = A.n(0) if letter == 0 else A.swap(0, abs(letter)) + term = A.mul(term, A.inv(op) if letter < 0 else op) + out = A.add(out, term) + return out + + +def bind(M, A, fresh): + return [[A.mul(fresh, evaluate(x, A)) for x in row] for row in M] + + +def ec(z): + return F.add(F.mono((), z[0]), F.mono((0,), z[1])) + + +def build(wrong_fanout=False, skip_progress=False): + p, f = Physical(skip_progress), Formal() + A = p.A + _, ops = skeleton(2, (1, 0)) + choices = probe(2, (1, 1), (1, 0)) + need(all(c is not None for _, _, c in choices), 'pinned source retractions exist') + f.scalar(5, 3, 1) + p.add(5, 3, 1, 'input c-basis inverse') + p.unary(1, A.n(0), 'NATIVE', 'shared entrance N exposure') + p.add(2, 1, 1, 'shared entrance b1 += N t') + p.unary(1, A.inv(A.n(0)), 'NATIVE', 'shared entrance N inverse') + stage = 0 + source_rows = [] + for typ, dst, src, z in ops: + if typ == 'a': + f.add(dst, src, ec(z)) + if z[1]: + need(stage == 0 and dst == 2 and src == 1 and z[0] == 0, + 'the only encountered external N-ADD is the compiled shared entrance') + else: + p.add(dst, src, z[0], 'scalar nested response bridge') + elif typ == 's': + f.swap(dst, src) + p.swap(dst, src, 'nested response bank permutation') + else: + stage += 1 + u = choices[stage - 1][2][1] + if stage == 4: + # This is exactly the current cut BEFORE its source N: + # all scalar source-retraction entrances are retained. + for bank, (a, b) in enumerate(u): + if bank != src: + f.scalar(bank, src, -a) + p.add(bank, src, -a, 'query4 scalar entrance before changed source identity') + break + continued = any(v[1] for v in u) + source_rows.append(dict(stage=stage, source=src, target=dst, + continued=continued, + source_retraction=[[str(x), str(y)] for x, y in u])) + for bank, value in enumerate(u): + if bank != src: + f.add(bank, src, F.neg(ec(value))) + f.add(dst, src, F.N) + f.unary(src, F.prod(F.N if continued else F.I, F.mono((stage,)))) + for bank, value in enumerate(u): + if bank != src: + f.add(bank, src, ec(value)) + for bank, (a, b) in enumerate(u): + if bank != src: + p.add(bank, src, -a, f'query{stage} scalar entrance') + p.unary(src, A.n(0), 'NATIVE', f'query{stage} existing source N') + for bank, (a, b) in enumerate(u): + if bank != src: + p.add(bank, src, -b, f'query{stage} entrance from source N exposure') + p.add(dst, src, 1, f'query{stage} raw delivery') + p.unary(src, A.swap(0, stage), 'ADDRESS', f'query{stage} source plane swap') + p.fresh(stage, src) + if continued: + for bank, (a, b) in enumerate(u): + if bank != src: + p.add(bank, src, -b, f'query{stage} pre-continuation fanout') + p.unary(src, A.n(0), 'NATIVE', f'query{stage} paid source continuation') + for bank, (a, b) in enumerate(u): + if bank != src: + p.add(bank, src, a, f'query{stage} scalar exit') + need(stage == 4, 'stop at the complete current query4 scalar entrance') + F3 = A.prod(*(A.n(j) for j in range(1, 4))) + need(p.M == bind(f.M, A, F3), 'all six current cut columns bind to actual plane phases') + cut = f.M + cut_physical = p.M + def scalar(dst, src, c, label): + f.scalar(dst, src, c) + p.add(dst, src, c, label) + def common(bank, label): + f.unary(bank, F.N) + p.unary(bank, A.n(0), 'NATIVE', label) + def swap(i, j, label): + f.swap(i, j) + p.swap(i, j, label) + def changed_source(bank, stage): + # Pulling the common fresh N_stage to the left gives + # N_stage^-1 P_stage = P_stage N^-1. + f.unary(bank, F.prod(F.mono((stage,)), F.inv(F.N))) + p.unary(bank, A.swap(0, stage), 'ADDRESS', f'query{stage} ADDRESS on changed source') + p.fresh(stage, bank) + scalar(3, 0, -1, 'query4 current encoder c1 -= a') + scalar(3, 4, -1, 'query4 current encoder c1 -= b2') + common(1, 'query4 existing source N on u+c2') + scalar(1, 3, -1, 'query4 isolate N c2 from held N u') + swap(1, 3, 'query4 source handoff BEFORE source ADDRESS') + changed_source(1, 4) + swap(3, 5, 'query4 put completed public c2 into slot5') + common(4, 'query5 existing source N on raw b2') + scalar(3, 4, 1, 'query5 cancel b2 from the dirty first-pivot field') + swap(4, 3, 'query5 source handoff BEFORE source ADDRESS') + scalar(2, 4, 1 if wrong_fanout else -1, + 'query5 current-source fanout b1 -= (-v-N a) BEFORE source ADDRESS') + changed_source(4, 5) + swap(4, 3, 'query5 restore pivot3 and completed public b2 slot4') + common(0, 'final paid N exposure on raw a') + scalar(2, 0, -1, 'finish b1 using the current completed public a') + return p, f, cut, cut_physical, source_rows + + +def replay(events, A, reverse=False): + M = A.eye(6) + for event in reversed(events) if reverse else events: + kind = event['kind'] + if kind == 'ADD': + c = Fraction(event['coefficient']) * (-1 if reverse else 1) + B = A.es(6, event['dst'], event['src'], A.mono(coefficient=c)) + elif kind == 'BANK_SWAP': + B = A.eye(6) + i, j = event['banks'] + B[i], B[j] = B[j], B[i] + else: + op = A.Z + for term in event['operator']: + bits = sum(1 << j for j in term['N_planes']) + op = A.add(op, A.mono(bits, term['ADDRESS_plane_permutation'], + Fraction(term['coefficient']))) + if reverse: + op = A.inv(op) + B = A.eye(6) + B[event['bank']][event['bank']] = op + M = A.mm(B, M) + return M + + +def prove(): + p, f, cut, cut_physical, source_rows = build() + A = p.A + F5 = A.prod(*(A.n(j) for j in range(1, 6))) + E = A.mul(F5, A.n(0)) + need(p.M == bind(f.M, A, F5), 'complete actual five-stage phase binding') + need(F.mm(f.M, f.Mi) == F.mm(f.Mi, f.M) == F.eye(6), + 'free noncommuting operator word has both literal inverse orders') + need(A.mm(p.M, p.Mi) == A.mm(p.Mi, p.M) == A.eye(6), + 'actual all-six-column word has both literal inverse orders') + need(replay(p.events, A) == p.M and replay(p.events, A, True) == p.Mi, + 'serialized actual events and their exact reversed inverses bind') + public, pivots = [0, 2, 4, 5], [1, 3] + for bank in public: + need(f.M[bank] == [F.N if j == bank else F.Z for j in range(6)], + 'every arbitrary public row is N times its own original input') + need(p.M[bank] == [E if j == bank else A.Z for j in range(6)], + 'every public field receives all six actual native planes') + H = [[f.M[i][j] for j in pivots] for i in pivots] + L = [[f.M[i][j] for j in public] for i in pivots] + histogram = Counter(event['native_arity'] for event in p.events if event['kind'] == 'NATIVE') + need(histogram == {2: 34}, 'complete prefix is exactly 34 rank-2f native queries') + need(build(True)[0].M != p.M, 'wrong current-source fanout sign changes all-column target') + need(build(skip_progress=True)[0].M != p.M, + 'omitted fresh progress on handoff public c2 is detected') + need(A.mm(replay(p.events[:-1], A, True), p.M) != A.eye(6), + 'omitted last inverse ADD is detected with arbitrary input columns') + scans = Counter(event['kind'] for event in p.events) + return dict( + status='PASS_EXACT_FIVE_STAGE_MID_QUERY_HANDOFF_PREFIX', no_new_kappa=True, + scientific_pin='20ecf2891d80b5acf18d980b2164fb44ea7faa90', + domain='Every f>=1; six arbitrary independent fields; actual common/fresh native planes N_i with N_i^2=-I and exact plane-permutation covariance. Formal retarded proof allows arbitrary invertible noncommuting P1,...,P5.', + banks=['a', 't', 'b1', 'c1', 'b2', 'c2'], + public_rows=public, pivot_rows=pivots, + query_stages=5, actual_native_planes=6, ambient_arity_in_units_f=12, + native_histogram_in_units_f=dict(histogram), native_rank_mass_in_units_f=68, + stock_if_two_pivots_finish_in_units_f=72, D_before_pivot_tail_in_units_f=4, + prefix_only=True, source_continuation_stages=[3], shared_entrance_N_calls=2, + final_standalone_N_calls=1, nonrecursive_event_counts=dict(scans), + source_retractions_first_three=source_rows, + events=p.events, complete_formal_matrix=F.sm(f.M), complete_formal_inverse=F.sm(f.Mi), + pivot_H=F.sm(H), public_L=F.sm(L), + complete_physical_matrix=[[A.serial(x) for x in row] for row in p.M], + complete_physical_inverse=[[A.serial(x) for x in row] for row in p.Mi], + current_cut_formal_matrix=F.sm(cut), + current_cut_physical_matrix=[[A.serial(x) for x in row] for row in cut_physical], + cut_contract='In the retarded F3 frame (a,t,b1,c1,b2,c2)=(a,u+C,N*x-v,N*u+a+B,B,-v-N*(a+B)); all six coordinates (a,x,B,C,u,v) are independent. They are derived from the full current word, not initialized helpers.', + handoff_endpoint_before_final_N='In F5 coordinates (a,P4*u,N*(x+a),P5*(N*v-a),N*B,N*C). Then N(a); b1-=a completes all four public rows.', + exact_inverse='Reverse every serialized event; negate ADD coefficients, invert every Gaussian native/ADDRESS word, keep each bank SWAP. Both orders are checked on all six independent columns.', + all_f_phase='N_f=i^(1-f) N1^tensor(f)=i Hp_f Hq_f, so N_f^2=-I. Disjoint planes commute and the literal ADDRESS swap satisfies P_i N_0=N_i P_i. These exact relations prove the serialized identity for every f>=1, including Gaussian global phases.', + negative_controls=['Wrong pre-P5 current-source fanout sign', 'Omit fresh N4 progress on the new public c2', 'Omit the last inverse ADD'], + attribution=['First-three-query nested-response entrance and its cut: mixed_carrier_caller_1019/caller/nested_prefix.py and nested_six.py.', + 'Mid-query source handoff: root/root-chronology/source_handoff.py.', + 'Second handoff and pre-P5 current-source fanout: independently derived by q4_pauli_fusion and stabilizer_escape_1019; final standalone N(a) closure proposed by root.', + 'This file composes these mechanisms into the complete changed five-stage arbitrary-column prefix.'], + limits=['The two pivot rows have not been compensated here. The 34-query invoice is a prefix invoice; an H/L tail must be added.', + 'This six-bank construction is exact; a recursive all-size response-sharing stage and bounded terminal cocycle are separate obligations.', + 'All scalar ADDs, bank SWAPs, ADDRESS permutations and native source/fresh scans are explicit. Native adapter and physical tape/precision/owner costs must be imported only under the actual caller interface.', + 'No whole multiplication theorem, formal-kernel result, or improved kappa is claimed.'], + source_pins=[dict(path=str(CALLER / name), sha256=hashlib.sha256((CALLER / name).read_bytes()).hexdigest()) + for name in ['free_ops.py', 'plane_group.py', 'nested_prefix.py', 'nested_six.py']]) + + +def main(): + ap = argparse.ArgumentParser(description=__doc__) + ap.add_argument('--write', action='store_true') + args = ap.parse_args() + out = prove() + out['producer_sha256'] = hashlib.sha256(Path(__file__).read_bytes()).hexdigest() + out = json.loads(json.dumps(out)) + path = HERE / 'SOURCE-HANDOFF-PREFIX.json' + if args.write: + path.write_text(json.dumps(out, indent=2, sort_keys=True) + '\n') + else: + need(json.loads(path.read_text()) == out, 'saved prefix receipt differs') + print(out['status'], out['native_histogram_in_units_f'], 'prefix mass68f stock72f D4f; tail pending') + + +if __name__ == '__main__': + main() diff --git a/research/marked-residual-reflection/source/root-chronology/CHRONOLOGY.json b/research/marked-residual-reflection/source/root-chronology/CHRONOLOGY.json new file mode 100644 index 0000000000..5e6c22c5b3 --- /dev/null +++ b/research/marked-residual-reflection/source/root-chronology/CHRONOLOGY.json @@ -0,0 +1,836 @@ +{ + "algebra": "N_a commute; N_a^2=-I; P N_a P^-1=N_P(a). Exact phases and block permutations retained.", + "all_f": "Algebra holds for the independently pinned phase-normalized N_f. Native arity 2 per occupied block is 2f at chunk size f. Permutation adapters preserve native rank.", + "block_count": 4, + "cases": [ + { + "final_single_response": { + "block_permutation": [ + 0, + 1, + 2, + 3 + ], + "native_arity": 6, + "native_blocks": [ + 1, + 2, + 3 + ], + "sign": 1 + }, + "kernel": { + "block_permutation": [ + 0, + 1, + 2, + 3 + ], + "native_arity": 0, + "native_blocks": [], + "sign": 1 + }, + "multiplicity": 8, + "new_first_at_between_cut": { + "block_permutation": [ + 0, + 1, + 2, + 3 + ], + "native_arity": 0, + "native_blocks": [], + "sign": 1 + }, + "old_first_at_between_cut": { + "block_permutation": [ + 0, + 1, + 2, + 3 + ], + "native_arity": 0, + "native_blocks": [], + "sign": 1 + } + }, + { + "final_single_response": { + "block_permutation": [ + 1, + 0, + 2, + 3 + ], + "native_arity": 6, + "native_blocks": [ + 1, + 2, + 3 + ], + "sign": 1 + }, + "kernel": { + "block_permutation": [ + 1, + 0, + 2, + 3 + ], + "native_arity": 0, + "native_blocks": [], + "sign": 1 + }, + "multiplicity": 3, + "new_first_at_between_cut": { + "block_permutation": [ + 1, + 2, + 0, + 3 + ], + "native_arity": 4, + "native_blocks": [ + 1, + 2 + ], + "sign": -1 + }, + "old_first_at_between_cut": { + "block_permutation": [ + 2, + 0, + 1, + 3 + ], + "native_arity": 4, + "native_blocks": [ + 0, + 1 + ], + "sign": -1 + } + }, + { + "final_single_response": { + "block_permutation": [ + 1, + 0, + 2, + 3 + ], + "native_arity": 8, + "native_blocks": [ + 0, + 1, + 2, + 3 + ], + "sign": 1 + }, + "kernel": { + "block_permutation": [ + 1, + 0, + 2, + 3 + ], + "native_arity": 2, + "native_blocks": [ + 0 + ], + "sign": 1 + }, + "multiplicity": 2, + "new_first_at_between_cut": { + "block_permutation": [ + 1, + 2, + 0, + 3 + ], + "native_arity": 4, + "native_blocks": [ + 0, + 1 + ], + "sign": 1 + }, + "old_first_at_between_cut": { + "block_permutation": [ + 2, + 0, + 1, + 3 + ], + "native_arity": 0, + "native_blocks": [], + "sign": -1 + } + }, + { + "final_single_response": { + "block_permutation": [ + 0, + 1, + 2, + 3 + ], + "native_arity": 4, + "native_blocks": [ + 2, + 3 + ], + "sign": 1 + }, + "kernel": { + "block_permutation": [ + 0, + 1, + 2, + 3 + ], + "native_arity": 2, + "native_blocks": [ + 1 + ], + "sign": -1 + }, + "multiplicity": 1, + "new_first_at_between_cut": { + "block_permutation": [ + 0, + 1, + 2, + 3 + ], + "native_arity": 4, + "native_blocks": [ + 1, + 2 + ], + "sign": 1 + }, + "old_first_at_between_cut": { + "block_permutation": [ + 0, + 1, + 2, + 3 + ], + "native_arity": 4, + "native_blocks": [ + 1, + 2 + ], + "sign": 1 + } + }, + { + "final_single_response": { + "block_permutation": [ + 0, + 1, + 2, + 3 + ], + "native_arity": 4, + "native_blocks": [ + 2, + 3 + ], + "sign": -1 + }, + "kernel": { + "block_permutation": [ + 0, + 1, + 2, + 3 + ], + "native_arity": 2, + "native_blocks": [ + 1 + ], + "sign": 1 + }, + "multiplicity": 1, + "new_first_at_between_cut": { + "block_permutation": [ + 0, + 1, + 2, + 3 + ], + "native_arity": 4, + "native_blocks": [ + 1, + 2 + ], + "sign": 1 + }, + "old_first_at_between_cut": { + "block_permutation": [ + 0, + 1, + 2, + 3 + ], + "native_arity": 4, + "native_blocks": [ + 1, + 2 + ], + "sign": 1 + } + }, + { + "final_single_response": { + "block_permutation": [ + 1, + 0, + 2, + 3 + ], + "native_arity": 4, + "native_blocks": [ + 2, + 3 + ], + "sign": 1 + }, + "kernel": { + "block_permutation": [ + 1, + 0, + 2, + 3 + ], + "native_arity": 2, + "native_blocks": [ + 1 + ], + "sign": -1 + }, + "multiplicity": 2, + "new_first_at_between_cut": { + "block_permutation": [ + 1, + 2, + 0, + 3 + ], + "native_arity": 0, + "native_blocks": [], + "sign": -1 + }, + "old_first_at_between_cut": { + "block_permutation": [ + 2, + 0, + 1, + 3 + ], + "native_arity": 4, + "native_blocks": [ + 0, + 2 + ], + "sign": 1 + } + }, + { + "final_single_response": { + "block_permutation": [ + 1, + 0, + 2, + 3 + ], + "native_arity": 6, + "native_blocks": [ + 0, + 2, + 3 + ], + "sign": 1 + }, + "kernel": { + "block_permutation": [ + 1, + 0, + 2, + 3 + ], + "native_arity": 4, + "native_blocks": [ + 0, + 1 + ], + "sign": -1 + }, + "multiplicity": 3, + "new_first_at_between_cut": { + "block_permutation": [ + 1, + 2, + 0, + 3 + ], + "native_arity": 4, + "native_blocks": [ + 0, + 2 + ], + "sign": -1 + }, + "old_first_at_between_cut": { + "block_permutation": [ + 2, + 0, + 1, + 3 + ], + "native_arity": 4, + "native_blocks": [ + 1, + 2 + ], + "sign": -1 + } + } + ], + "complete_orders": 20, + "distinct_kernels": 7, + "limits": [ + "No general caller obstruction. A coupled word can combine several responses.", + "No actual whole supplier, improved BIT, joint transfer or new kappa." + ], + "no_new_kappa": true, + "orders": [ + { + "events": [ + "S_before", + "N", + "S_after", + "T", + "ADD" + ], + "kernel": { + "block_permutation": [ + 0, + 1, + 2, + 3 + ], + "native_arity": 0, + "native_blocks": [], + "sign": 1 + } + }, + { + "events": [ + "S_before", + "N", + "S_after", + "ADD", + "T" + ], + "kernel": { + "block_permutation": [ + 0, + 1, + 2, + 3 + ], + "native_arity": 2, + "native_blocks": [ + 1 + ], + "sign": 1 + } + }, + { + "events": [ + "S_before", + "N", + "T", + "S_after", + "ADD" + ], + "kernel": { + "block_permutation": [ + 0, + 1, + 2, + 3 + ], + "native_arity": 0, + "native_blocks": [], + "sign": 1 + } + }, + { + "events": [ + "S_before", + "N", + "T", + "ADD", + "S_after" + ], + "kernel": { + "block_permutation": [ + 1, + 0, + 2, + 3 + ], + "native_arity": 4, + "native_blocks": [ + 0, + 1 + ], + "sign": -1 + } + }, + { + "events": [ + "S_before", + "N", + "ADD", + "S_after", + "T" + ], + "kernel": { + "block_permutation": [ + 1, + 0, + 2, + 3 + ], + "native_arity": 2, + "native_blocks": [ + 0 + ], + "sign": 1 + } + }, + { + "events": [ + "S_before", + "N", + "ADD", + "T", + "S_after" + ], + "kernel": { + "block_permutation": [ + 1, + 0, + 2, + 3 + ], + "native_arity": 2, + "native_blocks": [ + 0 + ], + "sign": 1 + } + }, + { + "events": [ + "S_before", + "T", + "N", + "S_after", + "ADD" + ], + "kernel": { + "block_permutation": [ + 0, + 1, + 2, + 3 + ], + "native_arity": 0, + "native_blocks": [], + "sign": 1 + } + }, + { + "events": [ + "S_before", + "T", + "N", + "ADD", + "S_after" + ], + "kernel": { + "block_permutation": [ + 1, + 0, + 2, + 3 + ], + "native_arity": 4, + "native_blocks": [ + 0, + 1 + ], + "sign": -1 + } + }, + { + "events": [ + "S_before", + "T", + "ADD", + "N", + "S_after" + ], + "kernel": { + "block_permutation": [ + 1, + 0, + 2, + 3 + ], + "native_arity": 2, + "native_blocks": [ + 1 + ], + "sign": -1 + } + }, + { + "events": [ + "S_before", + "ADD", + "N", + "S_after", + "T" + ], + "kernel": { + "block_permutation": [ + 1, + 0, + 2, + 3 + ], + "native_arity": 0, + "native_blocks": [], + "sign": 1 + } + }, + { + "events": [ + "S_before", + "ADD", + "N", + "T", + "S_after" + ], + "kernel": { + "block_permutation": [ + 1, + 0, + 2, + 3 + ], + "native_arity": 0, + "native_blocks": [], + "sign": 1 + } + }, + { + "events": [ + "S_before", + "ADD", + "T", + "N", + "S_after" + ], + "kernel": { + "block_permutation": [ + 1, + 0, + 2, + 3 + ], + "native_arity": 0, + "native_blocks": [], + "sign": 1 + } + }, + { + "events": [ + "T", + "S_before", + "N", + "S_after", + "ADD" + ], + "kernel": { + "block_permutation": [ + 0, + 1, + 2, + 3 + ], + "native_arity": 0, + "native_blocks": [], + "sign": 1 + } + }, + { + "events": [ + "T", + "S_before", + "N", + "ADD", + "S_after" + ], + "kernel": { + "block_permutation": [ + 1, + 0, + 2, + 3 + ], + "native_arity": 4, + "native_blocks": [ + 0, + 1 + ], + "sign": -1 + } + }, + { + "events": [ + "T", + "S_before", + "ADD", + "N", + "S_after" + ], + "kernel": { + "block_permutation": [ + 1, + 0, + 2, + 3 + ], + "native_arity": 2, + "native_blocks": [ + 1 + ], + "sign": -1 + } + }, + { + "events": [ + "T", + "ADD", + "S_before", + "N", + "S_after" + ], + "kernel": { + "block_permutation": [ + 0, + 1, + 2, + 3 + ], + "native_arity": 2, + "native_blocks": [ + 1 + ], + "sign": -1 + } + }, + { + "events": [ + "ADD", + "S_before", + "N", + "S_after", + "T" + ], + "kernel": { + "block_permutation": [ + 0, + 1, + 2, + 3 + ], + "native_arity": 0, + "native_blocks": [], + "sign": 1 + } + }, + { + "events": [ + "ADD", + "S_before", + "N", + "T", + "S_after" + ], + "kernel": { + "block_permutation": [ + 0, + 1, + 2, + 3 + ], + "native_arity": 0, + "native_blocks": [], + "sign": 1 + } + }, + { + "events": [ + "ADD", + "S_before", + "T", + "N", + "S_after" + ], + "kernel": { + "block_permutation": [ + 0, + 1, + 2, + 3 + ], + "native_arity": 0, + "native_blocks": [], + "sign": 1 + } + }, + { + "events": [ + "ADD", + "T", + "S_before", + "N", + "S_after" + ], + "kernel": { + "block_permutation": [ + 0, + 1, + 2, + 3 + ], + "native_arity": 0, + "native_blocks": [], + "sign": 1 + } + } + ], + "scope": "S,N,S source chronology and one fresh target T, one delivery ADD; no common U, extra bank bridge or general local synthesis. Endpoint test is a single isolated response F_all K only.", + "source_sha256": "eed0590640dadcd48c683d142899396b563e843a6c15c9df3cc5d1ecdc107a2c", + "status": "PASS_RESTRICTED_ONE_ADD_LOCAL_CHRONOLOGY" +} diff --git a/research/marked-residual-reflection/source/root-chronology/INDEPENDENT-MARKED-PLANE-BOUND.json b/research/marked-residual-reflection/source/root-chronology/INDEPENDENT-MARKED-PLANE-BOUND.json new file mode 100644 index 0000000000..2e60be8db4 --- /dev/null +++ b/research/marked-residual-reflection/source/root-chronology/INDEPENDENT-MARKED-PLANE-BOUND.json @@ -0,0 +1,93 @@ +{ + "all_parameter_proof": "The one-bit identities tensor to N_f^2=-I and complement every simultaneous X character. Pairing complementary characters and using the same Gaussian-unit gauge on every plane gives virtual iX and unchanged residual label. Choose two residual labels; retain the actual invariant subspace with exactly one marked residual. On its L*2^L basis states, C=(-1)^virtual_bit_at_owner. Whole-plane permutations move owner and bits together, and all X translations are diagonal, so every declared free bridge commutes C. A native product on r planes flips the marked bit on exactly r*2^L states, hence commutator rank r*2^L. Rank[C,AB]<=rank[C,A]+rank[C,B] then forces sum r>=nL for n full-native output banks and any restored dirty banks. Multiplying by2f gives rankmass>=n*(2Lf).", + "character_checks": [ + { + "all_characters": 4, + "f": 1, + "residual_dimension": 2 + }, + { + "all_characters": 16, + "f": 2, + "residual_dimension": 8 + }, + { + "all_characters": 64, + "f": 3, + "residual_dimension": 32 + }, + { + "all_characters": 256, + "f": 4, + "residual_dimension": 128 + }, + { + "all_characters": 1024, + "f": 5, + "residual_dimension": 512 + } + ], + "cut_checks": [ + { + "all_native_supports": 2, + "dimension": 2, + "full_native_cut_rank": 2, + "planes": 1 + }, + { + "all_native_supports": 4, + "dimension": 8, + "full_native_cut_rank": 8, + "planes": 2 + }, + { + "all_native_supports": 8, + "dimension": 24, + "full_native_cut_rank": 24, + "planes": 3 + }, + { + "all_native_supports": 16, + "dimension": 64, + "full_native_cut_rank": 64, + "planes": 4 + }, + { + "all_native_supports": 32, + "dimension": 160, + "full_native_cut_rank": 160, + "planes": 5 + }, + { + "all_native_supports": 64, + "dimension": 384, + "full_native_cut_rank": 384, + "planes": 6 + }, + { + "all_native_supports": 128, + "dimension": 896, + "full_native_cut_rank": 896, + "planes": 7 + }, + { + "all_native_supports": 256, + "dimension": 2048, + "full_native_cut_rank": 2048, + "planes": 8 + } + ], + "limits": [ + "The general proof is written and the listed finite checks are exact; this is not formal-kernel evidence.", + "A supplier using additional phase or coordinate operations lies outside the obstruction." + ], + "no_new_kappa": true, + "producer_sha256": "e66fe9b60753f33a58e1c4ee8e46d9ba9aa2759ffb875eb4e3275c2f49ed6b49", + "scope": "Actual normalized N_f plane products, arbitrary Gaussian scalar bank operations, whole-plane ADDRESS permutations and X translations; inverses and free conjugates included. No claim for free Pauli Z, general bit-linear ADDRESS, arbitrary native adapters, changed endpoint targets or partial-progress contracts.", + "source_chirp_formula": { + "binding": "The pinned C branch implements C=(1+i)I/2+(1-i)X/2 exactly; Hp=Z C^-1,Hq=Z C.", + "path": "/Users/ross/git/math/integer-mult-bounds/research/kernel92-frame-composition/vendor/pr531/vendor/clifford/clifford_exact.py", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + }, + "status": "PASS_INDEPENDENT_MARKED_PLANE_CUT_AUDIT" +} diff --git a/research/marked-residual-reflection/source/root-chronology/INDEPENDENT-PARTIAL-REFLECTION.json b/research/marked-residual-reflection/source/root-chronology/INDEPENDENT-PARTIAL-REFLECTION.json new file mode 100644 index 0000000000..e80e0b126c --- /dev/null +++ b/research/marked-residual-reflection/source/root-chronology/INDEPENDENT-PARTIAL-REFLECTION.json @@ -0,0 +1,45 @@ +{ + "all_parameter_proof": "For full old progress E_L=i^L D^-1 H_(2L) D, d(x)=sum_p x-sum_q x. Binary orthogonality makes P_A commute H. For A=I+vv^T, if v.x=1 the typed phase d(x)-d(Ax)=2-d(v) mod4. The chosen three-p/one-q vector has d(v)=2, so D^-1 P_A D=P_A. The identity tensorizes bitwise for every f. On the simultaneous X-character input q0=(1,...,1), all other chunks zero, A maps to p0=p1=p2=(1,...,1), all q zero: one marked residual becomes three, so the old invariant-subspace gate is inapplicable.", + "ambient_old_planes": 3, + "binary_vector": 23, + "escape_witness": { + "X_character_after": 21, + "X_character_before": 2, + "marked_planes_after": [ + 0, + 1, + 2 + ], + "marked_planes_before": [ + 0 + ] + }, + "finite_checks": { + "native_formula_planes": [ + 1, + 2, + 3 + ], + "normalizer_all_matrix_entries": 4096, + "one_bit_dimension": 64, + "paired_control_marked_states": 24 + }, + "helper_sha256": "e66fe9b60753f33a58e1c4ee8e46d9ba9aa2759ffb875eb4e3275c2f49ed6b49", + "limits": [ + "This is an exact native-zero ADDRESS resource and a scope escape, not a cheaper complete supplier.", + "A real source insertion must charge its ADDRESS scans, preserve actual current-source access, and bind all output/readers and inverse cleanup.", + "No new kappa, complete caller, precision, ownership or BIT compatibility is supplied by this resource." + ], + "native_cost": 0, + "no_new_kappa": true, + "physical_map": "A=I+v v^T over F2, applied independently to each bit position of the four selected chunks.", + "producer_sha256": "085eae2cb416de93293bef7c1aae922e49853329a172ec95c0ee093c752a5f0f", + "source_normalizer_identity": "R E3=E3 R exactly, R^2=I, R=P_A with no hidden diagonal phase.", + "status": "PASS_INDEPENDENT_UNPAIRED_REFLECTION_RESOURCE", + "support_chunks": [ + "p0", + "q0", + "p1", + "p2" + ] +} diff --git a/research/marked-residual-reflection/source/root-chronology/audit_marked_plane_bound.py b/research/marked-residual-reflection/source/root-chronology/audit_marked_plane_bound.py new file mode 100644 index 0000000000..f857465267 --- /dev/null +++ b/research/marked-residual-reflection/source/root-chronology/audit_marked_plane_bound.py @@ -0,0 +1,75 @@ +#!/usr/bin/env python3 +"""Independent exact small factors and symbolic counts for a marked-plane cut. +Apache-2.0; substantial OpenAI Codex assistance. Restricted grammar only. +""" +from pathlib import Path +from fractions import Fraction as Q +import argparse,hashlib,json,itertools +from chronology import need +HERE=Path(__file__).resolve().parent +ZERO=(Q(0),Q(0));ONE=(Q(1),Q(0));II=(Q(0),Q(1)) +def plus(a,b):return(a[0]+b[0],a[1]+b[1]) +def neg(a):return(-a[0],-a[1]) +def mul(a,b):return(a[0]*b[0]-a[1]*b[1],a[0]*b[1]+a[1]*b[0]) +def conj(a):return(a[0],-a[1]) +def scale(c,M):return[[mul(c,x)for x in row]for row in M] +def mm(A,B): + out=[] + for row in A: + r=[] + for col in zip(*B): + x=ZERO + for a,b in zip(row,col):x=plus(x,mul(a,b)) + r.append(x) + out.append(r) + return out + +def run(): + I=[[ONE,ZERO],[ZERO,ONE]];X=[[ZERO,ONE],[ONE,ZERO]];Z=[[ONE,ZERO],[ZERO,neg(ONE)]] + a=(Q(1,2),Q(1,2));b=(Q(1,2),Q(-1,2));C=[[a,b],[b,a]];Ci=[[conj(x)for x in row]for row in C] + Hp=mm(Z,Ci);Hq=mm(Z,C) + need(mm(C,X)==mm(X,C),'chirp commutes every X translation on this bit') + need(mm(Hp,Hp)==scale(neg(II),I)and mm(Hq,Hq)==scale(II,I),'exact one-bit square phases') + need(mm(Hp,X)==scale(neg(ONE),mm(X,Hp))and mm(Hq,X)==scale(neg(ONE),mm(X,Hq)),'each typed factor anticommutes X') + need(mm(C,Ci)==I,'exact Gaussian-dyadic chirp inverse') + # All-f scalar proof: N_f=i Hp^tensorf Hq^tensorf has square + # -(-i)^f i^f=-1 and complements every simultaneous X character. + gauge_checks=[] + for f in range(1,6): + for word in range(1<<(2*f)): + x=word&((1<>f;op=(1-x.bit_count()+y.bit_count())%4 + comp=((1<<(2*f))-1)^word;xx=comp&((1<>f;ip=(1-xx.bit_count()+yy.bit_count())%4 + need((op+ip)%4==2,'character pair square is -1') + virtual=word&1;residual=tuple(((word>>j)&1)^virtual for j in range(1,2*f)) + cv=comp&1;cr=tuple(((comp>>j)&1)^cv for j in range(1,2*f)) + need(residual==cr and virtual!=cv,'native flips virtual bit and preserves residual label') + if virtual==0: + # v1=i^(op-1) e_complement makes N v0=i v1 and N v1=i v0. + need(((op-1)+ip)%4==1,'same orbit gauge produces iX on reverse edge') + gauge_checks.append({'f':f,'all_characters':1<<(2*f),'residual_dimension':1<<(2*f-1)}) + cut_checks=[] + for L in range(1,9): + dimension=L*(1<>owner)&1)!=(((x^support)>>owner)&1)) + need(rank==support.bit_count()*(1<>i)&1)!=((x>>(i+1))&1):moved^=(1<>owner)&1)==((moved>>moved_owner)&1),'literal ADDRESS preserves marked cut') + cut_checks.append({'planes':L,'dimension':dimension,'all_native_supports':1<=nL for n full-native output banks and any restored dirty banks. Multiplying by2f gives rankmass>=n*(2Lf).',scope='Actual normalized N_f plane products, arbitrary Gaussian scalar bank operations, whole-plane ADDRESS permutations and X translations; inverses and free conjugates included. No claim for free Pauli Z, general bit-linear ADDRESS, arbitrary native adapters, changed endpoint targets or partial-progress contracts.',limits=['The general proof is written and the listed finite checks are exact; this is not formal-kernel evidence.','A supplier using additional phase or coordinate operations lies outside the obstruction.']) + +def main(): + p=argparse.ArgumentParser();p.add_argument('--write',action='store_true');a=p.parse_args();o=json.loads(json.dumps(run()));f=HERE/'INDEPENDENT-MARKED-PLANE-BOUND.json' + if a.write:f.write_text(json.dumps(o,indent=2,sort_keys=True)+'\n') + else:need(json.loads(f.read_bytes())==o,'saved cut audit differs') + print(o['status'],'character f1..5; all supports L1..8; written all-f/all-L proof') +if __name__=='__main__':main() diff --git a/research/marked-residual-reflection/source/root-chronology/audit_partial_reflection.py b/research/marked-residual-reflection/source/root-chronology/audit_partial_reflection.py new file mode 100644 index 0000000000..0e4d0e91dc --- /dev/null +++ b/research/marked-residual-reflection/source/root-chronology/audit_partial_reflection.py @@ -0,0 +1,58 @@ +#!/usr/bin/env python3 +"""Exact source-normalizer and obstruction-escape checks for an unpaired reflection. +Apache-2.0; substantial OpenAI Codex assistance. No positive caller claimed. +""" +from pathlib import Path +import argparse,hashlib,json +from audit_marked_plane_bound import Q,ZERO,ONE,II,plus,neg,mul,conj,mm,scale +from chronology import need +HERE=Path(__file__).resolve().parent + +def iphase(k):return(ONE,II,neg(ONE),neg(II))[k%4] +def dot(a,b):return(a&b).bit_count()%2 +def apply(v,w):return w^(v if dot(v,w)else 0) +def degree(w,L):return sum((1 if j%2==0 else -1)*((w>>j)&1)for j in range(2*L)) +def entry(i,j,L): + phase=iphase(L+degree(j,L)-degree(i,L)) + return mul((Q(-1 if dot(i,j)else 1,1<>k)&1][(j>>k)&1]) + return z + +def run(): + a=(Q(1,2),Q(1,2));b=(Q(1,2),Q(-1,2));C=[[a,b],[b,a]];Ci=[[conj(x)for x in r]for r in C];Z=[[ONE,ZERO],[ZERO,neg(ONE)]];Hp=mm(Z,Ci);Hq=mm(Z,C) + for L in(1,2,3): + for i in range(1<<(2*L)): + for j in range(1<<(2*L)):need(entry(i,j,L)==tensor_entry(i,j,L,Hp,Hq),'actual typed native equals exact D-Walsh-D formula') + L=3;v=sum(1<>(2*j))&1)!=((w>>(2*j+1))&1)] + need(marked(original)==[0]and marked(moved)==[0,1,2],'explicit actual X-character leakage from one marked plane to three') + paired=(1<<4)-1 + need(any(entry(apply(paired,i),j,L)!=entry(i,apply(paired,j),L)for i in range(dim)for j in range(dim)),'plain paired reflection fails without its phase correction') + paired_checks=0 + for w in range(dim): + old=marked(w) + if len(old)!=1:continue + # R=Z_v P_A; in X characters this acts by w -> A w + v. + transformed=apply(paired,w)^paired + need(marked(transformed)==old,'proper paired reflection preserves one marked residual owner') + owner=old[0];need(((w>>(2*owner))&1)==((transformed>>(2*owner))&1),'proper paired reflection commutes marked sign') + paired_checks+=1 + return dict(status='PASS_INDEPENDENT_UNPAIRED_REFLECTION_RESOURCE',no_new_kappa=True,producer_sha256=hashlib.sha256(Path(__file__).read_bytes()).hexdigest(),helper_sha256=hashlib.sha256((HERE/'audit_marked_plane_bound.py').read_bytes()).hexdigest(),support_chunks=['p0','q0','p1','p2'],binary_vector=v,ambient_old_planes=3,physical_map='A=I+v v^T over F2, applied independently to each bit position of the four selected chunks.',native_cost=0,source_normalizer_identity='R E3=E3 R exactly, R^2=I, R=P_A with no hidden diagonal phase.',all_parameter_proof='For full old progress E_L=i^L D^-1 H_(2L) D, d(x)=sum_p x-sum_q x. Binary orthogonality makes P_A commute H. For A=I+vv^T, if v.x=1 the typed phase d(x)-d(Ax)=2-d(v) mod4. The chosen three-p/one-q vector has d(v)=2, so D^-1 P_A D=P_A. The identity tensorizes bitwise for every f. On the simultaneous X-character input q0=(1,...,1), all other chunks zero, A maps to p0=p1=p2=(1,...,1), all q zero: one marked residual becomes three, so the old invariant-subspace gate is inapplicable.',finite_checks={'native_formula_planes':[1,2,3],'normalizer_all_matrix_entries':dim*dim,'one_bit_dimension':dim,'paired_control_marked_states':paired_checks},escape_witness={'X_character_before':original,'X_character_after':moved,'marked_planes_before':[0],'marked_planes_after':[0,1,2]},limits=['This is an exact native-zero ADDRESS resource and a scope escape, not a cheaper complete supplier.','A real source insertion must charge its ADDRESS scans, preserve actual current-source access, and bind all output/readers and inverse cleanup.','No new kappa, complete caller, precision, ownership or BIT compatibility is supplied by this resource.']) + +def main(): + ap=argparse.ArgumentParser();ap.add_argument('--write',action='store_true');a=ap.parse_args();o=json.loads(json.dumps(run()));p=HERE/'INDEPENDENT-PARTIAL-REFLECTION.json' + if a.write:p.write_text(json.dumps(o,indent=2,sort_keys=True)+'\n') + else:need(json.loads(p.read_bytes())==o,'saved reflection audit differs') + print(o['status'],'allf proof; exact64x64commutation; markedspaceleak; no completecaller') +if __name__=='__main__':main() diff --git a/research/marked-residual-reflection/source/root-chronology/chronology.py b/research/marked-residual-reflection/source/root-chronology/chronology.py new file mode 100644 index 0000000000..d71cf34957 --- /dev/null +++ b/research/marked-residual-reflection/source/root-chronology/chronology.py @@ -0,0 +1,114 @@ +#!/usr/bin/env python3 +"""Exact signed native-block permutation algebra. Apache-2.0; Codex assistance. + +This small census covers only one source N, one target T, source S wrappers, +one delivery ADD. It neither enumerates general monomial circuits nor callers. +""" +from dataclasses import dataclass +from itertools import permutations +from pathlib import Path +import argparse, hashlib, json + +def need(p, m): + if not p: + raise ValueError(m) + +@dataclass(frozen=True) +class Op: + sign: int + mask: int + perm: tuple + + def __matmul__(self, b): + moved = sum(1 << self.perm[i] for i in range(len(self.perm)) if b.mask >> i & 1) + phase = -1 if (self.mask & moved).bit_count() % 2 else 1 + return Op(self.sign * b.sign * phase, self.mask ^ moved, + tuple(self.perm[b.perm[i]] for i in range(len(self.perm)))) + + def inverse(self): + ip = tuple(self.perm.index(i) for i in range(len(self.perm))) + mask = sum(1 << ip[i] for i in range(len(ip)) if self.mask >> i & 1) + return Op(self.sign * (-1 if self.mask.bit_count() % 2 else 1), mask, ip) + + def data(self): + return dict(sign=self.sign, native_blocks=[i for i in range(len(self.perm)) if self.mask >> i & 1], + block_permutation=list(self.perm), native_arity=2*self.mask.bit_count()) + +def ident(b): + return Op(1, 0, tuple(range(b))) + +def native(b, i): + return Op(1, 1 << i, tuple(range(b))) + +def swap(b, i): + p = list(range(b)); p[0], p[i] = p[i], p[0] + return Op(1, 0, tuple(p)) + +def conj(a, b): + return a @ b @ a.inverse() + +def run(): + b=4; I=ident(b); N=native(b,0); T=native(b,1); S=swap(b,1) + need(S @ N == T @ S, 'native/address covariance') + for a in [I,N,T,S,N@S,T@N@S]: + need(a @ a.inverse() == I == a.inverse() @ a, 'literal two-sided inverse') + # All interleavings of S_before,N,S_after on source and T on target, + # with one ADD. Source S,N,S order is fixed. The source remains T. + orders=[]; kernels={} + for order in permutations(('S_before','N','S_after','T','ADD')): + if not (order.index('S_before') < order.index('N') < order.index('S_after')): + continue + src=I; target=I; cross=None + for event in order: + if event.startswith('S_'): + src=S@src + elif event=='N': + src=N@src + elif event=='T': + target=T@target + if cross is not None: + cross=T@cross + else: + cross=src + need(src==T and target==T and cross is not None, 'clean global fresh diagonal') + kernel=T.inverse()@cross + kernels[kernel]=kernels.get(kernel,0)+1 + orders.append(dict(events=order,kernel=kernel.data())) + F=native(b,1)@native(b,2)@native(b,3) + cases=[] + for K,multiplicity in sorted(kernels.items(),key=lambda z:(z[0].mask,z[0].perm,z[0].sign)): + # Re-label the one fresh block to make chronological pair i1,j2. + relabel=Op(1,0,(0,2,1,3)); Ki=K; Kj=conj(relabel,K) + D=native(b,1) + cases.append(dict(kernel=K.data(),multiplicity=multiplicity, + final_single_response=(F@K).data(), + old_first_at_between_cut=conj(D,Ki@Kj).data(), + new_first_at_between_cut=conj(D,Kj@Ki).data())) + full=[z for z in cases if z['final_single_response']['native_arity']==2*b] + need(len(full)==1, 'one full-width single-response type in restricted chronology') + need(full[0]['kernel']['native_blocks']==[0], 'full response is common N times swap') + need(full[0]['old_first_at_between_cut']['native_arity']==0, 'old-first is monomial') + need(full[0]['new_first_at_between_cut']['native_arity']==4, 'new-first costs rank4') + # Deliberately reversing the cut product cannot inherit monomial price. + need(full[0]['new_first_at_between_cut']['native_arity'] != 0, 'wrong product order rejected') + return dict(status='PASS_RESTRICTED_ONE_ADD_LOCAL_CHRONOLOGY',no_new_kappa=True, + source_sha256=hashlib.sha256(Path(__file__).read_bytes()).hexdigest(), + block_count=b, complete_orders=len(orders), distinct_kernels=len(kernels), + orders=orders,cases=cases, + algebra='N_a commute; N_a^2=-I; P N_a P^-1=N_P(a). Exact phases and block permutations retained.', + scope='S,N,S source chronology and one fresh target T, one delivery ADD; no common U, extra bank bridge or general local synthesis. Endpoint test is a single isolated response F_all K only.', + all_f='Algebra holds for the independently pinned phase-normalized N_f. Native arity 2 per occupied block is 2f at chunk size f. Permutation adapters preserve native rank.', + limits=['No general caller obstruction. A coupled word can combine several responses.', + 'No actual whole supplier, improved BIT, joint transfer or new kappa.']) + +def main(): + p=argparse.ArgumentParser();p.add_argument('--write',action='store_true');args=p.parse_args() + out=json.loads(json.dumps(run()));dest=Path(__file__).with_name('CHRONOLOGY.json') + if args.write: + dest.write_text(json.dumps(out,indent=2,sort_keys=True)+'\n') + else: + need(json.loads(dest.read_text())==out,'saved chronology differs') + print(out['status'],out['complete_orders'],'orders',out['distinct_kernels'],'kernels') + +if __name__=='__main__': + main() diff --git a/research/marked-residual-reflection/source/vendor/clifford_exact.py b/research/marked-residual-reflection/source/vendor/clifford_exact.py new file mode 100644 index 0000000000..166841a037 --- /dev/null +++ b/research/marked-residual-reflection/source/vendor/clifford_exact.py @@ -0,0 +1,149 @@ +"""Small exact Gaussian-dyadic Clifford compiler, independent of gx internals. +Paulis use i^p X^x Z^z. State vectors use integer Gaussian numerators / 2^d. +The tableau is supplemented by a literal circuit, so global phases are kept. +""" +from dataclasses import dataclass + +def parity(x):return x.bit_count()&1 +def rank(rows): + p={} + for x in rows: + while x: + b=x.bit_length()-1 + if b not in p:p[b]=x;break + x^=p[b] + return len(p) +def transpose(rows,n):return tuple(sum(((rows[j]>>i)&1)<>j&1);a[j],a[k]=a[k],a[j] + for i in range(n): + if i!=j and a[i]>>j&1:a[i]^=a[j] + assert [r&((1<>n for r in a) +def basis_extend(cols,n): + out=[] + for x in list(cols)+[1<len(out):out.append(x) + assert len(out)==n + return tuple(out) +def nullspace(rows,n): + a=list(rows);p=[];k=0 + for j in range(n): + t=next((i for i in range(k,len(a)) if a[i]>>j&1),None) + if t is None:continue + a[t],a[k]=a[k],a[t] + for i in range(len(a)): + if i!=k and a[i]>>j&1:a[i]^=a[k] + p.append(j);k+=1 + return tuple((1<>j)&1)<>i&1:out=pmul(out,T[i]) + for i in range(n): + if z>>i&1:out=pmul(out,T[n+i]) + return out +def compose(A,B):return tuple(apply(A,p) for p in B) +def inverse(T): + n=len(T)//2;cols=[x|(z<>n;u,v,p=apply(T,(x,z,0));assert (u,v)==identity(n)[j][:2];out.append((x,z,(-p)%4)) + return tuple(out) +def qvalue(Q,alpha,x,n): + return (sum(alpha[i] for i in range(n) if x>>i&1)+2*sum(parity((Q[i]>>(i+1))&(x>>(i+1))) for i in range(n) if x>>i&1))%4 +def mul_i(a,p): + x,y=a;p%=4 + return [(x,y),(-y,x),(-x,-y),(y,-x)][p] +@dataclass +class Op: + n:int + tab:tuple + circuit:list + def then(self,b): + assert self.n==b.n + return Op(self.n,compose(b.tab,self.tab),self.circuit+b.circuit) + def adjoint(self): + circ=[] + for e in reversed(self.circuit): + if e[0]=='P':circ.append(('P',inv(e[1],self.n))) + elif e[0]=='D':circ.append(('D',e[1],tuple((-x)%4 for x in e[2]))) + elif e[0]=='C':circ.append(('C',e[1],-e[2])) + elif e[0]=='phase':circ.append(('phase',(-e[1])%4)) + else:circ.append(e) + return Op(self.n,inverse(self.tab),circ) + def zero_state(self,basis=0): + N=1<>i)&1 for i in range(n)) + assert all(alpha[i]%2==(Q[i]>>i)&1 for i in range(n)) + return Op(n,tuple([(1<>i&1 else 0,1<>i&1 else 0) for i in range(n)]),[('C',q,sgn)]) +def xgate(n,b):return Op(n,tuple([(1<>i)&1)) for i in range(n)]),[('X',b)]) +def fourier(n,axes=None): + out=ident(n) + for i in range(n) if axes is None else axes:out=out.then(cgate(n,1<len(selected):picks.append(j);selected.append(x) + assert len(picks)==r and all(x>>r==0 for x in Bcols) + Br=transpose(selected,r);Bi=inv(Br,r);Dr=transpose([Dcols[j]&((1<> i & 1) + for i in range(operator.n): + if x >> i & 1: + phase += 2 * ((rows[i] >> (i + 1)) & (x >> (i + 1))).bit_count() + result[x] = gaussian_unit(value, phase) + state = result + elif kind == 'C': + direction, sign = event[1:] + result = {} + for x, (a, b) in state.items(): + for y, value in ((x, (a-sign*b, b+sign*a)), + (x ^ direction, (a+sign*b, b-sign*a))): + u, v = result.get(y, (0, 0)) + result[y] = u + value[0], v + value[1] + state = {x: value for x, value in result.items() if value != (0, 0)} + denominator += 1 + else: + raise ValueError(event) + while denominator and all(not ((a | b) & 1) for a, b in state.values()): + state = {x: (a // 2, b // 2) for x, (a, b) in state.items()} + denominator -= 1 + return state, denominator + + +def standard_product(ce, *operators): + """Return operators[0] ... operators[-1] in conventional product order.""" + result = ce.ident(operators[0].n) + for operator in reversed(operators): + result = result.then(operator) + return result + + +def canonical_predecessor(): + for name, expected in PINS.items(): + need(hashlib.sha256((OLD / name).read_bytes()).hexdigest() == expected, 'frozen source pin: ' + name) + spec = importlib.util.spec_from_file_location('stabilizer_frozen_endpoint', OLD / 'canonical_endpoints.py') + module = importlib.util.module_from_spec(spec) + sys.modules[spec.name] = module + spec.loader.exec_module(module) + need(hashlib.sha256(module.CP.read_bytes()).hexdigest() == '2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962', 'native compiler pin') + return module + + +def deliberate_monomial(ce, n, cut, variant): + """Dense pair stabilizer: nonorthogonal GL2, fresh GL, and cross chirps. + + This is one prescribed construction, not a seed or search. The common + address matrix is A=[[0,1],[1,1]], and Q_CC=I+A^-T A^-1=[[1,1],[1,0]]. + """ + rows = [1 << i for i in range(n)] + rows[:2] = [2, 3] + fresh = list(range(2, n)) + # Swap completed and future directions, then mix every fresh direction. + past = 2 + 5 * (cut + 1) - 1 + future = 2 + 5 * (cut + 1) + if future < n: + rows[past], rows[future] = rows[future], rows[past] + for index in range(len(fresh) - 1): + a, b = fresh[index], fresh[index + 1] + rows[a] ^= rows[b] + rows[0] ^= sum(1 << i for i in fresh if (i + variant) % 2 == 0) + rows[1] ^= sum(1 << i for i in fresh if (i + variant) % 3 == 0) + quadratic = [3, 1] + [0] * (n - 2) + for i in fresh: + j = (i + variant) % 2 + quadratic[i] ^= 1 << j + quadratic[j] ^= 1 << i + if (i + variant) % 3 == 1: + quadratic[i] ^= 1 << i + for a, b in zip(fresh[::2], fresh[1::2]): + quadratic[a] ^= 1 << b + quadratic[b] ^= 1 << a + operator = ce.perm(n, rows).then(ce.diag(n, quadratic)).then(ce.xgate(n, (1 << (2 + variant % (n - 2))) | 1)) + common = ce.cgate(n, 1).adjoint().then(ce.cgate(n, 2)) + other = standard_product(ce, common, operator, common.adjoint()) + need(native_rank(operator) == native_rank(other) == 0, 'prescribed full pair stabilizer admission') + # Sparse complete-column phase witness for the actual rank-zero conjugate. + state, den = sparse_column(other) + need(den == 0 and len(state) == 1 and next(iter(state.values())) in ((1, 0), (0, 1), (-1, 0), (0, -1)), 'actual second-cut monomial phase') + return operator, {'address_rows': rows, 'quadratic_rows': quadratic, 'second_front_zero_column': [list(state.items()), den]} + + +def verify_free_word(): + """Independent group-ring replay of the frozen arbitrary-input B1 word.""" + data = json.loads((OLD / 'NONCOMMON-B1.json').read_text()) + + def reduce(word): + result = [] + for symbol in word: + if result and result[-1] == -symbol: + result.pop() + else: + result.append(symbol) + return tuple(result) + + rows = [{((), 0): 1}, {((), 1): 1}] + for gate in data['word']: + if gate['op'] == 'LEFT': + rows[gate['dst']] = {(reduce(tuple(gate['word']) + word), column): coefficient for (word, column), coefficient in rows[gate['dst']].items()} + elif gate['op'] == 'ADD': + destination = dict(rows[gate['dst']]) + for key, coefficient in rows[gate['src']].items(): + destination[key] = destination.get(key, 0) + gate['q'] * coefficient + if destination[key] == 0: + del destination[key] + rows[gate['dst']] = destination + elif gate['op'] == 'EXCHANGE': + rows = [rows[1], {key: -coefficient for key, coefficient in rows[0].items()}] + else: + raise ValueError(gate) + endpoint = (-3, 5, -2, 4, -1) + need(rows == [{(endpoint, 0): 1}, {(endpoint, 1): 1}], 'independent arbitrary-column group-ring identity') + return {'input_columns': 2, 'free_invertible_operators': 5, 'endpoint': list(endpoint)} + + +def run(): + old = canonical_predecessor() + ce = old.ce + records, phase_cases, controls = [], [], [] + for group in range(3): + for coordinate, p in enumerate(old.bus['groups7'][group]): + q = old.bus['groups7'][(group + 1) % 3][coordinate] + r = old.bus['groups7'][(group + 2) % 3][coordinate] + chart = ce.perm(7, ce.transpose(old.completion(p, q), 7)) + if group == 2: + pre = old.build(7, old.winner[p]['pre_events']) + else: + direction = q ^ r + pre = ce.perm(7, [(1 << i) ^ (direction if direction >> i & 1 else 0) for i in range(7)]) + canonical_pre, _ = ce.monomial(chart.then(pre).then(chart.adjoint())) + local_p = canonical_pre.adjoint() + local_fresh = ce.fourier(7, range(2, 7)) + local_common = ce.cgate(7, 1).then(ce.cgate(7, 2).adjoint()) + first = standard_product(ce, local_fresh, local_p, local_common) + rank_first = native_rank(first) + need(rank_first == (3 if group == 2 else 5), 'actual fixed first-factor native rank') + # Complete phase check against the pinned compiler's literal lowering. + recipe, lowered = ce.lower_child(first) + need(recipe['rank'] == rank_first and first.tab == lowered.tab, 'native lowering signed tableau') + need(sparse_column(first) == sparse_column(lowered), 'independent local global phase') + cases = [] + for length in (1, 3, 5, 9): + n = 2 + 5 * length + cp, cq = ce.cgate(n, 1), ce.cgate(n, 2) + common = cp.then(cq.adjoint()) + fresh = [ce.fourier(n, range(2 + 5 * stage, 7 + 5 * stage)) for stage in range(length)] + ps = [old.embed(n, canonical_pre.circuit, [0, 1] + list(range(2 + 5 * stage, 7 + 5 * stage))).adjoint() for stage in range(length)] + qtotal, baseline, fpast, factored = ps[0], ps[0], fresh[0], standard_product(ce, fresh[0], ps[0], common) + monomials = [] + for stage in range(1, length): + monomial, _ = deliberate_monomial(ce, n, stage - 1, stage) + monomials.append(monomial) + insertion = standard_product(ce, fpast.adjoint(), monomial, fpast) + qtotal = standard_product(ce, ps[stage], insertion, qtotal) + baseline = standard_product(ce, ps[stage], baseline) + fpast = standard_product(ce, fresh[stage], fpast) + factor = standard_product(ce, fresh[stage], ps[stage]) + need(native_rank(factor) == 5, 'later factor native rank') + factored = standard_product(ce, factor, monomial, factored) + original = standard_product(ce, fpast, qtotal, common) + need(original.tab == factored.tab, 'exact signed tableau of telescoping factorization') + # Independent columns/multiplication agree with exact compiler. + independent = binary_product(binary_tableau(fpast), binary_product(binary_tableau(qtotal), binary_tableau(common))) + need(independent == binary_tableau(original), 'independent symplectic endpoint multiplication') + rank_y = native_rank(original) + bound = 5 * (length - 1) + rank_first + need(rank_y <= bound < n, 'universal theorem bound on deliberate insertion') + baseline_y = standard_product(ce, fpast, baseline, common) + need(native_rank(baseline_y) == bound, 'identity insertion attains universal Y bound') + fx = standard_product(ce, ce.fourier(n), ce.xgate(n, 1), qtotal) + rank_x = native_rank(fx) + # At genuine B1 size17, independently compare full columns for + # a representative A port and C port; this fixes global phase. + if length == 3 and coordinate == 0 and group in (0, 2): + original_state = sparse_column(original) + need(original_state == sparse_column(factored), 'global B1 exact Gaussian column') + phase_wrong = factored.then(ce.Op(n, ce.identity(n), [('phase', 1)])) + need(phase_wrong.tab == original.tab and sparse_column(phase_wrong) != original_state, 'global-phase omission control') + phase_cases.append({'group': group, 'p': p, 'n': n, 'output_support': len(original_state[0]), 'denominator_depth': original_state[1]}) + cases.append({'L': length, 'm': n, 'X_native_rank': rank_x, 'Y_native_rank': rank_y, 'Y_rank_upper_bound': bound, 'identity_insertion_Y_native_rank': native_rank(baseline_y), 'Y_deficit_lower_bound': n - bound}) + records.append({'group': group, 'coordinate': coordinate, 'p': p, 'q': q, 'first_factor_rank': rank_first, 'cases': cases}) + # An undressed logical ADDRESS swap has a real hidden native query. + n = 4 + cp, cq, past = ce.cgate(n, 1), ce.cgate(n, 2), ce.cgate(n, 4) + dx = standard_product(ce, cp, past) + swap = ce.perm(n, [1, 2, 8, 4]) + dressed = standard_product(ce, dx.adjoint(), swap, dx) + need(native_rank(standard_product(ce, dx, dressed, dx.adjoint())) == 0, 'dressed swap admitted') + hidden = native_rank(standard_product(ce, dx, swap, dx.adjoint())) + need(hidden == 2, 'undressed swap admission control') + common = standard_product(ce, cq, cp.adjoint()) + no_chirp = ce.perm(n, [2, 3, 4, 8]) + need(native_rank(standard_product(ce, common, no_chirp, common.adjoint())) > 0, 'common chirp omission control') + wrong_inverse = standard_product(ce, past, swap, past) + right_inverse = standard_product(ce, past.adjoint(), swap, past) + need(wrong_inverse.tab != right_inverse.tab, 'positive/adjoint past-frame control') + controls.extend(['undressed_swap_costs_rank2', 'common_chirp_omission_breaks_second_front', 'past_frame_inverse_sign_is_essential', 'global_phase_i_rejected_on_two_B1_ports']) + return { + 'status': 'PASS_FULL_MONOMIAL_INSERTION_Y_RANK_OBSTRUCTION_NO_NEW_KAPPA', + 'scientific_pin': PIN, + 'sources_sha256': PINS, + 'source_sha256': hashlib.sha256(Path(__file__).read_bytes()).hexdigest(), + 'free_word': verify_free_word(), + 'theorem': {'C_Y_rank_upper': '5L-2 = m-4', 'AB_Y_rank_upper': '5L = m-2', 'm': '2+5L', 'quantifiers': 'Every L>=1; every locally admitted monomial pre_s on common2 plus own fresh5 with fixed first-factor ranks3/5; every insertion whose physical X-cut pullback is any invertible monomial. Second-front admission is unnecessary for the upper bound. Arbitrary permutations and diagonal nonzero phases, including non-Clifford monomials, are covered by the row-support proof.'}, + 'factorization': 'F_all P_last (F_past^-1 M_last-1 F_past) ... P_1 (F_0^-1 M_0 F_0) P_0 R = (F_last P_last) M_last-1 ... (F_1 P_1) M_0 (F_0 P_0 R)', + 'records': records, + 'independent_global_phase_cases': phase_cases, + 'defect_controls': controls, + 'all_size': 'Tensor columnwise over f>=1: each later factor has row support2^(5f), first factor2^(3f) C or2^(5f) A/B; monomials preserve support. Thus terminal Y has row support <=2^((m-4)f) C or2^((m-2)f) A/B and cannot be a rank-mf native child, even with arbitrary input values.', + 'cost_boundary': {'OPEN_local_histogram': {'1': 8, '2': 40, '3': 16}, 'OPEN_local_rank_mass': 136, 'ordinary_helpers': 0, 'private_fields': 0, 'isolated_unary_completion_rank_lower_bound_per_twelve_port_Y_bank': 32, 'insertion_scans': 'All actual monomial address/phase scans remain paid; zero native rank does not mean zero work.'}, + 'limits': ['No arbitrary multibank insertion, changed scalar word, changed entrance code, overlapping local fresh supports, or different raw local boundary is excluded.', 'The proof does not calculate an optimal paid completion word, owner allocation, all-size rounded precision, physical tape controller, or positive conditional kappa.', 'This is a written all-parameter proof with finite exact operator checks, not formal-kernel verification.'], + 'attribution': 'Uses frozen source-carrier/common-F normalizers and canonical endpoint charts from the2026-10-18 run; predecessor complex and algebra lanes plus root own those constructions. This lane supplies the exact telescoping argument, full arbitrary-monomial support bound, independent symplectic arithmetic and Gaussian phase evaluator.' + } + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--write', action='store_true') + args = parser.parse_args() + output = json.loads(json.dumps(run())) + target = HERE / 'FULL-STABILIZER-BOUND.json' + if args.write: + target.write_text(json.dumps(output, indent=2, sort_keys=True) + '\n') + else: + need(json.loads(target.read_bytes()) == output, 'stored exact receipt mismatch') + print(output['status']) + print('12 ports x L1/3/5/9; arbitrary-monomial proof;2 exact n17 phase checks;4 defect controls') + + +if __name__ == '__main__': + main() diff --git a/research/marked-residual-reflection/verify.py b/research/marked-residual-reflection/verify.py new file mode 100644 index 0000000000..ef784a4b63 --- /dev/null +++ b/research/marked-residual-reflection/verify.py @@ -0,0 +1,164 @@ +#!/usr/bin/env python3 +"""Exact caller replay. Ross Richardson; substantial OpenAI Codex assistance. + +Apache-2.0. Immutable predecessor implementations are compiled from the same +bytes authenticated below, with optimize=0 to preserve historical assertions. +This direct verifier needs Python's standard library, no Git and no network. +""" +from pathlib import Path +from fractions import Fraction +from collections import Counter +import copy +import hashlib +import importlib +import importlib.abc +import importlib.util +import json +import sys + +sys.dont_write_bytecode=True +ROOT=Path(__file__).resolve().parent +META=json.loads((ROOT/'BINDINGS.json').read_bytes()) +PINS={row['path']:row for row in META['files']} +def need(condition,message): + if not condition:raise ValueError(message) +need(len(PINS)==len(META['files']),'duplicate retained-source path') +def checked(relative,raw=None): + row=PINS[relative];path=ROOT/relative + need(path.resolve()==path,'retained source must not be a symlink') + if raw is None:raw=path.read_bytes() + need(hashlib.sha256(raw).hexdigest()==row['sha256'],'retained source hash: '+relative) + return raw +for relative in PINS:checked(relative) + +def rejection(action,needle): + try:action() + except ValueError as error: + need(needle in str(error),'wrong rejecting predicate: '+str(error)) + else:raise ValueError('negative control unexpectedly accepted: '+needle) + +# Positive and negative source-binding controls use real source bytes. The +# loader below has no bytecode-cache path, including for dynamic source loads. +first=next(p for p in PINS if p.endswith('.py')) +need(checked(first,checked(first))==checked(first),'identical source positive control') +rejection(lambda:checked(first,checked(first)+b'\n# altered source\n'),'retained source hash') +MODULES={} +for relative in PINS: + if relative.startswith('source/') and relative.endswith('.py'): + stem=Path(relative).stem + need(stem not in MODULES,'ambiguous retained module '+stem) + MODULES[stem]=relative +class ByteLoader(importlib.abc.Loader): + def __init__(self,relative):self.relative=relative + def create_module(self,spec):return None + def exec_module(self,module): + raw=checked(self.relative) + exec(compile(raw,str(ROOT/self.relative),'exec',dont_inherit=True,optimize=0),module.__dict__) +class ByteFinder(importlib.abc.MetaPathFinder): + def find_spec(self,fullname,path=None,target=None): + if fullname in MODULES: + relative=MODULES[fullname] + return ORIGINAL_SPEC(fullname,str(ROOT/relative),loader=ByteLoader(relative)) +ORIGINAL_SPEC=importlib.util.spec_from_file_location +def bound_spec(name,location,*args,**kwargs): + path=Path(location).resolve() + if path.is_relative_to(ROOT): + relative=str(path.relative_to(ROOT)) + need(relative in PINS,'undeclared dynamic source '+relative) + return ORIGINAL_SPEC(name,str(path),loader=ByteLoader(relative)) + return ORIGINAL_SPEC(name,location,*args,**kwargs) +importlib.util.spec_from_file_location=bound_spec +sys.meta_path.insert(0,ByteFinder()) +def module(name):return importlib.import_module(name) +def data(relative):return json.loads(checked('source/'+relative)) +def source_path(original): + candidates=[p for p,row in PINS.items() if p.startswith('source/') and (row['origin']==original or row['origin'].endswith('/'+original))] + need(len(candidates)==1,'one retained original source for '+original) + return ROOT/candidates[0] + +# Receipts contain original absolute provenance paths. All retained bytes are +# separately checked above. These explicitly enumerated metadata fields are +# omitted ONLY when comparing replay's mathematical body to its frozen receipt. +PROVENANCE={'sources','source_pins','producer_sha256','helper_sha256', + 'native_model_sha256','reflection_source_sha256','source_path','source_sha256', + 'path','witness','witness_sha256'} +def body(value): + if isinstance(value,dict):return {str(k):body(v) for k,v in value.items() if k not in PROVENANCE} + if isinstance(value,(list,tuple)):return [body(v) for v in value] + return value +def difference(a,b,path='root'): + if type(a)!=type(b):return path+': type mismatch' + if isinstance(a,dict): + if a.keys()!=b.keys():return path+': keys '+str(set(a)^set(b)) + for k in a: + if a[k]!=b[k]:return difference(a[k],b[k],path+'.'+k) + elif isinstance(a,list): + if len(a)!=len(b):return path+': lengths '+str((len(a),len(b))) + for i,(x,y) in enumerate(zip(a,b)): + if x!=y:return difference(x,y,path+'['+str(i)+']') + elif a!=b:return path+': '+repr(a)[:150]+' != '+repr(b)[:150] + return path +RESULTS=[] +def replay(name,function,receipt): + actual=json.loads(json.dumps(getattr(module(name),function)())) + expected=data(receipt) + aa,bb=body(actual),body(expected) + need(aa==bb,'mathematical receipt mismatch '+receipt+' '+difference(aa,bb)) + RESULTS.append({'entry':name+'.'+function,'status':actual['status'],'mathematical_receipt':receipt}) + print('PASS_REPLAY',name,function,flush=True) + return actual + +def query_count_scope(): + """Replay arbitrary-support queries on every independent marked column.""" + gate=module('marked_residual_gate') + cases=[] + for L,masks,words in [ + (2,(3,3),[[(0,3),(1,3)],[(0,1),(0,2),(1,3)], + [(0,1),(0,2),(1,1),(1,2)]]), + (3,(1,6),[[(0,1),(1,6)]])]: + target=[(bank,x^mask,owner,mask.bit_count()%4) + for bank,mask in enumerate(masks) + for x in range(1<1: + need(len(sys.argv)==2 and sys.argv[1]=='--json','only --json is supported') + print(json.dumps(report,indent=2,sort_keys=True)) +else:print(report['status'],','.join(report['claims']),'no_new_kappa=true',flush=True)