diff --git a/research/coded-port-adapter-ceiling/.gitattributes b/research/coded-port-adapter-ceiling/.gitattributes new file mode 100644 index 0000000000..2bd10fb9be --- /dev/null +++ b/research/coded-port-adapter-ceiling/.gitattributes @@ -0,0 +1,2 @@ +# Preserve exact upstream source bytes, including CRLF. +source/* -text diff --git a/research/coded-port-adapter-ceiling/ATTRIBUTION.md b/research/coded-port-adapter-ceiling/ATTRIBUTION.md new file mode 100644 index 0000000000..8c8c6e7cb2 --- /dev/null +++ b/research/coded-port-adapter-ceiling/ATTRIBUTION.md @@ -0,0 +1,31 @@ +# Attribution and source boundaries + +Apache-2.0. Prepared for Chris R/Clear1nsight with substantial OpenAI Codex +assistance (gpt-6.1-sol/high source/interface agent and parent coordination). +The parent derived the scoped one-bank projection/rank argument and price +screen. The interface agent independently derived the physical forward and +raw-dual recovery wrappers and checked all 5824 actual supported transport +grades. This package makes the joint result self-contained and portable. + +Dugongue's PR4929, head `361f5d410`0640177d6a983dd2f336021c75bfd5e, supplies +the exact coded producer, code entries and native words. Its original +[attribution](source/ATTRIBUTION-4929.md), [proof](source/CODED-PROOF-4929.md) +and [notice](source/NOTICE-4929) are retained unchanged. Cinna Davis / +1337isnot1337 supplies the #4694 centre-free cache kernel and #4698 basis +and conditional consumer. Cao Yifan/intqwq supplies the #4610/native +round-three word. Cinna Davis/#4470, zxv, Jacob Alan Sussman and all retained +Gaussian, Clifford, higher-moment, finite compiler and outer contributors +retain their source-specific credit. + +The exact interval and Clifford libraries are copied without modification +from historical canonical main `624de9dc`. ORIGINS.json records original Git +blobs, source paths, complete commits and SHA256 values. The compressed +source `7679daa4` and decompressed payload `cfcd36b4` describe the same source. +The source producer's archival status is separate from scientific admission. + +No primary632-input producer proof audit, native amplitude replay, complete +consumer, compiler, Lean kernel, outer recursion or improved κ is claimed. +Standard group algebra, Fourier-grade invariance, tensor-power separation +and finite vector-space rank arguments are credited as mathematical methods, +not claimed as newly invented general techniques. Separate agent checks +are not independent human or formal proof-kernel acceptance. diff --git a/research/coded-port-adapter-ceiling/BUDGET.md b/research/coded-port-adapter-ceiling/BUDGET.md new file mode 100644 index 0000000000..f924b816fa --- /dev/null +++ b/research/coded-port-adapter-ceiling/BUDGET.md @@ -0,0 +1,45 @@ +# Complete obligation and cost ledger + +The historical native source is pinned at `624de9dc`; the investigation base +was `8c050952`; the publication base is `cef4b52f2a59009865bf8eabde1be3f159063703`. These are distinct from the producer head `361f5d410`. No selected +frontier is changed. The price comparison uses the funded #4610 value +.0030217758, not an older baseline guard. + +| Item | Status | Bound or remaining obligation | +|---|---|---| +| Changed native paid profile |Proved finite census |P_coded=2201H1+412H2+510H3+127H4+40H5, both orientations; eight H8 removed | +| Independent helper reward |Proved source census |408 per invocation, H=28H4+7H7+47H8+326H9; no extra reward from code invertibility | +| Coded all-input endpoint |Inherited #4929 premise |Autonomous 632-input code offer, source charts and actual raw dual; not freshly replayed here | +| Ground precompensation |Constructively upper-bounded upstream and recounted |6596 dyadic ADDs, allowance 32652 ordinary scalar primitives per invocation; no Gaussian child added | +| Forward uncoding adapter |Exact formula |K=U A^-1 U*, plus scalar exit A on common-full X | +| Backward uncoding adapter |Exact formula |barU A^T barU*, plus exit A^(-T); entry/exit chart labels are not reversed | +| Naive recursive implementation |Constructive recursive upper bill |112 H1 decode and 112 H1 restore, with scalar A^-1 in between; finite scalar word and storage still need binding | +| One parallel bank |Proved scoped lower bound |At least 112 grade 2 channels; its optimistic two-call bill loses throughout the interval | +| Odd rational normalization |Unknown finite admission |1/13 requires its actual fixed rational/scaled protocol and finite precision cost; no division oracle | +| Scaled13K |Exact alternative formula |12I+UAU* is dyadic, but produces a scaled offer until normalization or scale propagation is proved | +| Scalar exit mixing |Zero recursive Gaussian grade |Finite arithmetic, movement and owned buffers/cleanup remain charged; common chart does not make passes cost zero | +| Source storage |Inherited source contract |632 arbitrary persistent input fields and the owned centre scratch lifecycle remain; no productive centre credit | +| Adapter storage |Unknown finite binding |An out-of-place 112-field code protocol needs declared owned buffers and cleanup; an in-place protocol needs its literal fixed rational word | +| Norm/precision |Partial bounds |A and A^-1 norms 13 and 1; source endpoint condition≤196. Upstream prefix bounds 457/258 are source-specific. New adapter word prefixes, suffix/local-error propagation and guards are not supplied | +| Completed productive endpoint |Unknown |224 H17+2H is an unrealized relaxation, not credit supplied by the coded producer | +| Existing 18-FULL caller |Unknown changed binding |Old 15 query shears/IDLEs and all original targets must remain; code does not automatically commute through the physical boundaries | +| Uniform compiler |Unknown new admission |Rebind completion, disjoint ownership, max-rank/ambient condition, finite constants, saving gap and actual scalar/coefficient heights | +| Outer transfer |Unknown new admission |All 54 strict predicates and 4 functional guards need new supplier parameters and semantic proof; ordinary BIT cap.0034 is retained as a comparison interval, not newly certified | + +The rank-8 owner projector does not provide an eight-head native observation +query. #4712's 120-head correction and dirty-helper restoration objection are +not removed by a scalar matrix inverse. The new one-bank proof is a sharper +statement for this particular adapter grammar, not a universal query floor. + +The collective three-bank grant reuses 112 original helper owners across two +calls, replacing 224 independent H9 reward slots by 112 independent H17 jobs. +It therefore has 928 original owners, with 592 unselected helper jobs. H17 on +the selected bank is unproved; the known pattern gives H16 and loses. No +helper is credited both as its old job and as the new fused job. + +The finite-template arguments and outer formulas from #4610 may remain useful +proof schemas after a complete caller exists. Their frozen 18-FULL/rank-145 +coefficients, scalar caps, C1=1 semantic guard, finite height and reserve are +not certificates for a coupled code merely because the local P dictionary +is smaller. No expensive whole-compiler replay is justified by this local +raw margin alone. diff --git a/research/coded-port-adapter-ceiling/LICENSE b/research/coded-port-adapter-ceiling/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/coded-port-adapter-ceiling/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/coded-port-adapter-ceiling/NOTICE b/research/coded-port-adapter-ceiling/NOTICE new file mode 100644 index 0000000000..db10ab2868 --- /dev/null +++ b/research/coded-port-adapter-ceiling/NOTICE @@ -0,0 +1,5 @@ +Coded-port adapter ceiling, prepared for Chris R / Clear1nsight. +Apache-2.0; substantial OpenAI Codex assistance. +Retain the upstream notices under source/ and ATTRIBUTION.md. +Native coded producer: Dugongue #4929; native centre/helper/controller lineage: +Cinna Davis /1337isnot1337, Cao Yifan /intqwq, zxv and retained contributors. diff --git a/research/coded-port-adapter-ceiling/ORIGINS.json b/research/coded-port-adapter-ceiling/ORIGINS.json new file mode 100644 index 0000000000..33a780d380 --- /dev/null +++ b/research/coded-port-adapter-ceiling/ORIGINS.json @@ -0,0 +1,85 @@ +{ + "base_commit": "cef4b52f2a59009865bf8eabde1be3f159063703", + "files": [ + { + "git_blob": "46d929df83817b85a5387bcdb9745e0627d6366e", + "path": "source/ACTUAL-WORD.json.gz", + "sha256": "7679daa4ec6a40f56fc7f0202379a6f454310e94945aba4f48beaaaafb838d05", + "source_commit": "624de9dc66858af0945e5f8a0942488d62280d43", + "source_path": "research/kappa-round3-warp-20261022/ACTUAL-WORD.json.gz", + "source_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/624de9dc66858af0945e5f8a0942488d62280d43/research/kappa-round3-warp-20261022/ACTUAL-WORD.json.gz" + }, + { + "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2", + "path": "source/clifford_exact.py", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "source_commit": "624de9dc66858af0945e5f8a0942488d62280d43", + "source_path": "research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py", + "source_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/624de9dc66858af0945e5f8a0942488d62280d43/research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py" + }, + { + "git_blob": "4b24a5096154736ce060474eb8c72dc64c303699", + "path": "source/intervals.py", + "sha256": "0ce7e7137422d5ffeda22085c81fa88471bbe963100fdad62e659f1e3bf89326", + "source_commit": "624de9dc66858af0945e5f8a0942488d62280d43", + "source_path": "research/higher-moment-strictification/verify.py", + "source_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/624de9dc66858af0945e5f8a0942488d62280d43/research/higher-moment-strictification/verify.py" + }, + { + "git_blob": "03170f4a31f7a8a3db7228f1cd5a6fdcb32720ae", + "path": "source/CODE.json", + "sha256": "8be7f3f073b7981ec91c6af43edff0ac8a89f4824ef6026ae758c287dd6c03d0", + "source_commit": "361f5d4100640177d6a983dd2f336021c75bfd5e", + "source_path": "research/native-center-free-code/CODE.json", + "source_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/361f5d4100640177d6a983dd2f336021c75bfd5e/research/native-center-free-code/CODE.json" + }, + { + "git_blob": "935fedd9c9a77f870dd6afbabbf56c8ea6e321d4", + "path": "source/CODED-WORDS.json.gz", + "sha256": "797bad53122f84aa0f05b602f2bdceb6b50f95a64023799d4f24560d9c61aad6", + "source_commit": "361f5d4100640177d6a983dd2f336021c75bfd5e", + "source_path": "research/native-center-free-code/CODED-WORDS.json.gz", + "source_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/361f5d4100640177d6a983dd2f336021c75bfd5e/research/native-center-free-code/CODED-WORDS.json.gz" + }, + { + "git_blob": "b02b5ebb8b7482bf733744507095e37045c0ff83", + "path": "source/EXPECTED-4929.json", + "sha256": "e147122a93e3c2c5f78af42b631e1fb9410178987b9cc4ca6b5c63a5cb9dccc8", + "source_commit": "361f5d4100640177d6a983dd2f336021c75bfd5e", + "source_path": "research/native-center-free-code/EXPECTED.json", + "source_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/361f5d4100640177d6a983dd2f336021c75bfd5e/research/native-center-free-code/EXPECTED.json" + }, + { + "git_blob": "1f28d33884ec99b34f8366d022d8f7b9b7653ae2", + "path": "source/CODED-PROOF-4929.md", + "sha256": "acd904af677718da8cdaf81d205d29866a6855efd393047e7128320a46753b01", + "source_commit": "361f5d4100640177d6a983dd2f336021c75bfd5e", + "source_path": "research/native-center-free-code/CODED-PROOF.md", + "source_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/361f5d4100640177d6a983dd2f336021c75bfd5e/research/native-center-free-code/CODED-PROOF.md" + }, + { + "git_blob": "5f6cd0d364caa8e36aa6b933dca3d75ced917831", + "path": "source/ATTRIBUTION-4929.md", + "sha256": "7cdaf8b754a14b6bd54beb4d7d5336e36f782e2b59e6b06f286bdd8ad7126a00", + "source_commit": "361f5d4100640177d6a983dd2f336021c75bfd5e", + "source_path": "research/native-center-free-code/ATTRIBUTION.md", + "source_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/361f5d4100640177d6a983dd2f336021c75bfd5e/research/native-center-free-code/ATTRIBUTION.md" + }, + { + "git_blob": "42501d0a9910107bdc8405660b0c93b80b9e6cd9", + "path": "source/NOTICE-4929", + "sha256": "0de30db3221dafd34a82e3347a478a73d8338edef051c054ce6f8cf404f91154", + "source_commit": "361f5d4100640177d6a983dd2f336021c75bfd5e", + "source_path": "research/native-center-free-code/NOTICE", + "source_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/361f5d4100640177d6a983dd2f336021c75bfd5e/research/native-center-free-code/NOTICE" + } + ], + "native_source_commit": "624de9dc66858af0945e5f8a0942488d62280d43", + "producer_archival_status": "Head is a raw Git ancestor of publication base; archival merging does not imply scientific admission", + "producer_head": "361f5d4100640177d6a983dd2f336021c75bfd5e", + "producer_pr": 4929, + "producer_public_ref": "refs/pull/4929/head", + "schema_version": 1, + "source_bytes_locally_compared_to_git": true, + "investigation_initial_base": "8c05095235547f8169391abb273c7da0ea759fe6" +} diff --git a/research/coded-port-adapter-ceiling/PROOF.md b/research/coded-port-adapter-ceiling/PROOF.md new file mode 100644 index 0000000000..02876d6f7a --- /dev/null +++ b/research/coded-port-adapter-ceiling/PROOF.md @@ -0,0 +1,236 @@ +# A one-parallel-bank ceiling for the actual coded-port recovery adapter + +This is a scoped exact-operator result, conditional on Dugongue's native +producer #4929 at `361f5d4100640177d6a983dd2f336021c75bfd5e`. +It is not a complete caller obstruction or a κ improvement. The package +independently checks the source charts, supported transport grades and code +inverse used below. It does not rerun the producer's all 632-input replay. + +## 1. Actual source and physical offer + +The native source compressed SHA256 is +`7679daa4ec6a40f56fc7f0202379a6f454310e94945aba4f48beaaaafb838d05`. +Its decompressed payload SHA256 is +`cfcd36b40326d7a5815e1db5313444379b3fb756b27d5201c561574c085cc0dd`. +These are two hash conventions for the SAME source object, retained in +canonical main `624de9dc` and the frozen #4610 source; they are not different +native words. + +There are 112 X fields, 112 Y fields and 408 independent arbitrary helper +fields. X enters 112 distinct rank-1 charts U_i and exits a common full chart +T=F9 (its diagonal 112-fold action is denoted T below). Y enters the ground chart and exits 112 distinct rank-8 charts V_i. +Put U=diag(U_i), V=diag(V_i). All are the actual canonical source frame +Cliffords, including their phases; a bare C_q must not replace U_i without +its literal source normalizers. The source physical main operator is + + N_A = diag(T,V) S_y(A) diag(U*,I), + S_y(A) = [[I,0],[A,I]]. (1) + +The source producer supplies (1) with autonomous original helper operators +on their own arbitrary inputs. It removes exactly8H8, retaining + + P_coded =2201H1+412H2+510H3+127H4+40H5, + H =28H4+7H7+47H8+326H9. + +Its 6596 extra ground-chart dyadic ADDs have a supplied ordinary scalar +allowance 32652. The checker verifies these event counts and ground-chart +conditions from the emitted words; finite precision/stock admission is not +inferred. Eight owned centre Gaussian jobs disappear, but owned centre +scratch and its legal CLEAR lifecycle are not arbitrary productive inputs. +The original 632 input owners and all 408 helper jobs remain distinct. + +The scalar code is A=I-14P with P an orthogonal rank-8 projection. The exact +checked polynomial is + + A^2+12A=13I, A^-1=(A+12I)/13. (2) + +A is symmetric, has zero diagonal, and has 5824 nonzero off-diagonal entries +±1/2. Its eigenvalues are 1 and -13, with multiplicities 104 and 8. Thus its +Euclidean condition number is 13. The main shear and inverse each have norm +at most 14, giving condition number at most 196 for the complete physical +producer with its independent unitary helper block. These endpoint bounds +do not replace bounds on a newly implemented adapter's intermediate states +or propagation of rounding discrepancies inserted inside its word. + +## 2. Exact forward and raw-dual recovery + +Let N_I be the original uncoded main operator, replacing A by I in(1). +Set + + K=U A^-1 U*, L=diag(A,I). + +The common full X exit T commutes with scalar port mixing A. Hence + + N_I = L N_A diag(K,I). (3) + +All helper outputs are untouched by these main-only wrappers. This is an +exact algebraic recovery statement on all original inputs, not an +implementation of K in the heterogeneous entrance charts. + +The chronological naive implementation of K is: apply U_i* to every X_i, +perform the scalar A^-1 mixing in the common ground chart, then apply U_i +to every resulting X_i. It costs two banks of 112 H1, plus all scalar, routing, +storage, precision and normalization work. The full-exit A operation has +recursive grade 0, not zero ordinary cost. A simple out-of-place scalar +protocol needs owned output storage and a declared restoration/cleanup +protocol; an in-place rational elimination needs its actual fixed scalar +word. Neither is silently supplied by the matrix identity. + +The raw inverse transpose preserves product order: +(ABC)^(-T)=A^(-T)B^(-T)C^(-T). The retained backward source uses entrywise +conjugated frame maps, rather than reversing chart labels. Therefore(3) +gives backward recovery with + + entrance X: K_B=bar(U) A^T bar(U)*, + exit X: A^(-T) in the common conjugate-full chart. (4) + +Y and helpers remain unchanged. In general bar(U) is not U*. Source helper +raw-dual operations are also entrywise conjugates; no low-rank adjoint +replacement is assumed. The special full F9 product happens to be symmetric. +Formula(4) places the odd denominator in the full-exit scalar map, while +formula(3) places it in the entrance recoding. + +The dyadic scaled alternative + + 13K=12I+U A U* (5) + +is kept separate. It avoids 1/13 inside that entrance matrix, but produces +a scaled offer until the scalar 13 is carried or normalized at a specified +boundary. It is not automatically the old uncoded supplier. Fixed odd +rational normalization, rounded division/constant multiplication, storage, +all intermediate coefficients and error propagation require a finite +Word-RAM protocol in the selected ABI. No universal impossibility is +inferred merely from the denominator 13. + +## 3. Fourier grade and a finite phase quotient + +Fix a finite-phase one-column Clifford group G on the declared ambient +address space, containing all source frames and all allowed gates. Let Z +be its scalar subgroup. Let H contain Z and all admitted monomial +Cliffords. Free owner controls may have arbitrary coefficients over the +subgroup algebra B_f. This grants more owner mixing than a fixed finite +ADD schedule. Non-Clifford monomials and noncolumnwise width-specific +address operations are outside this grammar. + +At width f impose z=ζ^f for every scalar z=ζI. The resulting twisted +algebra A_f has one basis class per projective group element G/Z over a +characteristic-zero splitting field. No domain assumption is needed. +The Fourier grade of a pure Clifford is the binary rank of its Z-to-X +symplectic block. Scalar phases do not change grade. Multiplying on either +side by a monomial Clifford preserves grade. Consequently the basis +projection pi_2 retaining exactly grade 2 words is a B_f-bimodule map: + + pi_2(b a c)=b pi_2(a)c, b,c in B_f. (6) + +Grade is not asserted additive under general Clifford multiplication. +All actual phases remain in the quotient multiplication. + +For completeness, this algebra faithfully evaluates into the literal +columnwise tensor action at every sufficiently large f. Choose matrix +representatives v_t for G/Z. For each t and other u, a linear functional +can vanish on v_u and not v_t because they are nonproportional. The product +of these functionals isolates v_t in homogeneous degree |G/Z|-1. Multiplying +by a power of a functional nonzero at v_t extends the isolating polynomial +to every larger degree f. Applied to v_t^⊗f, it proves linear independence +of the projective representatives' tensor powers, with the scalar character +ζ^f retained. Thus an all-positive-width exact operator identity implies +the algebra identity at all sufficiently large widths, even when owner +coefficients depend on f. No width-1 independence of Clifford matrices, +phase deletion or tensor power of an operator sum is used. The scalar code +A remains owner mixing at each width; it is not replaced by A^⊗f. + +## 4. The one-bank theorem + +The checker classifies all 5824 supported pairs of the actual code. For +each nonzero A_ij, i differs from j and U_i U_j* has Fourier grade 2. +Together with A_ii=0, equations(2)-(3) give + + K=(12/13)I+(1/13)U A U*, + pi_2(K)=(1/13)U A U*. (7) + +The latter matrix is invertible over A_f: U and A are invertible, with +phases retained. As a K-linear operator on the regular module A_f^112, +it has rank 112 dim(A_f). The backward adapter K_B is also invertible with +every supported entry of grade 2. Scaling 13K preserves the same projected +rank. The scalar rank-8 of P does not provide eight native observation +oracles in heterogeneous input charts; coefficient projection pi_2 can +increase the ordinary operator rank of a low-rank update. + +Consider only a standalone exact adapter made from free B_f-valued linear +pre/post controls and ONE parallel bank D of pure Gaussian Clifford +operations, with identities on other channels. Rectangular boundaries, +zero scratch, free saved-input bypass, copies or output selection may be +granted. Let r be the number of grade 2 channels in D. Other grades have +zero pi_2 projection. A free bypass has zero grade 2 projection. By(6), + + pi_2(L D R + B_0)=L pi_2(D) R, B_0 over B_f. + +Each retained diagonal grade 2 entry is a group unit. On the regular module +pi_2(D) therefore has rank r dim(A_f); rectangular pre/post maps cannot +increase it. Equation(7) requires + + r >=112. (8) + +An H1-only parallel bank cannot realize K. A bank with other grades still +needs 112 grade 2 channels. This is a theorem about the specified exact, +fixed finite columnwise alphabet. It does not address approximate/border +endpoints, chronological multiple banks, absorbing a conversion into +existing native operations, source-prefix access, nonlinear controls or a +changed direct coded consumer. + +## 5. Complete optimistic tariff screen, not a constructed endpoint + +Grant, without an endpoint certificate, 224 independent H17 main targets +and all 816 original helper targets from two coded source calls. Their raw +margin at C=.0030217758 is + + 166.262158203082210620506138658847..848, + +and at C=.0034 it is 159.070799023745749761534310198754..755. Subtracting +112 H2, as forced for even one standalone bank by(8), gives respectively + + -57.269156882594712940928576503039..038, + -64.401921647290247704383966403396..395. + +The naive224 H1 route also loses. Exact rational intervals, profiles and +sign controls are regenerated in RESULT.json from the vendored interval +engine. For each stated bill, negative signed coefficients have ranks at +most5 and positive coefficients ranks at least7. Its normalized moment +M(t)/5^t is strictly increasing in t=1-C. Negativity at the funded lower-C +endpoint excludes the full interval through .0034. This does not price a +realized caller or establish its uniform compiler reserve. + +The stronger three-original-bank offer 336 H17+2H-224 H9 has 928 owners and a +positive raw relaxation, but its third H17 job is unproved. The known +#4698 pattern has a third H16 job and already loses even with free embedding. +A_ii=0 and the nonuniform physical headers prevent substituting either +old one-port template into the new code without a new all-input operator +identity. These distinct models are recorded explicitly in RESULT.json. + +For the frozen 18-FULL/15-query caller, a literal interface-preserving +replacement would change its paid profile by -144H8+K_added, retaining +its old query/IDLE costs and productive targets. That formula is conditional +on a chronological endpoint with every new adapter and resource counted. +The code does not automatically commute through port-dependent entrance +maps or standardized Q/native letters. No such amortization is proved. + +## 6. Admission and credit boundary + +The local Gaussian children and independent helper targets retain their +source phase/ownership contracts. The coded cross-transfer is changed. +The old 18-FULL word, its rank-145 productive endpoint, finite template +constants, 54 strict outer predicates and 4 functional guards do not bind +merely by replacing P in a dictionary. A complete Gaussian endpoint, +actual scalar/routing/storage word, prefix AND suffix/error bounds, +odd-denominator protocol, uniform compiler gap and ordinary BIT/outer +admission must be newly supplied. No κ is claimed here. + +Credit Dugongue for the exact native coded producer, Cinna Davis/1337isnot1337 +for #4694/#4698, Cao Yifan/intqwq for the retained round-three source and +#4610, and the retained native, Clifford, helper, compiler and outer +contributors. The parent agent derived the one-bank projection/rank +argument and exact price screen; the source/interface agent independently +bound the physical adapter, all supported grades and raw-dual formula. +The proof and portable checks were prepared for Chris R/Clear1nsight with +substantial OpenAI Codex assistance. Apache-2.0. Independent agent review +is separate from independent human or formal proof-kernel acceptance. diff --git a/research/coded-port-adapter-ceiling/README.md b/research/coded-port-adapter-ceiling/README.md new file mode 100644 index 0000000000..3f6547105a --- /dev/null +++ b/research/coded-port-adapter-ceiling/README.md @@ -0,0 +1,125 @@ +# A scoped one-bank ceiling for PR4929's coded-port adapter + +PR4929 removes eight rank-8 native children while retaining an autonomous +632-input supplier, but changes its main cross-transfer to an invertible +112-port code. This package identifies the actual physical recovery adapter +and proves that **a standalone single parallel Gaussian bank needs at least +112 rank-2 channels**. An H1-only bank cannot recover the uncoded interface. +The resulting optimistic two-call tariff already loses over +`C in [.0030217758,.0034]`. No complete caller or improved κ is supplied. + +The producer is Dugongue's #4929, exact head +`361f5d4100640177d6a983dd2f336021c75bfd5e`; archival merging does not certify +its mathematics. Its all 632-input producer proof is inherited, not replayed +here. The native word is byte-identical to frozen #4610: compressed hash `7679daa4`, +decompressed hash `cfcd36b4`. [ORIGINS.json](ORIGINS.json) pins the full hashes, +Git blobs, commits and original paths for every vendored input. + +## Result and exact boundary + +Let U be the 112 actual distinct rank-1 X entrance frames. X exits share a +common full frame T, while Y exits are distinct rank-8 frames V_i. The source +main is `diag(T,V) Sy(A) diag(U*,I)`, with + + A^2+12A=13I, Aii=0, + A^-1=(A+12I)/13. + +Forward recovery of the original uncoded offer needs entrance +`K=U A^-1 U*` and scalar exit A on X. Raw-dual recovery needs entrance +`bar(U) A^T bar(U)*` and scalar exit `A^(-T)` on X. Helpers are untouched. +The full-exit scalar maps have zero recursive Gaussian grade, with finite +ordinary arithmetic and storage still charged. + +All 5824 supported off-diagonal transports `U_i U_j*` have actual Fourier +grade 2. Consequently `pi2(K)=U A U*/13` is invertible. The self-contained +[proof](PROOF.md) gives the one-bank rank obstruction over the full +phase-quotiented finite Clifford algebra, including rectangular free +monomial controls, clean buffers and a free identity bypass. It uses +sufficiently-large-width tensor faithfulness, not a width-1 matrix argument. +The scaled dyadic matrix 13K has the same grade requirement; denominator 13 +is not used as a universal obstruction. + +The naive decode/mix/restore route has two banks of 112 H1. One rank-2 bank +requires 112 H2. Even granting an unrealized target `224 H17+2H`, where every +one of 816 inherited helper jobs is retained once, the funded-C margins are: + +| Added recursive bill | Exact outward margin at C=.0030217758 | +|---|---:| +| None; endpoint unproved |`[166.262158203082210620506138658847,166.262158203082210620506138658848]`| +|112 H1; not an implementation of K |`[54.262158203082210620506138658847,54.262158203082210620506138658848]`| +|224 H1; naive recursive bill |`[-57.737841796917789379493861341153,-57.737841796917789379493861341152]`| +|112 H2; necessary in the one-bank model |`[-57.269156882594712940928576503039,-57.269156882594712940928576503038]`| + +Exact rational intervals, the upper-C endpoint and monotonic sign arguments +are in [RESULT.json](RESULT.json). These are complete stated recursive +relaxations; finite scalar/precision/stock/outer costs are not admitted. + +## Reproduce + +Python 3.12 or later, standard library only, from repository root: + +```sh +python3 -I -W error -B research/coded-port-adapter-ceiling/verify.py +python3 -I -O -W error -B research/coded-port-adapter-ceiling/verify.py +python3 -B scripts/research_package.py --package research/coded-port-adapter-ceiling +``` + +Direct checks are read-only and Git-free after export. They authenticate the +vendored bytes before executing the exact Clifford or interval libraries, +verify the code inverse and all 5824 actual supported grades, recount the +changed Gaussian/precompensation profiles, recompute price intervals, and +reject semantic corruptions of grade, diagonal and matrix inverse/polynomial. +No producer 632 replay, Lean, native amplitude campaign, compiler or outer +replay is part of this package. [VALIDATION.md](VALIDATION.md) records actual +runs; [BUDGET.md](BUDGET.md) separates proved costs from open admission. + +## Scope and overlap + +This is a changed `supplier-boundary-audit` task, assigned specifically to +#4929 after the catalogue was written. #4929 supplies the producer and code; +we supply its physical adapter and a one-parallel-bank ceiling. #4694/#4698 +supply the centre-free/coupled antecedents. #4712's dirty-helper and 120-head +query failures remain relevant; code rank-8 does not grant eight query heads. +#4920/#4928 have different two-FULL projection models and do not certify +this new coded caller. No repetitive seed or family search was run. + +The theorem excludes multiple chronological banks, native absorption, +prefix access, approximate/border endpoints, noncolumnwise address grammar, +extra nonmonomial operations and direct coded consumers. It makes no claim +that a useful producer cannot exploit the code in another way. + +## Open next questions + +The priority question is a **collective coded three-original-bank consumer** +using one distinct original helper owner through both calls. Across 112 ports +the optimistic target is `336 H17+2H-224 H9` on 928 owners. It has a positive +raw relaxation, but its third H17 endpoint is unproved. The known #4698 +pattern gives H16 on that third bank and loses even with free embedding. +Aii=0 and cross-port unequal headers prevent importing that one-port word. + +The smallest useful step is an exact noncommutative, source-bound bypass or +other operator identity producing the missing third central factor while +preserving every arbitrary original input and all 592 unselected helper +jobs. It must include A and all native/header conjugations, and price any +extra query. Another 112 H1 already exceeds the optimistic allowance. Root's +ongoing prefix/consumer work owns this constructive question; no successful +bypass is claimed here. + +A second question is whether the actual frozen 18-FULL caller can amortize +code boundaries through a literal chronological cancellation. Test one pinned +interstage boundary with its physical normalizers before expansion; do not +commute A through port-dependent Q or D by assumption. The full replacement +would have paid delta `-144H8+K_added` only after its original endpoint and +all added bills are independently established. + +## Credit + +Credit Dugongue #4929, Cinna Davis/1337isnot1337 #4694/#4698, Cao Yifan/intqwq +#4610, zxv's exact higher-moment/Clifford/compiler work, Jacob Alan Sussman's +mixed-target lineage and every retained upstream contributor. The parent +agent derived the one-bank rank argument and exact price screen; the +source/interface agent independently bound the actual headers, all supported +grades and raw-dual adapters. Prepared for Chris R/Clear1nsight with substantial +OpenAI Codex assistance. Apache-2.0; [ATTRIBUTION.md](ATTRIBUTION.md) and the +retained source notices distinguish source authorship, local checks and +unclaimed independent human/formal-kernel acceptance. diff --git a/research/coded-port-adapter-ceiling/RESULT.json b/research/coded-port-adapter-ceiling/RESULT.json new file mode 100644 index 0000000000..f0b0d217b3 --- /dev/null +++ b/research/coded-port-adapter-ceiling/RESULT.json @@ -0,0 +1,282 @@ +{ + "A_dimension": 112, + "A_entries": { + "-1/2": 3920, + "0": 6720, + "1/2": 1904 + }, + "allwidth_claim_basis": "Written phase-quotient/projective tensor-separation proof", + "compiler_or_outer_replayed": false, + "consumer_constructed": false, + "forward_adapter": "K=U A^-1 U*; scalar exit A on common-full X", + "future_tariff_models": { + "third_bank_H16_template_grant": { + "coded_endpoint_constructed": false, + "owners": 928, + "paid": { + "1": 4402, + "2": 824, + "3": 1020, + "4": 254, + "5": 80 + }, + "target": { + "4": 56, + "7": 14, + "8": 94, + "9": 428, + "16": 112, + "17": 224 + }, + "values": { + ".0030217758": { + "exact_rational": [ + "-5820817128157704048229259285020842680156457993441794755911/98079714615416886934934209737619787751599303819750539264", + "-186266148101046529543336297120666965765006655790137429609321/3138550867693340381917894711603833208051177722232017256448" + ], + "lower": "-59.347818771515322459898771652882", + "upper": "-59.347818771515322459898771652881" + }, + ".0034": { + "exact_rational": [ + "-104730486416304180845617753365716725638127696899552595341479/1569275433846670190958947355801916604025588861116008628224", + "-104730486416304180845617753365716725638127696899552594065369/1569275433846670190958947355801916604025588861116008628224" + ], + "lower": "-66.738116303512544168326599787459", + "upper": "-66.738116303512544168326599787458" + } + } + }, + "unproved_three_H17_banks": { + "coded_endpoint_constructed": false, + "owners": 928, + "paid": { + "1": 4402, + "2": 824, + "3": 1020, + "4": 254, + "5": 80 + }, + "target": { + "4": 56, + "7": 14, + "8": 94, + "9": 428, + "17": 336 + }, + "values": { + ".0030217758": { + "exact_rational": [ + "2519270136759966497027304826184492165879926351463597854273/49039857307708443467467104868809893875799651909875269632", + "161233288752637855809747508875807498616315286493670265265623/3138550867693340381917894711603833208051177722232017256448" + ], + "lower": "51.371889623422072846206993322684", + "upper": "51.371889623422072846206993322685" + }, + ".0034": { + "exact_rational": [ + "68769267469906746020228302007538338460748418777805068658769/1569275433846670190958947355801916604025588861116008628224", + "68769267469906746020228302007538338460748418777805069949215/1569275433846670190958947355801916604025588861116008628224" + ], + "lower": "43.822305496325007630061764635295", + "upper": "43.822305496325007630061764635296" + } + } + } + }, + "helper_profile": { + "4": 28, + "7": 7, + "8": 47, + "9": 326 + }, + "native_invoice": { + "backward": { + "additional_ADDs": 6596, + "events": 28045, + "paid": { + "1": 2201, + "2": 412, + "3": 510, + "4": 127, + "5": 40 + }, + "precomp_scalar_allowance": 32652 + }, + "forward": { + "additional_ADDs": 6596, + "events": 28045, + "paid": { + "1": 2201, + "2": 412, + "3": 510, + "4": 127, + "5": 40 + }, + "precomp_scalar_allowance": 32652 + } + }, + "new_kappa": null, + "one_parallel_bank_grade2_channels_at_least": 112, + "producer_632_endpoint_replayed": false, + "producer_head": "361f5d4100640177d6a983dd2f336021c75bfd5e", + "raw_dual_adapter": "barU A^T barU*; scalar exit A^(-T) on conjugate-full X", + "semantic_controls": [ + "nonzero_code_diagonal", + "wrong_code_inverse", + "supported_transport_grade_zero", + "wrong_code_polynomial" + ], + "source_compressed_sha256": "7679daa4ec6a40f56fc7f0202379a6f454310e94945aba4f48beaaaafb838d05", + "source_payload_sha256": "cfcd36b40326d7a5815e1db5313444379b3fb756b27d5201c561574c085cc0dd", + "status": "PASS_CODED_PORT_ADAPTER_CEILING", + "supported_pair_grades": { + "2": 5824 + }, + "tariff_models": { + "after112H1": { + "endpoint_constructed": false, + "interval_reason": "M(t)/5^t strictly increasing; sign at proper endpoint", + "paid": { + "1": 4514, + "2": 824, + "3": 1020, + "4": 254, + "5": 80 + }, + "target": { + "4": 56, + "7": 14, + "8": 94, + "9": 652, + "17": 224 + }, + "values": { + ".0030217758": { + "exact_rational": [ + "2661008495487452807929381137614221411484354910855048185955/49039857307708443467467104868809893875799651909875269632", + "170304543711196979707480392807310170334998714294723086565343/3138550867693340381917894711603833208051177722232017256448" + ], + "lower": "54.262158203082210620506138658847", + "upper": "54.262158203082210620506138658848" + }, + ".0034": { + "exact_rational": [ + "73867048559498031136966448103101234781205095934776482776101/1569275433846670190958947355801916604025588861116008628224", + "73867048559498031136966448103101234781205095934776484089983/1569275433846670190958947355801916604025588861116008628224" + ], + "lower": "47.070799023745749761534310198754", + "upper": "47.070799023745749761534310198755" + } + } + }, + "after112H2": { + "endpoint_constructed": false, + "interval_reason": "M(t)/5^t strictly increasing; sign at proper endpoint", + "paid": { + "1": 4402, + "2": 936, + "3": 1020, + "4": 254, + "5": 80 + }, + "target": { + "4": 56, + "7": 14, + "8": 94, + "9": 652, + "17": 224 + }, + "values": { + ".0030217758": { + "exact_rational": [ + "-22467770253241709076932693793535120762438235583214728056543/392318858461667547739736838950479151006397215279002157056", + "-179742162025933672615461550348280966099505884665717821777313/3138550867693340381917894711603833208051177722232017256448" + ], + "lower": "-57.269156882594712940928576503039", + "upper": "-57.269156882594712940928576503038" + }, + ".0034": { + "exact_rational": [ + "-101064353533610664042208804357194708800575113978133491274959/1569275433846670190958947355801916604025588861116008628224", + "-101064353533610664042208804357194708800575113978133489955645/1569275433846670190958947355801916604025588861116008628224" + ], + "lower": "-64.401921647290247704383966403396", + "upper": "-64.401921647290247704383966403395" + } + } + }, + "after224H1": { + "endpoint_constructed": false, + "interval_reason": "M(t)/5^t strictly increasing; sign at proper endpoint", + "paid": { + "1": 4626, + "2": 824, + "3": 1020, + "4": 254, + "5": 80 + }, + "target": { + "4": 56, + "7": 14, + "8": 94, + "9": 652, + "17": 224 + }, + "values": { + ".0030217758": { + "exact_rational": [ + "-2831455522975892860426934607692486702605206103050982012829/49039857307708443467467104868809893875799651909875269632", + "-181213153470457143067323814892319148966733190595262846156833/3138550867693340381917894711603833208051177722232017256448" + ], + "lower": "-57.737841796917789379493861341153", + "upper": "-57.737841796917789379493861341152" + }, + ".0034": { + "exact_rational": [ + "-101891800031329030250435655746713424869660856510216483584987/1569275433846670190958947355801916604025588861116008628224", + "-101891800031329030250435655746713424869660856510216482271105/1569275433846670190958947355801916604025588861116008628224" + ], + "lower": "-64.929200976254250238465689801246", + "upper": "-64.929200976254250238465689801245" + } + } + }, + "unrealized_two_bank": { + "endpoint_constructed": false, + "interval_reason": "M(t)/5^t strictly increasing; sign at proper endpoint", + "paid": { + "1": 4402, + "2": 824, + "3": 1020, + "4": 254, + "5": 80 + }, + "target": { + "4": 56, + "7": 14, + "8": 94, + "9": 652, + "17": 224 + }, + "values": { + ".0030217758": { + "exact_rational": [ + "8153472513950798476285696882920929525573915924761078384739/49039857307708443467467104868809893875799651909875269632", + "521822240892851102482284600506939489636730619184709019287519/3138550867693340381917894711603833208051177722232017256448" + ], + "lower": "166.262158203082210620506138658847", + "upper": "166.262158203082210620506138658848" + }, + ".0034": { + "exact_rational": [ + "249625897150325092524368551952915894432071048379769449137189/1569275433846670190958947355801916604025588861116008628224", + "249625897150325092524368551952915894432071048379769450451071/1569275433846670190958947355801916604025588861116008628224" + ], + "lower": "159.070799023745749761534310198754", + "upper": "159.070799023745749761534310198755" + } + } + } + } +} diff --git a/research/coded-port-adapter-ceiling/SCIENCE.json b/research/coded-port-adapter-ceiling/SCIENCE.json new file mode 100644 index 0000000000..5ffb000d58 --- /dev/null +++ b/research/coded-port-adapter-ceiling/SCIENCE.json @@ -0,0 +1,90 @@ +{ + "schema_version": 1, + "scope": "Exact science/source byte integrity; no theorem-kernel acceptance implied", + "files": [ + { + "path": "PROOF.md", + "sha256": "f7b86b69d60219b3b251d842694861d1fb6efff0e4c3c885d267468b29846c13" + }, + { + "path": "check_core.py", + "sha256": "13e28bbee4905c7a3bc2e5912d8a0e1cd536c3088fed5ca14851d91a6546f8b5" + }, + { + "path": "verify.py", + "sha256": "9ca7798d09eff83ef0885e434819bfc10ee945edd8c6d446a93a362edfc4185e" + }, + { + "path": "RESULT.json", + "sha256": "bf5c0b9b34c4e5af66d3163942dbb8f6559fe669bbe8296673667a0c69f4425b" + }, + { + "path": "ORIGINS.json", + "sha256": "7e6f6ca01ce9830f212ce623e7d92b3e0e1ee486c825f2780f82a4ebf26f3af4" + }, + { + "path": "README.md", + "sha256": "916c5abc87d070148b2704bff0d5bacfc3019e00473e09769d950f8a4d3a25eb" + }, + { + "path": "BUDGET.md", + "sha256": "2ba482838164b6bb6c4b6cbd97064cfc804b7e1b5b5e88c0b776b7c0650d710d" + }, + { + "path": "ATTRIBUTION.md", + "sha256": "502f40c47b05c706439a3ef14d319b1bbc02937f09d51158f2c083e76e7fd7c6" + }, + { + "path": "NOTICE", + "sha256": "44793a86f7b3fc98d256d75f1f20622d79d4ab3f06dd0ad13b28a13bd23d6e87" + }, + { + "path": "LICENSE", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + { + "path": "source/ACTUAL-WORD.json.gz", + "sha256": "7679daa4ec6a40f56fc7f0202379a6f454310e94945aba4f48beaaaafb838d05" + }, + { + "path": "source/ATTRIBUTION-4929.md", + "sha256": "7cdaf8b754a14b6bd54beb4d7d5336e36f782e2b59e6b06f286bdd8ad7126a00" + }, + { + "path": "source/CODE.json", + "sha256": "8be7f3f073b7981ec91c6af43edff0ac8a89f4824ef6026ae758c287dd6c03d0" + }, + { + "path": "source/CODED-PROOF-4929.md", + "sha256": "acd904af677718da8cdaf81d205d29866a6855efd393047e7128320a46753b01" + }, + { + "path": "source/CODED-WORDS.json.gz", + "sha256": "797bad53122f84aa0f05b602f2bdceb6b50f95a64023799d4f24560d9c61aad6" + }, + { + "path": "source/EXPECTED-4929.json", + "sha256": "e147122a93e3c2c5f78af42b631e1fb9410178987b9cc4ca6b5c63a5cb9dccc8" + }, + { + "path": "source/NOTICE-4929", + "sha256": "0de30db3221dafd34a82e3347a478a73d8338edef051c054ce6f8cf404f91154" + }, + { + "path": "source/clifford_exact.py", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + }, + { + "path": "source/intervals.py", + "sha256": "0ce7e7137422d5ffeda22085c81fa88471bbe963100fdad62e659f1e3bf89326" + }, + { + "path": "VALIDATION.md", + "sha256": "9192fb949ebb97fa0906b3b4c500b1d49d4870bf0f0380310b212c990ca7d315" + }, + { + "path": ".gitattributes", + "sha256": "5697f0950578ef3c02fdb2a424480e5795ba7e0cc3516aeae93b0bdf982b1f74" + } + ] +} diff --git a/research/coded-port-adapter-ceiling/SOURCE-CHECK.json b/research/coded-port-adapter-ceiling/SOURCE-CHECK.json new file mode 100644 index 0000000000..84c419afb6 --- /dev/null +++ b/research/coded-port-adapter-ceiling/SOURCE-CHECK.json @@ -0,0 +1,82 @@ +{ + "checked_at_utc": "2026-10-23T01:50:43.707601+00:00", + "status": "PASS_EXACT_GIT_SOURCE_BYTES", + "upstream_main_seen": "624de9dc66858af0945e5f8a0942488d62280d43", + "upstream_pr_ref_seen": "361f5d4100640177d6a983dd2f336021c75bfd5e", + "public_ref_read_command": "git ls-remote https://github.com/CrocSwap/integer-mult-bounds.git refs/heads/main refs/pull/4929/head", + "note": "Public reachability and source-byte equality do not imply scientific admission; source ancestry is checked separately before publication.", + "sources": [ + { + "path": "source/ACTUAL-WORD.json.gz", + "source_commit": "624de9dc66858af0945e5f8a0942488d62280d43", + "source_path": "research/kappa-round3-warp-20261022/ACTUAL-WORD.json.gz", + "sha256": "7679daa4ec6a40f56fc7f0202379a6f454310e94945aba4f48beaaaafb838d05", + "git_blob": "46d929df83817b85a5387bcdb9745e0627d6366e", + "source_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/624de9dc66858af0945e5f8a0942488d62280d43/research/kappa-round3-warp-20261022/ACTUAL-WORD.json.gz" + }, + { + "path": "source/clifford_exact.py", + "source_commit": "624de9dc66858af0945e5f8a0942488d62280d43", + "source_path": "research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2", + "source_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/624de9dc66858af0945e5f8a0942488d62280d43/research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py" + }, + { + "path": "source/intervals.py", + "source_commit": "624de9dc66858af0945e5f8a0942488d62280d43", + "source_path": "research/higher-moment-strictification/verify.py", + "sha256": "0ce7e7137422d5ffeda22085c81fa88471bbe963100fdad62e659f1e3bf89326", + "git_blob": "4b24a5096154736ce060474eb8c72dc64c303699", + "source_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/624de9dc66858af0945e5f8a0942488d62280d43/research/higher-moment-strictification/verify.py" + }, + { + "path": "source/CODE.json", + "source_commit": "361f5d4100640177d6a983dd2f336021c75bfd5e", + "source_path": "research/native-center-free-code/CODE.json", + "sha256": "8be7f3f073b7981ec91c6af43edff0ac8a89f4824ef6026ae758c287dd6c03d0", + "git_blob": "03170f4a31f7a8a3db7228f1cd5a6fdcb32720ae", + "source_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/361f5d4100640177d6a983dd2f336021c75bfd5e/research/native-center-free-code/CODE.json" + }, + { + "path": "source/CODED-WORDS.json.gz", + "source_commit": "361f5d4100640177d6a983dd2f336021c75bfd5e", + "source_path": "research/native-center-free-code/CODED-WORDS.json.gz", + "sha256": "797bad53122f84aa0f05b602f2bdceb6b50f95a64023799d4f24560d9c61aad6", + "git_blob": "935fedd9c9a77f870dd6afbabbf56c8ea6e321d4", + "source_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/361f5d4100640177d6a983dd2f336021c75bfd5e/research/native-center-free-code/CODED-WORDS.json.gz" + }, + { + "path": "source/EXPECTED-4929.json", + "source_commit": "361f5d4100640177d6a983dd2f336021c75bfd5e", + "source_path": "research/native-center-free-code/EXPECTED.json", + "sha256": "e147122a93e3c2c5f78af42b631e1fb9410178987b9cc4ca6b5c63a5cb9dccc8", + "git_blob": "b02b5ebb8b7482bf733744507095e37045c0ff83", + "source_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/361f5d4100640177d6a983dd2f336021c75bfd5e/research/native-center-free-code/EXPECTED.json" + }, + { + "path": "source/CODED-PROOF-4929.md", + "source_commit": "361f5d4100640177d6a983dd2f336021c75bfd5e", + "source_path": "research/native-center-free-code/CODED-PROOF.md", + "sha256": "acd904af677718da8cdaf81d205d29866a6855efd393047e7128320a46753b01", + "git_blob": "1f28d33884ec99b34f8366d022d8f7b9b7653ae2", + "source_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/361f5d4100640177d6a983dd2f336021c75bfd5e/research/native-center-free-code/CODED-PROOF.md" + }, + { + "path": "source/ATTRIBUTION-4929.md", + "source_commit": "361f5d4100640177d6a983dd2f336021c75bfd5e", + "source_path": "research/native-center-free-code/ATTRIBUTION.md", + "sha256": "7cdaf8b754a14b6bd54beb4d7d5336e36f782e2b59e6b06f286bdd8ad7126a00", + "git_blob": "5f6cd0d364caa8e36aa6b933dca3d75ced917831", + "source_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/361f5d4100640177d6a983dd2f336021c75bfd5e/research/native-center-free-code/ATTRIBUTION.md" + }, + { + "path": "source/NOTICE-4929", + "source_commit": "361f5d4100640177d6a983dd2f336021c75bfd5e", + "source_path": "research/native-center-free-code/NOTICE", + "sha256": "0de30db3221dafd34a82e3347a478a73d8338edef051c054ce6f8cf404f91154", + "git_blob": "42501d0a9910107bdc8405660b0c93b80b9e6cd9", + "source_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/361f5d4100640177d6a983dd2f336021c75bfd5e/research/native-center-free-code/NOTICE" + } + ] +} diff --git a/research/coded-port-adapter-ceiling/SOURCES.json b/research/coded-port-adapter-ceiling/SOURCES.json new file mode 100644 index 0000000000..160d7c4c9c --- /dev/null +++ b/research/coded-port-adapter-ceiling/SOURCES.json @@ -0,0 +1,74 @@ +{ + "schema_version": 1, + "base_commit": "cef4b52f2a59009865bf8eabde1be3f159063703", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "c35482cd9035843b15a634cc8276a7e1e40e8395", + "sha256": "6fe0a099b89aa2aed796a13c3a21dafc63f3388ebf397464e44e0451893b9375" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "f126dd2e2dad2b669e75d1d0d0bd05c600725602", + "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72" + }, + { + "path": "research/kappa-round3-warp-20261022/ACTUAL-WORD.json.gz", + "usage": "provenance", + "pin": "head:624de9dc66858af0945e5f8a0942488d62280d43:research/kappa-round3-warp-20261022/ACTUAL-WORD.json.gz", + "git_blob": "46d929df83817b85a5387bcdb9745e0627d6366e", + "sha256": "7679daa4ec6a40f56fc7f0202379a6f454310e94945aba4f48beaaaafb838d05" + }, + { + "path": "research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py", + "usage": "provenance", + "pin": "head:624de9dc66858af0945e5f8a0942488d62280d43:research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py", + "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + }, + { + "path": "research/higher-moment-strictification/verify.py", + "usage": "provenance", + "pin": "head:624de9dc66858af0945e5f8a0942488d62280d43:research/higher-moment-strictification/verify.py", + "git_blob": "4b24a5096154736ce060474eb8c72dc64c303699", + "sha256": "0ce7e7137422d5ffeda22085c81fa88471bbe963100fdad62e659f1e3bf89326" + }, + { + "path": "research/native-center-free-code/CODE.json", + "usage": "provenance", + "pin": "head:361f5d4100640177d6a983dd2f336021c75bfd5e:research/native-center-free-code/CODE.json", + "git_blob": "03170f4a31f7a8a3db7228f1cd5a6fdcb32720ae", + "sha256": "8be7f3f073b7981ec91c6af43edff0ac8a89f4824ef6026ae758c287dd6c03d0" + }, + { + "path": "research/native-center-free-code/CODED-WORDS.json.gz", + "usage": "provenance", + "pin": "head:361f5d4100640177d6a983dd2f336021c75bfd5e:research/native-center-free-code/CODED-WORDS.json.gz", + "git_blob": "935fedd9c9a77f870dd6afbabbf56c8ea6e321d4", + "sha256": "797bad53122f84aa0f05b602f2bdceb6b50f95a64023799d4f24560d9c61aad6" + }, + { + "path": "research/native-center-free-code/EXPECTED.json", + "usage": "provenance", + "pin": "head:361f5d4100640177d6a983dd2f336021c75bfd5e:research/native-center-free-code/EXPECTED.json", + "git_blob": "b02b5ebb8b7482bf733744507095e37045c0ff83", + "sha256": "e147122a93e3c2c5f78af42b631e1fb9410178987b9cc4ca6b5c63a5cb9dccc8" + }, + { + "path": "research/native-center-free-code/CODED-PROOF.md", + "usage": "provenance", + "pin": "head:361f5d4100640177d6a983dd2f336021c75bfd5e:research/native-center-free-code/CODED-PROOF.md", + "git_blob": "1f28d33884ec99b34f8366d022d8f7b9b7653ae2", + "sha256": "acd904af677718da8cdaf81d205d29866a6855efd393047e7128320a46753b01" + }, + { + "path": "research/native-center-free-code/ATTRIBUTION.md", + "usage": "provenance", + "pin": "head:361f5d4100640177d6a983dd2f336021c75bfd5e:research/native-center-free-code/ATTRIBUTION.md", + "git_blob": "5f6cd0d364caa8e36aa6b933dca3d75ced917831", + "sha256": "7cdaf8b754a14b6bd54beb4d7d5336e36f782e2b59e6b06f286bdd8ad7126a00" + } + ] +} diff --git a/research/coded-port-adapter-ceiling/TASK.json b/research/coded-port-adapter-ceiling/TASK.json new file mode 100644 index 0000000000..e09c97de68 --- /dev/null +++ b/research/coded-port-adapter-ceiling/TASK.json @@ -0,0 +1,96 @@ +{ + "schema_version": 1, + "task_id": "supplier-boundary-audit", + "priority_revision": 7, + "base_commit": "cef4b52f2a59009865bf8eabde1be3f159063703", + "original_card": { + "id": "supplier-boundary-audit", + "question": "Can the #4088 four-provider dispatch satisfy the complete ordinary/outer admission contract?", + "starting_points": [ + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "research/staged544-mixed-fourth-entry/README.md", + "research/scatter-boundary-decision/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 #4088 Scope and Open next questions: local words, native receipts and literal fill do not include a rerun of the mixed four-provider ordinary/outer engine. #3801 is the newer scatter-boundary decision; do not restart #2977 as if untouched.", + "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately." + }, + "first_experiment": "Pin the provider registry, four native source closures and dispatch. Make a bounded acceptance coverage map or one registry adapter preserving every inherited admission predicate and rejection control (including an omitted fourth provider). Record remaining ordinary/outer obligations and a resource estimate before heavy execution. Stop at unresolved source/caller dependencies; no selected-result promotion from a local pass.", + "bottleneck_link": "Closing a current acceptance gap or proof obligation strengthens reliability even without changing kappa.", + "allowed_variations": [ + "One provider-registry, dispatch, native-closure or admission-predicate obligation; separate branches must name distinct coverage." + ], + "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.", + "Running another root enclosure instead of validating dispatch or weakening an inherited predicate to make mixed admission pass." + ], + "overlap_terms": [ + "owner boundary", + "bridge omission", + "hosting", + "2977", + "scatter export", + "duplicate index", + "parity semantics", + "4088", + "3801", + "staged544-mixed-fourth-entry", + "scatter-boundary-decision" + ], + "existing_checks": [ + { + "scope": "PR #4088: author-checked local words, native receipts, owner/phase fill and exact moment.", + "evidence": "research/staged544-mixed-fourth-entry/README.md", + "remaining": "Rebind and validate ordinary/outer admission with all four providers; full mixed release not established.", + "status": "author-checked", + "source_commit": "72d7efc181edb21806a878f174847c96dd410ab0", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #3801: successor scatter-boundary decision package.", + "evidence": "research/scatter-boundary-decision/README.md", + "remaining": "Consult its exact acceptance scope before any new exporter audit; not proof of a selected failure.", + "status": "author-checked", + "source_commit": "911f8800ba7a4b03603ef62c5ffc6240e53cb5fd", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + }, + "scope_status": "changed", + "actual_scope": "Bind the actual coded-port recovery adapters of PR4929 and prove a source-supported one-parallel-bank Fourier-grade ceiling, with complete explicitly unrealized recursive tariff screens.", + "scope_change_reason": "Explicit parent/user assignment replaces the older #4088 four-provider admission card with one new native coded supplier. The code changes the cross-transfer, so source-compatible recovery and a complete adapter bill are the current gate.", + "bottleneck_link": "Removing eight owned-centre children helps only if a caller uses the changed port code without repaying the saving in heterogeneous-chart Gaussian adapters.", + "budget_minutes": 60, + "stop_rule": "Check only the actual112-port code and supported5824 entrance transports. Stop the standalone one-bank policy if its rank2 resource lower bound exceeds the optimistic complete allowance. No family, seed, native-controller or whole-compiler search.", + "outcome": "negative-result", + "evidence": "PROOF.md supplies the all-width phase-quotient rank argument. RESULT.json/verify.py bind actual source charts, code inverse, all5824 supported grades, fixed precompensation and exact rational price intervals. The producer632 endpoint and all future caller targets remain separately inherited or unproved.", + "author": "Chris R / Clear1nsight, with substantial OpenAI Codex assistance", + "ai_assistance": "Substantial OpenAI Codex gpt-6.1-sol/high assistance. Parent derived the one-bank rank argument/price screen; source/interface agent derived the physical raw-dual/forward adapters and independently checked actual grades.", + "open_questions": [ + { + "question": "Can a collective coded three-original-bank consumer realize224mainH17 plus112selectedhelperH17 while preserving the other592 original helper jobs?", + "why_it_matters": "Its928-owner raw relaxation is positive, but the known H16 third-bank pattern already loses. A successful endpoint must supply the missing central factor through actual noncommuting native operations.", + "first_step": "Derive one literal noncommutative all-input bypass/cancellation identity including the actual cross-port A and all port/header conjugations before any family search.", + "blocked_by": "Aii=0, heterogeneous headers, unproved thirdH17 endpoint, source-access and restoration bills; another112H1 exceeds the optimistic margin." + }, + { + "question": "Can the actual18-FULL/15-query caller amortize code boundaries through a chronological cancellation?", + "why_it_matters": "A restored complete caller could change paid profile by-144H8+K_added rather than independently paying an adapter at every source invocation.", + "first_step": "Pin one actual interstage boundary and evaluate the code/header/normalizer products with exact phase; stop if it already repays the saving.", + "blocked_by": "No A commutation with source Q/D maps, no complete endpoint, no finite scalar/precision/compiler reserve." + } + ] +} diff --git a/research/coded-port-adapter-ceiling/VALIDATION.md b/research/coded-port-adapter-ceiling/VALIDATION.md new file mode 100644 index 0000000000..dab4349e30 --- /dev/null +++ b/research/coded-port-adapter-ceiling/VALIDATION.md @@ -0,0 +1,45 @@ +# Validation record + +Publication base: `cef4b52f2a59009865bf8eabde1be3f159063703`. +Historical native source: `624de9dc66858af0945e5f8a0942488d62280d43`. +Producer source: `361f5d4100640177d6a983dd2f336021c75bfd5e` (#4929). +Both source commits are raw Git ancestors of the publication base. + +Environment: Ubuntu Linux, CPython 3.12.3, Git 2.55.0, standard library only. +The direct normal and optimized checks each pass in about four seconds. + +```sh +python3 -I -W error -B research/coded-port-adapter-ceiling/verify.py +python3 -I -O -W error -B research/coded-port-adapter-ceiling/verify.py +python3 -B scripts/research_package.py --package research/coded-port-adapter-ceiling --check-only +python3 -B scripts/research_package.py --package research/coded-port-adapter-ceiling +``` + +Expected direct output starts `PASS_CODED_PORT_ADAPTER_CEILING` and records +5,824 supported grade-two pairs, at least 112 grade-two bank channels, +four semantic rejection controls, exact intervals and no new kappa. +The metadata-only check prints `PASS_PACKAGE_METADATA_AND_PINS`; +the registered runner prints `PASS_REGISTERED_RESEARCH_PACKAGE`. +These commands passed locally in both normal and optimized modes. + +The four semantic controls independently reject a nonzero code diagonal, +a wrong inverse entry, replacement of a supported transport by grade zero, +and a sign change violating the exact inverse polynomial. Checks execute +authenticated source bytes directly and authenticate science bytes before +and after the run. They regenerate the scientific result in memory and do +not write or repair frozen artifacts. + +The written all-width phase-quotient/rank argument was derived by the parent +agent and reviewed by the source/interface agent. These related AI-agent +checks are not independent human review or formal-kernel verification. +The source producer's complete 632-input endpoint is inherited from #4929; +it is not freshly replayed by this package. + +Before publication, compare committed bytes and require declared source +ancestry with `scripts/check_research_commit.py --check-source-history`. +Use `scripts/export_research_package.py` to export the committed package, +check its inventory, and run the direct verifier after extraction into a +fresh directory with Git absent from PATH. Operational receipts name the +actual contribution head and export hash; they do not authenticate themselves. +Hosted CI is pending until publication. No complete caller, uniform compiler, +outer recursion, selected frontier, or new kappa is validated here. diff --git a/research/coded-port-adapter-ceiling/VERIFY.json b/research/coded-port-adapter-ceiling/VERIFY.json new file mode 100644 index 0000000000..f4b0d5b4dc --- /dev/null +++ b/research/coded-port-adapter-ceiling/VERIFY.json @@ -0,0 +1,34 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 180, + "checks": "Authenticates vendored source/science bytes; checks actual frame/profile interface, matrix inverse and5824 supported Fourier grades; semantic diagonal/inverse/grade/polynomial corruptions reject; exact interval tariff screens match frozen receipt. Written proof supplies the scoped all-width rank theorem. No producer632, complete caller, compiler or outer replay." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 180, + "checks": "Authenticates vendored source/science bytes; checks actual frame/profile interface, matrix inverse and5824 supported Fourier grades; semantic diagonal/inverse/grade/polynomial corruptions reject; exact interval tariff screens match frozen receipt. Written proof supplies the scoped all-width rank theorem. No producer632, complete caller, compiler or outer replay." + } + ] +} diff --git a/research/coded-port-adapter-ceiling/check_core.py b/research/coded-port-adapter-ceiling/check_core.py new file mode 100644 index 0000000000..8e7a4cddd3 --- /dev/null +++ b/research/coded-port-adapter-ceiling/check_core.py @@ -0,0 +1,223 @@ +"""Exact source interface/grade/moment checks; no producer or caller search. +Apache-2.0; credit in ATTRIBUTION.md. Substantial OpenAI Codex assistance. +""" +from collections import Counter +from fractions import Fraction as Q +from hashlib import sha256, sha1 +from pathlib import Path +import gzip +import json +import sys +import types + + +def need(test, why): + if not test: + raise ValueError(why) + + +def authenticate_sources(here): + origins = json.loads((here / 'ORIGINS.json').read_text()) + raw = {} + for row in origins['files']: + path = here / row['path'] + need(not path.is_symlink(), 'Source is not a symlink') + value = path.read_bytes() + need(sha256(value).hexdigest() == row['sha256'], 'Source SHA256 ' + row['path']) + blob = sha1(b'blob ' + str(len(value)).encode() + b'\0' + value).hexdigest() + need(blob == row['git_blob'], 'Source Git blob ' + row['path']) + raw[path.name] = value + return origins, raw + + +def matrix_code(code): + need(len(code) == 112 and all(len(r) == 112 for r in code), 'Code dimensions') + A = [[Q(x) for x in row] for row in code] + need(all(A[i][i] == 0 for i in range(112)), 'Code zero diagonal') + need(all(A[i][j] == A[j][i] for i in range(112) for j in range(112)), 'Code symmetry') + need(all(x in (Q(0), Q(1, 2), Q(-1, 2)) for row in A for x in row), 'Code dyadic alphabet') + M = [[int(2*x) for x in row] for row in A] + for i in range(112): + for j in range(112): + need(sum(M[i][k]*M[k][j] for k in range(112)) + 24*M[i][j] + == 52*int(i == j), 'Code inverse polynomial A^2+12A=13I') + return A + + +def check_inverse(A, inverse): + # Exact entrywise rational identity; no numerical determinant or eigenvalue. + for i in range(112): + for j in range(112): + need(sum(A[i][k]*inverse[k][j] for k in range(112)) == int(i == j), + 'Explicit code matrix inverse') + + +def grade(op): + # Independent binary row reduction of the physical Z->X tableau block. + pivots = {} + for x, z, phase in op.tab[op.n:]: + while x: + bit = x.bit_length()-1 + if bit not in pivots: + pivots[bit] = x + break + x ^= pivots[bit] + return len(pivots) + + +def supported_grades(A, U): + result = Counter() + for i in range(112): + for j in range(112): + if A[i][j]: + # then is chronological: this matrix is U_i U_j^*. + r = grade(U[j].adjoint().then(U[i])) + need(r == 2, 'Supported entrance transport has grade two') + result[r] += 1 + need(result == Counter({2: 5824}), 'Complete supported-pair census') + return result + + +def reject(name, action, message): + try: + action() + except ValueError as error: + need(message in str(error), 'Mutation rejected at intended gate: ' + name) + return name + raise ValueError('Mutation not rejected: ' + name) + + +def outward(value, digits=30): + scale = 10**digits + def dec(n): + s = str(abs(n)).rjust(digits+1, '0') + return ('-' if n < 0 else '') + s[:-digits] + '.' + s[-digits:] + lo = (value[0]*scale).__floor__() + hi = -((-value[1]*scale).__floor__()) + return {'lower': dec(lo), 'upper': dec(hi), + 'exact_rational': [str(value[0]), str(value[1])]} + + +def price(moment, T, P, C): + a, b = moment(dict(T), 1-C), moment(dict(P), 1-C) + return a[0]-b[1], a[1]-b[0] + + +def run(here): + origins, raw = authenticate_sources(here) + source = json.loads(gzip.decompress(raw['ACTUAL-WORD.json.gz'])) + coded = json.loads(gzip.decompress(raw['CODED-WORDS.json.gz'])) + c, cc = source['canonical'], coded['canonical'] + need(sha256(raw['ACTUAL-WORD.json.gz']).hexdigest() + == '7679daa4ec6a40f56fc7f0202379a6f454310e94945aba4f48beaaaafb838d05', 'Actual compressed source') + need(sha256(gzip.decompress(raw['ACTUAL-WORD.json.gz'])).hexdigest() + == 'cfcd36b40326d7a5815e1db5313444379b3fb756b27d5201c561574c085cc0dd', 'Same decompressed source') + for key, value in c.items(): + if key != 'local_profile': + need(cc[key] == value, 'Original native frames/maps/owners retained') + frames = c['frames'] + need(len({c['start'][i] for i in range(112)}) == 112, '112 distinct X entrance charts') + need(all(len(frames[c['start'][i]]) == 1 and c['final'][i] == 1 + for i in range(112)), 'Rank-one X entrances / common full exit') + need(all(c['start'][i] == 0 and len(frames[c['final'][i]]) == 8 + for i in range(112, 224)), 'Ground Y entrances / rank-eight exits') + H = Counter(len(frames[c['final'][i]]) - len(frames[c['start'][i]]) + for i in range(224, 632)) + need(H == Counter({4: 28, 7: 7, 8: 47, 9: 326}), 'Every independent helper once') + P = Counter({1: 2201, 2: 412, 3: 510, 4: 127, 5: 40}) + invoice = {} + for direction in ('forward', 'backward'): + old, new = source['programs'][direction], coded['programs'][direction] + oldP = Counter(e[5] for e in old if e[0] == 'climb') + oldP.update(e[4] for e in old if e[0] == 'center') + newP = Counter(e[5] for e in new if e[0] == 'climb') + newP.update(e[4] for e in new if e[0] == 'center') + need(newP == P and oldP == P+Counter({8: 8}), 'Literal removed eight H8') + need(len(new)-len(old) == 6596, 'Literal fixed precompensation length') + allowance = 0 + for e in new[:6596]: + need(e[0] == 'scalar' and e[1][0] == 'add' and e[2] == 0, + 'Ground dyadic ADD precompensation') + a, b = e[1][1:3] + need(a[0] == b[0] == 'L' and c['start'][a[1]] == c['start'][b[1]] == 0, + 'Actual source and target common ground chart') + q = Q(e[1][3], e[1][4]) + need(abs(q.numerator) <= 4 and q.denominator <= 4, 'Dyadic coefficient bounds') + allowance += (3 + abs(q.numerator).bit_length()-1 + + abs(q.numerator).bit_count() + q.denominator.bit_length()-1) + need(allowance == 32652, 'Finite precompensation scalar allowance') + invoice[direction] = {'paid': dict(newP), 'events': len(new), + 'additional_ADDs': 6596, 'precomp_scalar_allowance': allowance} + ce = types.ModuleType('coded_port_pinned_clifford') + sys.modules[ce.__name__] = ce + exec(compile(raw['clifford_exact.py'], 'source/clifford_exact.py', 'exec'), ce.__dict__) + U = [ce.canonical_frame(9, frames[c['start'][i]]) for i in range(112)] + A = matrix_code(json.loads(raw['CODE.json'])['A']) + inverse = [[(A[i][j]+12*int(i == j))/13 for j in range(112)] for i in range(112)] + check_inverse(A, inverse) + grades = supported_grades(A, U) + controls = [] + badA = [row[:] for row in A] + badA[0][0] = Q(1, 2) + controls.append(reject('nonzero_code_diagonal', lambda: matrix_code(badA), 'Code zero diagonal')) + bad_inverse = [row[:] for row in inverse] + j = next(j for j in range(112) if A[0][j]) + bad_inverse[j][0] += Q(1, 13) + controls.append(reject('wrong_code_inverse', lambda: check_inverse(A, bad_inverse), 'Explicit code matrix inverse')) + badU = U[:] + badU[j] = U[0] + controls.append(reject('supported_transport_grade_zero', lambda: supported_grades(A, badU), 'Supported entrance transport has grade two')) + bad_poly = [row[:] for row in A] + bad_poly[0][j] *= -1 + bad_poly[j][0] *= -1 + controls.append(reject('wrong_code_polynomial', lambda: matrix_code(bad_poly), 'Code inverse polynomial')) + env = {'__name__': 'coded_port_pinned_intervals', '__file__': str(here/'source/intervals.py')} + exec(compile(raw['intervals.py'], 'source/intervals.py', 'exec'), env) + paid = Counter({r: 2*n for r, n in P.items()}) + target = Counter({r: 2*n for r, n in H.items()}) + target[17] = 224 + models = {} + for label, extra in [('unrealized_two_bank', {}), ('after112H1', {1: 112}), + ('after224H1', {1: 224}), ('after112H2', {2: 112})]: + cost = paid+Counter(extra) + coefficient = {r: target.get(r, 0)-cost.get(r, 0) for r in target.keys() | cost.keys() + if target.get(r, 0) != cost.get(r, 0)} + need(all((n < 0 and r <= 5) or (n > 0 and r >= 7) + for r, n in coefficient.items()), 'Moment sign separation at five') + values = {} + for cs in ('.0030217758', '.0034'): + value = price(env['moment'], target, cost, Q(cs)) + need(value[1] < 0 if label in ('after224H1', 'after112H2') else value[0] > 0, + 'Optimistic tariff model sign ' + label) + values[cs] = outward(value) + models[label] = {'target': dict(target), 'paid': dict(cost), 'values': values, + 'interval_reason': 'M(t)/5^t strictly increasing; sign at proper endpoint', + 'endpoint_constructed': False} + future = Counter(target) + future[17] += 112 + future[9] -= 224 + future16 = Counter(future) + future16[17] -= 112 + future16[16] += 112 + future_models = {} + for label, T in [('unproved_three_H17_banks', future), ('third_bank_H16_template_grant', future16)]: + values = {cs: outward(price(env['moment'], T, paid, Q(cs))) for cs in ('.0030217758', '.0034')} + need(all((T.get(r, 0)-paid.get(r, 0) < 0 and r <= 5) or (T.get(r, 0)-paid.get(r, 0) > 0 and r >= 7) for r in T.keys() | paid.keys() if T.get(r, 0) != paid.get(r, 0)), 'Future offer sign separation') + for cs in ('.0030217758', '.0034'): + v = price(env['moment'], T, paid, Q(cs)) + need(v[0] > 0 if label == 'unproved_three_H17_banks' else v[1] < 0, 'Future offer tariff sign') + future_models[label] = {'target': dict(T), 'owners': sum(T.values()), 'paid': dict(paid), + 'values': values, 'coded_endpoint_constructed': False} + return {'status': 'PASS_CODED_PORT_ADAPTER_CEILING', 'producer_head': origins['producer_head'], + 'source_compressed_sha256': sha256(raw['ACTUAL-WORD.json.gz']).hexdigest(), + 'source_payload_sha256': sha256(gzip.decompress(raw['ACTUAL-WORD.json.gz'])).hexdigest(), + 'native_invoice': invoice, 'helper_profile': dict(H), 'A_dimension': 112, + 'A_entries': dict(Counter(str(x) for row in A for x in row)), + 'supported_pair_grades': dict(grades), 'semantic_controls': controls, + 'forward_adapter': 'K=U A^-1 U*; scalar exit A on common-full X', + 'raw_dual_adapter': 'barU A^T barU*; scalar exit A^(-T) on conjugate-full X', + 'one_parallel_bank_grade2_channels_at_least': 112, + 'allwidth_claim_basis': 'Written phase-quotient/projective tensor-separation proof', + 'tariff_models': models, 'future_tariff_models': future_models, + 'producer_632_endpoint_replayed': False, 'consumer_constructed': False, + 'compiler_or_outer_replayed': False, 'new_kappa': None} diff --git a/research/coded-port-adapter-ceiling/source/ACTUAL-WORD.json.gz b/research/coded-port-adapter-ceiling/source/ACTUAL-WORD.json.gz new file mode 100644 index 0000000000..46d929df83 Binary files /dev/null and b/research/coded-port-adapter-ceiling/source/ACTUAL-WORD.json.gz differ diff --git a/research/coded-port-adapter-ceiling/source/ATTRIBUTION-4929.md b/research/coded-port-adapter-ceiling/source/ATTRIBUTION-4929.md new file mode 100644 index 0000000000..5f6cd0d364 --- /dev/null +++ b/research/coded-port-adapter-ceiling/source/ATTRIBUTION-4929.md @@ -0,0 +1,11 @@ +# Attribution and overlap + +Cao Yifan's canonical `research/kappa-round3-warp-20261022/` supplies the exact source payload. It changes helper entrances and shared native maps beyond his PR #4610 predecessor. Cinna Davis's PR #4470 and cumulative native/helper lineage, Dugongue's transported warp-frame lemma, zxv's native/productive/compiler work and Jacob Alan Sussman's mixed-target recursion retain credit. The exact upstream payload and replay-code precedents are pinned in SOURCES.json and ORIGINS.json; their Apache license is retained. + +[PR #4694](https://github.com/CrocSwap/integer-mult-bounds/pull/4694) already constructs a retained-center interface, its raw dual, and a center-free cache kernel whose old-input block is A-BR. Removing centers or observing a rank-eight defect is not claimed as new here. [PR #4698](https://github.com/CrocSwap/integer-mult-bounds/pull/4698) already isolates the eight helper observations by a legal common-chart basis and gives a conditional two-call consumer. This package instead cancels the helper part at the actual ground entrance, retains an explicit invertible main-port code, proves its exact projector/inverse/conditioning identities and emits its changed priced offer in both orientations. A general physical inverse is not assumed free. + +[PR #4623](https://github.com/CrocSwap/integer-mult-bounds/pull/4623) supplies the relevant border-controller and finite-precision warning. A center-deletion border was investigated here, but its recursive precision gap was not closed; it is not a multiplication result. The published construction uses fixed dyadic coefficients and no small parameter. Recent [PR #4912](https://github.com/CrocSwap/integer-mult-bounds/pull/4912) and #4918 informed the rank-saturation checks of rejected query-deletion ideas; their formal tariffs are not claimed as native gains here. + +The linear-algebra interpretation uses standard block elimination and orthogonal-projection identities. Local MathProof/DAG material motivated the representation; no fresh Lean/kernel verification, exhaustive search of the whole library, or priority for standard algebra is claimed. The earlier bounded-word fixed-rational implementation in [PR #4908](https://github.com/CrocSwap/integer-mult-bounds/pull/4908) is relevant to a future denominator-13 adapter, but is not invoked as a free operation here. + +Canonical main and priorities were refreshed during the session. The 100 most recently updated PR records were fetched, and relevant new entries and targeted source/Discussion searches were inspected; sparse source and bounded remote coverage do not establish global novelty or absence of concurrent work. The selected record remains unchanged. All checks and reviews in this package are author-side AI work, not independent human approval. diff --git a/research/coded-port-adapter-ceiling/source/CODE.json b/research/coded-port-adapter-ceiling/source/CODE.json new file mode 100644 index 0000000000..03170f4a31 --- /dev/null +++ b/research/coded-port-adapter-ceiling/source/CODE.json @@ -0,0 +1 @@ +{"A":[["0","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","0","0","0","0","0","-1/2","-1/2","-1/2","-1/2","0","0","0","0","0","0","0","0","0","-1/2","0","0","0","0","0","-1/2","-1/2","-1/2","-1/2","0","0","0","0","0","0","0","0","0","0","0","0","0","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","0","0","0","0","0","0","0","0","0","0","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","0","-1/2","0","-1/2","1/2","-1/2","-1/2","-1/2","-1/2","0","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","0","0","0","0","0","-1/2","-1/2","-1/2","-1/2","-1/2","0","0","0","0","0","0","0","0","0"],["-1/2","0","-1/2","-1/2","-1/2","-1/2","0","1/2","0","0","0","0","0","0","0","0","-1/2","1/2","1/2","1/2","0","0","0","0","0","0","-1/2","0","0","0","0","-1/2","0","0","0","-1/2","1/2","1/2","0","0","0","0","0","0","0","1/2","1/2","1/2","0","0","0","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","0","0","0","0","1/2","1/2","1/2","-1/2","-1/2","-1/2","0","0","0","0","0","0","-1/2","-1/2","-1/2","-1/2","0","-1/2","1/2","0","1/2","-1/2","-1/2","-1/2","-1/2","-1/2","0","-1/2","-1/2","-1/2","-1/2","0","1/2","0","0","0","0","1/2","0","0","0","0","1/2","-1/2","-1/2","-1/2","0","0","0","0","0"],["-1/2","-1/2","0","-1/2","-1/2","-1/2","0","0","-1/2","0","0","0","-1/2","0","0","0","-1/2","0","0","0","-1/2","-1/2","0","0","0","0","0","-1/2","0","0","0","0","0","0","0","-1/2","0","0","-1/2","-1/2","-1/2","0","0","0","1/2","0","1/2","1/2","-1/2","-1/2","-1/2","0","0","0","-1/2","-1/2","-1/2","0","-1/2","-1/2","-1/2","0","0","0","-1/2","-1/2","-1/2","0","0","0","-1/2","-1/2","-1/2","0","0","0","-1/2","0","-1/2","1/2","-1/2","0","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","0","-1/2","-1/2","-1/2","0","0","-1/2","0","0","0","0","1/2","0","0","0","-1/2","0","0","0","-1/2","-1/2","-1/2","0","0"],["-1/2","-1/2","-1/2","0","-1/2","-1/2","0","0","0","1/2","0","0","0","-1/2","0","0","0","1/2","0","0","0","0","1/2","1/2","0","0","0","0","-1/2","0","0","0","-1/2","0","0","0","0","0","-1/2","0","0","1/2","1/2","0","1/2","1/2","1/2","1/2","0","-1/2","-1/2","0","-1/2","-1/2","0","0","-1/2","1/2","0","-1/2","-1/2","0","1/2","1/2","0","0","-1/2","0","-1/2","-1/2","0","0","-1/2","0","0","-1/2","0","0","-1/2","1/2","-1/2","1/2","0","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","0","-1/2","-1/2","0","0","0","1/2","0","0","0","0","1/2","0","0","0","1/2","0","0","1/2","0","0","1/2","1/2"],["-1/2","-1/2","-1/2","-1/2","0","-1/2","0","0","0","0","1/2","0","0","0","-1/2","0","0","0","1/2","0","-1/2","0","1/2","0","1/2","0","0","0","0","-1/2","0","0","0","-1/2","0","0","1/2","0","0","-1/2","0","1/2","0","1/2","1/2","1/2","0","1/2","-1/2","0","-1/2","-1/2","0","-1/2","0","-1/2","0","1/2","-1/2","0","-1/2","1/2","0","1/2","0","-1/2","0","-1/2","0","-1/2","0","-1/2","0","0","-1/2","0","0","0","-1/2","1/2","-1/2","1/2","-1/2","0","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","0","-1/2","0","0","0","0","1/2","0","0","0","0","1/2","0","0","0","1/2","0","0","1/2","0","-1/2","0"],["-1/2","-1/2","-1/2","-1/2","-1/2","0","0","0","0","0","0","1/2","0","0","0","-1/2","0","0","0","1/2","0","-1/2","0","1/2","1/2","0","0","0","0","0","-1/2","0","0","0","-1/2","0","0","1/2","0","0","-1/2","0","1/2","1/2","1/2","1/2","1/2","0","-1/2","-1/2","0","-1/2","-1/2","0","-1/2","0","0","1/2","-1/2","-1/2","0","1/2","1/2","0","-1/2","0","0","-1/2","-1/2","0","-1/2","0","0","-1/2","0","0","0","0","-1/2","1/2","-1/2","1/2","-1/2","-1/2","0","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","0","0","0","0","0","0","1/2","0","0","0","0","1/2","0","0","0","1/2","0","0","1/2","0","-1/2"],["-1/2","0","0","0","0","0","0","1/2","-1/2","1/2","1/2","1/2","-1/2","-1/2","-1/2","-1/2","0","0","0","0","0","0","0","0","0","-1/2","0","0","0","0","0","0","0","0","0","1/2","-1/2","-1/2","1/2","1/2","1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","1/2","0","0","-1/2","1/2","-1/2","-1/2","-1/2","1/2","1/2","0","0","0","0","0","0","-1/2","1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","0","0","0","0","0","0","0","0","0"],["0","1/2","0","0","0","0","1/2","0","1/2","-1/2","-1/2","-1/2","0","0","0","0","1/2","-1/2","-1/2","-1/2","0","0","0","0","0","0","1/2","0","0","0","0","0","-1/2","-1/2","-1/2","0","0","0","-1/2","-1/2","-1/2","1/2","1/2","1/2","1/2","0","0","0","-1/2","-1/2","-1/2","0","0","0","0","0","0","0","0","0","0","-1/2","-1/2","-1/2","1/2","1/2","1/2","0","0","0","0","0","0","1/2","1/2","1/2","1/2","-1/2","0","-1/2","0","-1/2","1/2","1/2","1/2","-1/2","0","-1/2","0","0","0","0","-1/2","0","-1/2","1/2","1/2","1/2","-1/2","0","0","0","0","-1/2","1/2","1/2","1/2","0","0","0","0","0"],["0","0","-1/2","0","0","0","-1/2","1/2","0","1/2","1/2","1/2","-1/2","0","0","0","-1/2","0","0","0","-1/2","-1/2","0","0","0","0","0","-1/2","0","0","0","1/2","1/2","1/2","1/2","0","-1/2","-1/2","0","0","0","-1/2","-1/2","-1/2","0","-1/2","0","0","0","0","0","1/2","1/2","1/2","0","0","0","0","-1/2","-1/2","-1/2","0","0","0","-1/2","-1/2","-1/2","0","0","0","-1/2","-1/2","-1/2","0","0","0","-1/2","1/2","0","1/2","-1/2","0","-1/2","-1/2","-1/2","1/2","0","0","1/2","0","0","0","1/2","-1/2","0","-1/2","-1/2","-1/2","0","1/2","0","0","0","-1/2","0","0","0","-1/2","-1/2","-1/2","0","0"],["0","0","0","1/2","0","0","1/2","-1/2","1/2","0","-1/2","-1/2","0","1/2","0","0","0","-1/2","0","0","0","0","-1/2","-1/2","0","0","0","0","1/2","0","0","-1/2","0","-1/2","-1/2","-1/2","1/2","1/2","0","-1/2","-1/2","0","0","1/2","0","0","0","0","-1/2","0","0","-1/2","0","0","-1/2","-1/2","0","-1/2","0","1/2","1/2","0","-1/2","-1/2","0","0","1/2","0","1/2","1/2","0","0","1/2","0","0","1/2","0","-1/2","0","-1/2","1/2","-1/2","0","1/2","1/2","-1/2","0","0","0","-1/2","0","0","-1/2","1/2","-1/2","0","1/2","1/2","0","0","-1/2","0","0","0","-1/2","0","0","-1/2","0","0","-1/2","-1/2"],["0","0","0","0","1/2","0","1/2","-1/2","1/2","-1/2","0","-1/2","0","0","1/2","0","0","0","-1/2","0","1/2","0","-1/2","0","-1/2","0","0","0","0","1/2","0","-1/2","-1/2","0","-1/2","-1/2","0","1/2","-1/2","0","-1/2","0","1/2","0","0","0","1/2","0","0","-1/2","0","0","-1/2","0","-1/2","0","-1/2","-1/2","1/2","0","1/2","-1/2","0","-1/2","0","1/2","0","1/2","0","1/2","0","1/2","0","0","1/2","0","0","-1/2","0","-1/2","1/2","-1/2","1/2","0","1/2","-1/2","0","0","0","0","-1/2","0","-1/2","1/2","-1/2","1/2","0","1/2","0","0","0","-1/2","0","0","0","-1/2","0","0","-1/2","0","1/2","0"],["0","0","0","0","0","1/2","1/2","-1/2","1/2","-1/2","-1/2","0","0","0","0","1/2","0","0","0","-1/2","0","1/2","0","-1/2","-1/2","0","0","0","0","0","1/2","-1/2","-1/2","-1/2","0","-1/2","1/2","0","-1/2","-1/2","0","1/2","0","0","0","0","0","1/2","0","0","-1/2","0","0","-1/2","0","-1/2","-1/2","-1/2","1/2","1/2","0","-1/2","-1/2","0","1/2","0","0","1/2","1/2","0","1/2","0","0","1/2","0","0","0","-1/2","0","-1/2","1/2","-1/2","1/2","1/2","0","-1/2","0","0","0","0","0","-1/2","-1/2","1/2","-1/2","1/2","1/2","0","0","0","0","0","-1/2","0","0","0","-1/2","0","0","-1/2","0","1/2"],["-1/2","0","-1/2","0","0","0","-1/2","0","-1/2","0","0","0","0","-1/2","-1/2","-1/2","-1/2","0","0","0","-1/2","-1/2","0","0","0","0","1/2","0","1/2","1/2","1/2","0","0","0","0","0","-1/2","-1/2","0","0","0","-1/2","-1/2","-1/2","0","-1/2","0","0","-1/2","-1/2","-1/2","0","0","0","-1/2","-1/2","-1/2","-1/2","0","0","0","-1/2","-1/2","-1/2","0","0","0","0","0","0","-1/2","-1/2","-1/2","0","0","0","-1/2","1/2","-1/2","0","-1/2","0","-1/2","-1/2","-1/2","0","1/2","0","1/2","0","0","0","-1/2","0","-1/2","0","0","0","-1/2","0","-1/2","-1/2","-1/2","-1/2","0","0","0","-1/2","-1/2","-1/2","0","0"],["-1/2","0","0","-1/2","0","0","-1/2","0","0","1/2","0","0","-1/2","0","-1/2","-1/2","0","1/2","0","0","0","0","1/2","1/2","0","0","1/2","1/2","0","1/2","1/2","0","-1/2","0","0","1/2","-1/2","-1/2","0","1/2","1/2","0","0","-1/2","0","0","0","0","0","-1/2","-1/2","0","-1/2","-1/2","0","0","-1/2","0","1/2","0","0","-1/2","0","0","1/2","1/2","0","0","-1/2","-1/2","0","0","-1/2","0","0","-1/2","0","1/2","-1/2","0","-1/2","1/2","0","-1/2","-1/2","0","1/2","0","0","1/2","0","0","-1/2","0","0","1/2","0","0","-1/2","-1/2","0","-1/2","-1/2","0","1/2","0","0","1/2","0","0","1/2","1/2"],["-1/2","0","0","0","-1/2","0","-1/2","0","0","0","1/2","0","-1/2","-1/2","0","-1/2","0","0","1/2","0","-1/2","0","1/2","0","1/2","0","1/2","1/2","1/2","0","1/2","0","0","-1/2","0","1/2","0","-1/2","1/2","0","1/2","0","-1/2","0","0","0","-1/2","0","-1/2","0","-1/2","-1/2","0","-1/2","0","-1/2","0","0","0","1/2","0","0","-1/2","0","1/2","0","1/2","-1/2","0","-1/2","0","-1/2","0","0","-1/2","0","0","1/2","-1/2","0","-1/2","1/2","-1/2","0","-1/2","0","1/2","0","0","0","1/2","0","-1/2","0","0","0","1/2","0","-1/2","-1/2","-1/2","0","-1/2","0","0","1/2","0","0","1/2","0","-1/2","0"],["-1/2","0","0","0","0","-1/2","-1/2","0","0","0","0","1/2","-1/2","-1/2","-1/2","0","0","0","0","1/2","0","-1/2","0","1/2","1/2","0","1/2","1/2","1/2","1/2","0","0","0","0","-1/2","1/2","-1/2","0","1/2","1/2","0","-1/2","0","0","0","0","0","-1/2","-1/2","-1/2","0","-1/2","-1/2","0","-1/2","0","0","0","0","0","1/2","0","0","-1/2","0","1/2","1/2","-1/2","-1/2","0","-1/2","0","0","-1/2","0","0","0","1/2","-1/2","0","-1/2","1/2","-1/2","-1/2","0","0","1/2","0","0","0","0","1/2","-1/2","0","0","0","0","1/2","-1/2","-1/2","-1/2","-1/2","0","0","0","0","1/2","0","0","1/2","0","-1/2"],["0","-1/2","-1/2","0","0","0","0","1/2","-1/2","0","0","0","-1/2","0","0","0","0","1/2","1/2","1/2","-1/2","-1/2","0","0","0","1/2","0","0","1/2","1/2","1/2","0","1/2","1/2","1/2","-1/2","0","0","0","0","0","-1/2","-1/2","-1/2","0","0","1/2","1/2","0","0","0","0","0","0","-1/2","-1/2","-1/2","-1/2","0","0","0","0","0","0","-1/2","-1/2","-1/2","1/2","1/2","1/2","0","0","0","0","0","0","-1/2","1/2","-1/2","1/2","0","0","-1/2","-1/2","-1/2","0","0","1/2","1/2","0","0","0","0","1/2","-1/2","0","0","0","1/2","1/2","0","0","0","0","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","0","0"],["0","1/2","0","1/2","0","0","0","-1/2","0","-1/2","0","0","0","1/2","0","0","1/2","0","-1/2","-1/2","0","0","-1/2","-1/2","0","-1/2","0","-1/2","0","-1/2","-1/2","0","0","-1/2","-1/2","0","0","0","0","-1/2","-1/2","0","0","1/2","0","-1/2","-1/2","-1/2","-1/2","0","0","0","1/2","1/2","0","0","1/2","0","-1/2","0","0","0","-1/2","-1/2","0","0","1/2","-1/2","0","0","-1/2","-1/2","0","0","0","1/2","0","-1/2","1/2","-1/2","0","-1/2","0","1/2","1/2","0","0","-1/2","0","-1/2","0","0","0","-1/2","0","-1/2","0","0","-1/2","0","-1/2","0","0","-1/2","0","1/2","1/2","-1/2","0","0","-1/2","-1/2"],["0","1/2","0","0","1/2","0","0","-1/2","0","0","-1/2","0","0","0","1/2","0","1/2","-1/2","0","-1/2","1/2","0","-1/2","0","-1/2","-1/2","0","-1/2","-1/2","0","-1/2","0","-1/2","0","-1/2","0","-1/2","0","-1/2","0","-1/2","0","1/2","0","0","-1/2","0","-1/2","0","-1/2","0","1/2","0","1/2","0","1/2","0","0","0","-1/2","0","-1/2","0","-1/2","0","1/2","0","0","-1/2","0","-1/2","0","-1/2","0","1/2","0","0","-1/2","1/2","-1/2","0","-1/2","1/2","0","1/2","0","0","-1/2","0","0","-1/2","0","0","-1/2","0","0","-1/2","0","-1/2","0","0","-1/2","0","-1/2","1/2","0","1/2","0","-1/2","0","1/2","0"],["0","1/2","0","0","0","1/2","0","-1/2","0","0","0","-1/2","0","0","0","1/2","1/2","-1/2","-1/2","0","0","1/2","0","-1/2","-1/2","-1/2","0","-1/2","-1/2","-1/2","0","0","-1/2","-1/2","0","0","0","-1/2","-1/2","-1/2","0","1/2","0","0","0","-1/2","-1/2","0","0","0","-1/2","1/2","1/2","0","1/2","0","0","0","0","0","-1/2","-1/2","-1/2","0","1/2","0","0","0","0","-1/2","0","-1/2","-1/2","1/2","0","0","0","-1/2","1/2","-1/2","0","-1/2","1/2","1/2","0","0","0","-1/2","0","0","0","-1/2","0","-1/2","0","0","0","-1/2","-1/2","0","0","0","-1/2","-1/2","1/2","1/2","0","0","0","-1/2","0","1/2"],["0","0","-1/2","0","-1/2","0","0","0","-1/2","0","1/2","0","-1/2","0","-1/2","0","-1/2","0","1/2","0","0","-1/2","1/2","0","1/2","1/2","1/2","0","1/2","0","1/2","1/2","1/2","0","1/2","0","0","-1/2","0","-1/2","0","0","-1/2","0","1/2","0","0","1/2","-1/2","0","-1/2","0","1/2","0","0","-1/2","0","0","-1/2","0","-1/2","0","-1/2","0","0","-1/2","0","0","1/2","0","0","-1/2","0","1/2","0","1/2","0","1/2","-1/2","1/2","-1/2","0","-1/2","0","-1/2","0","0","0","1/2","0","1/2","0","0","0","-1/2","0","1/2","0","0","1/2","0","1/2","0","-1/2","0","1/2","0","-1/2","0","-1/2","-1/2","0"],["0","0","-1/2","0","0","-1/2","0","0","-1/2","0","0","1/2","-1/2","0","0","-1/2","-1/2","0","0","1/2","-1/2","0","0","1/2","1/2","1/2","1/2","0","1/2","1/2","0","1/2","1/2","1/2","0","0","-1/2","0","0","0","-1/2","-1/2","0","0","1/2","0","1/2","0","-1/2","-1/2","0","0","0","1/2","-1/2","0","0","0","-1/2","-1/2","0","0","0","-1/2","-1/2","0","0","0","0","1/2","-1/2","0","0","0","1/2","1/2","0","1/2","-1/2","1/2","-1/2","0","-1/2","-1/2","0","0","0","0","1/2","0","0","1/2","0","0","-1/2","0","0","1/2","0","1/2","0","0","1/2","-1/2","0","0","1/2","-1/2","-1/2","0","0","-1/2"],["0","0","0","1/2","1/2","0","0","0","0","-1/2","-1/2","0","0","1/2","1/2","0","0","-1/2","-1/2","0","1/2","0","0","-1/2","-1/2","-1/2","-1/2","-1/2","0","0","-1/2","-1/2","0","0","-1/2","-1/2","0","1/2","0","0","-1/2","-1/2","0","0","-1/2","-1/2","0","-1/2","0","0","1/2","0","0","1/2","-1/2","0","0","-1/2","0","0","1/2","0","0","-1/2","-1/2","0","0","0","0","1/2","-1/2","0","0","-1/2","0","0","-1/2","-1/2","1/2","-1/2","1/2","-1/2","0","0","1/2","0","0","0","0","-1/2","-1/2","0","0","0","0","-1/2","-1/2","0","0","0","-1/2","-1/2","0","0","-1/2","-1/2","0","-1/2","-1/2","0","0","-1/2"],["0","0","0","1/2","0","1/2","0","0","0","-1/2","0","-1/2","0","1/2","0","1/2","0","-1/2","0","-1/2","0","1/2","-1/2","0","-1/2","-1/2","-1/2","-1/2","0","-1/2","0","-1/2","0","-1/2","0","-1/2","1/2","0","0","-1/2","0","0","-1/2","0","-1/2","-1/2","-1/2","0","0","1/2","0","0","1/2","0","0","-1/2","0","-1/2","0","1/2","0","0","-1/2","0","0","-1/2","0","0","1/2","0","0","-1/2","0","0","-1/2","0","-1/2","-1/2","1/2","-1/2","1/2","-1/2","0","1/2","0","0","0","0","0","-1/2","0","-1/2","0","0","0","-1/2","0","-1/2","0","0","-1/2","0","-1/2","0","-1/2","0","-1/2","-1/2","0","-1/2","-1/2","0"],["0","0","0","0","1/2","1/2","0","0","0","0","-1/2","-1/2","0","0","1/2","1/2","0","0","-1/2","-1/2","1/2","1/2","-1/2","-1/2","0","-1/2","-1/2","-1/2","-1/2","0","0","-1/2","-1/2","0","0","-1/2","0","0","-1/2","0","0","0","0","-1/2","-1/2","-1/2","0","0","1/2","0","0","1/2","0","0","0","0","-1/2","-1/2","1/2","0","0","-1/2","0","0","0","0","-1/2","1/2","0","0","0","0","-1/2","0","0","-1/2","-1/2","-1/2","1/2","-1/2","1/2","-1/2","1/2","0","0","0","0","0","0","0","-1/2","-1/2","0","0","0","0","-1/2","-1/2","0","0","0","-1/2","-1/2","0","0","-1/2","-1/2","0","-1/2","-1/2","1/2","1/2"],["-1/2","0","0","0","0","0","-1/2","0","0","0","0","0","0","0","0","0","1/2","-1/2","-1/2","-1/2","1/2","1/2","-1/2","-1/2","-1/2","0","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","0","0","0","0","0","0","0","0","0","-1/2","-1/2","-1/2","-1/2","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","1/2","-1/2","0","0","0","0","0","0","0","-1/2","-1/2","-1/2","-1/2","-1/2","0","-1/2","1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","0","0","0","0","0","0","0","0","0"],["0","-1/2","0","0","0","0","0","1/2","0","0","0","0","1/2","1/2","1/2","1/2","0","0","0","0","1/2","1/2","-1/2","-1/2","-1/2","-1/2","0","-1/2","-1/2","-1/2","-1/2","-1/2","0","0","0","-1/2","1/2","1/2","0","0","0","0","0","0","-1/2","0","0","0","1/2","1/2","1/2","0","0","0","0","0","0","0","0","0","0","1/2","1/2","1/2","-1/2","-1/2","-1/2","0","0","0","0","0","0","-1/2","-1/2","-1/2","-1/2","-1/2","1/2","0","1/2","0","0","0","0","0","-1/2","0","-1/2","-1/2","-1/2","-1/2","1/2","0","1/2","-1/2","-1/2","-1/2","1/2","0","0","0","0","1/2","-1/2","-1/2","-1/2","0","0","0","0","0"],["0","0","-1/2","0","0","0","0","0","-1/2","0","0","0","0","1/2","1/2","1/2","0","-1/2","-1/2","-1/2","0","0","-1/2","-1/2","-1/2","-1/2","-1/2","0","-1/2","-1/2","-1/2","0","0","0","0","-1/2","0","0","-1/2","-1/2","-1/2","0","0","0","0","-1/2","0","0","0","0","0","1/2","1/2","1/2","0","0","0","0","-1/2","-1/2","-1/2","0","0","0","-1/2","-1/2","-1/2","0","0","0","-1/2","-1/2","-1/2","0","0","0","-1/2","-1/2","1/2","0","0","-1/2","0","0","0","0","-1/2","-1/2","0","-1/2","-1/2","-1/2","1/2","-1/2","0","-1/2","-1/2","-1/2","0","1/2","0","0","0","-1/2","0","0","0","-1/2","-1/2","-1/2","0","0"],["0","0","0","-1/2","0","0","0","0","0","1/2","0","0","1/2","0","1/2","1/2","1/2","0","-1/2","-1/2","1/2","1/2","0","0","-1/2","-1/2","-1/2","-1/2","0","-1/2","-1/2","0","-1/2","0","0","0","0","0","-1/2","0","0","1/2","1/2","0","0","0","0","0","1/2","0","0","1/2","0","0","1/2","1/2","0","1/2","0","-1/2","-1/2","0","1/2","1/2","0","0","-1/2","0","-1/2","-1/2","0","0","-1/2","0","0","-1/2","0","-1/2","1/2","0","0","0","1/2","0","0","0","-1/2","-1/2","-1/2","0","-1/2","-1/2","1/2","-1/2","1/2","0","-1/2","-1/2","0","0","1/2","0","0","0","1/2","0","0","1/2","0","0","1/2","1/2"],["0","0","0","0","-1/2","0","0","0","0","0","1/2","0","1/2","1/2","0","1/2","1/2","-1/2","0","-1/2","0","1/2","0","-1/2","0","-1/2","-1/2","-1/2","-1/2","0","-1/2","0","0","-1/2","0","0","1/2","0","0","-1/2","0","1/2","0","1/2","0","0","-1/2","0","0","1/2","0","0","1/2","0","1/2","0","1/2","1/2","-1/2","0","-1/2","1/2","0","1/2","0","-1/2","0","-1/2","0","-1/2","0","-1/2","0","0","-1/2","0","0","-1/2","1/2","0","0","0","0","1/2","0","0","-1/2","-1/2","-1/2","-1/2","0","-1/2","1/2","-1/2","1/2","-1/2","0","-1/2","0","0","0","1/2","0","0","0","1/2","0","0","1/2","0","-1/2","0"],["0","0","0","0","0","-1/2","0","0","0","0","0","1/2","1/2","1/2","1/2","0","1/2","-1/2","-1/2","0","1/2","0","-1/2","0","0","-1/2","-1/2","-1/2","-1/2","-1/2","0","0","0","0","-1/2","0","0","1/2","0","0","-1/2","0","1/2","1/2","0","0","0","-1/2","0","0","1/2","0","0","1/2","0","1/2","1/2","1/2","-1/2","-1/2","0","1/2","1/2","0","-1/2","0","0","-1/2","-1/2","0","-1/2","0","0","-1/2","0","0","0","-1/2","1/2","0","0","0","0","0","1/2","0","-1/2","-1/2","-1/2","-1/2","-1/2","0","1/2","-1/2","1/2","-1/2","-1/2","0","0","0","0","0","1/2","0","0","0","1/2","0","0","1/2","0","-1/2"],["-1/2","-1/2","0","0","0","0","0","0","1/2","-1/2","-1/2","-1/2","0","0","0","0","0","0","0","0","1/2","1/2","-1/2","-1/2","-1/2","-1/2","-1/2","0","0","0","0","0","-1/2","-1/2","-1/2","-1/2","1/2","1/2","0","0","0","0","0","0","-1/2","0","0","0","0","0","0","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","1/2","1/2","1/2","0","0","0","0","0","0","0","0","0","0","0","0","-1/2","-1/2","-1/2","-1/2","-1/2","0","-1/2","1/2","0","0","0","0","-1/2","0","0","-1/2","-1/2","-1/2","-1/2","-1/2","1/2","0","0","0","0","0","-1/2","-1/2","-1/2","-1/2","1/2","-1/2","-1/2","-1/2","0","0","0","0","0"],["-1/2","0","0","-1/2","0","0","0","-1/2","1/2","0","-1/2","-1/2","0","-1/2","0","0","1/2","0","-1/2","-1/2","1/2","1/2","0","0","-1/2","-1/2","0","0","-1/2","0","0","-1/2","0","-1/2","-1/2","0","0","0","-1/2","0","0","1/2","1/2","0","0","0","0","0","0","-1/2","-1/2","0","-1/2","-1/2","0","0","-1/2","0","1/2","0","0","-1/2","0","0","1/2","1/2","0","0","-1/2","-1/2","0","0","-1/2","0","0","-1/2","0","-1/2","0","-1/2","0","0","1/2","0","0","-1/2","0","-1/2","-1/2","0","-1/2","-1/2","-1/2","0","0","1/2","0","0","-1/2","-1/2","0","-1/2","-1/2","0","1/2","0","0","1/2","0","0","1/2","1/2"],["-1/2","0","0","0","-1/2","0","0","-1/2","1/2","-1/2","0","-1/2","0","0","-1/2","0","1/2","-1/2","0","-1/2","0","1/2","0","-1/2","0","-1/2","0","0","0","-1/2","0","-1/2","-1/2","0","-1/2","0","1/2","0","0","-1/2","0","1/2","0","1/2","0","0","-1/2","0","-1/2","0","-1/2","-1/2","0","-1/2","0","-1/2","0","0","0","1/2","0","0","-1/2","0","1/2","0","1/2","-1/2","0","-1/2","0","-1/2","0","0","-1/2","0","0","-1/2","0","-1/2","0","0","0","1/2","0","-1/2","0","-1/2","-1/2","-1/2","0","-1/2","-1/2","0","0","0","1/2","0","-1/2","-1/2","-1/2","0","-1/2","0","0","1/2","0","0","1/2","0","-1/2","0"],["-1/2","0","0","0","0","-1/2","0","-1/2","1/2","-1/2","-1/2","0","0","0","0","-1/2","1/2","-1/2","-1/2","0","1/2","0","-1/2","0","0","-1/2","0","0","0","0","-1/2","-1/2","-1/2","-1/2","0","0","0","1/2","0","0","-1/2","0","1/2","1/2","0","0","0","-1/2","-1/2","-1/2","0","-1/2","-1/2","0","-1/2","0","0","0","0","0","1/2","0","0","-1/2","0","1/2","1/2","-1/2","-1/2","0","-1/2","0","0","-1/2","0","0","0","-1/2","0","-1/2","0","0","0","0","1/2","-1/2","0","-1/2","-1/2","-1/2","-1/2","0","-1/2","0","0","0","0","1/2","-1/2","-1/2","-1/2","-1/2","0","0","0","0","1/2","0","0","1/2","0","-1/2"],["0","-1/2","-1/2","0","0","0","1/2","0","0","-1/2","-1/2","-1/2","0","1/2","1/2","1/2","-1/2","0","0","0","0","0","-1/2","-1/2","-1/2","0","-1/2","-1/2","0","0","0","-1/2","0","0","0","0","1/2","1/2","-1/2","-1/2","-1/2","0","0","0","0","0","1/2","1/2","0","0","0","0","0","0","-1/2","-1/2","-1/2","-1/2","0","0","0","0","0","0","-1/2","-1/2","-1/2","1/2","1/2","1/2","0","0","0","0","0","0","-1/2","-1/2","0","0","1/2","-1/2","0","0","0","-1/2","-1/2","0","0","-1/2","-1/2","-1/2","0","1/2","-1/2","0","0","0","1/2","1/2","0","0","0","0","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","0","0"],["0","1/2","0","0","1/2","0","-1/2","0","-1/2","1/2","0","1/2","-1/2","-1/2","0","-1/2","0","0","-1/2","0","0","-1/2","0","1/2","0","0","1/2","0","0","1/2","0","1/2","0","1/2","0","1/2","0","-1/2","0","1/2","0","-1/2","0","-1/2","0","-1/2","0","-1/2","0","-1/2","0","1/2","0","1/2","0","1/2","0","0","0","-1/2","0","-1/2","0","-1/2","0","1/2","0","0","-1/2","0","-1/2","0","-1/2","0","1/2","0","0","1/2","0","0","-1/2","0","0","-1/2","0","1/2","1/2","0","1/2","1/2","0","1/2","0","-1/2","0","0","-1/2","0","-1/2","0","0","-1/2","0","-1/2","1/2","0","1/2","0","-1/2","0","1/2","0"],["0","1/2","0","0","0","1/2","-1/2","0","-1/2","1/2","1/2","0","-1/2","-1/2","-1/2","0","0","0","0","-1/2","-1/2","0","1/2","0","0","0","1/2","0","0","0","1/2","1/2","0","0","1/2","1/2","-1/2","0","0","0","1/2","0","-1/2","-1/2","0","-1/2","-1/2","0","0","0","-1/2","1/2","1/2","0","1/2","0","0","0","0","0","-1/2","-1/2","-1/2","0","1/2","0","0","0","0","-1/2","0","-1/2","-1/2","1/2","0","0","0","1/2","0","0","-1/2","0","0","0","-1/2","1/2","1/2","0","1/2","1/2","1/2","0","0","-1/2","0","0","0","-1/2","-1/2","0","0","0","-1/2","-1/2","1/2","1/2","0","0","0","-1/2","0","1/2"],["0","0","-1/2","-1/2","0","0","1/2","-1/2","0","0","-1/2","-1/2","0","0","1/2","1/2","0","0","-1/2","-1/2","0","0","0","0","-1/2","0","0","-1/2","-1/2","0","0","0","-1/2","0","0","-1/2","0","0","0","-1/2","-1/2","1/2","1/2","0","1/2","0","1/2","1/2","0","-1/2","-1/2","1/2","0","0","0","0","-1/2","0","0","-1/2","-1/2","-1/2","0","0","0","0","-1/2","1/2","0","0","0","0","-1/2","1/2","1/2","0","0","-1/2","0","0","0","-1/2","1/2","0","0","-1/2","-1/2","-1/2","0","0","-1/2","-1/2","0","0","-1/2","1/2","0","0","0","1/2","1/2","0","0","-1/2","1/2","0","0","0","-1/2","-1/2","1/2","1/2"],["0","0","-1/2","0","-1/2","0","1/2","-1/2","0","-1/2","0","-1/2","0","1/2","0","1/2","0","-1/2","0","-1/2","-1/2","0","0","-1/2","0","0","0","-1/2","0","-1/2","0","0","0","-1/2","0","-1/2","1/2","0","-1/2","0","-1/2","1/2","0","1/2","1/2","0","0","1/2","-1/2","0","-1/2","0","1/2","0","0","-1/2","0","0","-1/2","0","-1/2","0","-1/2","0","0","-1/2","0","0","1/2","0","0","-1/2","0","1/2","0","1/2","0","-1/2","0","0","0","-1/2","0","1/2","0","-1/2","-1/2","-1/2","0","-1/2","0","-1/2","0","0","-1/2","0","1/2","0","0","1/2","0","1/2","0","-1/2","0","1/2","0","-1/2","0","-1/2","-1/2","0"],["0","0","-1/2","0","0","-1/2","1/2","-1/2","0","-1/2","-1/2","0","0","1/2","1/2","0","0","-1/2","-1/2","0","0","-1/2","-1/2","0","0","0","0","-1/2","0","0","-1/2","0","0","0","-1/2","-1/2","0","1/2","-1/2","-1/2","0","0","1/2","1/2","1/2","0","1/2","0","-1/2","-1/2","0","0","0","1/2","-1/2","0","0","0","-1/2","-1/2","0","0","0","-1/2","-1/2","0","0","0","0","1/2","-1/2","0","0","0","1/2","1/2","0","-1/2","0","0","0","-1/2","0","0","1/2","-1/2","-1/2","-1/2","0","-1/2","-1/2","0","0","0","-1/2","0","0","1/2","0","1/2","0","0","1/2","-1/2","0","0","1/2","-1/2","-1/2","0","0","-1/2"],["0","0","0","1/2","1/2","0","-1/2","1/2","-1/2","0","0","1/2","-1/2","0","0","-1/2","-1/2","0","0","1/2","0","-1/2","-1/2","0","0","0","0","0","1/2","1/2","0","0","1/2","1/2","0","0","-1/2","0","1/2","1/2","0","0","-1/2","-1/2","-1/2","-1/2","0","-1/2","0","0","1/2","0","0","1/2","-1/2","0","0","-1/2","0","0","1/2","0","0","-1/2","-1/2","0","0","0","0","1/2","-1/2","0","0","-1/2","0","0","-1/2","1/2","0","0","0","0","-1/2","-1/2","0","1/2","1/2","1/2","1/2","0","0","1/2","0","0","0","-1/2","-1/2","0","0","0","-1/2","-1/2","0","0","-1/2","-1/2","0","-1/2","-1/2","0","0","-1/2"],["0","0","0","1/2","0","1/2","-1/2","1/2","-1/2","0","1/2","0","-1/2","0","-1/2","0","-1/2","0","1/2","0","-1/2","0","0","-1/2","0","0","0","0","1/2","0","1/2","0","1/2","0","1/2","0","0","-1/2","1/2","0","1/2","-1/2","0","-1/2","-1/2","-1/2","-1/2","0","0","1/2","0","0","1/2","0","0","-1/2","0","-1/2","0","1/2","0","0","-1/2","0","0","-1/2","0","0","1/2","0","0","-1/2","0","0","-1/2","0","-1/2","1/2","0","0","0","0","-1/2","0","-1/2","1/2","1/2","1/2","1/2","0","1/2","0","0","0","0","-1/2","0","-1/2","0","0","-1/2","0","-1/2","0","-1/2","0","-1/2","-1/2","0","-1/2","-1/2","0"],["0","0","0","0","1/2","1/2","-1/2","1/2","-1/2","1/2","0","0","-1/2","-1/2","0","0","-1/2","1/2","0","0","0","0","0","0","-1/2","0","0","0","0","1/2","1/2","0","0","1/2","1/2","0","-1/2","-1/2","0","1/2","1/2","-1/2","-1/2","0","-1/2","-1/2","0","0","1/2","0","0","1/2","0","0","0","0","-1/2","-1/2","1/2","0","0","-1/2","0","0","0","0","-1/2","1/2","0","0","0","0","-1/2","0","0","-1/2","-1/2","1/2","0","0","0","0","0","-1/2","-1/2","1/2","1/2","1/2","1/2","1/2","0","0","0","0","0","0","-1/2","-1/2","0","0","0","-1/2","-1/2","0","0","-1/2","-1/2","0","-1/2","-1/2","1/2","1/2"],["0","0","1/2","1/2","1/2","1/2","-1/2","1/2","0","0","0","0","0","0","0","0","0","0","0","0","1/2","1/2","-1/2","-1/2","-1/2","-1/2","-1/2","0","0","0","0","-1/2","0","0","0","0","0","0","1/2","1/2","1/2","-1/2","-1/2","-1/2","0","-1/2","-1/2","-1/2","1/2","1/2","1/2","0","0","0","0","0","0","-1/2","1/2","1/2","1/2","0","0","0","0","0","0","0","0","0","0","0","0","-1/2","-1/2","-1/2","-1/2","0","1/2","-1/2","1/2","0","0","0","0","1/2","1/2","1/2","0","0","0","0","0","0","1/2","-1/2","-1/2","-1/2","0","-1/2","-1/2","-1/2","-1/2","1/2","-1/2","-1/2","-1/2","0","0","0","0","0"],["0","1/2","0","1/2","1/2","1/2","-1/2","0","-1/2","0","0","0","-1/2","0","0","0","0","-1/2","-1/2","-1/2","0","0","-1/2","-1/2","-1/2","-1/2","0","-1/2","0","0","0","0","0","0","0","0","-1/2","-1/2","0","0","0","-1/2","-1/2","-1/2","-1/2","0","-1/2","-1/2","0","0","0","1/2","1/2","1/2","0","0","0","-1/2","0","0","0","-1/2","-1/2","-1/2","0","0","0","0","0","0","-1/2","-1/2","-1/2","0","0","0","-1/2","0","1/2","-1/2","0","-1/2","0","0","0","1/2","1/2","0","1/2","0","0","0","0","-1/2","0","-1/2","-1/2","-1/2","-1/2","0","-1/2","-1/2","-1/2","-1/2","0","0","0","-1/2","-1/2","-1/2","0","0"],["0","1/2","1/2","1/2","0","1/2","-1/2","0","0","0","1/2","0","0","0","-1/2","0","1/2","-1/2","0","-1/2","0","1/2","0","-1/2","0","-1/2","0","0","0","-1/2","0","0","0","-1/2","0","1/2","0","-1/2","1/2","0","1/2","0","-1/2","0","-1/2","-1/2","0","-1/2","0","1/2","0","0","1/2","0","1/2","0","1/2","0","0","1/2","0","0","-1/2","0","1/2","0","1/2","-1/2","0","-1/2","0","-1/2","0","0","-1/2","0","0","0","1/2","-1/2","0","0","0","1/2","0","1/2","1/2","0","0","0","1/2","0","0","-1/2","1/2","-1/2","0","-1/2","-1/2","-1/2","-1/2","0","-1/2","0","0","1/2","0","0","1/2","0","-1/2","0"],["0","1/2","1/2","1/2","1/2","0","-1/2","0","0","0","0","1/2","0","0","0","-1/2","1/2","-1/2","-1/2","0","1/2","0","-1/2","0","0","-1/2","0","0","0","0","-1/2","0","0","0","-1/2","1/2","-1/2","0","1/2","1/2","0","-1/2","0","0","-1/2","-1/2","-1/2","0","0","0","1/2","0","0","1/2","0","1/2","1/2","0","0","0","1/2","0","0","-1/2","0","1/2","1/2","-1/2","-1/2","0","-1/2","0","0","-1/2","0","0","0","0","1/2","-1/2","0","0","0","0","1/2","1/2","1/2","0","0","0","0","1/2","0","-1/2","1/2","-1/2","-1/2","0","-1/2","-1/2","-1/2","-1/2","0","0","0","0","1/2","0","0","1/2","0","-1/2"],["-1/2","0","-1/2","0","-1/2","-1/2","0","-1/2","0","-1/2","0","0","-1/2","0","-1/2","-1/2","0","-1/2","0","0","-1/2","-1/2","0","0","1/2","0","1/2","0","1/2","0","0","0","0","-1/2","-1/2","0","0","0","0","-1/2","-1/2","0","0","1/2","1/2","0","0","0","0","-1/2","-1/2","-1/2","0","0","-1/2","-1/2","0","0","-1/2","0","0","0","-1/2","-1/2","0","0","1/2","-1/2","0","0","-1/2","-1/2","0","0","0","1/2","0","0","-1/2","0","-1/2","0","-1/2","0","0","-1/2","0","-1/2","0","-1/2","0","0","-1/2","0","-1/2","0","1/2","1/2","-1/2","0","-1/2","0","0","-1/2","0","1/2","1/2","-1/2","0","0","-1/2","-1/2"],["-1/2","0","-1/2","-1/2","0","-1/2","0","-1/2","0","0","-1/2","0","-1/2","-1/2","0","-1/2","0","0","-1/2","0","0","-1/2","0","1/2","0","0","1/2","0","0","1/2","0","0","-1/2","0","-1/2","0","-1/2","0","-1/2","0","-1/2","0","1/2","0","1/2","0","1/2","0","-1/2","0","-1/2","0","-1/2","0","-1/2","0","-1/2","0","0","-1/2","0","-1/2","0","-1/2","0","1/2","0","0","-1/2","0","-1/2","0","-1/2","0","1/2","0","0","0","-1/2","0","-1/2","0","0","-1/2","0","-1/2","0","-1/2","0","0","-1/2","0","-1/2","0","-1/2","1/2","0","1/2","-1/2","0","0","-1/2","0","-1/2","1/2","0","1/2","0","-1/2","0","1/2","0"],["-1/2","0","-1/2","-1/2","-1/2","0","0","-1/2","0","0","0","-1/2","-1/2","-1/2","-1/2","0","0","0","0","-1/2","-1/2","0","1/2","0","0","0","1/2","0","0","0","1/2","0","-1/2","-1/2","0","0","0","-1/2","-1/2","-1/2","0","1/2","0","0","1/2","0","0","1/2","-1/2","-1/2","0","0","0","-1/2","0","-1/2","-1/2","0","0","0","-1/2","-1/2","-1/2","0","1/2","0","0","0","0","-1/2","0","-1/2","-1/2","1/2","0","0","0","0","-1/2","0","-1/2","0","0","0","-1/2","-1/2","0","-1/2","0","0","0","-1/2","-1/2","0","-1/2","1/2","1/2","0","-1/2","0","0","0","-1/2","-1/2","1/2","1/2","0","0","0","-1/2","0","1/2"],["-1/2","-1/2","0","0","-1/2","-1/2","0","0","1/2","-1/2","0","0","0","0","-1/2","-1/2","0","0","1/2","1/2","0","0","0","0","1/2","0","0","1/2","1/2","0","0","-1/2","0","-1/2","-1/2","0","1/2","1/2","1/2","0","0","0","0","1/2","0","1/2","0","0","-1/2","0","0","0","-1/2","-1/2","-1/2","-1/2","0","0","0","1/2","1/2","1/2","0","0","0","0","1/2","-1/2","0","0","0","0","1/2","-1/2","-1/2","0","0","0","-1/2","0","0","1/2","-1/2","0","0","-1/2","0","0","-1/2","-1/2","0","0","-1/2","1/2","0","0","1/2","1/2","0","-1/2","-1/2","0","0","1/2","-1/2","0","0","0","1/2","1/2","-1/2","-1/2"],["-1/2","-1/2","0","-1/2","0","-1/2","0","0","1/2","0","-1/2","0","0","-1/2","0","-1/2","0","1/2","0","1/2","1/2","0","0","1/2","0","0","0","1/2","0","1/2","0","-1/2","-1/2","0","-1/2","0","0","1/2","0","1/2","0","0","1/2","0","0","1/2","1/2","0","0","-1/2","0","-1/2","0","-1/2","-1/2","0","-1/2","0","1/2","0","1/2","0","1/2","0","0","1/2","0","0","-1/2","0","0","1/2","0","-1/2","0","-1/2","0","0","-1/2","0","0","1/2","0","-1/2","0","-1/2","0","0","-1/2","0","-1/2","0","-1/2","1/2","0","1/2","0","1/2","0","-1/2","0","-1/2","0","1/2","0","-1/2","0","1/2","0","1/2","1/2","0"],["-1/2","-1/2","0","-1/2","-1/2","0","0","0","1/2","0","0","-1/2","0","-1/2","-1/2","0","0","1/2","1/2","0","0","1/2","1/2","0","0","0","0","1/2","0","0","1/2","-1/2","-1/2","-1/2","0","0","1/2","0","0","0","1/2","1/2","0","0","0","1/2","0","1/2","0","0","-1/2","-1/2","-1/2","0","0","-1/2","-1/2","0","1/2","1/2","0","0","0","1/2","1/2","0","0","0","0","-1/2","1/2","0","0","0","-1/2","-1/2","0","0","-1/2","0","0","1/2","0","0","-1/2","-1/2","0","0","-1/2","0","0","-1/2","-1/2","1/2","0","1/2","1/2","0","0","-1/2","0","0","-1/2","1/2","0","0","-1/2","1/2","1/2","0","0","1/2"],["-1/2","-1/2","-1/2","0","0","-1/2","0","0","0","-1/2","-1/2","0","-1/2","0","0","-1/2","-1/2","0","0","1/2","0","-1/2","-1/2","0","0","0","0","0","1/2","1/2","0","-1/2","0","0","-1/2","-1/2","0","1/2","0","0","-1/2","-1/2","0","0","0","0","1/2","0","-1/2","-1/2","0","-1/2","-1/2","0","0","-1/2","-1/2","-1/2","0","0","1/2","0","0","-1/2","-1/2","0","0","0","0","1/2","-1/2","0","0","-1/2","0","0","-1/2","0","-1/2","0","0","0","-1/2","-1/2","0","-1/2","0","0","0","-1/2","-1/2","0","-1/2","1/2","-1/2","0","0","1/2","0","0","-1/2","-1/2","0","0","-1/2","-1/2","0","-1/2","-1/2","0","0","-1/2"],["-1/2","-1/2","-1/2","0","-1/2","0","0","0","0","-1/2","0","-1/2","-1/2","0","-1/2","0","-1/2","0","1/2","0","-1/2","0","0","-1/2","0","0","0","0","1/2","0","1/2","-1/2","0","-1/2","0","-1/2","1/2","0","0","-1/2","0","0","-1/2","0","0","0","0","1/2","-1/2","0","-1/2","-1/2","0","-1/2","-1/2","0","-1/2","-1/2","0","1/2","0","0","-1/2","0","0","-1/2","0","0","1/2","0","0","-1/2","0","0","-1/2","0","-1/2","0","-1/2","0","0","0","-1/2","0","-1/2","-1/2","0","0","0","-1/2","0","-1/2","-1/2","1/2","-1/2","0","1/2","0","0","0","-1/2","0","-1/2","0","-1/2","0","-1/2","-1/2","0","-1/2","-1/2","0"],["-1/2","-1/2","-1/2","-1/2","0","0","0","0","0","0","-1/2","-1/2","-1/2","-1/2","0","0","-1/2","1/2","0","0","0","0","0","0","-1/2","0","0","0","0","1/2","1/2","-1/2","-1/2","0","0","-1/2","0","0","-1/2","0","0","0","0","-1/2","0","0","1/2","1/2","0","-1/2","-1/2","0","-1/2","-1/2","-1/2","-1/2","0","-1/2","1/2","0","0","-1/2","0","0","0","0","-1/2","1/2","0","0","0","0","-1/2","0","0","-1/2","-1/2","0","-1/2","0","0","0","0","-1/2","-1/2","-1/2","0","0","0","0","-1/2","-1/2","-1/2","1/2","-1/2","1/2","0","0","0","0","0","-1/2","-1/2","0","0","-1/2","-1/2","0","-1/2","-1/2","1/2","1/2"],["0","0","0","1/2","1/2","1/2","0","0","0","-1/2","-1/2","-1/2","-1/2","0","0","0","-1/2","0","0","0","0","0","-1/2","-1/2","-1/2","0","0","0","1/2","1/2","1/2","-1/2","0","0","0","-1/2","0","0","0","0","0","-1/2","-1/2","-1/2","-1/2","-1/2","0","0","0","0","0","0","0","0","-1/2","-1/2","-1/2","0","1/2","1/2","1/2","-1/2","-1/2","-1/2","0","0","0","1/2","1/2","1/2","0","0","0","0","0","0","-1/2","0","0","-1/2","1/2","-1/2","0","0","0","0","1/2","1/2","1/2","0","0","0","-1/2","1/2","-1/2","0","0","0","0","0","-1/2","-1/2","-1/2","0","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","0","0"],["0","0","-1/2","0","-1/2","-1/2","0","0","-1/2","0","1/2","1/2","0","1/2","0","0","0","-1/2","0","0","-1/2","-1/2","0","0","1/2","0","0","-1/2","0","-1/2","-1/2","1/2","1/2","0","0","0","0","0","0","-1/2","-1/2","0","0","1/2","1/2","0","0","0","-1/2","0","0","0","1/2","1/2","0","0","1/2","1/2","0","-1/2","-1/2","1/2","0","0","-1/2","-1/2","0","-1/2","0","0","-1/2","-1/2","0","0","0","1/2","0","0","0","1/2","-1/2","0","-1/2","0","0","0","-1/2","-1/2","0","-1/2","0","0","1/2","-1/2","0","-1/2","0","0","0","1/2","0","1/2","1/2","-1/2","0","1/2","1/2","-1/2","0","0","-1/2","-1/2"],["0","0","-1/2","-1/2","0","-1/2","0","0","-1/2","1/2","0","1/2","0","0","1/2","0","0","0","-1/2","0","0","-1/2","0","1/2","0","0","0","-1/2","-1/2","0","-1/2","1/2","0","1/2","0","0","-1/2","0","-1/2","0","-1/2","0","1/2","0","1/2","0","1/2","0","0","-1/2","0","1/2","0","1/2","0","1/2","0","1/2","-1/2","0","-1/2","0","1/2","0","-1/2","0","-1/2","0","-1/2","0","-1/2","0","-1/2","0","1/2","0","0","0","0","1/2","-1/2","0","0","-1/2","0","0","-1/2","-1/2","0","0","-1/2","0","1/2","-1/2","0","0","-1/2","0","0","1/2","1/2","0","1/2","-1/2","1/2","0","1/2","0","-1/2","0","1/2","0"],["0","0","-1/2","-1/2","-1/2","0","0","0","-1/2","1/2","1/2","0","0","0","0","1/2","0","0","0","-1/2","-1/2","0","1/2","0","0","0","0","-1/2","-1/2","-1/2","0","1/2","0","0","1/2","0","0","-1/2","-1/2","-1/2","0","1/2","0","0","1/2","0","0","1/2","0","0","-1/2","1/2","1/2","0","1/2","0","0","1/2","-1/2","-1/2","0","0","0","1/2","0","-1/2","-1/2","0","0","-1/2","0","-1/2","-1/2","1/2","0","0","0","0","0","1/2","-1/2","0","0","0","-1/2","0","-1/2","-1/2","0","0","0","-1/2","1/2","-1/2","0","0","0","-1/2","0","1/2","1/2","1/2","0","-1/2","1/2","1/2","0","0","0","-1/2","0","1/2"],["0","1/2","0","0","1/2","1/2","0","-1/2","0","0","-1/2","-1/2","-1/2","-1/2","0","0","0","0","-1/2","-1/2","0","0","0","0","-1/2","0","1/2","0","0","1/2","1/2","0","-1/2","0","0","0","-1/2","-1/2","-1/2","0","0","0","0","-1/2","0","-1/2","0","0","0","-1/2","-1/2","1/2","0","0","0","0","-1/2","-1/2","1/2","0","0","0","-1/2","-1/2","1/2","1/2","0","1/2","0","0","0","0","-1/2","1/2","1/2","0","0","0","0","-1/2","0","-1/2","1/2","0","0","0","1/2","0","1/2","1/2","0","0","-1/2","0","-1/2","1/2","0","0","-1/2","0","0","-1/2","-1/2","-1/2","1/2","0","0","0","-1/2","-1/2","1/2","1/2"],["0","1/2","0","1/2","0","1/2","0","-1/2","0","-1/2","0","-1/2","-1/2","0","-1/2","0","0","-1/2","0","-1/2","-1/2","0","0","-1/2","0","0","1/2","0","1/2","0","1/2","0","0","-1/2","0","0","0","-1/2","0","-1/2","0","0","-1/2","0","0","-1/2","-1/2","0","-1/2","0","-1/2","0","1/2","0","0","-1/2","0","-1/2","0","1/2","0","-1/2","0","-1/2","1/2","0","1/2","0","1/2","0","0","-1/2","0","1/2","0","1/2","0","0","0","-1/2","0","-1/2","0","1/2","0","0","1/2","0","1/2","0","1/2","0","-1/2","0","-1/2","0","1/2","0","-1/2","0","-1/2","0","-1/2","-1/2","0","1/2","0","-1/2","0","-1/2","-1/2","0"],["0","1/2","0","1/2","1/2","0","0","-1/2","0","-1/2","-1/2","0","-1/2","0","0","-1/2","0","-1/2","-1/2","0","0","-1/2","-1/2","0","0","0","1/2","0","1/2","1/2","0","0","0","0","-1/2","0","-1/2","0","0","0","-1/2","-1/2","0","0","0","-1/2","0","-1/2","-1/2","-1/2","0","0","0","1/2","-1/2","0","0","-1/2","0","0","1/2","-1/2","-1/2","0","0","1/2","1/2","0","0","1/2","-1/2","0","0","0","1/2","1/2","0","0","0","-1/2","0","-1/2","0","0","1/2","0","1/2","0","1/2","0","0","1/2","-1/2","0","-1/2","0","0","1/2","-1/2","0","-1/2","-1/2","0","-1/2","0","0","1/2","-1/2","-1/2","0","0","-1/2"],["0","-1/2","-1/2","0","0","-1/2","0","1/2","-1/2","0","0","1/2","0","1/2","1/2","0","-1/2","0","0","1/2","0","-1/2","-1/2","0","0","0","-1/2","-1/2","0","0","-1/2","0","1/2","1/2","0","-1/2","0","1/2","0","0","-1/2","-1/2","0","0","0","0","1/2","0","0","0","1/2","0","0","1/2","-1/2","0","0","0","-1/2","-1/2","0","1/2","1/2","0","0","-1/2","-1/2","0","0","1/2","-1/2","0","0","-1/2","0","0","-1/2","0","0","1/2","0","0","-1/2","-1/2","0","0","-1/2","0","0","-1/2","-1/2","0","1/2","0","0","-1/2","-1/2","0","1/2","1/2","0","0","1/2","0","-1/2","-1/2","0","-1/2","-1/2","0","0","-1/2"],["0","-1/2","-1/2","0","-1/2","0","0","1/2","-1/2","0","1/2","0","0","1/2","0","1/2","-1/2","0","1/2","0","-1/2","0","0","-1/2","0","0","-1/2","-1/2","0","-1/2","0","0","1/2","0","1/2","-1/2","1/2","0","0","-1/2","0","0","-1/2","0","0","0","0","1/2","0","1/2","0","0","1/2","0","0","-1/2","0","0","-1/2","0","-1/2","1/2","0","1/2","-1/2","0","-1/2","0","1/2","0","0","-1/2","0","0","-1/2","0","-1/2","0","0","1/2","0","0","-1/2","0","-1/2","0","-1/2","0","0","-1/2","0","-1/2","1/2","0","0","-1/2","0","-1/2","1/2","1/2","0","1/2","0","0","-1/2","0","-1/2","-1/2","0","-1/2","-1/2","0"],["0","-1/2","-1/2","-1/2","0","0","0","1/2","-1/2","1/2","0","0","0","0","1/2","1/2","-1/2","1/2","0","0","0","0","0","0","-1/2","0","-1/2","-1/2","-1/2","0","0","0","0","1/2","1/2","-1/2","0","0","-1/2","0","0","0","0","-1/2","0","0","1/2","1/2","1/2","0","0","1/2","0","0","0","0","-1/2","0","0","-1/2","-1/2","0","1/2","1/2","-1/2","-1/2","0","1/2","0","0","0","0","-1/2","0","0","-1/2","-1/2","0","0","1/2","0","0","0","-1/2","-1/2","0","-1/2","0","0","0","-1/2","-1/2","1/2","0","0","0","-1/2","-1/2","1/2","1/2","1/2","0","0","0","0","-1/2","-1/2","0","-1/2","-1/2","1/2","1/2"],["-1/2","0","0","0","-1/2","-1/2","-1/2","0","0","0","1/2","1/2","0","0","-1/2","-1/2","1/2","-1/2","0","0","0","0","0","0","1/2","-1/2","0","0","0","-1/2","-1/2","0","0","-1/2","-1/2","1/2","0","0","1/2","0","0","0","0","1/2","0","0","-1/2","-1/2","-1/2","0","0","-1/2","0","0","0","0","1/2","1/2","-1/2","0","0","1/2","0","0","0","0","1/2","0","-1/2","-1/2","-1/2","-1/2","0","-1/2","-1/2","0","0","0","0","0","-1/2","1/2","-1/2","0","0","0","0","-1/2","-1/2","-1/2","0","0","0","-1/2","1/2","-1/2","0","0","-1/2","-1/2","-1/2","0","0","0","0","1/2","1/2","0","1/2","1/2","-1/2","-1/2"],["-1/2","0","0","-1/2","0","-1/2","-1/2","0","0","1/2","0","1/2","0","-1/2","0","-1/2","1/2","0","-1/2","0","1/2","0","0","1/2","0","-1/2","0","0","-1/2","0","-1/2","0","-1/2","0","-1/2","1/2","-1/2","0","0","1/2","0","0","1/2","0","0","0","0","-1/2","0","-1/2","0","0","-1/2","0","0","1/2","0","1/2","0","-1/2","0","0","1/2","0","0","1/2","0","-1/2","0","-1/2","-1/2","0","-1/2","-1/2","0","-1/2","0","0","0","0","-1/2","1/2","0","-1/2","0","0","0","-1/2","-1/2","0","-1/2","0","0","-1/2","1/2","0","-1/2","0","-1/2","-1/2","0","-1/2","0","0","1/2","0","1/2","1/2","0","1/2","1/2","0"],["-1/2","0","0","-1/2","-1/2","0","-1/2","0","0","1/2","1/2","0","0","-1/2","-1/2","0","1/2","0","0","-1/2","0","1/2","1/2","0","0","-1/2","0","0","-1/2","-1/2","0","0","-1/2","-1/2","0","1/2","0","-1/2","0","0","1/2","1/2","0","0","0","0","-1/2","0","0","0","-1/2","0","0","-1/2","1/2","0","0","1/2","0","0","-1/2","0","0","1/2","1/2","0","0","-1/2","-1/2","0","0","-1/2","-1/2","0","-1/2","-1/2","0","0","0","0","-1/2","1/2","0","0","-1/2","0","0","-1/2","-1/2","0","0","-1/2","0","-1/2","1/2","0","0","-1/2","-1/2","-1/2","0","0","-1/2","0","1/2","1/2","0","1/2","1/2","0","0","1/2"],["-1/2","0","-1/2","0","0","-1/2","-1/2","0","-1/2","0","0","1/2","-1/2","0","0","-1/2","0","-1/2","-1/2","0","0","-1/2","-1/2","0","0","-1/2","0","-1/2","0","0","-1/2","0","0","0","-1/2","0","-1/2","0","0","0","-1/2","-1/2","0","0","0","-1/2","0","-1/2","-1/2","-1/2","0","0","0","1/2","-1/2","0","0","0","-1/2","-1/2","0","0","0","-1/2","-1/2","0","0","-1/2","-1/2","0","0","-1/2","-1/2","-1/2","0","0","-1/2","0","0","0","-1/2","0","-1/2","-1/2","0","0","0","-1/2","0","-1/2","-1/2","0","0","-1/2","0","-1/2","-1/2","0","-1/2","0","-1/2","-1/2","0","-1/2","0","0","1/2","-1/2","-1/2","0","0","-1/2"],["-1/2","0","-1/2","0","-1/2","0","-1/2","0","-1/2","0","1/2","0","-1/2","0","-1/2","0","0","-1/2","0","-1/2","-1/2","0","0","-1/2","0","-1/2","0","-1/2","0","-1/2","0","0","0","-1/2","0","0","0","-1/2","0","-1/2","0","0","-1/2","0","0","-1/2","-1/2","0","-1/2","0","-1/2","0","1/2","0","0","-1/2","0","0","-1/2","0","-1/2","0","-1/2","0","0","-1/2","0","-1/2","0","-1/2","-1/2","0","-1/2","0","-1/2","0","-1/2","0","0","0","-1/2","0","-1/2","0","-1/2","0","0","-1/2","0","-1/2","0","-1/2","0","-1/2","0","-1/2","0","-1/2","-1/2","0","-1/2","0","-1/2","-1/2","0","1/2","0","-1/2","0","-1/2","-1/2","0"],["-1/2","0","-1/2","-1/2","0","0","-1/2","0","-1/2","1/2","0","0","-1/2","-1/2","0","0","0","0","-1/2","-1/2","0","0","0","0","-1/2","-1/2","0","-1/2","-1/2","0","0","0","-1/2","0","0","0","-1/2","-1/2","-1/2","0","0","0","0","-1/2","0","-1/2","0","0","0","-1/2","-1/2","1/2","0","0","0","0","-1/2","0","0","-1/2","-1/2","-1/2","0","0","0","0","-1/2","0","-1/2","-1/2","-1/2","-1/2","0","0","0","-1/2","-1/2","0","0","0","-1/2","0","0","-1/2","-1/2","0","0","-1/2","0","0","-1/2","-1/2","0","-1/2","0","0","-1/2","-1/2","-1/2","0","0","-1/2","-1/2","-1/2","1/2","0","0","0","-1/2","-1/2","1/2","1/2"],["-1/2","-1/2","0","0","0","-1/2","-1/2","1/2","0","0","0","1/2","0","0","0","-1/2","0","0","0","1/2","1/2","0","-1/2","0","0","-1/2","-1/2","0","0","0","-1/2","-1/2","0","0","-1/2","0","0","1/2","1/2","1/2","0","-1/2","0","0","-1/2","0","0","-1/2","0","0","1/2","-1/2","-1/2","0","-1/2","0","0","0","0","0","1/2","1/2","1/2","0","-1/2","0","0","-1/2","-1/2","0","-1/2","0","0","0","-1/2","-1/2","-1/2","0","0","0","0","1/2","-1/2","-1/2","0","0","0","0","-1/2","-1/2","-1/2","0","0","0","1/2","-1/2","-1/2","0","0","-1/2","-1/2","-1/2","0","1/2","-1/2","-1/2","0","0","0","1/2","0","-1/2"],["-1/2","-1/2","0","0","-1/2","0","-1/2","1/2","0","0","1/2","0","0","0","-1/2","0","0","0","1/2","0","0","1/2","0","-1/2","0","-1/2","-1/2","0","0","-1/2","0","-1/2","0","-1/2","0","0","1/2","0","1/2","0","1/2","0","-1/2","0","-1/2","0","-1/2","0","0","1/2","0","-1/2","0","-1/2","0","-1/2","0","0","0","1/2","0","1/2","0","1/2","0","-1/2","0","-1/2","0","-1/2","0","-1/2","0","-1/2","0","-1/2","-1/2","0","0","0","0","1/2","-1/2","0","-1/2","0","0","0","-1/2","-1/2","0","-1/2","0","0","1/2","-1/2","0","-1/2","0","-1/2","-1/2","0","-1/2","1/2","-1/2","0","-1/2","0","1/2","0","-1/2","0"],["-1/2","-1/2","0","-1/2","0","0","-1/2","1/2","0","1/2","0","0","0","-1/2","0","0","0","1/2","0","0","1/2","1/2","0","0","-1/2","-1/2","-1/2","0","-1/2","0","0","-1/2","-1/2","0","0","0","0","0","0","1/2","1/2","0","0","-1/2","-1/2","0","0","0","1/2","0","0","0","-1/2","-1/2","0","0","-1/2","0","1/2","0","0","0","1/2","1/2","0","0","-1/2","0","-1/2","-1/2","0","0","-1/2","-1/2","-1/2","0","-1/2","0","0","0","0","1/2","0","-1/2","-1/2","0","0","0","-1/2","0","-1/2","-1/2","0","0","1/2","0","-1/2","-1/2","0","-1/2","0","-1/2","-1/2","1/2","0","-1/2","-1/2","1/2","0","0","1/2","1/2"],["-1/2","-1/2","-1/2","0","0","0","-1/2","1/2","-1/2","0","0","0","-1/2","0","0","0","-1/2","0","0","0","0","0","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","0","0","0","-1/2","0","0","0","-1/2","0","0","0","0","0","-1/2","-1/2","-1/2","-1/2","-1/2","0","0","0","0","0","0","0","0","-1/2","-1/2","-1/2","-1/2","0","0","0","0","0","0","-1/2","-1/2","-1/2","0","0","0","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","0","0","0","0","0","0","-1/2","-1/2","-1/2","0","0","0","0","-1/2","-1/2","-1/2","0","0","0","-1/2","-1/2","-1/2","0","0","-1/2","-1/2","-1/2","0","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","0","0"],["0","0","0","0","0","0","1/2","-1/2","1/2","-1/2","-1/2","-1/2","1/2","1/2","1/2","1/2","1/2","-1/2","-1/2","-1/2","1/2","1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","1/2","1/2","-1/2","-1/2","-1/2","1/2","1/2","1/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","1/2","-1/2","1/2","-1/2","1/2","1/2","1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0"],["-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","0","0","0","0","0","0","-1/2","-1/2","-1/2","-1/2","-1/2","1/2","1/2","1/2","-1/2","-1/2","1/2","1/2","1/2","1/2","1/2","1/2","1/2","1/2","1/2","0","0","0","0","0","0","0","0","0","0","0","0","0","1/2","1/2","1/2","1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","1/2","0","1/2","-1/2","1/2","-1/2","-1/2","-1/2","-1/2","0","0","0","0","0","0","-1/2","1/2","-1/2","1/2","1/2","1/2","0","0","0","0","0","0","0","0","0","0","0","0","0","0"],["0","1/2","1/2","1/2","1/2","1/2","0","-1/2","1/2","-1/2","-1/2","-1/2","0","0","0","0","1/2","-1/2","-1/2","-1/2","1/2","1/2","-1/2","-1/2","-1/2","-1/2","0","0","0","0","0","-1/2","-1/2","-1/2","-1/2","0","0","0","0","0","0","0","0","0","-1/2","-1/2","-1/2","-1/2","0","0","0","0","0","0","0","0","0","-1/2","1/2","1/2","1/2","-1/2","-1/2","-1/2","1/2","1/2","1/2","0","0","0","0","0","0","0","0","0","0","-1/2","1/2","0","1/2","-1/2","1/2","1/2","1/2","0","1/2","0","0","0","0","0","-1/2","0","0","0","0","0","-1/2","-1/2","-1/2","-1/2","-1/2","0","0","0","0","0","0","0","0","0"],["-1/2","0","-1/2","-1/2","-1/2","-1/2","-1/2","0","-1/2","1/2","1/2","1/2","-1/2","-1/2","-1/2","-1/2","0","0","0","0","-1/2","-1/2","1/2","1/2","1/2","0","1/2","0","0","0","0","1/2","0","0","0","1/2","-1/2","-1/2","0","0","0","0","0","0","1/2","0","0","0","-1/2","-1/2","-1/2","0","0","0","0","0","0","1/2","-1/2","-1/2","-1/2","0","0","0","0","0","0","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","0","0","0","0","1/2","-1/2","1/2","0","1/2","-1/2","-1/2","-1/2","0","0","-1/2","0","0","0","0","0","-1/2","0","0","0","0","-1/2","0","0","0","0","-1/2","1/2","1/2","1/2","0","0","0","0","0"],["1/2","1/2","0","1/2","1/2","1/2","1/2","-1/2","0","-1/2","-1/2","-1/2","0","1/2","1/2","1/2","0","-1/2","-1/2","-1/2","0","0","-1/2","-1/2","-1/2","0","0","-1/2","0","0","0","0","0","0","0","-1/2","0","0","-1/2","-1/2","-1/2","0","0","0","0","-1/2","0","0","0","0","0","1/2","1/2","1/2","0","0","0","-1/2","0","0","0","-1/2","-1/2","-1/2","0","0","0","1/2","1/2","1/2","0","0","0","1/2","1/2","1/2","0","-1/2","1/2","-1/2","1/2","0","1/2","1/2","1/2","0","0","0","1/2","0","0","0","0","0","-1/2","0","0","0","0","1/2","0","0","0","-1/2","0","0","0","-1/2","-1/2","-1/2","0","0"],["-1/2","-1/2","-1/2","0","-1/2","-1/2","-1/2","1/2","-1/2","0","1/2","1/2","-1/2","0","-1/2","-1/2","-1/2","0","1/2","1/2","-1/2","-1/2","0","0","1/2","0","0","0","1/2","0","0","0","1/2","0","0","0","0","0","1/2","0","0","-1/2","-1/2","0","0","0","0","0","-1/2","0","0","-1/2","0","0","-1/2","-1/2","0","0","-1/2","0","0","1/2","0","0","-1/2","-1/2","0","-1/2","0","0","-1/2","-1/2","0","-1/2","-1/2","0","-1/2","1/2","-1/2","1/2","-1/2","1/2","0","-1/2","-1/2","0","0","0","0","-1/2","0","0","0","0","0","-1/2","0","0","0","0","-1/2","0","0","0","-1/2","0","0","-1/2","0","0","-1/2","-1/2"],["-1/2","-1/2","-1/2","-1/2","0","-1/2","-1/2","1/2","-1/2","1/2","0","1/2","-1/2","-1/2","0","-1/2","-1/2","1/2","0","1/2","0","-1/2","0","1/2","0","0","0","0","0","1/2","0","0","0","1/2","0","0","-1/2","0","0","1/2","0","-1/2","0","-1/2","0","0","1/2","0","0","-1/2","0","0","-1/2","0","-1/2","0","-1/2","0","0","-1/2","0","0","1/2","0","-1/2","0","-1/2","0","-1/2","0","-1/2","0","-1/2","-1/2","0","-1/2","-1/2","1/2","-1/2","1/2","-1/2","1/2","-1/2","0","-1/2","0","0","0","0","0","-1/2","0","0","0","0","0","-1/2","0","0","0","0","-1/2","0","0","0","-1/2","0","0","-1/2","0","1/2","0"],["-1/2","-1/2","-1/2","-1/2","-1/2","0","-1/2","1/2","-1/2","1/2","1/2","0","-1/2","-1/2","-1/2","0","-1/2","1/2","1/2","0","-1/2","0","1/2","0","0","0","0","0","0","0","1/2","0","0","0","1/2","0","0","-1/2","0","0","1/2","0","-1/2","-1/2","0","0","0","1/2","0","0","-1/2","0","0","-1/2","0","-1/2","-1/2","0","0","0","-1/2","0","0","1/2","0","-1/2","-1/2","0","0","-1/2","0","-1/2","-1/2","0","-1/2","-1/2","-1/2","1/2","-1/2","1/2","-1/2","1/2","-1/2","-1/2","0","0","0","0","0","0","0","-1/2","0","0","0","0","0","-1/2","0","0","0","0","-1/2","0","0","0","-1/2","0","0","-1/2","0","1/2"],["-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","1/2","-1/2","1/2","-1/2","-1/2","-1/2","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","-1/2","-1/2","-1/2","-1/2","-1/2","1/2","1/2","-1/2","-1/2","-1/2","1/2","1/2","1/2","1/2","1/2","1/2","1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","-1/2","-1/2","0","0","0","0","0","0","0","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","1/2","-1/2","1/2","1/2","1/2","0","0","0","0","0","0","0","0","0","0","0","0","0","0"],["0","-1/2","-1/2","-1/2","-1/2","-1/2","1/2","0","0","0","0","0","1/2","1/2","1/2","1/2","0","0","0","0","0","0","0","0","0","0","-1/2","-1/2","-1/2","-1/2","-1/2","0","0","0","0","-1/2","1/2","1/2","-1/2","-1/2","-1/2","1/2","1/2","1/2","1/2","1/2","1/2","1/2","0","0","0","0","0","0","0","0","0","1/2","-1/2","-1/2","-1/2","1/2","1/2","1/2","-1/2","-1/2","-1/2","0","0","0","0","0","0","0","0","0","0","-1/2","0","1/2","0","0","0","0","0","-1/2","0","-1/2","-1/2","-1/2","-1/2","-1/2","1/2","0","0","0","0","0","1/2","1/2","1/2","1/2","1/2","0","0","0","0","0","0","0","0","0"],["-1/2","0","-1/2","-1/2","-1/2","-1/2","0","-1/2","0","0","0","0","0","0","0","0","1/2","-1/2","-1/2","-1/2","0","0","0","0","0","-1/2","0","-1/2","-1/2","-1/2","-1/2","0","-1/2","-1/2","-1/2","0","0","0","-1/2","-1/2","-1/2","1/2","1/2","1/2","1/2","0","0","0","-1/2","-1/2","-1/2","0","0","0","0","0","0","1/2","-1/2","-1/2","-1/2","0","0","0","0","0","0","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","0","0","0","0","-1/2","0","0","-1/2","0","0","0","0","-1/2","-1/2","0","-1/2","-1/2","-1/2","-1/2","0","-1/2","0","0","0","0","-1/2","0","0","0","0","-1/2","1/2","1/2","1/2","0","0","0","0","0"],["-1/2","-1/2","0","-1/2","-1/2","-1/2","0","0","1/2","0","0","0","1/2","0","0","0","1/2","0","0","0","1/2","1/2","0","0","0","-1/2","-1/2","0","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","0","1/2","1/2","0","0","0","1/2","1/2","1/2","0","1/2","0","0","0","0","0","-1/2","-1/2","-1/2","0","0","0","1/2","0","0","0","1/2","1/2","1/2","0","0","0","-1/2","-1/2","-1/2","0","0","0","-1/2","-1/2","-1/2","0","-1/2","0","0","0","1/2","0","0","0","-1/2","-1/2","-1/2","0","-1/2","-1/2","-1/2","0","0","1/2","0","0","0","0","-1/2","0","0","0","1/2","0","0","0","1/2","1/2","1/2","0","0"],["-1/2","-1/2","-1/2","0","-1/2","-1/2","0","0","0","-1/2","0","0","0","1/2","0","0","0","-1/2","0","0","0","0","-1/2","-1/2","0","-1/2","-1/2","-1/2","0","-1/2","-1/2","-1/2","0","-1/2","-1/2","-1/2","1/2","1/2","0","-1/2","-1/2","0","0","1/2","0","0","0","0","-1/2","0","0","-1/2","0","0","-1/2","-1/2","0","0","-1/2","0","0","1/2","0","0","-1/2","-1/2","0","-1/2","0","0","-1/2","-1/2","0","-1/2","-1/2","0","-1/2","-1/2","0","0","0","0","-1/2","0","0","-1/2","-1/2","-1/2","-1/2","0","-1/2","-1/2","0","0","0","-1/2","0","0","0","0","-1/2","0","0","0","-1/2","0","0","-1/2","0","0","-1/2","-1/2"],["-1/2","-1/2","-1/2","-1/2","0","-1/2","0","0","0","0","-1/2","0","0","0","1/2","0","0","0","-1/2","0","1/2","0","-1/2","0","-1/2","-1/2","-1/2","-1/2","-1/2","0","-1/2","-1/2","-1/2","0","-1/2","-1/2","0","1/2","-1/2","0","-1/2","0","1/2","0","0","0","1/2","0","0","-1/2","0","0","-1/2","0","-1/2","0","-1/2","0","0","-1/2","0","0","1/2","0","-1/2","0","-1/2","0","-1/2","0","-1/2","0","-1/2","-1/2","0","-1/2","-1/2","-1/2","0","0","0","0","0","-1/2","0","-1/2","-1/2","-1/2","-1/2","-1/2","0","-1/2","0","0","0","0","-1/2","0","0","0","0","-1/2","0","0","0","-1/2","0","0","-1/2","0","1/2","0"],["-1/2","-1/2","-1/2","-1/2","-1/2","0","0","0","0","0","0","-1/2","0","0","0","1/2","0","0","0","-1/2","0","1/2","0","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","0","-1/2","-1/2","-1/2","0","-1/2","1/2","0","-1/2","-1/2","0","1/2","0","0","0","0","0","1/2","0","0","-1/2","0","0","-1/2","0","-1/2","-1/2","0","0","0","-1/2","0","0","1/2","0","-1/2","-1/2","0","0","-1/2","0","-1/2","-1/2","0","-1/2","-1/2","-1/2","-1/2","0","0","0","0","0","0","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","0","0","0","0","0","0","-1/2","0","0","0","0","-1/2","0","0","0","-1/2","0","0","-1/2","0","1/2"],["-1/2","0","0","0","0","0","0","-1/2","1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","0","0","0","0","0","0","0","0","0","0","1/2","1/2","1/2","1/2","1/2","-1/2","-1/2","-1/2","-1/2","0","0","0","0","0","0","0","0","0","0","0","0","0","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","1/2","1/2","1/2","-1/2","-1/2","-1/2","1/2","1/2","1/2","0","0","0","0","0","0","0","0","0","0","0","-1/2","-1/2","0","0","0","0","0","-1/2","1/2","0","0","0","0","0","0","1/2","-1/2","1/2","1/2","1/2","-1/2","-1/2","-1/2","-1/2","-1/2","0","0","0","0","0","0","0","0","0"],["0","1/2","0","0","0","0","-1/2","0","-1/2","1/2","1/2","1/2","0","0","0","0","1/2","-1/2","-1/2","-1/2","0","0","0","0","0","-1/2","0","-1/2","-1/2","-1/2","-1/2","1/2","0","0","0","1/2","-1/2","-1/2","0","0","0","0","0","0","0","-1/2","-1/2","-1/2","0","0","0","1/2","1/2","1/2","1/2","1/2","1/2","1/2","-1/2","-1/2","-1/2","0","0","0","0","0","0","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","0","0","0","0","0","1/2","0","-1/2","0","0","0","0","1/2","0","-1/2","0","0","0","0","1/2","0","1/2","-1/2","-1/2","-1/2","-1/2","0","0","0","0","-1/2","1/2","1/2","1/2","0","0","0","0","0"],["0","0","-1/2","0","0","0","1/2","-1/2","0","-1/2","-1/2","-1/2","-1/2","0","0","0","-1/2","0","0","0","-1/2","-1/2","0","0","0","1/2","1/2","0","1/2","1/2","1/2","0","0","0","0","-1/2","0","0","-1/2","-1/2","-1/2","0","0","0","1/2","0","1/2","1/2","-1/2","-1/2","-1/2","0","0","0","-1/2","-1/2","-1/2","-1/2","0","0","0","-1/2","-1/2","-1/2","0","0","0","1/2","1/2","1/2","0","0","0","1/2","1/2","1/2","0","0","-1/2","0","0","-1/2","0","0","0","-1/2","0","0","1/2","0","0","0","-1/2","1/2","0","1/2","1/2","1/2","0","1/2","0","0","0","-1/2","0","0","0","-1/2","-1/2","-1/2","0","0"],["0","0","0","1/2","0","0","-1/2","1/2","-1/2","0","1/2","1/2","0","1/2","0","0","0","-1/2","0","0","0","0","-1/2","-1/2","0","-1/2","-1/2","-1/2","0","-1/2","-1/2","0","1/2","0","0","0","0","0","1/2","0","0","-1/2","-1/2","0","-1/2","-1/2","-1/2","-1/2","0","1/2","1/2","0","1/2","1/2","0","0","1/2","0","-1/2","0","0","1/2","0","0","-1/2","-1/2","0","-1/2","0","0","-1/2","-1/2","0","-1/2","-1/2","0","-1/2","0","1/2","0","0","0","-1/2","0","0","1/2","0","0","0","-1/2","0","0","1/2","-1/2","1/2","0","-1/2","-1/2","0","0","-1/2","0","0","0","-1/2","0","0","-1/2","0","0","-1/2","-1/2"],["0","0","0","0","1/2","0","-1/2","1/2","-1/2","1/2","0","1/2","0","0","1/2","0","0","0","-1/2","0","1/2","0","-1/2","0","-1/2","-1/2","-1/2","-1/2","-1/2","0","-1/2","0","0","1/2","0","0","-1/2","0","0","1/2","0","-1/2","0","-1/2","-1/2","-1/2","0","-1/2","1/2","0","1/2","1/2","0","1/2","0","1/2","0","0","0","-1/2","0","0","1/2","0","-1/2","0","-1/2","0","-1/2","0","-1/2","0","-1/2","-1/2","0","-1/2","-1/2","0","1/2","0","0","0","0","-1/2","0","1/2","0","0","0","0","-1/2","0","1/2","-1/2","1/2","-1/2","0","-1/2","0","0","0","-1/2","0","0","0","-1/2","0","0","-1/2","0","1/2","0"],["0","0","0","0","0","1/2","-1/2","1/2","-1/2","1/2","1/2","0","0","0","0","1/2","0","0","0","-1/2","0","1/2","0","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","0","0","0","0","1/2","0","0","-1/2","0","0","1/2","0","-1/2","-1/2","-1/2","-1/2","-1/2","0","1/2","1/2","0","1/2","1/2","0","1/2","0","0","0","0","0","-1/2","0","0","1/2","0","-1/2","-1/2","0","0","-1/2","0","-1/2","-1/2","0","-1/2","-1/2","-1/2","0","1/2","0","0","0","0","0","-1/2","1/2","0","0","0","0","0","-1/2","1/2","-1/2","1/2","-1/2","-1/2","0","0","0","0","0","-1/2","0","0","0","-1/2","0","0","-1/2","0","1/2"],["-1/2","1/2","0","0","0","0","-1/2","-1/2","0","0","0","0","-1/2","-1/2","-1/2","-1/2","1/2","-1/2","-1/2","-1/2","0","0","0","0","0","-1/2","1/2","0","0","0","0","0","-1/2","-1/2","-1/2","1/2","-1/2","-1/2","0","0","0","0","0","0","0","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","0","0","0","0","0","0","0","0","0","0","-1/2","-1/2","-1/2","1/2","1/2","1/2","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","0","0","0","0","0","0","-1/2","-1/2","0","0","0","0","0","1/2","-1/2","0","0","0","0","-1/2","-1/2","0","0","0","0","0","-1/2","-1/2","-1/2","-1/2","-1/2","1/2","1/2","1/2","0","0","0","0","0"],["-1/2","0","1/2","0","0","0","-1/2","0","1/2","0","0","0","0","-1/2","-1/2","-1/2","1/2","0","0","0","1/2","1/2","0","0","0","-1/2","0","1/2","0","0","0","-1/2","-1/2","-1/2","-1/2","1/2","0","0","1/2","1/2","1/2","0","0","0","-1/2","0","-1/2","-1/2","0","0","0","-1/2","-1/2","-1/2","0","0","0","0","1/2","1/2","1/2","0","0","0","1/2","1/2","1/2","-1/2","-1/2","-1/2","0","0","0","-1/2","-1/2","-1/2","0","0","0","-1/2","0","1/2","0","0","0","0","1/2","0","-1/2","0","0","0","-1/2","0","1/2","0","0","0","-1/2","0","-1/2","-1/2","-1/2","1/2","0","0","0","1/2","1/2","1/2","0","0"],["-1/2","0","0","1/2","0","0","-1/2","0","0","-1/2","0","0","-1/2","0","-1/2","-1/2","0","-1/2","0","0","0","0","-1/2","-1/2","0","-1/2","0","0","1/2","0","0","-1/2","0","-1/2","-1/2","0","0","0","1/2","0","0","-1/2","-1/2","0","-1/2","-1/2","-1/2","-1/2","-1/2","0","0","-1/2","0","0","-1/2","-1/2","0","-1/2","0","1/2","1/2","0","-1/2","-1/2","0","0","1/2","-1/2","0","0","-1/2","-1/2","0","-1/2","-1/2","0","-1/2","0","0","-1/2","0","0","-1/2","0","0","0","1/2","0","0","-1/2","0","0","-1/2","0","0","-1/2","0","0","-1/2","-1/2","0","-1/2","-1/2","0","-1/2","0","0","-1/2","0","0","-1/2","-1/2"],["-1/2","0","0","0","1/2","0","-1/2","0","0","0","-1/2","0","-1/2","-1/2","0","-1/2","0","0","-1/2","0","1/2","0","-1/2","0","-1/2","-1/2","0","0","0","1/2","0","-1/2","-1/2","0","-1/2","0","-1/2","0","0","1/2","0","-1/2","0","-1/2","-1/2","-1/2","0","-1/2","0","-1/2","0","0","-1/2","0","-1/2","0","-1/2","-1/2","1/2","0","1/2","-1/2","0","-1/2","0","1/2","0","0","-1/2","0","-1/2","0","-1/2","-1/2","0","-1/2","-1/2","0","0","-1/2","0","0","0","-1/2","0","0","1/2","0","0","0","-1/2","0","-1/2","0","0","0","-1/2","0","-1/2","-1/2","-1/2","0","-1/2","0","0","-1/2","0","0","-1/2","0","1/2","0"],["-1/2","0","0","0","0","1/2","-1/2","0","0","0","0","-1/2","-1/2","-1/2","-1/2","0","0","0","0","-1/2","0","1/2","0","-1/2","-1/2","-1/2","0","0","0","0","1/2","-1/2","-1/2","-1/2","0","0","0","-1/2","0","0","1/2","0","-1/2","-1/2","-1/2","-1/2","-1/2","0","0","0","-1/2","0","0","-1/2","0","-1/2","-1/2","-1/2","1/2","1/2","0","-1/2","-1/2","0","1/2","0","0","0","0","-1/2","0","-1/2","-1/2","0","-1/2","-1/2","-1/2","0","0","-1/2","0","0","0","0","-1/2","0","1/2","0","0","0","0","-1/2","-1/2","0","0","0","0","-1/2","-1/2","-1/2","-1/2","-1/2","0","0","0","0","-1/2","0","0","-1/2","0","1/2"],["0","1/2","-1/2","0","0","0","0","-1/2","-1/2","0","0","0","-1/2","0","0","0","0","-1/2","-1/2","-1/2","-1/2","-1/2","0","0","0","0","1/2","-1/2","0","0","0","1/2","0","0","0","0","-1/2","-1/2","-1/2","-1/2","-1/2","0","0","0","1/2","-1/2","0","0","-1/2","-1/2","-1/2","1/2","1/2","1/2","0","0","0","0","-1/2","-1/2","-1/2","-1/2","-1/2","-1/2","0","0","0","0","0","0","-1/2","-1/2","-1/2","1/2","1/2","1/2","0","0","0","0","-1/2","-1/2","0","0","0","0","0","-1/2","1/2","0","0","0","0","-1/2","-1/2","0","0","0","-1/2","1/2","0","0","0","0","1/2","1/2","1/2","-1/2","-1/2","-1/2","0","0"],["0","-1/2","0","1/2","0","0","0","1/2","0","-1/2","0","0","0","1/2","0","0","-1/2","0","1/2","1/2","0","0","-1/2","-1/2","0","0","-1/2","0","1/2","0","0","-1/2","1/2","0","0","-1/2","1/2","1/2","1/2","0","0","-1/2","-1/2","0","-1/2","0","0","0","0","1/2","1/2","-1/2","0","0","-1/2","-1/2","0","-1/2","0","1/2","1/2","1/2","0","0","-1/2","-1/2","0","0","1/2","1/2","0","0","1/2","-1/2","-1/2","0","-1/2","0","0","0","1/2","0","-1/2","0","0","0","0","1/2","0","-1/2","0","0","0","1/2","0","-1/2","0","0","1/2","0","-1/2","0","0","1/2","0","-1/2","-1/2","-1/2","0","0","-1/2","-1/2"],["0","-1/2","0","0","1/2","0","0","1/2","0","0","-1/2","0","0","0","1/2","0","-1/2","1/2","0","1/2","1/2","0","-1/2","0","-1/2","0","-1/2","0","0","1/2","0","-1/2","0","1/2","0","-1/2","0","1/2","0","1/2","0","-1/2","0","-1/2","-1/2","0","1/2","0","1/2","0","1/2","0","-1/2","0","-1/2","0","-1/2","-1/2","1/2","0","1/2","0","1/2","0","-1/2","0","-1/2","1/2","0","1/2","0","1/2","0","-1/2","0","-1/2","-1/2","0","0","0","1/2","0","0","-1/2","0","0","0","1/2","0","0","-1/2","0","0","1/2","0","0","-1/2","0","1/2","0","0","-1/2","0","1/2","-1/2","0","-1/2","0","-1/2","0","1/2","0"],["0","-1/2","0","0","0","1/2","0","1/2","0","0","0","-1/2","0","0","0","1/2","-1/2","1/2","1/2","0","0","1/2","0","-1/2","-1/2","0","-1/2","0","0","0","1/2","-1/2","0","0","1/2","-1/2","1/2","0","0","0","1/2","0","-1/2","-1/2","-1/2","0","0","1/2","1/2","1/2","0","0","0","-1/2","0","-1/2","-1/2","-1/2","1/2","1/2","0","0","0","1/2","0","-1/2","-1/2","1/2","1/2","0","1/2","0","0","0","-1/2","-1/2","-1/2","0","0","0","1/2","0","0","0","-1/2","0","0","1/2","0","0","0","-1/2","0","1/2","0","0","0","-1/2","1/2","0","0","0","-1/2","1/2","-1/2","-1/2","0","0","0","-1/2","0","1/2"],["0","0","-1/2","1/2","0","0","0","0","-1/2","-1/2","0","0","-1/2","1/2","0","0","-1/2","-1/2","0","0","-1/2","-1/2","-1/2","-1/2","0","0","0","-1/2","1/2","0","0","0","1/2","0","0","-1/2","0","0","0","-1/2","-1/2","-1/2","-1/2","0","0","-1/2","0","0","-1/2","0","0","0","1/2","1/2","-1/2","-1/2","0","-1/2","-1/2","0","0","0","-1/2","-1/2","-1/2","-1/2","0","0","1/2","1/2","-1/2","-1/2","0","0","0","1/2","-1/2","0","0","0","0","-1/2","-1/2","0","0","0","0","0","1/2","-1/2","0","0","0","0","-1/2","-1/2","0","0","0","1/2","-1/2","0","0","-1/2","-1/2","0","0","0","-1/2","-1/2","-1/2","-1/2"],["0","0","-1/2","0","1/2","0","0","0","-1/2","0","-1/2","0","-1/2","0","1/2","0","-1/2","0","-1/2","0","0","-1/2","-1/2","0","-1/2","0","0","-1/2","0","1/2","0","0","0","1/2","0","-1/2","-1/2","0","-1/2","0","-1/2","-1/2","0","-1/2","0","-1/2","1/2","0","0","-1/2","0","1/2","0","1/2","-1/2","0","-1/2","-1/2","0","-1/2","0","-1/2","0","-1/2","-1/2","0","-1/2","1/2","0","1/2","-1/2","0","-1/2","0","1/2","0","-1/2","0","0","0","0","-1/2","0","-1/2","0","0","0","0","1/2","0","-1/2","0","0","0","-1/2","0","-1/2","0","0","1/2","0","-1/2","0","-1/2","0","-1/2","0","-1/2","0","-1/2","1/2","0"],["0","0","-1/2","0","0","1/2","0","0","-1/2","0","0","-1/2","-1/2","0","0","1/2","-1/2","0","0","-1/2","-1/2","0","0","-1/2","-1/2","0","0","-1/2","0","0","1/2","0","0","0","1/2","-1/2","0","-1/2","-1/2","-1/2","0","0","-1/2","-1/2","0","-1/2","0","1/2","0","0","-1/2","1/2","1/2","0","0","-1/2","-1/2","-1/2","0","0","-1/2","-1/2","-1/2","0","0","-1/2","-1/2","1/2","1/2","0","0","-1/2","-1/2","1/2","0","0","-1/2","0","0","0","0","-1/2","0","0","-1/2","0","0","0","1/2","0","0","-1/2","0","0","-1/2","0","0","-1/2","0","1/2","0","0","-1/2","-1/2","0","0","-1/2","-1/2","-1/2","0","0","1/2"],["0","0","0","1/2","-1/2","0","0","0","0","-1/2","1/2","0","0","1/2","-1/2","0","0","-1/2","1/2","0","-1/2","0","0","-1/2","1/2","0","0","0","1/2","-1/2","0","0","1/2","-1/2","0","0","1/2","0","1/2","-1/2","0","0","-1/2","1/2","0","0","-1/2","0","-1/2","1/2","0","-1/2","1/2","0","0","-1/2","1/2","0","-1/2","1/2","0","1/2","-1/2","0","0","-1/2","1/2","-1/2","1/2","0","0","-1/2","1/2","0","-1/2","1/2","0","0","0","0","0","0","-1/2","1/2","0","0","0","0","0","-1/2","1/2","0","0","0","0","-1/2","1/2","0","0","0","-1/2","1/2","0","0","-1/2","1/2","0","-1/2","1/2","0","0","-1/2"],["0","0","0","1/2","0","-1/2","0","0","0","-1/2","0","1/2","0","1/2","0","-1/2","0","-1/2","0","1/2","0","-1/2","-1/2","0","1/2","0","0","0","1/2","0","-1/2","0","1/2","0","-1/2","0","0","1/2","1/2","0","-1/2","-1/2","0","1/2","0","0","0","-1/2","-1/2","0","1/2","-1/2","0","1/2","-1/2","0","1/2","0","-1/2","0","1/2","1/2","0","-1/2","-1/2","0","1/2","-1/2","0","1/2","-1/2","0","1/2","-1/2","0","1/2","0","0","0","0","0","0","-1/2","0","1/2","0","0","0","0","-1/2","0","1/2","0","0","0","-1/2","0","1/2","0","0","-1/2","0","1/2","0","-1/2","0","1/2","-1/2","0","1/2","-1/2","0"]]} diff --git a/research/coded-port-adapter-ceiling/source/CODED-PROOF-4929.md b/research/coded-port-adapter-ceiling/source/CODED-PROOF-4929.md new file mode 100644 index 0000000000..1f28d33884 --- /dev/null +++ b/research/coded-port-adapter-ceiling/source/CODED-PROOF-4929.md @@ -0,0 +1,80 @@ +# An exact center-free native offer with an invertible eight-mode code + +Prepared for Dugongue with substantial OpenAI Codex assistance. Apache-2.0. + +Building on Cinna Davis's center-free cache kernel in PR #4694, this gives an explicit free ground-chart helper pre-compensation and an invertible eight-mode main code: all eight rank-eight center Gaussian calls disappear, all 408 independent helper jobs remain, and the main cross-transfer is an explicitly known invertible constant code. It is not the old uncoded main ABI and does not by itself prove a new κ. + +## The exact offer + +Freeze the native source payload with SHA-256 `cfcd36b40326d7a5815e1db5313444379b3fb756b27d5201c561574c085cc0dd`. Its persistent logical rows are 112 X, 112 Y and 408 independent helpers H. The original normalized endpoint is `(X,Y,H) -> (X,Y+X,H)`. Physical entrance and exit charts remain exactly those of the frozen source. + +There is a completely emitted constant dyadic pre-compensation, followed by the source word with every center Gaussian operation replaced by an owned CLEAR, whose exact normalized endpoint is + +`X' = X; Y' = Y + A X; H' = H`. + +All 632 persistent inputs are arbitrary and independent; no helper is initialized, discarded, identified or counted twice. The literal backward construction has exact normalized endpoint + +`X' = X - A^T Y; Y' = Y; H' = H`, + +the raw inverse transpose of the forward endpoint. The paid profile in both directions is + +`{1:2201, 2:412, 3:510, 4:127, 5:40}`. + +The helper profile stays `{4:28,7:7,8:47,9:326}`. Relative to the source, exactly eight rank-eight children are removed and no Gaussian child is added. The pre-compensation adds 6,596 scalar ADDs with a retained scalar allowance of 32,652 primitives; all numerator magnitudes and denominators are at most 4. These finite scalar operations do not establish a better recursive exponent on their own. + +## Constructive proof + +Delete all eight center calls by replacing each with CLEAR of the owned center field in the call's destination chart. Zero has every chart, so this is a valid erasure of owned scratch, not a borrowed input overwrite. Retain every other physical instruction and every endpoint chart. + +The exact sparse replay over the rational free group algebra on the 72 native symbols gives + +`M_0 = I + S + E_X + E_H`. + +Here S is the original transfer X to Y. Both error blocks land only in Y. E_X reads X; E_H reads only 106 particular helpers, each with a ground entrance and full-frame exit. Every helper and every X output remains autonomous. All error terms have EMPTY native word: the errors are ordinary constant dyadic matrices, not uncomputed address-operator oracles. The 12,532 nonzero entries split into 5,936 in E_X and 6,596 in E_H. + +Every pairwise product of S, E_X and E_H is zero, because all three maps land in Y and none reads Y. Before executing the center-cleared word, apply `I-E_H`. Every required source and target is in the actual ground chart: the targets are Y and the sources are those 106 ground-ended helpers. The operation is the explicit list of 6,596 dyadic ADDs. + +Consequently + +`M_0 (I-E_H) = I+S+E_X`. + +Thus `A=I+E_X` on the 112 main port indices gives the claimed offer, with no helper contamination. Scalar operations in one common address chart have their exact owner-space action, so this is a physical fixed-template pre-compensation and not an abstract change of logical coordinates. + +For the backward direction, the separately emitted center-cleared source word is verified to equal `I-S^T-E_X^T-E_H^T`, with the source's distinct inverse-transpose native letters. Prepend `I+E_H^T`, again using only actual ground-chart fields. The product is `I-S^T-E_X^T`. The verifier compares all 632 independent rows in both orientations. The owned center field is empty at termination. + +## Explicit code, inverse and conditioning + +The same exact entries satisfy + +`E_X^T = E_X, E_X^2 = -14 E_X, tr(E_X) = -112`. + +Set `P=-E_X/14`. It is a real symmetric idempotent of trace 8, hence an orthogonal projection of rank 8. Therefore + +`A=I-14P`, + +with eigenvalue -13 on the eight-dimensional image of P and eigenvalue +1 on its 104-dimensional kernel. In particular + +`A^-1 = I + E_X/13`, + +and its Euclidean condition number is exactly 13. The complete main shear is I+N_A with N_A^2=0 and ||N_A||_2=13; both it and its inverse have norm at most 14, so its condition number is at most 196. Helpers are an independent identity block, and the physical boundary charts are unitary, so this same bound applies to the complete physical coded offer. Its inverse uses I-N_A and needs no 1/13 arithmetic; 1/13 appears only when separately inverting the main code A. Every diagonal entry of A is zero; its 5,824 nonzero off-diagonal entries are ±1/2. The exact checker verifies the degree-two polynomial entry by entry over rational arithmetic, so the spectrum and inverse are universal consequences of that identity rather than numerical eigenvalue observations. + +The coefficient 1/13 is part of the mathematical inverse formula. This deliverable does not call it a free dyadic SCALE, assume a division oracle, or insert A^-1 across different physical address charts without paying for the resulting adapters. + +## Arbitrary fiber widths + +The replay identities hold over Q[FreeGroup72]. Every consistently shared invertible assignment of the 72 native operators defines an evaluation homomorphism. Hence the logical word identity holds at every positive column multiplicity under the retained source native implementation. It does not rely on one-column matrix testing, erasure of central phases or tensor powers preserving sums. + +Every physical frame, native monomial and Gaussian child is retained from the authenticated source, except the eight deleted owned-center calls. The new instructions are only constant dyadic scalar operations at an explicitly common ground chart. No fresh nonmonomial address implementation is introduced. + +The exact observed maximum prefix coefficient ℓ1 norms are 457 forward and 258 backward, checked on the fixed free-symbol words. Unitary evaluation bounds intermediate exact states and perturbations at the initial input in the maximum-over-fields Euclidean fiber norm by fixed constants independent of fiber width. For discrepancies inserted at later sites, use a separate suffix bound: assign each scalar ADD or SCALE of coefficient c the bound 1+|c|, and every unitary Gaussian/monomial, owned CLEAR or owned COPY the bound 1. The product of these elementary bounds over the finite word bounds every suffix. Thus the sum of local error magnitudes times this fixed product bounds propagated rounding error; no prefix norm is substituted for a suffix norm. Entrywise infinity-norm statements require the appropriate square-root fiber-volume conversion. There is no precision-dependent epsilon and no recursive border-precision claim. + +## Integration boundary + +The old source wrapper's port-dependent entrance lines and exit hyperplanes remain. A is a constant matrix in the stated normalized logical coordinates. It must not be silently treated as a constant free recoding in every physical main chart or in a different standardized central-Q ABI. Its nonzero off-diagonal entries connect distinct entrance-line charts. A useful next step is an actual coded caller or a paid simultaneous adapter that exploits the eight-mode structure, together with complete moment, raw-dual, compiler, finite precision and outer recovery budgets. This document supplies the exact producer and its bill, not those missing consumers. + +## Predecessor overlap and credit + +Cinna Davis's PR #4694, head `2add42d1edf14a263abe90a3bcde67fc1ba30768`, already emits a center-free kernel with paid profile minus eight rank-eight calls, records its coupled cache ABI, constructs its raw dual, and proves that its 106 observed helpers start at the empty chart. The source CACHE.md was read directly. None of center deletion, the cold-helper observation or the abstract block Schur elimination is claimed here as new. PR #4698, scientific head `9079ab66ba9a1717df478a08eb957c20d84d3e61`, already emits a dyadic helper basis of 379 gates in each direction reducing observations to eight helpers, and a conditional consumer. The present deliberately dense 6,596-ADD pre-compensation is easier to audit, not a claim to a better basis count. Its changed sufficient result is the actual fixed-template helper-independent coded offer, explicit A entries, exact eight-mode spectrum/inverse/conditioning, and unchanged independent helper ABI. + + +Cao Yifan / intqwq supplies the joint-helper/native-map round-three word at canonical `research/kappa-round3-warp-20261022/ACTUAL-WORD.json.gz`, commit `624de9dc66858af0945e5f8a0942488d62280d43`. Its predecessor and refreshed public lineage includes PR #4610; the exact source package and bytes, rather than an older PR headline, bind this result. Cinna Davis, the PR #4470 native/helper/controller lineage, Dugongue's exact native and complementary-provider work, DaysSky, Nick Petalas, Ryanson Jonathan, Jacob Alan Sussman, zxv and the retained scalar, Clifford, precision, compiler and outer contributors retain predecessor credit. The common-chart pre-compensation and exact eight-mode code are the present construction. Local MathProof's Schur block elimination and low-rank composition notes motivated the representation; their source-only inspection is not a fresh Lean/kernel audit or a claim of priority for elementary projection algebra. diff --git a/research/coded-port-adapter-ceiling/source/CODED-WORDS.json.gz b/research/coded-port-adapter-ceiling/source/CODED-WORDS.json.gz new file mode 100644 index 0000000000..935fedd9c9 Binary files /dev/null and b/research/coded-port-adapter-ceiling/source/CODED-WORDS.json.gz differ diff --git a/research/coded-port-adapter-ceiling/source/EXPECTED-4929.json b/research/coded-port-adapter-ceiling/source/EXPECTED-4929.json new file mode 100644 index 0000000000..b02b5ebb8b --- /dev/null +++ b/research/coded-port-adapter-ceiling/source/EXPECTED-4929.json @@ -0,0 +1,41 @@ +{ + "all_632_arbitrary_rows": true, + "code_inverse": "I+E_X/13", + "code_spectrum": { + "-13": 8, + "1": 104 + }, + "condition_number_2": 13, + "new_kappa": null, + "precompensation_ADDs": 6596, + "precompensation_scalar_primitive_allowance": 32652, + "runs": [ + { + "backward": false, + "events": 28045, + "max_prefix_l1": "457", + "paid": { + "1": 2201, + "2": 412, + "3": 510, + "4": 127, + "5": 40 + } + }, + { + "backward": true, + "events": 28045, + "max_prefix_l1": "258", + "paid": { + "1": 2201, + "2": 412, + "3": 510, + "4": 127, + "5": 40 + } + } + ], + "source_payload_sha256": "cfcd36b40326d7a5815e1db5313444379b3fb756b27d5201c561574c085cc0dd", + "status": "PASS_CENTER_FREE_CODED_SUPPLIER", + "symmetric_defect_rank": 8 +} diff --git a/research/coded-port-adapter-ceiling/source/NOTICE-4929 b/research/coded-port-adapter-ceiling/source/NOTICE-4929 new file mode 100644 index 0000000000..42501d0a99 --- /dev/null +++ b/research/coded-port-adapter-ceiling/source/NOTICE-4929 @@ -0,0 +1,5 @@ +Cao Yifan / intqwq: authenticated joint-helper/native-map round-three word, canonical research/kappa-round3-warp-20261022, commit 624de9dc66858af0945e5f8a0942488d62280d43; PR4610 lineage. +Cinna Davis: PR4694 center-free/cache kernel and arbitrary-input raw dual, PR4698 cold-helper basis/conditional consumer; PR4440/4441/4447/4470 lineage. +Dugongue: present ground-chart helper pre-compensation and explicit invertible coded offer, with substantial OpenAI Codex assistance. +Retains native, E8, scalar, Clifford, compiler, precision, outer and contributor notices in the cited upstream sources; zxv, Jacob Alan Sussman, DaysSky, Nick Petalas and Ryanson Jonathan retain predecessor credit. +Apache-2.0. No independent human or formal proof-kernel review is claimed. diff --git a/research/coded-port-adapter-ceiling/source/clifford_exact.py b/research/coded-port-adapter-ceiling/source/clifford_exact.py new file mode 100644 index 0000000000..166841a037 --- /dev/null +++ b/research/coded-port-adapter-ceiling/source/clifford_exact.py @@ -0,0 +1,149 @@ +"""Small exact Gaussian-dyadic Clifford compiler, independent of gx internals. +Paulis use i^p X^x Z^z. State vectors use integer Gaussian numerators / 2^d. +The tableau is supplemented by a literal circuit, so global phases are kept. +""" +from dataclasses import dataclass + +def parity(x):return x.bit_count()&1 +def rank(rows): + p={} + for x in rows: + while x: + b=x.bit_length()-1 + if b not in p:p[b]=x;break + x^=p[b] + return len(p) +def transpose(rows,n):return tuple(sum(((rows[j]>>i)&1)<>j&1);a[j],a[k]=a[k],a[j] + for i in range(n): + if i!=j and a[i]>>j&1:a[i]^=a[j] + assert [r&((1<>n for r in a) +def basis_extend(cols,n): + out=[] + for x in list(cols)+[1<len(out):out.append(x) + assert len(out)==n + return tuple(out) +def nullspace(rows,n): + a=list(rows);p=[];k=0 + for j in range(n): + t=next((i for i in range(k,len(a)) if a[i]>>j&1),None) + if t is None:continue + a[t],a[k]=a[k],a[t] + for i in range(len(a)): + if i!=k and a[i]>>j&1:a[i]^=a[k] + p.append(j);k+=1 + return tuple((1<>j)&1)<>i&1:out=pmul(out,T[i]) + for i in range(n): + if z>>i&1:out=pmul(out,T[n+i]) + return out +def compose(A,B):return tuple(apply(A,p) for p in B) +def inverse(T): + n=len(T)//2;cols=[x|(z<>n;u,v,p=apply(T,(x,z,0));assert (u,v)==identity(n)[j][:2];out.append((x,z,(-p)%4)) + return tuple(out) +def qvalue(Q,alpha,x,n): + return (sum(alpha[i] for i in range(n) if x>>i&1)+2*sum(parity((Q[i]>>(i+1))&(x>>(i+1))) for i in range(n) if x>>i&1))%4 +def mul_i(a,p): + x,y=a;p%=4 + return [(x,y),(-y,x),(-x,-y),(y,-x)][p] +@dataclass +class Op: + n:int + tab:tuple + circuit:list + def then(self,b): + assert self.n==b.n + return Op(self.n,compose(b.tab,self.tab),self.circuit+b.circuit) + def adjoint(self): + circ=[] + for e in reversed(self.circuit): + if e[0]=='P':circ.append(('P',inv(e[1],self.n))) + elif e[0]=='D':circ.append(('D',e[1],tuple((-x)%4 for x in e[2]))) + elif e[0]=='C':circ.append(('C',e[1],-e[2])) + elif e[0]=='phase':circ.append(('phase',(-e[1])%4)) + else:circ.append(e) + return Op(self.n,inverse(self.tab),circ) + def zero_state(self,basis=0): + N=1<>i)&1 for i in range(n)) + assert all(alpha[i]%2==(Q[i]>>i)&1 for i in range(n)) + return Op(n,tuple([(1<>i&1 else 0,1<>i&1 else 0) for i in range(n)]),[('C',q,sgn)]) +def xgate(n,b):return Op(n,tuple([(1<>i)&1)) for i in range(n)]),[('X',b)]) +def fourier(n,axes=None): + out=ident(n) + for i in range(n) if axes is None else axes:out=out.then(cgate(n,1<len(selected):picks.append(j);selected.append(x) + assert len(picks)==r and all(x>>r==0 for x in Bcols) + Br=transpose(selected,r);Bi=inv(Br,r);Dr=transpose([Dcols[j]&((1< 0, 'positive interval denominator') + return mul(a, rounded(1/b[1], 1/b[0])) + + +@lru_cache(None) +def log_bounds(n): + """Exact atanh series, binary reduction; round only the final interval.""" + need(isinstance(n, int) and n >= 1, 'positive integer logarithm') + + def series(x): + u = (x-1)/(x+1) + term, total = u, Q(0) + for j in range(80): + total += 2*term/(2*j+1) + term *= u*u + tail = 2*term/(161*(1-u*u)) + return total, total+tail + + k = n.bit_length()-1 + a, b = series(Q(2)) + c, d = series(Q(n, 2**k)) + return rounded(k*a+c, k*b+d) + + +def exp_point(x): + """Outward fixed-point Taylor enclosure, with binary scaling/squaring.""" + need(abs(x) < 16, 'bounded exponential argument') + if x < 0: + a, b = exp_point(-x) + return rounded(1/b, 1/a) + divisions = 0 + while x > Q(1, 2): + x /= 2 + divisions += 1 + term = total = (Q(1), Q(1)) + for j in range(1, 65): + term = scale(term, x/j) + total = rounded(total[0]+term[0], total[1]+term[1]) + following = scale(term, x/65) + # Every remaining ratio is <= 1/132. Twice the next term is safe. + result = rounded(total[0], total[1]+2*following[1]) + for _ in range(divisions): + result = mul(result, result) + return result + + +def exp_interval(a): + return exp_point(a[0])[0], exp_point(a[1])[1] + + +@lru_cache(None) +def power(n, exponent): + return exp_interval(scale(log_bounds(n), exponent)) + + +def moment(histogram, exponent): + low = high = Q(0) + for n, count in histogram.items(): + a, b = power(n, exponent) + low += count*a + high += count*b + return rounded(low, high) + + +def display(a): + unit = 10**30 + + def fixed(n): + sign = '-' if n < 0 else '' + s = str(abs(n)).rjust(31, '0') + return sign+s[:-30]+'.'+s[-30:] + + return {'lower': fixed((a[0]*unit).__floor__()), + 'upper': fixed(-((-a[1]*unit).__floor__()))} + + +def encoded(x): + if isinstance(x, Q): + return str(x) + if isinstance(x, dict): + return {str(k): encoded(v) for k, v in x.items()} + if isinstance(x, (list, tuple)): + return [encoded(v) for v in x] + return x + + +def source_environment(path): + env = {'__file__': str(path), '__name__': 'pinned_source_oracle'} + exec(compile(path.read_bytes(), str(path), 'exec'), env) + return env + + +def authenticate(): + result = {} + for row in json.loads((HERE/'VENDOR.json').read_text())['files']: + path = HERE/'vendor'/Path(row['path']).relative_to( + 'research/higher-moment-strictification/vendor') + digest = sha256(path.read_bytes()).hexdigest() + need(digest == row['sha256'], 'changed source: '+row['path']) + raw = path.read_bytes() + need(sha1(b'blob '+str(len(raw)).encode()+b'\0'+raw).hexdigest() + == row['git_blob'], 'changed Git source blob') + result[row['path']] = digest + return result + + +def invoice_oracle(): + """Run #4426 unchanged, rebinding only its two file-location globals.""" + path = HERE/'vendor/invoice-review/verify.py' + env = source_environment(path) + env.update(ROOT=path.parent, PHASES='DATA-PHASES.json') + output = io.StringIO() + with redirect_stdout(output): + env['main']() + result = json.loads(output.getvalue()) + need(result['status'] == 'PASS_PR4416_INVOICE_REBUILD', 'source invoice oracle') + need({int(k): v for k, v in result['targets'].items()} == T + and {int(k): v for k, v in result['paid'].items()} == P, + 'exact literal-word invoice') + return result + + +def tail_certificate(v=150, cutoff=10, floor=15, u=Q(3, 10)): + t = 1-C + need(v >= 1 and 1 < cutoff < floor < 121, 'strict finite ranks') + need(t+u >= 1, 'tail moment exponent at least one') + target, paid = moment(T, t), moment(P, t) + alpha = divide(paid, target) + gamma = divide(moment(P, t+u), mul(power(cutoff, u), target)) + delta = divide((Q(sum(T.values())*floor),)*2, + mul(power(cutoff, C), target)) + limits = (1-Q(1, 10**8), Q(181, 200), Q(439, 500)) + for name, bounds, limit in zip(('alpha', 'gamma', 'delta'), + (alpha, gamma, delta), limits): + need(0 < bounds[0] <= bounds[1] < limit < 1, name+' certified limit') + a, g, d = limits + bound = 1/(1+v*(1-a))+2*g**v+2*d**v + need(bound < 1, 'complete charged normalized moment') + old_gamma = divide((Q(sum(k*n for k, n in P.items())),)*2, + mul(power(cutoff, C), target)) + old_lower = alpha[0]**v+2*old_gamma[0]**v + need(old_lower > 1, 'rank-one-tail estimate fails at this tensor power') + return {'tensor_power': v, 'cutoff_base': cutoff, 'floor_base': floor, + 'paid_moment_exponent': t+u, 'tail_offset_u': u, + 'tested_saving': C, 'alpha': display(alpha), 'gamma': display(gamma), + 'delta': display(delta), 'rational_upper_limits': limits, + 'normalized_paid_upper': bound, 'strict_moment_gap': display((1-bound,)*2), + 'old_rank_one_gamma': display(old_gamma), + 'old_rank_one_bound_lower': display((old_lower, old_lower)), + 'ambient': '121^'+str(v), 'minimum_target': str(floor)+'^'+str(v), + 'maximum_paid': str(cutoff)+'^'+str(v), + 'productive_fields_before_uniform_compiler': '7688^'+str(v), + 'rank_one_surplus': '131723^'+str(v)+'-131115^'+str(v), + 'materialized_product_or_uniform_word': False} + + +def uniform_rank(v): + t, p, theta = 1-C, 13, Q(6, 7) + gap = (C-KAPPA)/7 + uniform_saving = C-gap + need(10**7 < 15**6, 'theta upper bound') + need(2*(10**v)**7 <= (121**v)**6, 'shifted logarithm inequality') + eta = scale(exp_interval(scale(log_bounds(121), -v*C)), t) + need(eta[0] > theta**p, 'exit contraction below complement capacity') + base = exp_interval(scale(log_bounds(121), v*C)) + need(base[1] < 2**p, 'entire ordinary base range fits') + # Integer grid: gap*H is integral, avoiding enormous rational powers. + step = gap.denominator + need(gap.numerator == 1, 'chosen rational gap grid') + + def passes(j): + H = step*j + return (H+1)**p < 2**j + + lo, hi = 1, 2 + while not passes(hi): + lo, hi = hi, 2*hi + while hi-lo > 1: + mid = (lo+hi)//2 + if passes(mid): + hi = mid + else: + lo = mid + H = step*hi + need(H > 7*v and passes(hi) and not passes(hi-1), 'final integer comparison') + need(eta[1] < theta**(p-1), 'one smaller logarithmic power fails') + return {'t': t, 'uniform_saving': uniform_saving, 'gap': gap, + 'logarithm_power': p, 'theta_upper': theta, 'eta': display(eta), + 'eta_minus_theta_to_p': display((eta[0]-theta**p, eta[1]-theta**p)), + 'm_to_saving': display(base), 'H': H, 'N': '2^'+str(H), + 'integer_test': {'left_base': H+1, 'left_exponent': p, + 'right_base': 2, 'right_exponent': hi}, + 'grid_step': step, 'previous_grid_point_rejected': True, + 'smaller_logarithmic_power_rejected': True} + + +def power_majorant_comparison(v, uniform_saving): + """Retain #4416's older power proof, changing only the new unit's ranks.""" + t, z, h = 1-C, 1-uniform_saving, Q(1, 7) + z0 = (t+z)/2 + delta = z0-t + B, debt = (4+7*h)*v, 1+7*v*(1-z0) + ratio = (delta*B+debt)/(h*delta) + H0 = -((-ratio.numerator)//ratio.denominator) + ratio = H0*(1-z0)/(z-z0) + H1 = ratio.numerator//ratio.denominator+1 + need(H0 >= 7*v and H0*h*delta >= delta*B+debt, 'power majorant threshold') + need((H0-1)*h*delta < delta*B+debt, 'previous power threshold rejected') + need(H1*(z-z0) > H0*(1-z0) >= (H1-1)*(z-z0), + 'strict power-majorant comparison and previous-rank control') + return {'H0': H0, 'H1': H1, 'N': '2^'+str(H1), 'theta_upper': 1-h, + 'scope': 'Tail transformation alone, retaining the older power majorant.'} + + +def outer_ledger(uniform_saving): + d = (C-KAPPA)/7 + params = {'kappa': KAPPA, 'tested_saving': C, + 'complex_uniform_saving': uniform_saving, 'b': KAPPA+5*d, + 'a': KAPPA+4*d, 'q': KAPPA+3*d, 'bit_saving': Q('0.0027'), + 'epsilon': 1-d, 'beta': 1-3*d, 'r0': d/10, + 'stop': d, 'layout': d, 'd': d} + env = source_environment(HERE/'vendor/outer_endpoint.py') + row = env['ledger'](params) + need(len(row['strict_checks']) == 54 and len(row['functional_checks']) == 3, + 'complete first outer ledger') + need(all(v > 0 for group in ('strict_checks', 'functional_checks') + for v in row[group].values()), 'all outer predicates') + frozen = json.loads((HERE/'vendor/p7-RESULT.json').read_text())['endpoint']['outer'] + need(encoded(row) == frozen, 'unchanged full p7 endpoint ledger') + parsed = ast.parse((HERE/'vendor/check_ledger.py').read_bytes()) + function = next(n for n in parsed.body + if isinstance(n, ast.FunctionDef) and n.name == 'ledger') + constants = [n for n in parsed.body if isinstance(n, ast.Assign) + and any(isinstance(t, ast.Name) and t.id.startswith('KAPPA_') + for t in n.targets)] + eps, beta, q, a = (params[k] for k in ('epsilon', 'beta', 'q', 'a')) + grid = 10**10 + backoff = Q((eps*q*grid).__floor__(), grid)-KAPPA + need(backoff > 0, 'strict derived oracle grid backoff') + oracle = {'Q': Q, 'R0': params['r0'], 'ZETA': Q(1, 10**8), + 'SLACK': d, 'STOP': d, 'FLOOR': grid, 'BACKOFF': backoff, + 'EPS': eps, 'BETA': beta, 'THETA_POWER': Q(2), + 'HALO_POWER': 48, 'CORE_POWER': 128, 'STRASSEN_TAU': Q(45, 16), + 'b': params['b'], 'q': q, 'a': a, 'bit': params['bit_saving'], + 'online': Q('0.001730970419199163702738'), + 'old': Q('0.001730970419199163702738')} + code = ast.fix_missing_locations(ast.Module(body=constants+[function], type_ignores=[])) + exec(compile(code, 'pinned 63-predicate ledger', 'exec'), oracle) + second = oracle['ledger']('higher_moment_smaller_ranks') + need(second['kappa'] == KAPPA and second['margins'] == row['margins'], + 'all nine rows match both ledgers') + need(len(second['strict_checks']) == 63 and + all(v > 0 for v in second['strict_checks'].values()), 'all 63 legacy predicates') + controls = {} + for name, updates in [('closed_epsilon', {'epsilon': Q(1)}), + ('missing_layout', {'layout': Q(0)}), + ('unfunded_kappa', {'kappa': C}), + ('closed_uniform_gap', {'complex_uniform_saving': params['b']}), + ('insufficient_BIT', {'bit_saving': Q('0.0023')})]: + bad = env['ledger'](dict(params, **updates)) + failed = sorted(k for k, v in bad['strict_checks'].items() if v <= 0) + need(failed, 'outer control rejected: '+name) + controls[name] = failed + for name, options in [('old_per_axis_scan', {'old_scan': True}), + ('group_equals_dimension', {'beta_': eps})]: + bad = oracle['ledger']('reject_'+name, **options) + failed = sorted(k for k, v in bad['strict_checks'].items() if v <= 0) + need(failed, 'legacy control rejected: '+name) + controls[name] = failed + return {'ledger': row, 'legacy_63_checks': second['strict_checks'], + 'legacy_grid': grid, 'legacy_backoff': backoff, + 'minimum_margin_minus_kappa': min(row['margins'].values())-KAPPA, + 'rejected_controls': controls} + + +def finite_controls(): + def tensor(histogram): + out = Counter() + for k, n in histogram.items(): + for h, b in histogram.items(): + out[k*h] += n*b + return out + + def split(histogram, cutoff): + out = Counter() + for k, n in histogram.items(): + q, r = divmod(k, cutoff) + out[cutoff] += q*n + if r: + out[r] += n + return +out + + target, paid = tensor({2:1, 5:1}), tensor({1:2, 4:1}) + padded, completion = Counter(), Counter() + for k, n in target.items(): + padded[max(k, 9)] += n + if k < 9: + completion[9-k] += n + final = split(paid+completion, 4) + mass = lambda x: sum(k*n for k, n in x.items()) + need(mass(padded)-mass(final) == 7**2-6**2 == 13, 'exact paid padding mass') + need(min(padded) > max(final), 'exact toy separation') + need(final == Counter({1:5, 4:9}), 'literal toy expanded inventory') + # t=1/2, sigma=3/4, R=100, J=1 refutes a sublinear tail extension. + invalid = power(100, Q(1, 2))[1]+2*power(100, Q(3, 4))[1] + need(invalid < 100, 'sublinear upper-tail moment cannot bound splitting') + return {'toy_targets': padded, 'toy_paid': final, 'rank_one_surplus': 13, + 'sublinear_tail_counterexample': {'R': 100, 'J': 1, 't': '1/2', + 'sigma': '3/4', 'actual_charge': 100, + 'invalid_upper': display((invalid, invalid))}} + + +def verify(): + sources = authenticate() + invoice = invoice_oracle() + tail = tail_certificate() + rank = uniform_rank(tail['tensor_power']) + endpoint = outer_ledger(rank['uniform_saving']) + controls = finite_controls() + rejected = [] + for name, updates, expected in [ + ('too_short_product', {'v': 100}, 'complete charged normalized moment'), + ('sublinear_tail', {'u': C/2}, 'tail moment exponent at least one'), + ('lost_separation', {'floor': 10}, 'strict finite ranks'), + ]: + try: + tail_certificate(**updates) + except ValueError as error: + need(str(error) == expected, 'wrong rejection: '+name) + rejected.append({'mutation': name, 'failed_at': str(error)}) + else: + raise ValueError('accepted mutation: '+name) + old = json.loads((HERE/'vendor/p7-RESULT.json').read_text())['endpoint']['compiler'] + return encoded({'schema': 'higher-moment-native-strictification/1', + 'status': 'PASS_HIGHER_MOMENT_STRICTIFICATION', 'kappa': KAPPA, + 'invoice_oracle': invoice, 'strictification': tail, + 'uniform_rank': rank, 'outer': endpoint, + 'tail_only_power_majorant': power_majorant_comparison( + tail['tensor_power'], rank['uniform_saving']), + 'finite_controls': controls, 'rejected_mutations': rejected, + 'predecessor_H': old['H1'], + 'rank_exponent_reduction_factor': Q(old['H1'], rank['H']), + 'tensor_power_reduction_factor': Q(6240, tail['tensor_power']), + 'source_sha256': sources, + 'verifier_sha256': sha256(Path(__file__).read_bytes()).hexdigest(), + 'scope': 'Conditional charged transformation and finite compiler rank. Native all-column, physical, analytic, precision, storage, fixed-tape and recovery premises remain inherited. No new kappa, selected frontier or practical word.'}) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--out', type=Path) + args = parser.parse_args() + result = verify() + if args.out: + need(not args.out.exists(), 'new output path required') + args.out.write_text(json.dumps(result, indent=2, sort_keys=True)+'\n') + else: + need(json.loads((HERE/'RESULT.json').read_text()) == result, 'changed saved receipt') + print(json.dumps({'status': result['status'], 'tensor_power': result['strictification']['tensor_power'], + 'uniform_rank': result['uniform_rank']['N'], + 'strict_moment_gap': result['strictification']['strict_moment_gap'], + 'kappa': result['kappa']})) + + +if __name__ == '__main__': + main() diff --git a/research/coded-port-adapter-ceiling/verify.py b/research/coded-port-adapter-ceiling/verify.py new file mode 100644 index 0000000000..0b82c4028c --- /dev/null +++ b/research/coded-port-adapter-ceiling/verify.py @@ -0,0 +1,36 @@ +#!/usr/bin/env python3 +"""Read-only portable verifier for the scoped coded-port adapter ceiling. +Apache-2.0; substantial OpenAI Codex assistance, source credit in ATTRIBUTION.md. +""" +from hashlib import sha256 +from pathlib import Path +import json +import sys + +HERE = Path(__file__).resolve().parent +sys.dont_write_bytecode = True + + +def authenticate(): + manifest = json.loads((HERE / 'SCIENCE.json').read_text()) + for row in manifest['files']: + path = HERE / row['path'] + if path.is_symlink() or sha256(path.read_bytes()).hexdigest() != row['sha256']: + raise ValueError('Frozen science bytes differ: ' + row['path']) + + +def main(): + authenticate() + scope = {'__name__': 'coded_port_scoped_core', '__file__': str(HERE/'check_core.py')} + # Compile authenticated bytes directly: no ambient source or stale pyc import. + exec(compile((HERE/'check_core.py').read_bytes(), str(HERE/'check_core.py'), 'exec'), scope) + result = json.loads(json.dumps(scope['run'](HERE))) + if result != json.loads((HERE/'RESULT.json').read_text()): + raise ValueError('Fixed scientific receipt differs') + authenticate() + print('PASS_CODED_PORT_ADAPTER_CEILING 5824supported_grade2 ' + '112grade2channels_one_bank 4semantic_controls exact_intervals no_new_kappa') + + +if __name__ == '__main__': + main()