From 830a94bf25479adf0694407e88cc5d15a9359d69 Mon Sep 17 00:00:00 2001 From: Andrey Mas <67960725+an664@users.noreply.github.com> Date: Wed, 14 Oct 2026 11:23:33 +0400 Subject: [PATCH] instantiate p112 integral retraction in lean --- .../p112-integral-retraction-instance/LICENSE | 202 + .../README.md | 150 + .../REPAIR.diff | 24 + .../REPLAY.json | 4042 ++++++++++++ .../REVIEW.md | 30 + .../SOURCES.json | 239 + .../TASK.json | 108 + .../VERIFY.json | 84 + .../source/BINDING.tsv | 5467 +++++++++++++++++ .../source/DECLARATIONS.tsv | 637 ++ .../source/GENERATED_FILES.txt | 39 + .../source/LICENSE | 202 + .../source/MANIFEST.tsv | 66 + .../source/P112.json | 1 + .../source/P112/MP00.lean | 116 + .../source/P112/MP01.lean | 116 + .../source/P112/MP02.lean | 116 + .../source/P112/MP03.lean | 116 + .../source/P112/MP04.lean | 116 + .../source/P112/MP05.lean | 116 + .../source/P112/MP06.lean | 116 + .../source/P112/MP07.lean | 116 + .../source/P112/MP08.lean | 116 + .../source/P112/MP09.lean | 116 + .../source/P112/MP10.lean | 116 + .../source/P112/MP11.lean | 116 + .../source/P112/MP12.lean | 116 + .../source/P112/MP13.lean | 116 + .../source/P112/MP14.lean | 116 + .../source/P112/MP15.lean | 116 + .../source/P112/MP16.lean | 116 + .../source/P112/MP17.lean | 116 + .../source/P112/QP00.lean | 116 + .../source/P112/QP01.lean | 116 + .../source/P112/QP02.lean | 26 + .../source/P112/Residual00.lean | 76 + .../source/P112/Residual01.lean | 76 + .../source/P112/Residual02.lean | 76 + .../source/P112/Residual03.lean | 76 + .../source/P112/Residual04.lean | 76 + .../source/P112/Residual05.lean | 76 + .../source/P112/Residual06.lean | 76 + .../source/P112/Residual07.lean | 76 + .../source/P112/Residual08.lean | 76 + .../source/P112/Residual09.lean | 76 + .../source/P112/Residual10.lean | 76 + .../source/P112/Residual11.lean | 76 + .../source/P112/Residual12.lean | 76 + .../source/P112Certificate.lean | 953 +++ .../source/P112Consequences.lean | 110 + .../source/P112Damaged.lean | 80 + .../source/P112Data.lean | 1649 +++++ .../source/P112Sparse.lean | 83 + .../source/PR1497Bridge.lean | 1405 +++++ .../source/PRODUCER_CHECKS.json | 119 + .../source/PROVENANCE.json | 55 + .../source/README.md | 127 + .../source/REPLAY_PLAN.json | 53 + .../source/SCOPE.md | 279 + .../source/SHA256SUMS | 66 + .../source/audit_sources.py | 171 + .../source/check_axioms.py | 73 + .../source/check_numeric.py | 115 + .../source/fixtures/RejectDamagedW.lean | 18 + .../source/generate.py | 374 ++ .../source/producer/integer-check.stderr | 0 .../source/producer/integer-check.stdout | 46 + .../source/producer/regeneration.stderr | 0 .../source/producer/regeneration.stdout | 15 + .../source/producer/source-audit.stderr | 0 .../source/producer/source-audit.stdout | 24 + .../source/producer/tooling-tests.stderr | 19 + .../source/producer/tooling-tests.stdout | 0 .../source/replay.py | 209 + .../source/test_tooling.py | 111 + 75 files changed, 20779 insertions(+) create mode 100644 research/p112-integral-retraction-instance/LICENSE create mode 100644 research/p112-integral-retraction-instance/README.md create mode 100644 research/p112-integral-retraction-instance/REPAIR.diff create mode 100644 research/p112-integral-retraction-instance/REPLAY.json create mode 100644 research/p112-integral-retraction-instance/REVIEW.md create mode 100644 research/p112-integral-retraction-instance/SOURCES.json create mode 100644 research/p112-integral-retraction-instance/TASK.json create mode 100644 research/p112-integral-retraction-instance/VERIFY.json create mode 100644 research/p112-integral-retraction-instance/source/BINDING.tsv create mode 100644 research/p112-integral-retraction-instance/source/DECLARATIONS.tsv create mode 100644 research/p112-integral-retraction-instance/source/GENERATED_FILES.txt create mode 100644 research/p112-integral-retraction-instance/source/LICENSE create mode 100644 research/p112-integral-retraction-instance/source/MANIFEST.tsv create mode 100644 research/p112-integral-retraction-instance/source/P112.json create mode 100644 research/p112-integral-retraction-instance/source/P112/MP00.lean create mode 100644 research/p112-integral-retraction-instance/source/P112/MP01.lean create mode 100644 research/p112-integral-retraction-instance/source/P112/MP02.lean create mode 100644 research/p112-integral-retraction-instance/source/P112/MP03.lean create mode 100644 research/p112-integral-retraction-instance/source/P112/MP04.lean create mode 100644 research/p112-integral-retraction-instance/source/P112/MP05.lean create mode 100644 research/p112-integral-retraction-instance/source/P112/MP06.lean create mode 100644 research/p112-integral-retraction-instance/source/P112/MP07.lean create mode 100644 research/p112-integral-retraction-instance/source/P112/MP08.lean create mode 100644 research/p112-integral-retraction-instance/source/P112/MP09.lean create mode 100644 research/p112-integral-retraction-instance/source/P112/MP10.lean create mode 100644 research/p112-integral-retraction-instance/source/P112/MP11.lean create mode 100644 research/p112-integral-retraction-instance/source/P112/MP12.lean create mode 100644 research/p112-integral-retraction-instance/source/P112/MP13.lean create mode 100644 research/p112-integral-retraction-instance/source/P112/MP14.lean create mode 100644 research/p112-integral-retraction-instance/source/P112/MP15.lean create mode 100644 research/p112-integral-retraction-instance/source/P112/MP16.lean create mode 100644 research/p112-integral-retraction-instance/source/P112/MP17.lean create mode 100644 research/p112-integral-retraction-instance/source/P112/QP00.lean create mode 100644 research/p112-integral-retraction-instance/source/P112/QP01.lean create mode 100644 research/p112-integral-retraction-instance/source/P112/QP02.lean create mode 100644 research/p112-integral-retraction-instance/source/P112/Residual00.lean create mode 100644 research/p112-integral-retraction-instance/source/P112/Residual01.lean create mode 100644 research/p112-integral-retraction-instance/source/P112/Residual02.lean create mode 100644 research/p112-integral-retraction-instance/source/P112/Residual03.lean create mode 100644 research/p112-integral-retraction-instance/source/P112/Residual04.lean create mode 100644 research/p112-integral-retraction-instance/source/P112/Residual05.lean create mode 100644 research/p112-integral-retraction-instance/source/P112/Residual06.lean create mode 100644 research/p112-integral-retraction-instance/source/P112/Residual07.lean create mode 100644 research/p112-integral-retraction-instance/source/P112/Residual08.lean create mode 100644 research/p112-integral-retraction-instance/source/P112/Residual09.lean create mode 100644 research/p112-integral-retraction-instance/source/P112/Residual10.lean create mode 100644 research/p112-integral-retraction-instance/source/P112/Residual11.lean create mode 100644 research/p112-integral-retraction-instance/source/P112/Residual12.lean create mode 100644 research/p112-integral-retraction-instance/source/P112Certificate.lean create mode 100644 research/p112-integral-retraction-instance/source/P112Consequences.lean create mode 100644 research/p112-integral-retraction-instance/source/P112Damaged.lean create mode 100644 research/p112-integral-retraction-instance/source/P112Data.lean create mode 100644 research/p112-integral-retraction-instance/source/P112Sparse.lean create mode 100644 research/p112-integral-retraction-instance/source/PR1497Bridge.lean create mode 100644 research/p112-integral-retraction-instance/source/PRODUCER_CHECKS.json create mode 100644 research/p112-integral-retraction-instance/source/PROVENANCE.json create mode 100644 research/p112-integral-retraction-instance/source/README.md create mode 100644 research/p112-integral-retraction-instance/source/REPLAY_PLAN.json create mode 100644 research/p112-integral-retraction-instance/source/SCOPE.md create mode 100644 research/p112-integral-retraction-instance/source/SHA256SUMS create mode 100644 research/p112-integral-retraction-instance/source/audit_sources.py create mode 100644 research/p112-integral-retraction-instance/source/check_axioms.py create mode 100644 research/p112-integral-retraction-instance/source/check_numeric.py create mode 100644 research/p112-integral-retraction-instance/source/fixtures/RejectDamagedW.lean create mode 100644 research/p112-integral-retraction-instance/source/generate.py create mode 100644 research/p112-integral-retraction-instance/source/producer/integer-check.stderr create mode 100644 research/p112-integral-retraction-instance/source/producer/integer-check.stdout create mode 100644 research/p112-integral-retraction-instance/source/producer/regeneration.stderr create mode 100644 research/p112-integral-retraction-instance/source/producer/regeneration.stdout create mode 100644 research/p112-integral-retraction-instance/source/producer/source-audit.stderr create mode 100644 research/p112-integral-retraction-instance/source/producer/source-audit.stdout create mode 100644 research/p112-integral-retraction-instance/source/producer/tooling-tests.stderr create mode 100644 research/p112-integral-retraction-instance/source/producer/tooling-tests.stdout create mode 100644 research/p112-integral-retraction-instance/source/replay.py create mode 100644 research/p112-integral-retraction-instance/source/test_tooling.py diff --git a/research/p112-integral-retraction-instance/LICENSE b/research/p112-integral-retraction-instance/LICENSE new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/research/p112-integral-retraction-instance/LICENSE @@ -0,0 +1,202 @@ + + 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/p112-integral-retraction-instance/README.md b/research/p112-integral-retraction-instance/README.md new file mode 100644 index 0000000000..d892249eb4 --- /dev/null +++ b/research/p112-integral-retraction-instance/README.md @@ -0,0 +1,150 @@ +# P112 integral retraction instance + +The fixed P112 integer matrices now instantiate the conditional Lean bridge in +[PR1610](https://github.com/CrocSwap/integer-mult-bounds/pull/1610). +Local Lean 4.30.0 replay accepts all 40 positive units and 636 named axiom reports, +including the unchanged dependency. The damaged-W control fails at its intended +false equality. This is a finite matrix certificate and its inherited algebraic +consequences, not a proof of the geometric premises needed to use them. + +The complete 65-member canonical payload and checksum inventory authenticate. +All six normal/optimized Python source, integer and tooling checks pass. The +unchanged dedicated replay command also passes locally on the packaged closure; +its evidence is separate from the generic Python hook. + +## Exact result + +The preserved `source/P112.json` is the complete +`/units/P112/gluing_lattice_certificate` fragment of PR1497's saved certificate. +It defines ordinary integer matrices of shapes + +```text +M : 288 x 104, P : 104 x 33, Q : 33 x 104, W : 104 x 288. +``` + +`P112Cert.certificate` proves, without a matrix-certificate hypothesis, +`MP = 0`, `QP = I_33` and `I_104 - PQ = WM` under the unchanged +`PR1497.MatrixIdentities` definitions. A proved sparse-row adapter connects the +literal coefficients to the dependency's ordinary finite integer matrix product. +The staged ordinary `decide` proofs cover all 21,409 scalar obligations. Neither +a Python result nor an unchecked evaluator is imported as a proof. + +`P112Consequences.lean` binds the existing image/kernel equality, surjectivity, +actual image-difference quotient isomorphism and lattice saturation to these +constants. Its multiplicative reconstruction, converse and parameter-uniqueness +statements quantify over an explicitly lawful `PR1497.CommGroup` and retain the +individual relation-row hypotheses where required. They do not supply a field +nonzero-element adapter or prove that geometry establishes those relations. + +The coordinate labels, anchors and copied `rankMetadata := 71` remain metadata. +No numeric rank operation or rank-71 theorem is defined. Geometry reconstruction, +generator-to-relation coverage, P120, zero exclusion, local Lemma 5, decoder K, +physical supplier budgets and the multiplication theorem remain outside scope. +The selected frontier is unchanged. See the exact interfaces and exclusions in +the preserved producer `source/SCOPE.md`. + +## Sources and repair + +The mathematical parents are [PR1497](https://github.com/CrocSwap/integer-mult-bounds/pull/1497) +at `7a1309f18f56d04c2db33bf1607e0332d19f72b3` and PR1610 at +`985fd79ffea7ae7375fe6aa3ce9940b125c7dca2`. `SOURCES.json` pins the public +audit, verifier and exact vendored bridge, and records the operator's extraction +from the authenticated saved numerical certificate. The 13,183-byte fragment +has SHA256 `a1b43a5a7a8dcce0b84858244c512e53e6c344877cc35e87937fedd2601f29d5`; +the 48,758-byte unchanged dependency has SHA256 +`a27494b0d40bbf7874fd9a875e468c67d11545b266e17bc98f2ca75c77f6ee40`. + +The full input can be regenerated using the pinned PR1497 verifier and its documented `python3 -I -B verify.py --certificate-out certificate.json` command, then reading `/units/P112/gluing_lattice_certificate` and serializing sorted keys with compact JSON separators, UTF-8 and a final newline. The operator rechecked the saved full-certificate hash and exact subobject equality before publication; its reported rank metadata is not promoted to a theorem. + +The producer supplied source without running Lean. The original local run stopped +at the certificate's rewrite elaboration error after 37 accepted units; its +printed error-generated `sorryAx` reports were rejected. GPT-6 Pro supplied three +exact source repair sites: normalization before existing rewrites in the +generator and two damaged-certificate proofs. Regeneration updates the certificate +and four declaration line numbers. Statements, matrices, dependency, limits and +the 636-query inventory are unchanged. `REPAIR.diff` contains the complete source +delta with zero context (apply with `git apply --unidiff-zero`); `REPLAY.json` records all six repaired source/inventory hashes. + +The canonical files in `source/` are preserved byte-for-byte, including their +historical source-only remarks, producer logs and original execution claims. +Those remarks describe delivery time. The separate root receipt supplies the +later local kernel evidence. No original failed source tree is duplicated here. + +## Verification + +The registered Python hook performs exact source/manifest binding, inverse literal +parsing, integer checks and tooling controls. It does not provision or invoke Lean: + +```sh +python3.12 -I -B scripts/research_package.py --package research/p112-integral-retraction-instance +``` + +Generic CI acceptance is separate from kernel acceptance; no hosted-CI result +is claimed here. A separate Pro review of the original source candidate reports +no distinct mathematical flaw beyond the known elaboration error. Its compact +response was read locally; the full report and independent checker were not +retrieved, the checker was not replayed locally, and the repair was not reviewed. +See `REVIEW.md` for these boundaries. + +For the dedicated kernel replay, use an already installed direct Lean binary at +version 4.30.0, commit `d024af099ca4bf2c86f649261ebf59565dc8c622`, core/Std only: + +```sh +env -i PATH="$PATH" LANG=C.UTF-8 python3.12 -B \ + research/p112-integral-retraction-instance/source/replay.py \ + --lean /absolute/path/to/installed/lean \ + --output /tmp/p112-replay-new-directory +``` + +The output directory must be new. No installation or network download is used. +The clean environment avoids inherited Lean settings; the runner sets only its +fresh scratch import path. Its manifest preflight checks all canonical source +members. It enforces 120 seconds per unit and 600 seconds for the successor, +excluding only the unchanged dependency. + +The recorded operator run compiled the same exact Lean closure directly in a +fresh scratch tree, with those limits plus an independent 750-second process-group +watchdog. It accepted the dependency in 3.557 seconds and the successor in +47.591 seconds. All 636 reports (159 inherited, 477 new) are present once; the +observed axiom union is `{propext, Quot.sound}`. `Classical.choice` is allowed but +unused. No positive errors, warnings, `sorryAx` or additional axioms were accepted. +The unchanged delivered parser independently agrees by name and axiom set. + +The advertised dedicated runner was then tested on the complete packaged source +with a separate 750-second watchdog covering its compiler sessions. It accepted +the same 40 positive units, 636 reports and intended negative control in 53.657 +seconds total (50.120 seconds charged to the successor). Both runs used the same +unchanged source and limits. `REPLAY.json` retains the complete named census, +source hashes, timings and the earlier operator-watchdog limitation. + +The W control changes only entry `(5,0)` from `+1` to `-1`. Its positive theorems +prove the residual mismatch and absence of a matrix certificate. The separate +fixture exits 1 at `RejectDamagedW.lean:18:2`, where ordinary `decide` rejects +`1 = -1`, and produces no object file. An import, syntax or timeout failure would +not satisfy that control. No resource limit was raised. + +## Open next questions + +The remaining application boundary is the geometric generator-to-relation +implication: which exact geometric hypotheses produce the 288 individual +monomial relations? A useful first step is to pin one geometric generator list +and state that implication against `P112Cert.M`. Its blocker is the absence of +that geometric theorem in this numerical package. + +A separate lawful nonzero-field-element adapter could connect the explicit +commutative-group interface to field notation. Start with one chosen field API +and prove its group laws independently. No such API is included here. Both +questions are recorded in `TASK.json`; neither is a new reservation. + +## Credit + +Andrey Mas with substantial GPT-6 Pro mathematical/source development and +diagnostic repair through ChatGPT, using the observed model label. Codex handled +source preparation, execution audit, local kernel replay and mechanical packaging; +it made no mathematical repair. PR1497/1610 retain their separate credit. +Inherited lineage includes Brett Halligan / @burntout76 and Ninefold (PR1212), +DreamingOfClouds (PR717), and themilkman216 (PR968). Apache-2.0; see `LICENSE`. + +This follows the [scoped P112 claim](https://github.com/CrocSwap/integer-mult-bounds/discussions/1527#discussioncomment-18915722), +revision 3 `formal-interface-lemma`. Historical preparation provenance remains +at `c24fb5e6537d19d79c62265e4a12781aef9309cb`; the publication base is `0b1cccf86e2f5132ed286a26ef0a681a495740ea`. The bounded pre-submission overlap check is recorded in `TASK.json`; publication and local replay do not imply maintainer acceptance. diff --git a/research/p112-integral-retraction-instance/REPAIR.diff b/research/p112-integral-retraction-instance/REPAIR.diff new file mode 100644 index 0000000000..4601634256 --- /dev/null +++ b/research/p112-integral-retraction-instance/REPAIR.diff @@ -0,0 +1,24 @@ +--- a/generate.py ++++ b/generate.py +@@ -295,0 +296,2 @@ ++ change rowMul (Sparse.row (P_entries i)) Q j = ++ Sparse.eval (P_entries i) Q j at hp +@@ -297,0 +300,2 @@ ++ change rowMul (Sparse.row (W_entries i)) M j = ++ Sparse.eval (W_entries i) M j at hw +--- a/P112Certificate.lean ++++ b/P112Certificate.lean +@@ -930,0 +931,2 @@ ++ change rowMul (Sparse.row (P_entries i)) Q j = ++ Sparse.eval (P_entries i) Q j at hp +@@ -932,0 +935,2 @@ ++ change rowMul (Sparse.row (W_entries i)) M j = ++ Sparse.eval (W_entries i) M j at hw +--- a/P112Damaged.lean ++++ b/P112Damaged.lean +@@ -41,0 +42,2 @@ ++ change rowMul (Sparse.row (P_entries (5 : Fin 104))) Q (0 : Fin 104) = ++ Sparse.eval (P_entries (5 : Fin 104)) Q (0 : Fin 104) at hp +@@ -50,0 +53,2 @@ ++ change rowMul (Sparse.row (W_entries_bad (5 : Fin 104))) M (0 : Fin 104) = ++ Sparse.eval (W_entries_bad (5 : Fin 104)) M (0 : Fin 104) at hw diff --git a/research/p112-integral-retraction-instance/REPLAY.json b/research/p112-integral-retraction-instance/REPLAY.json new file mode 100644 index 0000000000..801724b823 --- /dev/null +++ b/research/p112-integral-retraction-instance/REPLAY.json @@ -0,0 +1,4042 @@ +{ + "status": "LOCAL_COMPLETE_CANONICAL_PACKAGE_AND_KERNEL_REPLAY_PASS", + "toolchain": { + "lean": "4.30.0", + "commit": "d024af099ca4bf2c86f649261ebf59565dc8c622", + "binary_sha256": "b48bc5ab229bd8b320a224b87e20fc428dba6fa8a1c054bd4fa6def846e19997", + "python": "3.12.14", + "platform": "arm64-apple-darwin" + }, + "accepted_positive_units": 40, + "accepted_negative_controls": 1, + "named_reports": 636, + "inherited_named_reports": 159, + "new_named_reports": 477, + "observed_axiom_union": [ + "Quot.sound", + "propext" + ], + "limits_seconds": { + "per_unit": 120, + "successor": 600, + "independent_watchdog": 750 + }, + "observed_seconds": { + "dependency": 3.556961, + "successor": 47.590992, + "whole_worker": 51.147947 + }, + "exact_pro_repair_hashes": [ + { + "path": "generate.py", + "bytes": 16960, + "sha256": "ebd2d4eeb44064c04ff6097d8b7e50e14370f893d56bd5b11536f225a10aa319" + }, + { + "path": "P112Certificate.lean", + "bytes": 49456, + "sha256": "3cc91d09e6f743a3e2e0ed02b8d73246b306965c2f12e82f49deac8d16899ff0" + }, + { + "path": "P112Damaged.lean", + "bytes": 3230, + "sha256": "e915b6ca54379292462315ca613ccfe46e5d77acd2b31e07e83dbcd7f0f3fd32" + }, + { + "path": "DECLARATIONS.tsv", + "bytes": 36006, + "sha256": "c27eed09af9db4cec1dabe690f9c81efbdb2c9a9830083b2e2656d20c1f964f0" + }, + { + "path": "MANIFEST.tsv", + "bytes": 5754, + "sha256": "4303973a433b61faf34a59f6d785cfd9bb85e59b500de8c4a54d3effb431963e" + }, + { + "path": "SHA256SUMS", + "bytes": 5558, + "sha256": "d1e6655ad83d2d0f31ee111474866e0c06239a087c10ef3b776d660ad221935d" + } + ], + "units": [ + { + "unit": "PR1497Bridge.lean", + "negative_control": false, + "timeout_seconds": 120, + "returncode": 0, + "timed_out": false, + "seconds": 3.556961, + "source_sha256": "a27494b0d40bbf7874fd9a875e468c67d11545b266e17bc98f2ca75c77f6ee40", + "olean_present": true, + "expected_query_count": 159, + "observed_query_count": 159, + "census_exact": true, + "axiom_union": [ + "Quot.sound", + "propext" + ], + "accepted": true, + "stdout_bytes": 10026, + "stdout_sha256": "c67d84a1b7847cd3eed0adfc8fb2cb7531e5a1dc14ad8178a96b7ff669b9952d", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "olean_sha256": "8e127898bdfbc04a199e5a245be99d7420c8079b99cc8860f1957423c48f9877" + }, + { + "unit": "P112Sparse.lean", + "negative_control": false, + "timeout_seconds": 120, + "returncode": 0, + "timed_out": false, + "seconds": 0.444955, + "source_sha256": "1f9cae94b0767d117cd0c30c5852df385a1e98f6d255f130303130d9b7b4d071", + "olean_present": true, + "expected_query_count": 6, + "observed_query_count": 6, + "census_exact": true, + "axiom_union": [ + "Quot.sound", + "propext" + ], + "accepted": true, + "stdout_bytes": 407, + "stdout_sha256": "91acc2b26dc6d2548bba19c39190234824a82f311f05a3d116bea7626ddce4a8", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "olean_sha256": "df88f54e96c88af78a2fe595e3386da08fecdd14682f54508d104a8eace473de" + }, + { + "unit": "P112Data.lean", + "negative_control": false, + "timeout_seconds": 120, + "returncode": 0, + "timed_out": false, + "seconds": 3.229262, + "source_sha256": "c5619fb4e1b10663f48deb39272d191ba444f7052b0170a65186422e8177d967", + "olean_present": true, + "expected_query_count": 15, + "observed_query_count": 15, + "census_exact": true, + "axiom_union": [ + "Quot.sound", + "propext" + ], + "accepted": true, + "stdout_bytes": 812, + "stdout_sha256": "ec9b38e95aa4e5e5dda46e23024b0246e97fdb0cff077946fe0aa17c42bba7f5", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "olean_sha256": "00b7b4066e452242713d4d1ed3190d423bb25c38a4e68000ba59910e2f459e9c" + }, + { + "unit": "P112/MP00.lean", + "negative_control": false, + "timeout_seconds": 120, + "returncode": 0, + "timed_out": false, + "seconds": 0.937904, + "source_sha256": "13f94407d2f564d1df02abd05d65c789f9ef0fd146ea83f219cc2b0790530da5", + "olean_present": true, + "expected_query_count": 16, + "observed_query_count": 16, + "census_exact": true, + "axiom_union": [ + "Quot.sound", + "propext" + ], + "accepted": true, + "stdout_bytes": 1008, + "stdout_sha256": "0c4e4afc405e30ad2ac701f658063d8e86afcd26f44944ebe1d22174ac4e5d1d", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "olean_sha256": "253901c421c8bffb0b6bb073cf38d06793ee85091620f228a36e068db9986bb6" + }, + { + "unit": "P112/MP01.lean", + "negative_control": false, + "timeout_seconds": 120, + "returncode": 0, + "timed_out": false, + "seconds": 0.938739, + "source_sha256": "374fac864b91f4d3be22c064933bd04fe68479e0aae3a2d47f417c053ebf7c26", + "olean_present": true, + "expected_query_count": 16, + "observed_query_count": 16, + "census_exact": true, + "axiom_union": [ + "Quot.sound", + "propext" + ], + "accepted": true, + "stdout_bytes": 1008, + "stdout_sha256": "e568ce096abe3d94ebacfe97967fd5169a1df21b2f32efa27d9628e57f7db343", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "olean_sha256": "9cd03b2f7a15f9408eac9b25843b7f929b94759e099941af43bcc67f013d4674" + }, + { + "unit": "P112/MP02.lean", + "negative_control": false, + "timeout_seconds": 120, + "returncode": 0, + "timed_out": false, + "seconds": 1.043555, + "source_sha256": "a2d4ce0941183e59c87d89a1369bd8cae8e5aa17457a20352ecbcdd0eec847ac", + "olean_present": true, + "expected_query_count": 16, + "observed_query_count": 16, + "census_exact": true, + "axiom_union": [ + "Quot.sound", + "propext" + ], + "accepted": true, + "stdout_bytes": 1008, + "stdout_sha256": "be0d64dc4fc66521f9030c4f16bdaf3a2baa6ade1aa67de0619f5fc00d047df3", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "olean_sha256": "f006b63c1f76a871a10039603c9ac0e55ea3718eabb592e61d065ea14a4f0ab3" + }, + { + "unit": "P112/MP03.lean", + "negative_control": false, + "timeout_seconds": 120, + "returncode": 0, + "timed_out": false, + "seconds": 1.035127, + "source_sha256": "25846cbeac859682f102a4eba089f88fd6aece81538d368422b0347323d9a450", + "olean_present": true, + "expected_query_count": 16, + "observed_query_count": 16, + "census_exact": true, + "axiom_union": [ + "Quot.sound", + "propext" + ], + "accepted": true, + "stdout_bytes": 1008, + "stdout_sha256": "8204ee0cf2d2ab74347106f84a6e72106418286e5bc632de0e810c1058e08a14", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "olean_sha256": "142b3c49ceff76e8cac6246d1f3bf68a692a9c6606459db7409264f75c77161e" + }, + { + "unit": "P112/MP04.lean", + "negative_control": false, + "timeout_seconds": 120, + "returncode": 0, + "timed_out": false, + "seconds": 0.972919, + "source_sha256": "9c9694edc8e991dcc669d37de9116309c86bf408743993384b01c6bf7eae0e64", + "olean_present": true, + "expected_query_count": 16, + "observed_query_count": 16, + "census_exact": true, + "axiom_union": [ + "Quot.sound", + "propext" + ], + "accepted": true, + "stdout_bytes": 1008, + "stdout_sha256": "3e42da9b71ea7f7ed7e628400fc40adb723ada3f76b21aaf94d3dc45009eaace", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "olean_sha256": "30ce1313165dd0af55a551315fed12cbff5191a12ba5c2e6c5180ecc411d05f7" + }, + { + "unit": "P112/MP05.lean", + "negative_control": false, + "timeout_seconds": 120, + "returncode": 0, + "timed_out": false, + "seconds": 0.996995, + "source_sha256": "e90fd3cebc97e91d1fec063ccd50fa67e82375c23e317d755ee52de07c6e2840", + "olean_present": true, + "expected_query_count": 16, + "observed_query_count": 16, + "census_exact": true, + "axiom_union": [ + "Quot.sound", + "propext" + ], + "accepted": true, + "stdout_bytes": 1008, + "stdout_sha256": "69b1a5bf77db932c49b08e0aadf9a1b261a9b4956ded16e898524633be6069b1", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "olean_sha256": "ca786dde8c1908426288e6be91f208e27eb57fe80511833f8af9ccf8e216978b" + }, + { + "unit": "P112/MP06.lean", + "negative_control": false, + "timeout_seconds": 120, + "returncode": 0, + "timed_out": false, + "seconds": 1.03888, + "source_sha256": "02d4f4c3dc89e560e8f1109b051bb912f26e6a238c8f3c25237b67b144321f7e", + "olean_present": true, + "expected_query_count": 16, + "observed_query_count": 16, + "census_exact": true, + "axiom_union": [ + "Quot.sound", + "propext" + ], + "accepted": true, + "stdout_bytes": 1008, + "stdout_sha256": "912870abf9df40b7d9724d0d073b0dc2b503b7a6747c65c8aeaf04a26e1b5d02", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "olean_sha256": "5a7c599856aeded82f650c6f93ffa87068c7bb40efd2a2fda87fd86dfe87f959" + }, + { + "unit": "P112/MP07.lean", + "negative_control": false, + "timeout_seconds": 120, + "returncode": 0, + "timed_out": false, + "seconds": 0.9746, + "source_sha256": "39452ad57ba92c9cd54e9868a663b1b773c25143e0c24556899153cbcdae3842", + "olean_present": true, + "expected_query_count": 16, + "observed_query_count": 16, + "census_exact": true, + "axiom_union": [ + "Quot.sound", + "propext" + ], + "accepted": true, + "stdout_bytes": 1008, + "stdout_sha256": "593e3ee2e3a9033cf618052a9a4eb3dcf43ddb574bbefc4c6e288c974571c005", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "olean_sha256": "9f01bc2c20775848ce92853d6f9be450aa8adc88db96176620215da20706d4fd" + }, + { + "unit": "P112/MP08.lean", + "negative_control": false, + "timeout_seconds": 120, + "returncode": 0, + "timed_out": false, + "seconds": 1.141627, + "source_sha256": "5905bb732b9976adba77dab859b52f1a3dbd01a2368ca92e1144d98db0c0b967", + "olean_present": true, + "expected_query_count": 16, + "observed_query_count": 16, + "census_exact": true, + "axiom_union": [ + "Quot.sound", + "propext" + ], + "accepted": true, + "stdout_bytes": 1008, + "stdout_sha256": "9f8b1b5883c5a3b629260c849aaad1bcee0262bba838a9a856f7dfb6a4472b5c", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "olean_sha256": "5a53664e831157e59bb133c66dd62d935ce019659f01b84c375d97d6c0d68e2b" + }, + { + "unit": "P112/MP09.lean", + "negative_control": false, + "timeout_seconds": 120, + "returncode": 0, + "timed_out": false, + "seconds": 1.042758, + "source_sha256": "580c7521ccf594444d673a66280d448d36f5111bdfdc5303ad95547420c49ca2", + "olean_present": true, + "expected_query_count": 16, + "observed_query_count": 16, + "census_exact": true, + "axiom_union": [ + "Quot.sound", + "propext" + ], + "accepted": true, + "stdout_bytes": 1008, + "stdout_sha256": "f8accf666eabaf3afbdb41cb0593060551d9c38ebdc9ad1fa4b1561f974168e3", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "olean_sha256": "02ea38204387c506f39e53650d791fab50fbdcde1440ee93a9319e1bd3fc141c" + }, + { + "unit": "P112/MP10.lean", + "negative_control": false, + "timeout_seconds": 120, + "returncode": 0, + "timed_out": false, + "seconds": 1.148982, + "source_sha256": "317283042cdb1844c55de12c5fc9afaaf8efbd97552f64d7a3172a3b51fbd4d3", + "olean_present": true, + "expected_query_count": 16, + "observed_query_count": 16, + "census_exact": true, + "axiom_union": [ + "Quot.sound", + "propext" + ], + "accepted": true, + "stdout_bytes": 1008, + "stdout_sha256": "4952fa15fc78321a2a8ac9c817e901cc07da2e57095e64a9c8762995d3dcf494", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "olean_sha256": "2795bbe189affa2e4375b75331d6d48c56215b5bb14d127f0dd060e578eb7fa9" + }, + { + "unit": "P112/MP11.lean", + "negative_control": false, + "timeout_seconds": 120, + "returncode": 0, + "timed_out": false, + "seconds": 1.226924, + "source_sha256": "e8898d45d1e5d0e39235b6a1eaf1880cdb9928442b4238d3a909a0b725ca394e", + "olean_present": true, + "expected_query_count": 16, + "observed_query_count": 16, + "census_exact": true, + "axiom_union": [ + "Quot.sound", + "propext" + ], + "accepted": true, + "stdout_bytes": 1008, + "stdout_sha256": "c1443a90f0e4bc75d0b22373e4441110e08ba1f14fa1bc5a2c54c7939beea890", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "olean_sha256": "53ab4d287c7720555bb974316ad0e48f958fc8f456d5d57a72d9d622e92ec522" + }, + { + "unit": "P112/MP12.lean", + "negative_control": false, + "timeout_seconds": 120, + "returncode": 0, + "timed_out": false, + "seconds": 0.989281, + "source_sha256": "9244768a96a7351430167c9865051fcac394f591cd37bb21b8a93c59a0d9295a", + "olean_present": true, + "expected_query_count": 16, + "observed_query_count": 16, + "census_exact": true, + "axiom_union": [ + "Quot.sound", + "propext" + ], + "accepted": true, + "stdout_bytes": 1008, + "stdout_sha256": "8afb83ddee53a0112f2b724ad1a8e8b85447d100b949e5f545056868868c187e", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "olean_sha256": "27ad4414626da264492febc918fd0370e4628b6df3d4660794ff638eb2fe5ba1" + }, + { + "unit": "P112/MP13.lean", + "negative_control": false, + "timeout_seconds": 120, + "returncode": 0, + "timed_out": false, + "seconds": 0.937175, + "source_sha256": "b84a8d8657b85161f98fb8971b574526a6d53fce9e50847f59bf816a91351a38", + "olean_present": true, + "expected_query_count": 16, + "observed_query_count": 16, + "census_exact": true, + "axiom_union": [ + "Quot.sound", + "propext" + ], + "accepted": true, + "stdout_bytes": 1008, + "stdout_sha256": "b9fc2c2cb2b7a0d4ce057c03c2e42189a4092384c6e4a9d86ffc4835e154b359", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "olean_sha256": "851ff2de8288038a9fe25ac3e02defebb6647313a0ea6624730197dd4d59a00c" + }, + { + "unit": "P112/MP14.lean", + "negative_control": false, + "timeout_seconds": 120, + "returncode": 0, + "timed_out": false, + "seconds": 0.937698, + "source_sha256": "03915213d9aec2110071dcfd205de00e929220d092ea8238ed9036f96ac1fc4f", + "olean_present": true, + "expected_query_count": 16, + "observed_query_count": 16, + "census_exact": true, + "axiom_union": [ + "Quot.sound", + "propext" + ], + "accepted": true, + "stdout_bytes": 1008, + "stdout_sha256": "7c9f3ebf3d4632ee1257e4b541099bf2aad4f737e4f4179ed677e1b864de22c9", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "olean_sha256": "9e0fe9fde25d128bb9a523219e103083435ee104ec14dde47ad8a52909f45e3c" + }, + { + "unit": "P112/MP15.lean", + "negative_control": false, + "timeout_seconds": 120, + "returncode": 0, + "timed_out": false, + "seconds": 0.941171, + "source_sha256": "c1342bca97cb22f3773f16453fa88ec4a4ec4a5b2ad8deaa8f37317cc131fa04", + "olean_present": true, + "expected_query_count": 16, + "observed_query_count": 16, + "census_exact": true, + "axiom_union": [ + "Quot.sound", + "propext" + ], + "accepted": true, + "stdout_bytes": 1008, + "stdout_sha256": "d780797e9872c513aa22adcf7ec4be547c3b9e879c6dcd2d5801e97a0c919329", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "olean_sha256": "cd8296d304b3335b882221ce50ccfddd91748eda0727cf3711c7d5f3a28f7f57" + }, + { + "unit": "P112/MP16.lean", + "negative_control": false, + "timeout_seconds": 120, + "returncode": 0, + "timed_out": false, + "seconds": 0.931263, + "source_sha256": "47336a6652bdfb9efac4291b73be99f41efe2fc68014562bd86ff092a34f2368", + "olean_present": true, + "expected_query_count": 16, + "observed_query_count": 16, + "census_exact": true, + "axiom_union": [ + "Quot.sound", + "propext" + ], + "accepted": true, + "stdout_bytes": 1008, + "stdout_sha256": "8b7e06437be845b55b8046b7265454ec6727c1eb89aea8b84f5fd6e261aacec6", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "olean_sha256": "ef205bce5a21a26904949f97a19d7239c32a17219fa131bf146282791bc0ef3e" + }, + { + "unit": "P112/MP17.lean", + "negative_control": false, + "timeout_seconds": 120, + "returncode": 0, + "timed_out": false, + "seconds": 0.94182, + "source_sha256": "7da6a378c8e262cd027a7b8391df3f9b8c445eb750a5e2e11a2fa988314368a5", + "olean_present": true, + "expected_query_count": 16, + "observed_query_count": 16, + "census_exact": true, + "axiom_union": [ + "Quot.sound", + "propext" + ], + "accepted": true, + "stdout_bytes": 1008, + "stdout_sha256": "983b65f8b52fd60ab470475d6e0b994017180995c71b9efb1a468945ce47e1dc", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "olean_sha256": "407e125ace186d7e08dcabf37926d089d37978c76079ffc74decad810948a003" + }, + { + "unit": "P112/QP00.lean", + "negative_control": false, + "timeout_seconds": 120, + "returncode": 0, + "timed_out": false, + "seconds": 0.605545, + "source_sha256": "b5015a85de7edf9df93f1b00fd6433113ef25ef177b75a840cdaa29068e5edff", + "olean_present": true, + "expected_query_count": 16, + "observed_query_count": 16, + "census_exact": true, + "axiom_union": [ + "Quot.sound", + "propext" + ], + "accepted": true, + "stdout_bytes": 1008, + "stdout_sha256": "3d1bcde846c40a71a3616bd6dd96e6a9326d37381abc1dbe6ae82fa0ec25ae00", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "olean_sha256": "c109b77cebc064e6cfb4124499cd4e6b05bf9cde17e1b20c07a2eb4a1dc1aece" + }, + { + "unit": "P112/QP01.lean", + "negative_control": false, + "timeout_seconds": 120, + "returncode": 0, + "timed_out": false, + "seconds": 0.765682, + "source_sha256": "e00cc8dd0c6798387436fa2625ef7bc59d61bfdf0b67efc4d5b132d1b9679f43", + "olean_present": true, + "expected_query_count": 16, + "observed_query_count": 16, + "census_exact": true, + "axiom_union": [ + "Quot.sound", + "propext" + ], + "accepted": true, + "stdout_bytes": 1008, + "stdout_sha256": "80ab282cdd2877c37a8898b4ee25842b0828f612e9a201e5b1f05873a9d03a67", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "olean_sha256": "90bf1248be21f63d416380da49a4ca4e1e484e08e7fb1825b9f77d3d8819906f" + }, + { + "unit": "P112/QP02.lean", + "negative_control": false, + "timeout_seconds": 120, + "returncode": 0, + "timed_out": false, + "seconds": 0.392617, + "source_sha256": "4fa1e2783b8082d03b434d7acc6549de4027d3e72685c9913158283c76957ea7", + "olean_present": true, + "expected_query_count": 1, + "observed_query_count": 1, + "census_exact": true, + "axiom_union": [ + "Quot.sound", + "propext" + ], + "accepted": true, + "stdout_bytes": 63, + "stdout_sha256": "12a0ad638398a3942498508b3f5fa19cb077e9c4f46174512f70b61861082fc8", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "olean_sha256": "55394897ed45ddce4e1b4f967fdc99a82caa9e14422251779cb454435de2a26f" + }, + { + "unit": "P112/Residual00.lean", + "negative_control": false, + "timeout_seconds": 120, + "returncode": 0, + "timed_out": false, + "seconds": 1.042057, + "source_sha256": "f0018130a836f72d6a830da8247d4cd37df7df7c9418f5c528785227e364b577", + "olean_present": true, + "expected_query_count": 8, + "observed_query_count": 8, + "census_exact": true, + "axiom_union": [ + "Quot.sound", + "propext" + ], + "accepted": true, + "stdout_bytes": 552, + "stdout_sha256": "d75e679c9341bc89fcfb17aa365bd007cd550bf0aee48ae3672e3ba6479ce0ae", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "olean_sha256": "7d0aba0d98ef205b5043ea15ede5339f29aeff2652389addc72b1a222cf29cb8" + }, + { + "unit": "P112/Residual01.lean", + "negative_control": false, + "timeout_seconds": 120, + "returncode": 0, + "timed_out": false, + "seconds": 1.316885, + "source_sha256": "c31b6b2d62e7b4dc0ff2d7d93c9510160c4015da8cf03729345fa4afec6e7db2", + "olean_present": true, + "expected_query_count": 8, + "observed_query_count": 8, + "census_exact": true, + "axiom_union": [ + "Quot.sound", + "propext" + ], + "accepted": true, + "stdout_bytes": 552, + "stdout_sha256": "eacd5eaa388d0aa26361b7ecbadb6f3c6db6c28f0baa4eaa01c5255bcd125c04", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "olean_sha256": "84d1753817a40bb865ceed922c3a401ef134910fdc4733c0b6f9bb380132b78e" + }, + { + "unit": "P112/Residual02.lean", + "negative_control": false, + "timeout_seconds": 120, + "returncode": 0, + "timed_out": false, + "seconds": 1.427271, + "source_sha256": "fd3d9e3ec624ef77309b78f21214f9e1d44ad97b96c1268bf3f10924a50ca1f2", + "olean_present": true, + "expected_query_count": 8, + "observed_query_count": 8, + "census_exact": true, + "axiom_union": [ + "Quot.sound", + "propext" + ], + "accepted": true, + "stdout_bytes": 552, + "stdout_sha256": "2e8afae2d618967017bed775426c6ff0d9449fea1ee7487c15930f5d53a20c37", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "olean_sha256": "95de77da53d65954caf25e2b75999e9fa72076460b1be025a4fa86a54e8cdd11" + }, + { + "unit": "P112/Residual03.lean", + "negative_control": false, + "timeout_seconds": 120, + "returncode": 0, + "timed_out": false, + "seconds": 1.372349, + "source_sha256": "fee2b63b5a52a3f0cd88973c0b1e9ec75a3966ff152e42cf540cb20cc737cc05", + "olean_present": true, + "expected_query_count": 8, + "observed_query_count": 8, + "census_exact": true, + "axiom_union": [ + "Quot.sound", + "propext" + ], + "accepted": true, + "stdout_bytes": 552, + "stdout_sha256": "e2fc80bb5fef16aceb15ad79b16f9cd02c35b03d223e723c7b870ed4e6718d42", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "olean_sha256": "869e6af32d846aa0acabedb5fafbe2f33134666f82934db81ba96a2b95227e5e" + }, + { + "unit": "P112/Residual04.lean", + "negative_control": false, + "timeout_seconds": 120, + "returncode": 0, + "timed_out": false, + "seconds": 1.36407, + "source_sha256": "45bf845eb22460635f81d85757ed29e33622a5b123dc858b5f0673f3ad968c42", + "olean_present": true, + "expected_query_count": 8, + "observed_query_count": 8, + "census_exact": true, + "axiom_union": [ + "Quot.sound", + "propext" + ], + "accepted": true, + "stdout_bytes": 552, + "stdout_sha256": "712fef986bf77c1985c92c78cd711418a1bfe9eeca7c52157030113ae7852298", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "olean_sha256": "e077a59c20d1c7aec5f3775a4f2b11b1000245be3d3fa383f468f0467ffded29" + }, + { + "unit": "P112/Residual05.lean", + "negative_control": false, + "timeout_seconds": 120, + "returncode": 0, + "timed_out": false, + "seconds": 1.362723, + "source_sha256": "1fce648ce627b596a758be98790829f4df7f414a90d29cec34bdcefe749c08dd", + "olean_present": true, + "expected_query_count": 8, + "observed_query_count": 8, + "census_exact": true, + "axiom_union": [ + "Quot.sound", + "propext" + ], + "accepted": true, + "stdout_bytes": 552, + "stdout_sha256": "7c6bc9650fd1de6fbc8be50f7f56f2a8eba532c9f680603f222c8bf1f47f65a0", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "olean_sha256": "aa06c549099359cfa18db51907eb5d2df98401108d006849270ce5fca56457a4" + }, + { + "unit": "P112/Residual06.lean", + "negative_control": false, + "timeout_seconds": 120, + "returncode": 0, + "timed_out": false, + "seconds": 1.537296, + "source_sha256": "fc26879525f376ee93a7d4c037ca42e49c597372a30b82d4f1107c9f0c36d1bb", + "olean_present": true, + "expected_query_count": 8, + "observed_query_count": 8, + "census_exact": true, + "axiom_union": [ + "Quot.sound", + "propext" + ], + "accepted": true, + "stdout_bytes": 552, + "stdout_sha256": "d6d0c4179bd3aa6e27b3ff073726ee1fc3dd79178d8087fd9812505826e4b6df", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "olean_sha256": "5e58f9da08dd330c7d68c646f8f617668c439348bfe146c69f78830b4a3d7d74" + }, + { + "unit": "P112/Residual07.lean", + "negative_control": false, + "timeout_seconds": 120, + "returncode": 0, + "timed_out": false, + "seconds": 2.038151, + "source_sha256": "828f358afed3c9ea4839a3e15400294b77e313b31dcfd58b278f309e5f4854fd", + "olean_present": true, + "expected_query_count": 8, + "observed_query_count": 8, + "census_exact": true, + "axiom_union": [ + "Quot.sound", + "propext" + ], + "accepted": true, + "stdout_bytes": 552, + "stdout_sha256": "a261ef79acd4b2ceb7c0d4048a0c8193c800d936aad77506dea3643b94876c05", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "olean_sha256": "a1754cadde072fcca86a7c4e36062c632f71ae164919cb97e97b12675f52eeb6" + }, + { + "unit": "P112/Residual08.lean", + "negative_control": false, + "timeout_seconds": 120, + "returncode": 0, + "timed_out": false, + "seconds": 1.850108, + "source_sha256": "665f03ae5197ee1b90c585613e717da85b682cae471d8b00da97846b28732497", + "olean_present": true, + "expected_query_count": 8, + "observed_query_count": 8, + "census_exact": true, + "axiom_union": [ + "Quot.sound", + "propext" + ], + "accepted": true, + "stdout_bytes": 552, + "stdout_sha256": "713ff9a6309fbbab9bb7369af4265933ca66bad6f466442132525eeb13c40dfb", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "olean_sha256": "17bc3dac7a9a40aa688c609805bc1335452c7017b1b983b74311f00127abb39c" + }, + { + "unit": "P112/Residual09.lean", + "negative_control": false, + "timeout_seconds": 120, + "returncode": 0, + "timed_out": false, + "seconds": 1.894996, + "source_sha256": "ada3f0b6e1e66fd4a16f56bbcfb62e02f248d3d085889697ff818f95ade3b95d", + "olean_present": true, + "expected_query_count": 8, + "observed_query_count": 8, + "census_exact": true, + "axiom_union": [ + "Quot.sound", + "propext" + ], + "accepted": true, + "stdout_bytes": 552, + "stdout_sha256": "fcb9ebf3aeee0554cf7115bb30d61134a01e7223e5b94795ad4daa1e6e58f77d", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "olean_sha256": "ee80075ab1a06de1e3ae6fd66ac6f08ddd5d6b9b4057144ec3f7fd21288c2346" + }, + { + "unit": "P112/Residual10.lean", + "negative_control": false, + "timeout_seconds": 120, + "returncode": 0, + "timed_out": false, + "seconds": 2.012299, + "source_sha256": "3dfeb23cd21058c8b98b58cc97d0fc2812d49efad5b1752dcb52cd2b47ff317f", + "olean_present": true, + "expected_query_count": 8, + "observed_query_count": 8, + "census_exact": true, + "axiom_union": [ + "Quot.sound", + "propext" + ], + "accepted": true, + "stdout_bytes": 552, + "stdout_sha256": "3368f713eb9c0ae390e171a797629caee0eaf555bf02bcd1777d43419ec68169", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "olean_sha256": "a18c99ebd7a05a86fe6798d2ad45f3195d0f0e2340beafcec9e01ba7e842bb50" + }, + { + "unit": "P112/Residual11.lean", + "negative_control": false, + "timeout_seconds": 120, + "returncode": 0, + "timed_out": false, + "seconds": 2.225545, + "source_sha256": "6d7604d36d7879801758de815fbfbdf38b2975ae6cd5ce722c20709bd00c50bc", + "olean_present": true, + "expected_query_count": 8, + "observed_query_count": 8, + "census_exact": true, + "axiom_union": [ + "Quot.sound", + "propext" + ], + "accepted": true, + "stdout_bytes": 552, + "stdout_sha256": "1e173b85a54074bb97ce030a484105367231a387259cfbdf3f1f4c41694e2c4c", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "olean_sha256": "4fb9e4b17f818634b697d4843b2ecdc4037d45cf0a7620ec0f46c00043491de9" + }, + { + "unit": "P112/Residual12.lean", + "negative_control": false, + "timeout_seconds": 120, + "returncode": 0, + "timed_out": false, + "seconds": 2.295858, + "source_sha256": "6a727a2c56358da83565fc27474cef83c02fb0fa5af53dae4e18af6d55675810", + "olean_present": true, + "expected_query_count": 8, + "observed_query_count": 8, + "census_exact": true, + "axiom_union": [ + "Quot.sound", + "propext" + ], + "accepted": true, + "stdout_bytes": 552, + "stdout_sha256": "56819a49a2f5ab7b976feea558b3ed1bdacfadf0270bb8fc906bd50d595feb5c", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "olean_sha256": "b26b000b6fec356b14cb0c0a67628de69b97b12b7504ce20c01288eba958d51d" + }, + { + "unit": "P112Certificate.lean", + "negative_control": false, + "timeout_seconds": 120, + "returncode": 0, + "timed_out": false, + "seconds": 0.679371, + "source_sha256": "3cc91d09e6f743a3e2e0ed02b8d73246b306965c2f12e82f49deac8d16899ff0", + "olean_present": true, + "expected_query_count": 7, + "observed_query_count": 7, + "census_exact": true, + "axiom_union": [ + "Quot.sound", + "propext" + ], + "accepted": true, + "stdout_bytes": 439, + "stdout_sha256": "5280fdecef6e04916f67f213774c2b067ec83304c5cd43f92d86d15b49914d4c", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "olean_sha256": "cc7ce419288f649c655217cb639a8682bd0ff67b998d36659e9e4fdebef54d45" + }, + { + "unit": "P112Consequences.lean", + "negative_control": false, + "timeout_seconds": 120, + "returncode": 0, + "timed_out": false, + "seconds": 0.398954, + "source_sha256": "bf2d28f786f2aeee4ea0e0d733ad3f6973c133fe9cde452c21fc36ca709444bc", + "olean_present": true, + "expected_query_count": 15, + "observed_query_count": 15, + "census_exact": true, + "axiom_union": [ + "Quot.sound", + "propext" + ], + "accepted": true, + "stdout_bytes": 1098, + "stdout_sha256": "ddeeeaa9f466529c7f5c4449e5ca775e1b45fa8d1525f2a711bb7d28990b0a55", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "olean_sha256": "32f76b31456464ce84eac5cf39fca2eb6405084925a1cab9238180e3cf899eb3" + }, + { + "unit": "P112Damaged.lean", + "negative_control": false, + "timeout_seconds": 120, + "returncode": 0, + "timed_out": false, + "seconds": 0.40056, + "source_sha256": "e915b6ca54379292462315ca613ccfe46e5d77acd2b31e07e83dbcd7f0f3fd32", + "olean_present": true, + "expected_query_count": 9, + "observed_query_count": 9, + "census_exact": true, + "axiom_union": [ + "Quot.sound", + "propext" + ], + "accepted": true, + "stdout_bytes": 676, + "stdout_sha256": "b69d26836ddc6cbe00d19f46f117dbacedc574fa9153b1413279b3e5fe0c9d41", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "olean_sha256": "915343fa69d9f3f156e3fb87bfa572de744434cc9c85ac74862045846c379476" + }, + { + "unit": "fixtures/RejectDamagedW.lean", + "negative_control": true, + "timeout_seconds": 120, + "returncode": 1, + "timed_out": false, + "seconds": 0.349336, + "source_sha256": "7796f968b92e57759776b10c9a37847ffde62bbc6d8a7fda321f09b3cba2dda5", + "olean_present": false, + "expected_query_count": 0, + "observed_query_count": 0, + "census_exact": true, + "axiom_union": [], + "accepted": true, + "stdout_bytes": 104, + "stdout_sha256": "74b5e004493ecbf647619f0c78653b4bdf3d84735841c5325f5a1dc0fee6b6db", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + } + ], + "observed_dependencies": { + "PR1497.AbGroup": [], + "PR1497.AbGroup.sub": [], + "PR1497.AbGroup.add_left_cancel": [], + "PR1497.AbGroup.add_right_cancel": [], + "PR1497.AbGroup.add_left_comm": [], + "PR1497.AbGroup.add_four": [], + "PR1497.AbGroup.neg_zero": [], + "PR1497.AbGroup.neg_neg": [], + "PR1497.AbGroup.neg_add_distrib": [], + "PR1497.AbGroup.sub_zero": [], + "PR1497.AbGroup.sub_self": [], + "PR1497.AbGroup.sub_add_cancel": [], + "PR1497.AbGroup.add_sub_cancel": [], + "PR1497.AbGroup.sub_eq_zero_iff": [], + "PR1497.AbGroup.eq_of_sub_eq": [], + "PR1497.AbGroup.nsmul": [], + "PR1497.AbGroup.zsmul": [], + "PR1497.AbGroup.nsmul_zero": [ + "propext" + ], + "PR1497.AbGroup.zsmul_zero": [], + "PR1497.AbGroup.zsmul_zero_right": [ + "propext" + ], + "PR1497.AbGroup.zsmul_one": [], + "PR1497.AbGroup.int_induction": [], + "PR1497.AbGroup.zsmul_succ": [ + "propext", + "Quot.sound" + ], + "PR1497.AbGroup.zsmul_pred": [ + "propext", + "Quot.sound" + ], + "PR1497.AbGroup.zsmul_add": [ + "propext", + "Quot.sound" + ], + "PR1497.Hom": [], + "PR1497.Hom.id": [], + "PR1497.Hom.comp": [], + "PR1497.Hom.ext": [ + "Quot.sound" + ], + "PR1497.Hom.map_neg": [], + "PR1497.Hom.map_sub": [], + "PR1497.Hom.map_nsmul": [ + "propext" + ], + "PR1497.Hom.map_zsmul": [ + "propext" + ], + "PR1497.fsum": [ + "propext" + ], + "PR1497.Finite.sum_congr": [ + "propext", + "Quot.sound" + ], + "PR1497.Finite.sum_zero": [ + "propext" + ], + "PR1497.Finite.sum_add": [ + "propext" + ], + "PR1497.Finite.sum_neg": [ + "propext" + ], + "PR1497.Finite.sum_sub": [ + "propext" + ], + "PR1497.Finite.sum_swap": [ + "propext" + ], + "PR1497.Finite.sum_single": [ + "propext", + "Quot.sound" + ], + "PR1497.Finite.map_sum": [ + "propext" + ], + "PR1497.intGroup": [ + "propext" + ], + "PR1497.functionGroup": [ + "Quot.sound" + ], + "PR1497.Row": [], + "PR1497.Mat": [], + "PR1497.rowGroup": [ + "propext", + "Quot.sound" + ], + "PR1497.scale": [], + "PR1497.basis": [], + "PR1497.eye": [], + "PR1497.zeroMat": [], + "PR1497.matSub": [], + "PR1497.rowMul": [ + "propext" + ], + "PR1497.matMul": [ + "propext" + ], + "PR1497.Rows.sum_apply": [ + "propext", + "Quot.sound" + ], + "PR1497.Rows.nsmul_apply": [ + "Quot.sound" + ], + "PR1497.Rows.zsmul_apply": [ + "Quot.sound" + ], + "PR1497.Rows.int_nsmul": [ + "propext" + ], + "PR1497.Rows.int_zsmul": [ + "propext" + ], + "PR1497.Rows.row_zsmul": [ + "propext", + "Quot.sound" + ], + "PR1497.Rows.sum_mul_right": [ + "propext" + ], + "PR1497.Rows.sum_mul_left": [ + "propext", + "Quot.sound" + ], + "PR1497.Rows.rowMul_zero_left": [ + "propext", + "Quot.sound" + ], + "PR1497.Rows.rowMul_zero_right": [ + "propext", + "Quot.sound" + ], + "PR1497.Rows.rowMul_add": [ + "propext", + "Quot.sound" + ], + "PR1497.Rows.rowMul_matSub": [ + "propext", + "Quot.sound" + ], + "PR1497.Rows.rowMul_assoc": [ + "propext", + "Quot.sound" + ], + "PR1497.Rows.rowMul_basis": [ + "propext", + "Quot.sound" + ], + "PR1497.Rows.rowMul_eye": [ + "propext", + "Quot.sound" + ], + "PR1497.Rows.rowMul_linear_combination": [ + "propext", + "Quot.sound" + ], + "PR1497.Rows.rowHom": [ + "propext", + "Quot.sound" + ], + "PR1497.Retraction": [], + "PR1497.AddIso": [], + "PR1497.TorsionFree": [], + "PR1497.Retraction.L": [], + "PR1497.Retraction.mem_image_iff": [], + "PR1497.Retraction.image_eq_kernel": [ + "propext", + "Quot.sound" + ], + "PR1497.Retraction.surjective": [], + "PR1497.Retraction.decomposition": [], + "PR1497.Retraction.Rel": [], + "PR1497.Retraction.rel_iff": [ + "propext" + ], + "PR1497.Retraction.latticeSetoid": [ + "propext" + ], + "PR1497.Retraction.LQuot": [ + "propext" + ], + "PR1497.Retraction.qmk": [ + "propext" + ], + "PR1497.Retraction.qmap": [ + "propext" + ], + "PR1497.Retraction.qinv": [ + "propext" + ], + "PR1497.Retraction.qmap_mk": [ + "propext" + ], + "PR1497.Retraction.qmap_qinv": [ + "propext" + ], + "PR1497.Retraction.qinv_qmap": [ + "propext", + "Quot.sound" + ], + "PR1497.Retraction.qmap_injective": [ + "propext", + "Quot.sound" + ], + "PR1497.Retraction.qadd": [ + "propext", + "Quot.sound" + ], + "PR1497.Retraction.qneg": [ + "propext", + "Quot.sound" + ], + "PR1497.Retraction.qmap_zero": [ + "propext" + ], + "PR1497.Retraction.qmap_add": [ + "propext", + "Quot.sound" + ], + "PR1497.Retraction.qmap_neg": [ + "propext", + "Quot.sound" + ], + "PR1497.Retraction.quotientGroup": [ + "propext", + "Quot.sound" + ], + "PR1497.Retraction.quotientMap": [ + "propext", + "Quot.sound" + ], + "PR1497.Retraction.quotientInv": [ + "propext", + "Quot.sound" + ], + "PR1497.Retraction.quotientIso": [ + "propext", + "Quot.sound" + ], + "PR1497.Retraction.saturated": [ + "propext" + ], + "PR1497.Retraction.character_factor": [], + "PR1497.Retraction.character_unique": [], + "PR1497.MatrixIdentities": [ + "propext" + ], + "PR1497.matrixRetraction": [ + "propext", + "Quot.sound" + ], + "PR1497.MatrixBridge.Lattice": [ + "propext" + ], + "PR1497.MatrixBridge.lattice_iff_integer_span": [ + "propext", + "Quot.sound" + ], + "PR1497.MatrixBridge.lattice_eq_kernel": [ + "propext", + "Quot.sound" + ], + "PR1497.MatrixBridge.lattice_eq_kernel_as_predicate": [ + "propext", + "Quot.sound" + ], + "PR1497.MatrixBridge.quotient_relation": [ + "propext", + "Quot.sound" + ], + "PR1497.MatrixBridge.quotient_equal_iff": [ + "propext", + "Quot.sound" + ], + "PR1497.MatrixBridge.phi_surjective": [ + "propext", + "Quot.sound" + ], + "PR1497.MatrixBridge.quotientIso": [ + "propext", + "Quot.sound" + ], + "PR1497.MatrixBridge.quotient_forward_on_representative": [ + "propext", + "Quot.sound" + ], + "PR1497.MatrixBridge.quotient_inverse_on_parameter": [ + "propext", + "Quot.sound" + ], + "PR1497.MatrixBridge.quotient_left_inverse": [ + "propext", + "Quot.sound" + ], + "PR1497.MatrixBridge.quotient_right_inverse": [ + "propext", + "Quot.sound" + ], + "PR1497.MatrixBridge.row_torsion_free": [ + "propext", + "Quot.sound" + ], + "PR1497.MatrixBridge.lattice_saturated": [ + "propext", + "Quot.sound" + ], + "PR1497.CommGroup": [], + "PR1497.CommGroup.asAdd": [], + "PR1497.CommGroup.npow": [], + "PR1497.CommGroup.zpow": [], + "PR1497.CommGroup.prod": [ + "propext" + ], + "PR1497.CommGroup.div": [], + "PR1497.CommGroup.npow_zero": [], + "PR1497.CommGroup.npow_succ": [], + "PR1497.CommGroup.zpow_nat": [], + "PR1497.CommGroup.zpow_negative": [], + "PR1497.CommGroup.zpow_zero": [], + "PR1497.CommGroup.zpow_one": [], + "PR1497.CommGroup.one_zpow": [ + "propext" + ], + "PR1497.CommGroup.zpow_add": [ + "propext", + "Quot.sound" + ], + "PR1497.CommGroup.prod_zero": [ + "propext" + ], + "PR1497.CommGroup.prod_succ": [ + "propext" + ], + "PR1497.CommGroup.prod_mul": [ + "propext" + ], + "PR1497.monomial": [ + "propext" + ], + "PR1497.monomialHom": [ + "propext", + "Quot.sound" + ], + "PR1497.Character.row_image": [ + "propext", + "Quot.sound" + ], + "PR1497.Character.rows_annihilate_span": [ + "propext", + "Quot.sound" + ], + "PR1497.Monomial.zero": [ + "propext", + "Quot.sound" + ], + "PR1497.Monomial.add": [ + "propext", + "Quot.sound" + ], + "PR1497.Monomial.sub": [ + "propext", + "Quot.sound" + ], + "PR1497.Monomial.scale": [ + "propext", + "Quot.sound" + ], + "PR1497.Monomial.on_basis": [ + "propext", + "Quot.sound" + ], + "PR1497.Monomial.substitution": [ + "propext", + "Quot.sound" + ], + "PR1497.Monomial.individual_rows_to_span": [ + "propext", + "Quot.sound" + ], + "PR1497.MonomialBridge.parameters": [ + "propext" + ], + "PR1497.MonomialBridge.realization": [ + "propext" + ], + "PR1497.MonomialBridge.Relations": [ + "propext" + ], + "PR1497.MonomialBridge.reconstruction_all_exponents": [ + "propext", + "Quot.sound" + ], + "PR1497.MonomialBridge.reconstruct_coordinate": [ + "propext", + "Quot.sound" + ], + "PR1497.MonomialBridge.reconstruction": [ + "propext", + "Quot.sound" + ], + "PR1497.MonomialBridge.converse_relations": [ + "propext", + "Quot.sound" + ], + "PR1497.MonomialBridge.parameters_recover": [ + "propext", + "Quot.sound" + ], + "PR1497.MonomialBridge.parameters_unique": [ + "propext", + "Quot.sound" + ], + "PR1497.MonomialBridge.residual_exponent_formula": [ + "propext", + "Quot.sound" + ], + "PR1497.MonomialBridge.residual_relations_formula": [ + "propext", + "Quot.sound" + ], + "PR1497.MonomialBridge.residual_eq_one": [ + "propext", + "Quot.sound" + ], + "PR1497.MonomialBridge.unique_parameterization": [ + "propext", + "Quot.sound" + ], + "P112Cert.Sparse.row": [ + "propext", + "Quot.sound" + ], + "P112Cert.Sparse.eval": [ + "propext", + "Quot.sound" + ], + "P112Cert.Sparse.row_apply": [ + "propext", + "Quot.sound" + ], + "P112Cert.Sparse.rowMul_scale": [ + "propext", + "Quot.sound" + ], + "P112Cert.Sparse.rowMul_row": [ + "propext", + "Quot.sound" + ], + "P112Cert.Sparse.allFinAdd": [ + "propext", + "Quot.sound" + ], + "P112Cert.M_entries": [], + "P112Cert.M": [ + "propext", + "Quot.sound" + ], + "P112Cert.P_entries": [], + "P112Cert.P": [ + "propext", + "Quot.sound" + ], + "P112Cert.Q_entries": [], + "P112Cert.Q": [ + "propext", + "Quot.sound" + ], + "P112Cert.W_entries": [], + "P112Cert.W": [ + "propext", + "Quot.sound" + ], + "P112Cert.anchors": [], + "P112Cert.basePairRepresentatives": [], + "P112Cert.coordinateLabels": [], + "P112Cert.freeParameters": [], + "P112Cert.parameterClassCount": [], + "P112Cert.gPoints": [], + "P112Cert.rankMetadata": [], + "P112Cert.mp_row_000": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_001": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_002": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_003": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_004": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_005": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_006": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_007": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_008": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_009": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_010": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_011": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_012": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_013": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_014": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_015": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_016": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_017": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_018": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_019": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_020": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_021": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_022": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_023": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_024": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_025": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_026": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_027": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_028": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_029": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_030": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_031": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_032": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_033": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_034": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_035": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_036": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_037": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_038": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_039": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_040": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_041": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_042": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_043": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_044": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_045": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_046": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_047": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_048": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_049": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_050": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_051": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_052": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_053": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_054": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_055": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_056": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_057": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_058": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_059": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_060": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_061": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_062": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_063": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_064": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_065": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_066": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_067": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_068": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_069": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_070": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_071": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_072": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_073": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_074": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_075": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_076": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_077": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_078": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_079": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_080": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_081": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_082": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_083": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_084": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_085": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_086": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_087": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_088": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_089": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_090": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_091": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_092": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_093": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_094": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_095": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_096": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_097": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_098": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_099": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_100": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_101": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_102": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_103": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_104": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_105": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_106": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_107": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_108": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_109": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_110": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_111": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_112": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_113": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_114": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_115": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_116": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_117": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_118": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_119": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_120": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_121": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_122": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_123": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_124": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_125": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_126": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_127": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_128": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_129": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_130": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_131": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_132": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_133": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_134": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_135": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_136": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_137": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_138": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_139": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_140": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_141": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_142": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_143": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_144": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_145": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_146": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_147": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_148": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_149": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_150": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_151": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_152": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_153": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_154": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_155": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_156": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_157": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_158": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_159": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_160": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_161": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_162": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_163": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_164": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_165": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_166": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_167": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_168": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_169": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_170": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_171": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_172": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_173": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_174": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_175": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_176": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_177": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_178": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_179": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_180": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_181": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_182": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_183": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_184": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_185": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_186": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_187": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_188": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_189": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_190": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_191": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_192": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_193": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_194": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_195": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_196": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_197": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_198": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_199": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_200": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_201": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_202": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_203": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_204": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_205": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_206": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_207": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_208": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_209": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_210": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_211": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_212": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_213": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_214": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_215": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_216": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_217": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_218": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_219": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_220": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_221": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_222": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_223": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_224": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_225": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_226": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_227": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_228": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_229": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_230": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_231": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_232": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_233": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_234": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_235": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_236": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_237": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_238": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_239": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_240": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_241": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_242": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_243": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_244": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_245": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_246": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_247": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_248": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_249": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_250": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_251": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_252": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_253": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_254": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_255": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_256": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_257": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_258": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_259": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_260": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_261": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_262": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_263": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_264": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_265": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_266": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_267": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_268": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_269": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_270": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_271": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_272": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_273": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_274": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_275": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_276": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_277": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_278": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_279": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_280": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_281": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_282": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_283": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_284": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_285": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_286": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_row_287": [ + "propext", + "Quot.sound" + ], + "P112Cert.qp_row_000": [ + "propext", + "Quot.sound" + ], + "P112Cert.qp_row_001": [ + "propext", + "Quot.sound" + ], + "P112Cert.qp_row_002": [ + "propext", + "Quot.sound" + ], + "P112Cert.qp_row_003": [ + "propext", + "Quot.sound" + ], + "P112Cert.qp_row_004": [ + "propext", + "Quot.sound" + ], + "P112Cert.qp_row_005": [ + "propext", + "Quot.sound" + ], + "P112Cert.qp_row_006": [ + "propext", + "Quot.sound" + ], + "P112Cert.qp_row_007": [ + "propext", + "Quot.sound" + ], + "P112Cert.qp_row_008": [ + "propext", + "Quot.sound" + ], + "P112Cert.qp_row_009": [ + "propext", + "Quot.sound" + ], + "P112Cert.qp_row_010": [ + "propext", + "Quot.sound" + ], + "P112Cert.qp_row_011": [ + "propext", + "Quot.sound" + ], + "P112Cert.qp_row_012": [ + "propext", + "Quot.sound" + ], + "P112Cert.qp_row_013": [ + "propext", + "Quot.sound" + ], + "P112Cert.qp_row_014": [ + "propext", + "Quot.sound" + ], + "P112Cert.qp_row_015": [ + "propext", + "Quot.sound" + ], + "P112Cert.qp_row_016": [ + "propext", + "Quot.sound" + ], + "P112Cert.qp_row_017": [ + "propext", + "Quot.sound" + ], + "P112Cert.qp_row_018": [ + "propext", + "Quot.sound" + ], + "P112Cert.qp_row_019": [ + "propext", + "Quot.sound" + ], + "P112Cert.qp_row_020": [ + "propext", + "Quot.sound" + ], + "P112Cert.qp_row_021": [ + "propext", + "Quot.sound" + ], + "P112Cert.qp_row_022": [ + "propext", + "Quot.sound" + ], + "P112Cert.qp_row_023": [ + "propext", + "Quot.sound" + ], + "P112Cert.qp_row_024": [ + "propext", + "Quot.sound" + ], + "P112Cert.qp_row_025": [ + "propext", + "Quot.sound" + ], + "P112Cert.qp_row_026": [ + "propext", + "Quot.sound" + ], + "P112Cert.qp_row_027": [ + "propext", + "Quot.sound" + ], + "P112Cert.qp_row_028": [ + "propext", + "Quot.sound" + ], + "P112Cert.qp_row_029": [ + "propext", + "Quot.sound" + ], + "P112Cert.qp_row_030": [ + "propext", + "Quot.sound" + ], + "P112Cert.qp_row_031": [ + "propext", + "Quot.sound" + ], + "P112Cert.qp_row_032": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_000": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_001": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_002": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_003": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_004": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_005": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_006": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_007": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_008": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_009": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_010": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_011": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_012": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_013": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_014": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_015": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_016": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_017": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_018": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_019": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_020": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_021": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_022": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_023": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_024": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_025": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_026": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_027": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_028": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_029": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_030": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_031": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_032": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_033": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_034": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_035": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_036": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_037": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_038": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_039": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_040": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_041": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_042": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_043": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_044": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_045": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_046": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_047": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_048": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_049": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_050": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_051": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_052": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_053": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_054": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_055": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_056": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_057": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_058": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_059": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_060": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_061": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_062": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_063": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_064": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_065": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_066": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_067": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_068": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_069": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_070": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_071": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_072": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_073": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_074": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_075": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_076": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_077": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_078": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_079": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_080": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_081": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_082": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_083": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_084": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_085": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_086": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_087": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_088": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_089": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_090": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_091": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_092": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_093": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_094": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_095": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_096": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_097": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_098": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_099": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_100": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_101": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_102": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_row_103": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp_sparse_all": [ + "propext", + "Quot.sound" + ], + "P112Cert.qp_sparse_all": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_sparse_all": [ + "propext", + "Quot.sound" + ], + "P112Cert.mp": [ + "propext", + "Quot.sound" + ], + "P112Cert.qp": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual": [ + "propext", + "Quot.sound" + ], + "P112Cert.certificate": [ + "propext", + "Quot.sound" + ], + "P112Cert.lattice_eq_kernel": [ + "propext", + "Quot.sound" + ], + "P112Cert.phi_surjective": [ + "propext", + "Quot.sound" + ], + "P112Cert.quotientIso": [ + "propext", + "Quot.sound" + ], + "P112Cert.quotient_relation": [ + "propext", + "Quot.sound" + ], + "P112Cert.quotient_forward_on_representative": [ + "propext", + "Quot.sound" + ], + "P112Cert.quotient_inverse_on_parameter": [ + "propext", + "Quot.sound" + ], + "P112Cert.quotient_left_inverse": [ + "propext", + "Quot.sound" + ], + "P112Cert.quotient_right_inverse": [ + "propext", + "Quot.sound" + ], + "P112Cert.lattice_saturated": [ + "propext", + "Quot.sound" + ], + "P112Cert.reconstruction": [ + "propext", + "Quot.sound" + ], + "P112Cert.reconstruct_coordinate": [ + "propext", + "Quot.sound" + ], + "P112Cert.converse_relations": [ + "propext", + "Quot.sound" + ], + "P112Cert.parameters_recover": [ + "propext", + "Quot.sound" + ], + "P112Cert.unique_parameterization": [ + "propext", + "Quot.sound" + ], + "P112Cert.residual_relations_formula": [ + "propext", + "Quot.sound" + ], + "P112Cert.Damaged.W_entries_bad": [], + "P112Cert.Damaged.W_bad": [ + "propext", + "Quot.sound" + ], + "P112Cert.Damaged.original_coefficient": [ + "propext", + "Quot.sound" + ], + "P112Cert.Damaged.damaged_coefficient": [ + "propext", + "Quot.sound" + ], + "P112Cert.Damaged.unchanged_other_rows": [ + "propext", + "Quot.sound" + ], + "P112Cert.Damaged.residual_entry": [ + "propext", + "Quot.sound" + ], + "P112Cert.Damaged.damaged_product_entry": [ + "propext", + "Quot.sound" + ], + "P112Cert.Damaged.not_residual": [ + "propext", + "Quot.sound" + ], + "P112Cert.Damaged.no_certificate": [ + "propext", + "Quot.sound" + ] + }, + "negative_diagnostic": "fixtures/RejectDamagedW.lean:18:2: error: Tactic `decide` proved that the proposition\n 1 = -1\nis false\n", + "source_preservation": { + "all_six_declared_repair_hashes_match": true, + "other_available_bytes_unchanged": true, + "full_failed_original_preserved_locally": true, + "repaired_source_draft_bytes_exact": true + }, + "method": "Exact repaired canonical package authenticated, normal/optimized Python checks run, and unchanged dedicated Pro runner executed on a fresh source copy with minimal environment and descendant-session-aware external750s watchdog. Earlier direct operator replay retained separately. No source or limits changed.", + "original_receipt_sha256": "758a9b4e6da8bb10d1b3b36419c4b32163c541fab20aa5ae0c7b85bf83ad5c12", + "full_manifest_accepted": true, + "canonical_metadata_missing_at_draft": [], + "original_manifest_authentication": { + "recorded_at_utc": "2026-10-14T07:13:29.394128+00:00", + "original_manifest_members": 65, + "all_original_payload_members_authenticated": true, + "original_manifest_sha256": "7b2205ccfae455e86ddcded2375ee9b9f51add8985b9810702c9aa8e0b2641c1", + "original_sha256sums_sha256": "07da9af631a5e169d92abad7a536e777fc6b3159beb074852bf77fad9a099a8e", + "repaired_payload_members": 65, + "repaired_exact_file_set_verified": true, + "repaired_manifest_sha256": "4303973a433b61faf34a59f6d785cfd9bb85e59b500de8c4a54d3effb431963e", + "repaired_sha256sums_sha256": "d1e6655ad83d2d0f31ee111474866e0c06239a087c10ef3b776d660ad221935d", + "newly_recovered_metadata_members": [ + "PRODUCER_CHECKS.json", + "producer/integer-check.stderr", + "producer/integer-check.stdout", + "producer/regeneration.stderr", + "producer/regeneration.stdout", + "producer/source-audit.stderr", + "producer/source-audit.stdout", + "producer/tooling-tests.stderr", + "producer/tooling-tests.stdout" + ], + "all_declared_checksum_records_verified": true + }, + "advertised_dedicated_replay": { + "status": "ACCEPTED_ON_THIS_ACTUAL_OPERATOR_REPLAY", + "exact_version_output": { + "--short-version": "4.30.0\n", + "--githash": "d024af099ca4bf2c86f649261ebf59565dc8c622\n", + "--version": "Lean (version 4.30.0, arm64-apple-darwin24.6.0, commit d024af099ca4bf2c86f649261ebf59565dc8c622, Release)\n" + }, + "complete_named_axiom_census": 636, + "observed_axiom_union": [ + "Quot.sound", + "propext" + ], + "positive_units": 40, + "intended_negative_controls": 1, + "total_seconds": 53.65717304102145, + "dependency_seconds": 3.5374191249720752, + "successor_seconds_including_preflight": 50.119753916049376, + "runner_sha256": "cf32f674bfdc1b62903b8fa7d647d1c918f319f21d6e882bb59c38186e8f55c6", + "receipt_sha256": "0ebe2b1bde223e737393c8664a32b8ae350105aeee13d4b518cd1a89f716c5db", + "watchdog": { + "returncode": 0, + "whole_timeout_seconds": 750, + "timed_out": false, + "watchdog_failure": null, + "wall_seconds": 53.767878, + "tracked_process_count": 41, + "killed_groups": [], + "all_separate_child_sessions_covered": true + }, + "units": [ + { + "source": "PR1497Bridge.lean", + "source_utf8_bytes": 48758, + "source_sha256": "a27494b0d40bbf7874fd9a875e468c67d11545b266e17bc98f2ca75c77f6ee40", + "stdout_log": "logs/PR1497Bridge.stdout", + "stderr_log": "logs/PR1497Bridge.stderr", + "external_timeout_seconds": 120.0, + "accepted": true, + "returncode": 0, + "process_seconds": 3.534374459006358, + "olean_produced": true, + "axiom_query_count": 159, + "olean_sha256": "8e127898bdfbc04a199e5a245be99d7420c8079b99cc8860f1957423c48f9877" + }, + { + "source": "P112Sparse.lean", + "source_utf8_bytes": 3312, + "source_sha256": "1f9cae94b0767d117cd0c30c5852df385a1e98f6d255f130303130d9b7b4d071", + "stdout_log": "logs/P112Sparse.stdout", + "stderr_log": "logs/P112Sparse.stderr", + "external_timeout_seconds": 120.0, + "accepted": true, + "returncode": 0, + "process_seconds": 0.3987493749591522, + "olean_produced": true, + "axiom_query_count": 6, + "olean_sha256": "df88f54e96c88af78a2fe595e3386da08fecdd14682f54508d104a8eace473de" + }, + { + "source": "P112Data.lean", + "source_utf8_bytes": 96317, + "source_sha256": "c5619fb4e1b10663f48deb39272d191ba444f7052b0170a65186422e8177d967", + "stdout_log": "logs/P112Data.stdout", + "stderr_log": "logs/P112Data.stderr", + "external_timeout_seconds": 120.0, + "accepted": true, + "returncode": 0, + "process_seconds": 2.767351958027575, + "olean_produced": true, + "axiom_query_count": 15, + "olean_sha256": "00b7b4066e452242713d4d1ed3190d423bb25c38a4e68000ba59910e2f459e9c" + }, + { + "source": "P112/MP00.lean", + "source_utf8_bytes": 3678, + "source_sha256": "13f94407d2f564d1df02abd05d65c789f9ef0fd146ea83f219cc2b0790530da5", + "stdout_log": "logs/P112_MP00.stdout", + "stderr_log": "logs/P112_MP00.stderr", + "external_timeout_seconds": 120.0, + "accepted": true, + "returncode": 0, + "process_seconds": 0.8907745000324212, + "olean_produced": true, + "axiom_query_count": 16, + "olean_sha256": "253901c421c8bffb0b6bb073cf38d06793ee85091620f228a36e068db9986bb6" + }, + { + "source": "P112/MP01.lean", + "source_utf8_bytes": 3698, + "source_sha256": "374fac864b91f4d3be22c064933bd04fe68479e0aae3a2d47f417c053ebf7c26", + "stdout_log": "logs/P112_MP01.stdout", + "stderr_log": "logs/P112_MP01.stderr", + "external_timeout_seconds": 120.0, + "accepted": true, + "returncode": 0, + "process_seconds": 0.8897384579759091, + "olean_produced": true, + "axiom_query_count": 16, + "olean_sha256": "9cd03b2f7a15f9408eac9b25843b7f929b94759e099941af43bcc67f013d4674" + }, + { + "source": "P112/MP02.lean", + "source_utf8_bytes": 3698, + "source_sha256": "a2d4ce0941183e59c87d89a1369bd8cae8e5aa17457a20352ecbcdd0eec847ac", + "stdout_log": "logs/P112_MP02.stdout", + "stderr_log": "logs/P112_MP02.stderr", + "external_timeout_seconds": 120.0, + "accepted": true, + "returncode": 0, + "process_seconds": 0.8803231249912642, + "olean_produced": true, + "axiom_query_count": 16, + "olean_sha256": "f006b63c1f76a871a10039603c9ac0e55ea3718eabb592e61d065ea14a4f0ab3" + }, + { + "source": "P112/MP03.lean", + "source_utf8_bytes": 3698, + "source_sha256": "25846cbeac859682f102a4eba089f88fd6aece81538d368422b0347323d9a450", + "stdout_log": "logs/P112_MP03.stdout", + "stderr_log": "logs/P112_MP03.stderr", + "external_timeout_seconds": 120.0, + "accepted": true, + "returncode": 0, + "process_seconds": 0.889255374961067, + "olean_produced": true, + "axiom_query_count": 16, + "olean_sha256": "142b3c49ceff76e8cac6246d1f3bf68a692a9c6606459db7409264f75c77161e" + }, + { + "source": "P112/MP04.lean", + "source_utf8_bytes": 3698, + "source_sha256": "9c9694edc8e991dcc669d37de9116309c86bf408743993384b01c6bf7eae0e64", + "stdout_log": "logs/P112_MP04.stdout", + "stderr_log": "logs/P112_MP04.stderr", + "external_timeout_seconds": 120.0, + "accepted": true, + "returncode": 0, + "process_seconds": 0.9365326249971986, + "olean_produced": true, + "axiom_query_count": 16, + "olean_sha256": "30ce1313165dd0af55a551315fed12cbff5191a12ba5c2e6c5180ecc411d05f7" + }, + { + "source": "P112/MP05.lean", + "source_utf8_bytes": 3698, + "source_sha256": "e90fd3cebc97e91d1fec063ccd50fa67e82375c23e317d755ee52de07c6e2840", + "stdout_log": "logs/P112_MP05.stdout", + "stderr_log": "logs/P112_MP05.stderr", + "external_timeout_seconds": 120.0, + "accepted": true, + "returncode": 0, + "process_seconds": 0.939881999976933, + "olean_produced": true, + "axiom_query_count": 16, + "olean_sha256": "ca786dde8c1908426288e6be91f208e27eb57fe80511833f8af9ccf8e216978b" + }, + { + "source": "P112/MP06.lean", + "source_utf8_bytes": 3722, + "source_sha256": "02d4f4c3dc89e560e8f1109b051bb912f26e6a238c8f3c25237b67b144321f7e", + "stdout_log": "logs/P112_MP06.stdout", + "stderr_log": "logs/P112_MP06.stderr", + "external_timeout_seconds": 120.0, + "accepted": true, + "returncode": 0, + "process_seconds": 0.9941322499653324, + "olean_produced": true, + "axiom_query_count": 16, + "olean_sha256": "5a7c599856aeded82f650c6f93ffa87068c7bb40efd2a2fda87fd86dfe87f959" + }, + { + "source": "P112/MP07.lean", + "source_utf8_bytes": 3730, + "source_sha256": "39452ad57ba92c9cd54e9868a663b1b773c25143e0c24556899153cbcdae3842", + "stdout_log": "logs/P112_MP07.stdout", + "stderr_log": "logs/P112_MP07.stderr", + "external_timeout_seconds": 120.0, + "accepted": true, + "returncode": 0, + "process_seconds": 0.8907156659988686, + "olean_produced": true, + "axiom_query_count": 16, + "olean_sha256": "9f01bc2c20775848ce92853d6f9be450aa8adc88db96176620215da20706d4fd" + }, + { + "source": "P112/MP08.lean", + "source_utf8_bytes": 3730, + "source_sha256": "5905bb732b9976adba77dab859b52f1a3dbd01a2368ca92e1144d98db0c0b967", + "stdout_log": "logs/P112_MP08.stdout", + "stderr_log": "logs/P112_MP08.stderr", + "external_timeout_seconds": 120.0, + "accepted": true, + "returncode": 0, + "process_seconds": 0.889110415999312, + "olean_produced": true, + "axiom_query_count": 16, + "olean_sha256": "5a53664e831157e59bb133c66dd62d935ce019659f01b84c375d97d6c0d68e2b" + }, + { + "source": "P112/MP09.lean", + "source_utf8_bytes": 3730, + "source_sha256": "580c7521ccf594444d673a66280d448d36f5111bdfdc5303ad95547420c49ca2", + "stdout_log": "logs/P112_MP09.stdout", + "stderr_log": "logs/P112_MP09.stderr", + "external_timeout_seconds": 120.0, + "accepted": true, + "returncode": 0, + "process_seconds": 0.889715957979206, + "olean_produced": true, + "axiom_query_count": 16, + "olean_sha256": "02ea38204387c506f39e53650d791fab50fbdcde1440ee93a9319e1bd3fc141c" + }, + { + "source": "P112/MP10.lean", + "source_utf8_bytes": 3730, + "source_sha256": "317283042cdb1844c55de12c5fc9afaaf8efbd97552f64d7a3172a3b51fbd4d3", + "stdout_log": "logs/P112_MP10.stdout", + "stderr_log": "logs/P112_MP10.stderr", + "external_timeout_seconds": 120.0, + "accepted": true, + "returncode": 0, + "process_seconds": 0.9370699580176733, + "olean_produced": true, + "axiom_query_count": 16, + "olean_sha256": "2795bbe189affa2e4375b75331d6d48c56215b5bb14d127f0dd060e578eb7fa9" + }, + { + "source": "P112/MP11.lean", + "source_utf8_bytes": 3730, + "source_sha256": "e8898d45d1e5d0e39235b6a1eaf1880cdb9928442b4238d3a909a0b725ca394e", + "stdout_log": "logs/P112_MP11.stdout", + "stderr_log": "logs/P112_MP11.stderr", + "external_timeout_seconds": 120.0, + "accepted": true, + "returncode": 0, + "process_seconds": 0.9295908749918453, + "olean_produced": true, + "axiom_query_count": 16, + "olean_sha256": "53ab4d287c7720555bb974316ad0e48f958fc8f456d5d57a72d9d622e92ec522" + }, + { + "source": "P112/MP12.lean", + "source_utf8_bytes": 3730, + "source_sha256": "9244768a96a7351430167c9865051fcac394f591cd37bb21b8a93c59a0d9295a", + "stdout_log": "logs/P112_MP12.stdout", + "stderr_log": "logs/P112_MP12.stderr", + "external_timeout_seconds": 120.0, + "accepted": true, + "returncode": 0, + "process_seconds": 0.9423155410331674, + "olean_produced": true, + "axiom_query_count": 16, + "olean_sha256": "27ad4414626da264492febc918fd0370e4628b6df3d4660794ff638eb2fe5ba1" + }, + { + "source": "P112/MP13.lean", + "source_utf8_bytes": 3730, + "source_sha256": "b84a8d8657b85161f98fb8971b574526a6d53fce9e50847f59bf816a91351a38", + "stdout_log": "logs/P112_MP13.stdout", + "stderr_log": "logs/P112_MP13.stderr", + "external_timeout_seconds": 120.0, + "accepted": true, + "returncode": 0, + "process_seconds": 0.9447822500369512, + "olean_produced": true, + "axiom_query_count": 16, + "olean_sha256": "851ff2de8288038a9fe25ac3e02defebb6647313a0ea6624730197dd4d59a00c" + }, + { + "source": "P112/MP14.lean", + "source_utf8_bytes": 3730, + "source_sha256": "03915213d9aec2110071dcfd205de00e929220d092ea8238ed9036f96ac1fc4f", + "stdout_log": "logs/P112_MP14.stdout", + "stderr_log": "logs/P112_MP14.stderr", + "external_timeout_seconds": 120.0, + "accepted": true, + "returncode": 0, + "process_seconds": 0.9431898340117186, + "olean_produced": true, + "axiom_query_count": 16, + "olean_sha256": "9e0fe9fde25d128bb9a523219e103083435ee104ec14dde47ad8a52909f45e3c" + }, + { + "source": "P112/MP15.lean", + "source_utf8_bytes": 3730, + "source_sha256": "c1342bca97cb22f3773f16453fa88ec4a4ec4a5b2ad8deaa8f37317cc131fa04", + "stdout_log": "logs/P112_MP15.stdout", + "stderr_log": "logs/P112_MP15.stderr", + "external_timeout_seconds": 120.0, + "accepted": true, + "returncode": 0, + "process_seconds": 0.9340493340278044, + "olean_produced": true, + "axiom_query_count": 16, + "olean_sha256": "cd8296d304b3335b882221ce50ccfddd91748eda0727cf3711c7d5f3a28f7f57" + }, + { + "source": "P112/MP16.lean", + "source_utf8_bytes": 3730, + "source_sha256": "47336a6652bdfb9efac4291b73be99f41efe2fc68014562bd86ff092a34f2368", + "stdout_log": "logs/P112_MP16.stdout", + "stderr_log": "logs/P112_MP16.stderr", + "external_timeout_seconds": 120.0, + "accepted": true, + "returncode": 0, + "process_seconds": 0.8866951250238344, + "olean_produced": true, + "axiom_query_count": 16, + "olean_sha256": "ef205bce5a21a26904949f97a19d7239c32a17219fa131bf146282791bc0ef3e" + }, + { + "source": "P112/MP17.lean", + "source_utf8_bytes": 3730, + "source_sha256": "7da6a378c8e262cd027a7b8391df3f9b8c445eb750a5e2e11a2fa988314368a5", + "stdout_log": "logs/P112_MP17.stdout", + "stderr_log": "logs/P112_MP17.stderr", + "external_timeout_seconds": 120.0, + "accepted": true, + "returncode": 0, + "process_seconds": 0.8851946250069886, + "olean_produced": true, + "axiom_query_count": 16, + "olean_sha256": "407e125ace186d7e08dcabf37926d089d37978c76079ffc74decad810948a003" + }, + { + "source": "P112/QP00.lean", + "source_utf8_bytes": 4100, + "source_sha256": "b5015a85de7edf9df93f1b00fd6433113ef25ef177b75a840cdaa29068e5edff", + "stdout_log": "logs/P112_QP00.stdout", + "stderr_log": "logs/P112_QP00.stderr", + "external_timeout_seconds": 120.0, + "accepted": true, + "returncode": 0, + "process_seconds": 0.6507650410057977, + "olean_produced": true, + "axiom_query_count": 16, + "olean_sha256": "c109b77cebc064e6cfb4124499cd4e6b05bf9cde17e1b20c07a2eb4a1dc1aece" + }, + { + "source": "P112/QP01.lean", + "source_utf8_bytes": 4130, + "source_sha256": "e00cc8dd0c6798387436fa2625ef7bc59d61bfdf0b67efc4d5b132d1b9679f43", + "stdout_log": "logs/P112_QP01.stdout", + "stderr_log": "logs/P112_QP01.stderr", + "external_timeout_seconds": 120.0, + "accepted": true, + "returncode": 0, + "process_seconds": 0.7859341670409776, + "olean_produced": true, + "axiom_query_count": 16, + "olean_sha256": "90bf1248be21f63d416380da49a4ca4e1e484e08e7fb1825b9f77d3d8819906f" + }, + { + "source": "P112/QP02.lean", + "source_utf8_bytes": 725, + "source_sha256": "4fa1e2783b8082d03b434d7acc6549de4027d3e72685c9913158283c76957ea7", + "stdout_log": "logs/P112_QP02.stdout", + "stderr_log": "logs/P112_QP02.stderr", + "external_timeout_seconds": 120.0, + "accepted": true, + "returncode": 0, + "process_seconds": 0.39277908398071304, + "olean_produced": true, + "axiom_query_count": 1, + "olean_sha256": "55394897ed45ddce4e1b4f967fdc99a82caa9e14422251779cb454435de2a26f" + }, + { + "source": "P112/Residual00.lean", + "source_utf8_bytes": 2890, + "source_sha256": "f0018130a836f72d6a830da8247d4cd37df7df7c9418f5c528785227e364b577", + "stdout_log": "logs/P112_Residual00.stdout", + "stderr_log": "logs/P112_Residual00.stderr", + "external_timeout_seconds": 120.0, + "accepted": true, + "returncode": 0, + "process_seconds": 1.0456112909596413, + "olean_produced": true, + "axiom_query_count": 8, + "olean_sha256": "7d0aba0d98ef205b5043ea15ede5339f29aeff2652389addc72b1a222cf29cb8" + }, + { + "source": "P112/Residual01.lean", + "source_utf8_bytes": 2914, + "source_sha256": "c31b6b2d62e7b4dc0ff2d7d93c9510160c4015da8cf03729345fa4afec6e7db2", + "stdout_log": "logs/P112_Residual01.stdout", + "stderr_log": "logs/P112_Residual01.stderr", + "external_timeout_seconds": 120.0, + "accepted": true, + "returncode": 0, + "process_seconds": 1.4558206659858115, + "olean_produced": true, + "axiom_query_count": 8, + "olean_sha256": "84d1753817a40bb865ceed922c3a401ef134910fdc4733c0b6f9bb380132b78e" + }, + { + "source": "P112/Residual02.lean", + "source_utf8_bytes": 2922, + "source_sha256": "fd3d9e3ec624ef77309b78f21214f9e1d44ad97b96c1268bf3f10924a50ca1f2", + "stdout_log": "logs/P112_Residual02.stdout", + "stderr_log": "logs/P112_Residual02.stderr", + "external_timeout_seconds": 120.0, + "accepted": true, + "returncode": 0, + "process_seconds": 1.6792315829661675, + "olean_produced": true, + "axiom_query_count": 8, + "olean_sha256": "95de77da53d65954caf25e2b75999e9fa72076460b1be025a4fa86a54e8cdd11" + }, + { + "source": "P112/Residual03.lean", + "source_utf8_bytes": 2922, + "source_sha256": "fee2b63b5a52a3f0cd88973c0b1e9ec75a3966ff152e42cf540cb20cc737cc05", + "stdout_log": "logs/P112_Residual03.stdout", + "stderr_log": "logs/P112_Residual03.stderr", + "external_timeout_seconds": 120.0, + "accepted": true, + "returncode": 0, + "process_seconds": 1.4263410840067081, + "olean_produced": true, + "axiom_query_count": 8, + "olean_sha256": "869e6af32d846aa0acabedb5fafbe2f33134666f82934db81ba96a2b95227e5e" + }, + { + "source": "P112/Residual04.lean", + "source_utf8_bytes": 2922, + "source_sha256": "45bf845eb22460635f81d85757ed29e33622a5b123dc858b5f0673f3ad968c42", + "stdout_log": "logs/P112_Residual04.stdout", + "stderr_log": "logs/P112_Residual04.stderr", + "external_timeout_seconds": 120.0, + "accepted": true, + "returncode": 0, + "process_seconds": 1.9743547500111163, + "olean_produced": true, + "axiom_query_count": 8, + "olean_sha256": "e077a59c20d1c7aec5f3775a4f2b11b1000245be3d3fa383f468f0467ffded29" + }, + { + "source": "P112/Residual05.lean", + "source_utf8_bytes": 2922, + "source_sha256": "1fce648ce627b596a758be98790829f4df7f414a90d29cec34bdcefe749c08dd", + "stdout_log": "logs/P112_Residual05.stdout", + "stderr_log": "logs/P112_Residual05.stderr", + "external_timeout_seconds": 120.0, + "accepted": true, + "returncode": 0, + "process_seconds": 1.7973399169859476, + "olean_produced": true, + "axiom_query_count": 8, + "olean_sha256": "aa06c549099359cfa18db51907eb5d2df98401108d006849270ce5fca56457a4" + }, + { + "source": "P112/Residual06.lean", + "source_utf8_bytes": 2922, + "source_sha256": "fc26879525f376ee93a7d4c037ca42e49c597372a30b82d4f1107c9f0c36d1bb", + "stdout_log": "logs/P112_Residual06.stdout", + "stderr_log": "logs/P112_Residual06.stderr", + "external_timeout_seconds": 120.0, + "accepted": true, + "returncode": 0, + "process_seconds": 2.5628002079902217, + "olean_produced": true, + "axiom_query_count": 8, + "olean_sha256": "5e58f9da08dd330c7d68c646f8f617668c439348bfe146c69f78830b4a3d7d74" + }, + { + "source": "P112/Residual07.lean", + "source_utf8_bytes": 2922, + "source_sha256": "828f358afed3c9ea4839a3e15400294b77e313b31dcfd58b278f309e5f4854fd", + "stdout_log": "logs/P112_Residual07.stdout", + "stderr_log": "logs/P112_Residual07.stderr", + "external_timeout_seconds": 120.0, + "accepted": true, + "returncode": 0, + "process_seconds": 2.194540166994557, + "olean_produced": true, + "axiom_query_count": 8, + "olean_sha256": "a1754cadde072fcca86a7c4e36062c632f71ae164919cb97e97b12675f52eeb6" + }, + { + "source": "P112/Residual08.lean", + "source_utf8_bytes": 2922, + "source_sha256": "665f03ae5197ee1b90c585613e717da85b682cae471d8b00da97846b28732497", + "stdout_log": "logs/P112_Residual08.stdout", + "stderr_log": "logs/P112_Residual08.stderr", + "external_timeout_seconds": 120.0, + "accepted": true, + "returncode": 0, + "process_seconds": 2.29240433301311, + "olean_produced": true, + "axiom_query_count": 8, + "olean_sha256": "17bc3dac7a9a40aa688c609805bc1335452c7017b1b983b74311f00127abb39c" + }, + { + "source": "P112/Residual09.lean", + "source_utf8_bytes": 2922, + "source_sha256": "ada3f0b6e1e66fd4a16f56bbcfb62e02f248d3d085889697ff818f95ade3b95d", + "stdout_log": "logs/P112_Residual09.stdout", + "stderr_log": "logs/P112_Residual09.stderr", + "external_timeout_seconds": 120.0, + "accepted": true, + "returncode": 0, + "process_seconds": 1.90911170799518, + "olean_produced": true, + "axiom_query_count": 8, + "olean_sha256": "ee80075ab1a06de1e3ae6fd66ac6f08ddd5d6b9b4057144ec3f7fd21288c2346" + }, + { + "source": "P112/Residual10.lean", + "source_utf8_bytes": 2922, + "source_sha256": "3dfeb23cd21058c8b98b58cc97d0fc2812d49efad5b1752dcb52cd2b47ff317f", + "stdout_log": "logs/P112_Residual10.stdout", + "stderr_log": "logs/P112_Residual10.stderr", + "external_timeout_seconds": 120.0, + "accepted": true, + "returncode": 0, + "process_seconds": 3.210947333020158, + "olean_produced": true, + "axiom_query_count": 8, + "olean_sha256": "a18c99ebd7a05a86fe6798d2ad45f3195d0f0e2340beafcec9e01ba7e842bb50" + }, + { + "source": "P112/Residual11.lean", + "source_utf8_bytes": 2922, + "source_sha256": "6d7604d36d7879801758de815fbfbdf38b2975ae6cd5ce722c20709bd00c50bc", + "stdout_log": "logs/P112_Residual11.stdout", + "stderr_log": "logs/P112_Residual11.stderr", + "external_timeout_seconds": 120.0, + "accepted": true, + "returncode": 0, + "process_seconds": 2.333265791996382, + "olean_produced": true, + "axiom_query_count": 8, + "olean_sha256": "4fb9e4b17f818634b697d4843b2ecdc4037d45cf0a7620ec0f46c00043491de9" + }, + { + "source": "P112/Residual12.lean", + "source_utf8_bytes": 2938, + "source_sha256": "6a727a2c56358da83565fc27474cef83c02fb0fa5af53dae4e18af6d55675810", + "stdout_log": "logs/P112_Residual12.stdout", + "stderr_log": "logs/P112_Residual12.stderr", + "external_timeout_seconds": 120.0, + "accepted": true, + "returncode": 0, + "process_seconds": 2.130624292010907, + "olean_produced": true, + "axiom_query_count": 8, + "olean_sha256": "b26b000b6fec356b14cb0c0a67628de69b97b12b7504ce20c01288eba958d51d" + }, + { + "source": "P112Certificate.lean", + "source_utf8_bytes": 49456, + "source_sha256": "3cc91d09e6f743a3e2e0ed02b8d73246b306965c2f12e82f49deac8d16899ff0", + "stdout_log": "logs/P112Certificate.stdout", + "stderr_log": "logs/P112Certificate.stderr", + "external_timeout_seconds": 120.0, + "accepted": true, + "returncode": 0, + "process_seconds": 0.7183487080037594, + "olean_produced": true, + "axiom_query_count": 7, + "olean_sha256": "cc7ce419288f649c655217cb639a8682bd0ff67b998d36659e9e4fdebef54d45" + }, + { + "source": "P112Consequences.lean", + "source_utf8_bytes": 4848, + "source_sha256": "bf2d28f786f2aeee4ea0e0d733ad3f6973c133fe9cde452c21fc36ca709444bc", + "stdout_log": "logs/P112Consequences.stdout", + "stderr_log": "logs/P112Consequences.stderr", + "external_timeout_seconds": 120.0, + "accepted": true, + "returncode": 0, + "process_seconds": 0.3962349999928847, + "olean_produced": true, + "axiom_query_count": 15, + "olean_sha256": "32f76b31456464ce84eac5cf39fca2eb6405084925a1cab9238180e3cf899eb3" + }, + { + "source": "P112Damaged.lean", + "source_utf8_bytes": 3230, + "source_sha256": "e915b6ca54379292462315ca613ccfe46e5d77acd2b31e07e83dbcd7f0f3fd32", + "stdout_log": "logs/P112Damaged.stdout", + "stderr_log": "logs/P112Damaged.stderr", + "external_timeout_seconds": 120.0, + "accepted": true, + "returncode": 0, + "process_seconds": 0.40117550001014024, + "olean_produced": true, + "axiom_query_count": 9, + "olean_sha256": "915343fa69d9f3f156e3fb87bfa572de744434cc9c85ac74862045846c379476" + }, + { + "source": "fixtures/RejectDamagedW.lean", + "source_utf8_bytes": 596, + "source_sha256": "7796f968b92e57759776b10c9a37847ffde62bbc6d8a7fda321f09b3cba2dda5", + "stdout_log": "logs/fixtures_RejectDamagedW.stdout", + "stderr_log": "logs/fixtures_RejectDamagedW.stderr", + "external_timeout_seconds": 120.0, + "accepted": true, + "returncode": 1, + "process_seconds": 0.34335475001716986, + "olean_produced": false, + "negative_control": "intended decide rejection of 1 = -1" + } + ] + }, + "registered_python_checks": { + "status": "ALL_SIX_COMPLETE_PACKAGE_PYTHON_COMMANDS_PASS", + "full_manifest_accepted": true, + "normal_optimized_source_and_numeric_outputs_identical": true, + "tooling_tests_per_mode": 14, + "runs": [ + { + "label": "normal-audit_sources", + "returncode": 0, + "seconds": 0.243261, + "stdout_bytes": 732, + "stdout_sha256": "82b916031bbdd46a6a133137770fcef8c0e29fbf920c2f7f60429c64a423b3c8", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "label": "normal-check_numeric", + "returncode": 0, + "seconds": 0.288085, + "stdout_bytes": 824, + "stdout_sha256": "808f025e73edf581cb4d0f232f375ed1447be3a7bdd1d38e5621ffc68805cfb4", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "label": "normal-test_tooling", + "returncode": 0, + "seconds": 0.518613, + "stdout_bytes": 0, + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stderr_bytes": 1711, + "stderr_sha256": "384674c3cfcea5104084610fd00466f85f66bc304fafbc3270c27af8c8ec9d9a" + }, + { + "label": "optimized-audit_sources", + "returncode": 0, + "seconds": 0.320813, + "stdout_bytes": 732, + "stdout_sha256": "82b916031bbdd46a6a133137770fcef8c0e29fbf920c2f7f60429c64a423b3c8", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "label": "optimized-check_numeric", + "returncode": 0, + "seconds": 0.381743, + "stdout_bytes": 824, + "stdout_sha256": "808f025e73edf581cb4d0f232f375ed1447be3a7bdd1d38e5621ffc68805cfb4", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "label": "optimized-test_tooling", + "returncode": 0, + "seconds": 0.663238, + "stdout_bytes": 0, + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stderr_bytes": 1711, + "stderr_sha256": "4e404644bdb2e674d43d64cb3fcd0442be67dc3df1ca7f8777b194937cc42940" + } + ] + }, + "operator_containment_note": "First advertised-run outer watchdog encountered a sandbox denial of process inspection; that delivered runner completed with its own120/600bounds. After verifying all its task processes had exited, a fresh replay used process-inspection preflight and a750s descendant-session-aware watchdog. Only this later guarded run supplies the advertised complete watchdog evidence.", + "separate_review": { + "compact_core_recovered_and_read": true, + "scope": "Original source candidate before repair", + "no_distinct_material_flaw_reported_beyond_known_elaboration": true, + "full_report_recovered": false, + "reviewer_checker_recovered_or_locally_run": false, + "repair_reviewed": false, + "lean_run_by_reviewer": false, + "details": "REVIEW.md" + }, + "final_registered_replay": { + "observed_at_utc": "2026-10-14T07:22:00Z", + "time_precision": "minute", + "base_commit": "0b1cccf86e2f5132ed286a26ef0a681a495740ea", + "python": "3.12.14", + "command": [ + "python3.12", + "-I", + "-B", + "scripts/research_package.py", + "--package", + "research/p112-integral-retraction-instance" + ], + "exit_code": 0, + "wall_seconds": 2.845997, + "registered_commands": 6, + "result": "PASS_REGISTERED_RESEARCH_PACKAGE research/p112-integral-retraction-instance outcome=completed", + "scope": "Local source/numeric/tooling execution; dedicated Lean evidence is separate; no hosted CI approval inferred." + } +} diff --git a/research/p112-integral-retraction-instance/REVIEW.md b/research/p112-integral-retraction-instance/REVIEW.md new file mode 100644 index 0000000000..fe7e201fbd --- /dev/null +++ b/research/p112-integral-retraction-instance/REVIEW.md @@ -0,0 +1,30 @@ +# Separate Pro review: scope and limits + +A separate GPT-6 Pro review of the original source candidate completed on +14 October 2026. Its compact final statement reports no distinct mathematical, +orientation, data-binding or coverage flaw beyond the known rewrite elaboration +failure. The reviewer reports reconstructing all 39 generated outputs at their +original hashes, checking all 21,409 integer comparisons and 425 complete row +statements, and inspecting the sparse adapter and inherited bridge applications. + +The reported assessment preserves the actual row orientation +`v - (vP)Q = (vW)M`, the image-defined quotient, and the explicit ordinary group +and individual-relation hypotheses. It does not promote the copied rank metadata +into a formal rank theorem. The reviewer also identified the same rewrite pattern +in the two unrun damaged-entry proofs; the separate Pro-authored repair addresses +those sites as well as the certificate. + +The compact response was recovered and read locally. The full 35,082-byte review +was **not** retrieved; its reported SHA256 is +`a0eeae6b652074edaa993e6773893f6d3eccafd0c6ed286ecfaee3395aac0c4a`. +The reported 21,137-byte independent checker, SHA256 +`8d8736c28e24b3fd9344ca14152c7772f5e332693f593bf02ad3a9fdbb739dec`, +was not recovered or run locally. Its normal/optimized execution and 12 rejection +controls are reviewer reports only, not operator replay evidence. + +The reviewer did not execute Lean, independently hash the bridge file, certify +the original complete manifest or review the later repair. This is a separate +model assessment of the original candidate, not independent human review or a +second kernel run. The complete repaired-package authentication and exact local +Lean execution are recorded separately in `REPLAY.json`. No mathematical or +source change was made by Codex in response to this review. diff --git a/research/p112-integral-retraction-instance/SOURCES.json b/research/p112-integral-retraction-instance/SOURCES.json new file mode 100644 index 0000000000..f82efda3d1 --- /dev/null +++ b/research/p112-integral-retraction-instance/SOURCES.json @@ -0,0 +1,239 @@ +{ + "schema_version": 1, + "base_commit": "c24fb5e6537d19d79c62265e4a12781aef9309cb", + "current_main_at_publication_base": "0b1cccf86e2f5132ed286a26ef0a681a495740ea", + "files": [ + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "06c96f5579bb67ed1b86d334e78fbed7da6945f1", + "sha256": "6686ad58f1fbdbc87134a78901b60fd53a20d3984355e91defbbebc9e9fa8075" + }, + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" + } + ], + "external_predecessors": [ + { + "head": "985fd79ffea7ae7375fe6aa3ce9940b125c7dca2", + "path": "research/integral-retraction-monomial-bridge/README.md", + "git_blob": "bb2e7e397fe9f92333420810364159b5ff624d47", + "sha256": "40346c82c436a06dfe0de580787ff46afa5f4dcac20003e19a644aa8750392b0", + "bytes": 7277, + "url": "https://github.com/CrocSwap/integer-mult-bounds/blob/985fd79ffea7ae7375fe6aa3ce9940b125c7dca2/research/integral-retraction-monomial-bridge/README.md" + }, + { + "head": "985fd79ffea7ae7375fe6aa3ce9940b125c7dca2", + "path": "research/integral-retraction-monomial-bridge/SCOPE.md", + "git_blob": "6b14ad599d8d19acf3182ad4a4b0ce08bf2f6932", + "sha256": "651022d2367726f227b7f193316789b2bac7e96a79e7ad84b71dc7821f28608c", + "bytes": 9765, + "url": "https://github.com/CrocSwap/integer-mult-bounds/blob/985fd79ffea7ae7375fe6aa3ce9940b125c7dca2/research/integral-retraction-monomial-bridge/SCOPE.md" + }, + { + "head": "985fd79ffea7ae7375fe6aa3ce9940b125c7dca2", + "path": "research/integral-retraction-monomial-bridge/PR1497Bridge.lean", + "git_blob": "950829a2871b4d069bf7c286525214ab1724ce5f", + "sha256": "a27494b0d40bbf7874fd9a875e468c67d11545b266e17bc98f2ca75c77f6ee40", + "bytes": 48758, + "url": "https://github.com/CrocSwap/integer-mult-bounds/blob/985fd79ffea7ae7375fe6aa3ce9940b125c7dca2/research/integral-retraction-monomial-bridge/PR1497Bridge.lean" + }, + { + "head": "7a1309f18f56d04c2db33bf1607e0332d19f72b3", + "path": "research/complex-rank8-ratio-gluing-audit/audit.md", + "git_blob": "8753847aea8d5afdc34fcda85ed6fa54cde7c1d8", + "sha256": "2e6bf15efc5293e85b4a0cc486fbd84989209ee22c6e04a8d741bb2f76405d4c", + "bytes": 42168, + "url": "https://github.com/CrocSwap/integer-mult-bounds/blob/7a1309f18f56d04c2db33bf1607e0332d19f72b3/research/complex-rank8-ratio-gluing-audit/audit.md" + }, + { + "head": "7a1309f18f56d04c2db33bf1607e0332d19f72b3", + "path": "research/complex-rank8-ratio-gluing-audit/verify.py", + "git_blob": "f8d78251e09a4759c36506bd97ac42a6a8ea285e", + "sha256": "224355b93102d22bea4bc8c818baa13cfc9149f9e2752ec1722b959b77d59c42", + "bytes": 35522, + "url": "https://github.com/CrocSwap/integer-mult-bounds/blob/7a1309f18f56d04c2db33bf1607e0332d19f72b3/research/complex-rank8-ratio-gluing-audit/verify.py" + }, + { + "head": "7a1309f18f56d04c2db33bf1607e0332d19f72b3", + "path": "research/complex-rank8-ratio-gluing-audit/README.md", + "git_blob": "440d4ce2258397c739b35d3a1f8711de7b79a151", + "sha256": "a2334abc5a2b39ba9969bc7c03e0a786f7f1d5621b8fef67bfa7e01029be3c48", + "bytes": 6707, + "url": "https://github.com/CrocSwap/integer-mult-bounds/blob/7a1309f18f56d04c2db33bf1607e0332d19f72b3/research/complex-rank8-ratio-gluing-audit/README.md" + } + ], + "numerical_fragment": { + "certificate_path": "work/pro-audit/received/certificate.json", + "certificate_bytes": 1019927, + "certificate_sha256": "102cb8ddda027286b010b6edfd80c2b1c201a24020dfe32b0caee0f2a827c57e", + "fragment_json_pointer": "/units/P112/gluing_lattice_certificate", + "fragment_bytes": 13183, + "fragment_sha256": "a1b43a5a7a8dcce0b84858244c512e53e6c344877cc35e87937fedd2601f29d5", + "method": "JSON structure reading and sparse entry counting only; no imports, matrix products, regeneration, theorem derivation or Lean execution", + "dimensions_from_saved_shape_and_explicit_source": { + "m": 288, + "N": 104, + "d": 33 + }, + "matrix_rows_and_stored_entries": { + "M": { + "rows": 288, + "stored_entries": 1152 + }, + "P": { + "rows": 104, + "stored_entries": 195 + }, + "Q": { + "rows": 33, + "stored_entries": 66 + }, + "W": { + "rows": 104, + "stored_entries": 111 + } + }, + "parameter_order": { + "class_parameters": 26, + "g_points": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ] + }, + "coordinate_labels": 104, + "anchors": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 2, + 2, + 2, + 2, + 4 + ], + "base_pair_representatives": { + "1": 0, + "2": 0, + "3": 0, + "4": 1, + "5": 1, + "6": 3, + "7": 3 + }, + "inherited_rank_metadata_not_new_proof": 71, + "public_reproduction": { + "source_commit": "7a1309f18f56d04c2db33bf1607e0332d19f72b3", + "package_path": "research/complex-rank8-ratio-gluing-audit", + "command": [ + "python3", + "-I", + "-B", + "verify.py", + "--certificate-out", + "certificate.json" + ], + "verifier_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/7a1309f18f56d04c2db33bf1607e0332d19f72b3/research/complex-rank8-ratio-gluing-audit/verify.py", + "json_pointer": "/units/P112/gluing_lattice_certificate", + "fragment_serialization": "UTF8json.dumps(sort_keys=True,separators=(comma,colon),ensure_ascii=False) plus one LF", + "root_final_source_binding": "Root reports full1019927-byte saved certificate SHA256102cb8ddda027286b010b6edfd80c2b1c201a24020dfe32b0caee0f2a827c57e and exact JSON-subobject equality rechecked before publication; no matrix recomputation." + } + }, + "fragment_binding_note": "Operator authenticated the full saved certificate and exact JSON subobject before Pro dispatch. Pro received only the pinned fragment and did not rehash the full saved certificate. No full E8 geometry input is a runtime dependency of this scoped package.", + "canonical_source": { + "directory": "source", + "manifest_sha256": "4303973a433b61faf34a59f6d785cfd9bb85e59b500de8c4a54d3effb431963e", + "checksums_sha256": "d1e6655ad83d2d0f31ee111474866e0c06239a087c10ef3b776d660ad221935d", + "original_manifest_sha256": "7b2205ccfae455e86ddcded2375ee9b9f51add8985b9810702c9aa8e0b2641c1", + "full_manifest_accepted": true, + "missing_members": [], + "repair_source_diff": "REPAIR.diff", + "repair_inventory": [ + { + "path": "generate.py", + "bytes": 16960, + "sha256": "ebd2d4eeb44064c04ff6097d8b7e50e14370f893d56bd5b11536f225a10aa319" + }, + { + "path": "P112Certificate.lean", + "bytes": 49456, + "sha256": "3cc91d09e6f743a3e2e0ed02b8d73246b306965c2f12e82f49deac8d16899ff0" + }, + { + "path": "P112Damaged.lean", + "bytes": 3230, + "sha256": "e915b6ca54379292462315ca613ccfe46e5d77acd2b31e07e83dbcd7f0f3fd32" + }, + { + "path": "DECLARATIONS.tsv", + "bytes": 36006, + "sha256": "c27eed09af9db4cec1dabe690f9c81efbdb2c9a9830083b2e2656d20c1f964f0" + }, + { + "path": "MANIFEST.tsv", + "bytes": 5754, + "sha256": "4303973a433b61faf34a59f6d785cfd9bb85e59b500de8c4a54d3effb431963e" + }, + { + "path": "SHA256SUMS", + "bytes": 5558, + "sha256": "d1e6655ad83d2d0f31ee111474866e0c06239a087c10ef3b776d660ad221935d" + } + ], + "unchanged_executable_dependency": { + "path": "PR1497Bridge.lean", + "sha256": "a27494b0d40bbf7874fd9a875e468c67d11545b266e17bc98f2ca75c77f6ee40", + "bytes": 48758, + "matches_exact_public_source": true + }, + "historical_source_only_comments_preserved": true + }, + "source_authorship_and_attribution": "Andrey Mas with substantial GPT-6 Pro for PR1497/1610; inherited Brett Halligan/burntout76 and Ninefold PR1212, DreamingOfClouds PR717,themilkman216 PR968; Codex mechanical source collection/replay only.", + "claim": { + "node_id": "DC_kwDOU-508s4BIKGK", + "url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1527#discussioncomment-18915722", + "created_at": "2026-10-14T05:24:58Z", + "expires_at": "2026-10-14T07:20:00Z", + "original_expires_at": "2026-10-14T07:20:00Z", + "latest_advisory_expires_at": "2026-10-14T08:00:00Z", + "expiry_history_note": "The original expires_at is historical. Root reports a later public extension to08:00UTC." + }, + "local_kernel_receipt": "REPLAY.json", + "generic_hook_boundary": "Source binding, integer checks and tooling controls only; no Lean is invoked by VERIFY.json.", + "separate_review": { + "compact_core_recovered_and_read": true, + "scope": "Original source candidate before repair", + "no_distinct_material_flaw_reported_beyond_known_elaboration": true, + "full_report_recovered": false, + "reviewer_checker_recovered_or_locally_run": false, + "repair_reviewed": false, + "lean_run_by_reviewer": false, + "details": "REVIEW.md" + } +} diff --git a/research/p112-integral-retraction-instance/TASK.json b/research/p112-integral-retraction-instance/TASK.json new file mode 100644 index 0000000000..f8ad5c278e --- /dev/null +++ b/research/p112-integral-retraction-instance/TASK.json @@ -0,0 +1,108 @@ +{ + "schema_version": 1, + "task_id": "formal-interface-lemma", + "priority_revision": 3, + "base_commit": "c24fb5e6537d19d79c62265e4a12781aef9309cb", + "current_main_at_publication_base": "0b1cccf86e2f5132ed286a26ef0a681a495740ea", + "original_card": { + "id": "formal-interface-lemma", + "question": "Can one small, precisely scoped interface lemma be formalized with its actual hypotheses?", + "starting_points": [ + "certificates/selected-result.json", + "research/hyperplane-end-lean/PROOF.md" + ], + "methods": [ + "Formalize a missing boundary lemma identified by the selected review.", + "Audit a formal theorem-to-certificate binding independently." + ], + "acceptance_gate": "State the exact formalized proposition and remaining assumptions; avoid duplicate arithmetic formalizations already present.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read the exact hypotheses in the hyperplane-end proof and distinguish Lean theorems from finite supplier assumptions.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "first_experiment": "State one missing boundary lemma in full before starting a proof-assistant build.", + "bottleneck_link": "A missing interface proof can reduce the conditional gap even if it does not change kappa.", + "allowed_variations": [ + "Narrow to one formal lemma or one theorem-to-certificate binding." + ], + "scope_change_triggers": [ + "Formalizing already-covered arithmetic and claiming the full multiplication theorem." + ], + "overlap_terms": [ + "hyperplane end", + "formal interface", + "Lean binding" + ] + }, + "scope_status": "refined", + "actual_scope": "Bind the exact pinned P112 integer M/P/Q/W fragment to the unchanged PR1610 MatrixIdentities interface, prove its three finite matrix identities and instantiate only the already proved algebraic consequences.", + "scope_change_reason": "Follow the explicit PR1610 open interface, narrowed to one actual finite certificate and its existing conditional consequences. The separate field adapter and geometric bridge remain open.", + "scope_key": "P112/PR1497-frozen-M-P-Q-W/PR1610-MatrixIdentities/kernel-instance", + "bottleneck_link": "Discharges one concrete finite-data hypothesis of the published conditional retraction/reconstruction bridge; it does not claim new geometry, supplier budgets or kappa.", + "budget_minutes": 120, + "stop_rule": "Preserve exact scientific inputs;120seconds per Lean unit,600seconds total successor and750seconds independent watchdog; no raised-limit retry. Stop at first failed proof/census/control.", + "outcome": "completed", + "evidence": "Complete repaired package authenticates against the exact65-member canonical manifest and checksums. Six normal/optimized Python runs pass. Both direct operator replay and the unchanged dedicated runner accept40positive units,636named queries and one intended negative fixture under exactLean4.30.0; observed axioms onlypropext/Quot.sound. Separate compact Pro review of the original source found no distinct material flaw beyond known elaboration; full report/checker not retrieved or locally replayed and repair not reviewed.", + "author": "Andrey Mas", + "ai_assistance": "Substantial GPT-6 Pro mathematical/source development and diagnostic repair through ChatGPT. Codex source coordination, execution audit, local kernel replay and mechanical packaging; no local mathematical proof repair.", + "open_questions": [ + { + "question": "Which exact P112 geometric hypotheses imply the288individual monomial relation rows?", + "why_it_matters": "The fixed integer certificate and conditional reconstruction do not establish the geometric premises needed for their application.", + "first_step": "Pin one geometric generator list and state its implication to MonomialBridge.Relations for the exact P112Cert.M.", + "blocked_by": "No geometric generator-to-relation or coverage theorem is included." + }, + { + "question": "Can a lawful nonzero-field-element adapter instantiate the explicit commutative-group interface?", + "why_it_matters": "The current multiplicative consequences use explicit abstract group laws and do not supply field or Units notation.", + "first_step": "Choose one field API and prove its nonzero-element group laws before applying the existing reconstruction theorem.", + "blocked_by": "No field API or nonzero-element adapter is included." + } + ], + "coordination": { + "claim": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1527#discussioncomment-18915722", + "claim_expiry_utc": "2026-10-14T08:00:00Z", + "initial_overlap": { + "coverage": { + "open_prs": { + "fetched_at": "2026-10-14T05:15:32.508363+00:00", + "complete_pagination": true, + "records": 595 + }, + "discussions": { + "fetched_at": "2026-10-14T05:16:58.444190+00:00", + "complete_pagination": true, + "records": 295 + } + }, + "warnings": [], + "terms": [ + "1610", + "1497", + "1527", + "MatrixIdentities", + "finite E8 matrices", + "E8 instance", + "field adapter", + "integral retraction" + ], + "finding": "No active matching numerical-instance scope found; direct1527released, sourceheadsunchanged.", + "limits": "Remote PR scope is open PRs including drafts. Closed work is searched through local READMEs, TASK metadata and ledger only. No code diffs or arbitrary package files are searched. Recheck relevant heads before submission." + }, + "prepublication_overlap": { + "read_at_utc": "2026-10-14T06:57:59Z", + "coverage": "Complete direct Discussions1635,1167,1527,1166; newest100openPRs of382reported, plus older complete533PR/305Discussion snapshot. Bounded fresh coverage, not a full repository audit.", + "finding": "No competing pinned P112 retraction-instance scope found; source heads1497and1610 unchanged." + }, + "draft_only": true, + "original_claim_expiry_utc": "2026-10-14T07:20:00Z", + "expiry_update_evidence": "Root reports latest public extension to08:00UTC; original historical claim retained." + }, + "pending_canonical_source_members": [] +} diff --git a/research/p112-integral-retraction-instance/VERIFY.json b/research/p112-integral-retraction-instance/VERIFY.json new file mode 100644 index 0000000000..715937b473 --- /dev/null +++ b/research/p112-integral-retraction-instance/VERIFY.json @@ -0,0 +1,84 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "-c", + "import runpy,sys;from pathlib import Path;p=Path(sys.argv[1]).resolve();sys.path.insert(0,str(p));sys.argv=[str(p/'audit_sources.py')]+['--manifest'];runpy.run_path(sys.argv[0],run_name='__main__')", + "{package}/source" + ], + "timeout_seconds": 30, + "checks": "NON-KERNEL normal: Exact source/manifest binding and complete declaration inventory. Does not invoke Lean." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "-c", + "import runpy,sys;from pathlib import Path;p=Path(sys.argv[1]).resolve();sys.path.insert(0,str(p));sys.argv=[str(p/'check_numeric.py')]+[];runpy.run_path(sys.argv[0],run_name='__main__')", + "{package}/source" + ], + "timeout_seconds": 30, + "checks": "NON-KERNEL normal: All21409integer comparisons and source-specific W sign corruption. Does not invoke Lean." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "-c", + "import runpy,sys;from pathlib import Path;p=Path(sys.argv[1]).resolve();sys.path.insert(0,str(p));sys.argv=[str(p/'test_tooling.py')]+[];runpy.run_path(sys.argv[0],run_name='__main__')", + "{package}/source" + ], + "timeout_seconds": 30, + "checks": "NON-KERNEL normal: All14tooling controls. Does not invoke Lean." + }, + { + "argv": [ + "{python}", + "-O", + "-I", + "-B", + "-c", + "import runpy,sys;from pathlib import Path;p=Path(sys.argv[1]).resolve();sys.path.insert(0,str(p));sys.argv=[str(p/'audit_sources.py')]+['--manifest'];runpy.run_path(sys.argv[0],run_name='__main__')", + "{package}/source" + ], + "timeout_seconds": 30, + "checks": "NON-KERNEL optimized: Exact source/manifest binding and complete declaration inventory. Does not invoke Lean." + }, + { + "argv": [ + "{python}", + "-O", + "-I", + "-B", + "-c", + "import runpy,sys;from pathlib import Path;p=Path(sys.argv[1]).resolve();sys.path.insert(0,str(p));sys.argv=[str(p/'check_numeric.py')]+[];runpy.run_path(sys.argv[0],run_name='__main__')", + "{package}/source" + ], + "timeout_seconds": 30, + "checks": "NON-KERNEL optimized: All21409integer comparisons and source-specific W sign corruption. Does not invoke Lean." + }, + { + "argv": [ + "{python}", + "-O", + "-I", + "-B", + "-c", + "import runpy,sys;from pathlib import Path;p=Path(sys.argv[1]).resolve();sys.path.insert(0,str(p));sys.argv=[str(p/'test_tooling.py')]+[];runpy.run_path(sys.argv[0],run_name='__main__')", + "{package}/source" + ], + "timeout_seconds": 30, + "checks": "NON-KERNEL optimized: All14tooling controls. Does not invoke Lean." + } + ] +} diff --git a/research/p112-integral-retraction-instance/source/BINDING.tsv b/research/p112-integral-retraction-instance/source/BINDING.tsv new file mode 100644 index 0000000000..192fb83216 --- /dev/null +++ b/research/p112-integral-retraction-instance/source/BINDING.tsv @@ -0,0 +1,5467 @@ +json_pointer node_kind value_or_shape lean_binding +/ object_keys ["M","P","Q","W","anchors","base_pair_representatives","coordinates","free_parameters","parameter_order","rank"] P112Cert constants and fixed matrix shapes +/M array_length 288 M_entries +/M/0 array_length 4 M_entries[0] +/M/0/0 array_length 2 M_entries[0][0] +/M/0/0/0 integer 0 M_entries[0][0][0] +/M/0/0/1 integer 1 M_entries[0][0][1] +/M/0/1 array_length 2 M_entries[0][1] +/M/0/1/0 integer 1 M_entries[0][1][0] +/M/0/1/1 integer -1 M_entries[0][1][1] +/M/0/2 array_length 2 M_entries[0][2] +/M/0/2/0 integer 4 M_entries[0][2][0] +/M/0/2/1 integer -1 M_entries[0][2][1] +/M/0/3 array_length 2 M_entries[0][3] +/M/0/3/0 integer 5 M_entries[0][3][0] +/M/0/3/1 integer 1 M_entries[0][3][1] +/M/1 array_length 4 M_entries[1] +/M/1/0 array_length 2 M_entries[1][0] +/M/1/0/0 integer 0 M_entries[1][0][0] +/M/1/0/1 integer 1 M_entries[1][0][1] +/M/1/1 array_length 2 M_entries[1][1] +/M/1/1/0 integer 1 M_entries[1][1][0] +/M/1/1/1 integer -1 M_entries[1][1][1] +/M/1/2 array_length 2 M_entries[1][2] +/M/1/2/0 integer 8 M_entries[1][2][0] +/M/1/2/1 integer -1 M_entries[1][2][1] +/M/1/3 array_length 2 M_entries[1][3] +/M/1/3/0 integer 9 M_entries[1][3][0] +/M/1/3/1 integer 1 M_entries[1][3][1] +/M/2 array_length 4 M_entries[2] +/M/2/0 array_length 2 M_entries[2][0] +/M/2/0/0 integer 0 M_entries[2][0][0] +/M/2/0/1 integer 1 M_entries[2][0][1] +/M/2/1 array_length 2 M_entries[2][1] +/M/2/1/0 integer 1 M_entries[2][1][0] +/M/2/1/1 integer -1 M_entries[2][1][1] +/M/2/2 array_length 2 M_entries[2][2] +/M/2/2/0 integer 12 M_entries[2][2][0] +/M/2/2/1 integer -1 M_entries[2][2][1] +/M/2/3 array_length 2 M_entries[2][3] +/M/2/3/0 integer 13 M_entries[2][3][0] +/M/2/3/1 integer 1 M_entries[2][3][1] +/M/3 array_length 4 M_entries[3] +/M/3/0 array_length 2 M_entries[3][0] +/M/3/0/0 integer 0 M_entries[3][0][0] +/M/3/0/1 integer 1 M_entries[3][0][1] +/M/3/1 array_length 2 M_entries[3][1] +/M/3/1/0 integer 1 M_entries[3][1][0] +/M/3/1/1 integer -1 M_entries[3][1][1] +/M/3/2 array_length 2 M_entries[3][2] +/M/3/2/0 integer 16 M_entries[3][2][0] +/M/3/2/1 integer -1 M_entries[3][2][1] +/M/3/3 array_length 2 M_entries[3][3] +/M/3/3/0 integer 17 M_entries[3][3][0] +/M/3/3/1 integer 1 M_entries[3][3][1] +/M/4 array_length 4 M_entries[4] +/M/4/0 array_length 2 M_entries[4][0] +/M/4/0/0 integer 0 M_entries[4][0][0] +/M/4/0/1 integer 1 M_entries[4][0][1] +/M/4/1 array_length 2 M_entries[4][1] +/M/4/1/0 integer 2 M_entries[4][1][0] +/M/4/1/1 integer -1 M_entries[4][1][1] +/M/4/2 array_length 2 M_entries[4][2] +/M/4/2/0 integer 20 M_entries[4][2][0] +/M/4/2/1 integer -1 M_entries[4][2][1] +/M/4/3 array_length 2 M_entries[4][3] +/M/4/3/0 integer 21 M_entries[4][3][0] +/M/4/3/1 integer 1 M_entries[4][3][1] +/M/5 array_length 4 M_entries[5] +/M/5/0 array_length 2 M_entries[5][0] +/M/5/0/0 integer 0 M_entries[5][0][0] +/M/5/0/1 integer 1 M_entries[5][0][1] +/M/5/1 array_length 2 M_entries[5][1] +/M/5/1/0 integer 2 M_entries[5][1][0] +/M/5/1/1 integer -1 M_entries[5][1][1] +/M/5/2 array_length 2 M_entries[5][2] +/M/5/2/0 integer 24 M_entries[5][2][0] +/M/5/2/1 integer -1 M_entries[5][2][1] +/M/5/3 array_length 2 M_entries[5][3] +/M/5/3/0 integer 25 M_entries[5][3][0] +/M/5/3/1 integer 1 M_entries[5][3][1] +/M/6 array_length 4 M_entries[6] +/M/6/0 array_length 2 M_entries[6][0] +/M/6/0/0 integer 0 M_entries[6][0][0] +/M/6/0/1 integer 1 M_entries[6][0][1] +/M/6/1 array_length 2 M_entries[6][1] +/M/6/1/0 integer 2 M_entries[6][1][0] +/M/6/1/1 integer -1 M_entries[6][1][1] +/M/6/2 array_length 2 M_entries[6][2] +/M/6/2/0 integer 28 M_entries[6][2][0] +/M/6/2/1 integer -1 M_entries[6][2][1] +/M/6/3 array_length 2 M_entries[6][3] +/M/6/3/0 integer 29 M_entries[6][3][0] +/M/6/3/1 integer 1 M_entries[6][3][1] +/M/7 array_length 4 M_entries[7] +/M/7/0 array_length 2 M_entries[7][0] +/M/7/0/0 integer 0 M_entries[7][0][0] +/M/7/0/1 integer 1 M_entries[7][0][1] +/M/7/1 array_length 2 M_entries[7][1] +/M/7/1/0 integer 2 M_entries[7][1][0] +/M/7/1/1 integer -1 M_entries[7][1][1] +/M/7/2 array_length 2 M_entries[7][2] +/M/7/2/0 integer 32 M_entries[7][2][0] +/M/7/2/1 integer -1 M_entries[7][2][1] +/M/7/3 array_length 2 M_entries[7][3] +/M/7/3/0 integer 33 M_entries[7][3][0] +/M/7/3/1 integer 1 M_entries[7][3][1] +/M/8 array_length 4 M_entries[8] +/M/8/0 array_length 2 M_entries[8][0] +/M/8/0/0 integer 0 M_entries[8][0][0] +/M/8/0/1 integer 1 M_entries[8][0][1] +/M/8/1 array_length 2 M_entries[8][1] +/M/8/1/0 integer 3 M_entries[8][1][0] +/M/8/1/1 integer -1 M_entries[8][1][1] +/M/8/2 array_length 2 M_entries[8][2] +/M/8/2/0 integer 36 M_entries[8][2][0] +/M/8/2/1 integer -1 M_entries[8][2][1] +/M/8/3 array_length 2 M_entries[8][3] +/M/8/3/0 integer 37 M_entries[8][3][0] +/M/8/3/1 integer 1 M_entries[8][3][1] +/M/9 array_length 4 M_entries[9] +/M/9/0 array_length 2 M_entries[9][0] +/M/9/0/0 integer 0 M_entries[9][0][0] +/M/9/0/1 integer 1 M_entries[9][0][1] +/M/9/1 array_length 2 M_entries[9][1] +/M/9/1/0 integer 3 M_entries[9][1][0] +/M/9/1/1 integer -1 M_entries[9][1][1] +/M/9/2 array_length 2 M_entries[9][2] +/M/9/2/0 integer 40 M_entries[9][2][0] +/M/9/2/1 integer -1 M_entries[9][2][1] +/M/9/3 array_length 2 M_entries[9][3] +/M/9/3/0 integer 41 M_entries[9][3][0] +/M/9/3/1 integer 1 M_entries[9][3][1] +/M/10 array_length 4 M_entries[10] +/M/10/0 array_length 2 M_entries[10][0] +/M/10/0/0 integer 0 M_entries[10][0][0] +/M/10/0/1 integer 1 M_entries[10][0][1] +/M/10/1 array_length 2 M_entries[10][1] +/M/10/1/0 integer 3 M_entries[10][1][0] +/M/10/1/1 integer -1 M_entries[10][1][1] +/M/10/2 array_length 2 M_entries[10][2] +/M/10/2/0 integer 44 M_entries[10][2][0] +/M/10/2/1 integer -1 M_entries[10][2][1] +/M/10/3 array_length 2 M_entries[10][3] +/M/10/3/0 integer 45 M_entries[10][3][0] +/M/10/3/1 integer 1 M_entries[10][3][1] +/M/11 array_length 4 M_entries[11] +/M/11/0 array_length 2 M_entries[11][0] +/M/11/0/0 integer 0 M_entries[11][0][0] +/M/11/0/1 integer 1 M_entries[11][0][1] +/M/11/1 array_length 2 M_entries[11][1] +/M/11/1/0 integer 3 M_entries[11][1][0] +/M/11/1/1 integer -1 M_entries[11][1][1] +/M/11/2 array_length 2 M_entries[11][2] +/M/11/2/0 integer 48 M_entries[11][2][0] +/M/11/2/1 integer -1 M_entries[11][2][1] +/M/11/3 array_length 2 M_entries[11][3] +/M/11/3/0 integer 49 M_entries[11][3][0] +/M/11/3/1 integer 1 M_entries[11][3][1] +/M/12 array_length 4 M_entries[12] +/M/12/0 array_length 2 M_entries[12][0] +/M/12/0/0 integer 1 M_entries[12][0][0] +/M/12/0/1 integer 1 M_entries[12][0][1] +/M/12/1 array_length 2 M_entries[12][1] +/M/12/1/0 integer 2 M_entries[12][1][0] +/M/12/1/1 integer -1 M_entries[12][1][1] +/M/12/2 array_length 2 M_entries[12][2] +/M/12/2/0 integer 52 M_entries[12][2][0] +/M/12/2/1 integer -1 M_entries[12][2][1] +/M/12/3 array_length 2 M_entries[12][3] +/M/12/3/0 integer 53 M_entries[12][3][0] +/M/12/3/1 integer 1 M_entries[12][3][1] +/M/13 array_length 4 M_entries[13] +/M/13/0 array_length 2 M_entries[13][0] +/M/13/0/0 integer 1 M_entries[13][0][0] +/M/13/0/1 integer 1 M_entries[13][0][1] +/M/13/1 array_length 2 M_entries[13][1] +/M/13/1/0 integer 2 M_entries[13][1][0] +/M/13/1/1 integer -1 M_entries[13][1][1] +/M/13/2 array_length 2 M_entries[13][2] +/M/13/2/0 integer 56 M_entries[13][2][0] +/M/13/2/1 integer -1 M_entries[13][2][1] +/M/13/3 array_length 2 M_entries[13][3] +/M/13/3/0 integer 57 M_entries[13][3][0] +/M/13/3/1 integer 1 M_entries[13][3][1] +/M/14 array_length 4 M_entries[14] +/M/14/0 array_length 2 M_entries[14][0] +/M/14/0/0 integer 1 M_entries[14][0][0] +/M/14/0/1 integer 1 M_entries[14][0][1] +/M/14/1 array_length 2 M_entries[14][1] +/M/14/1/0 integer 2 M_entries[14][1][0] +/M/14/1/1 integer -1 M_entries[14][1][1] +/M/14/2 array_length 2 M_entries[14][2] +/M/14/2/0 integer 60 M_entries[14][2][0] +/M/14/2/1 integer -1 M_entries[14][2][1] +/M/14/3 array_length 2 M_entries[14][3] +/M/14/3/0 integer 61 M_entries[14][3][0] +/M/14/3/1 integer 1 M_entries[14][3][1] +/M/15 array_length 4 M_entries[15] +/M/15/0 array_length 2 M_entries[15][0] +/M/15/0/0 integer 1 M_entries[15][0][0] +/M/15/0/1 integer 1 M_entries[15][0][1] +/M/15/1 array_length 2 M_entries[15][1] +/M/15/1/0 integer 2 M_entries[15][1][0] +/M/15/1/1 integer -1 M_entries[15][1][1] +/M/15/2 array_length 2 M_entries[15][2] +/M/15/2/0 integer 64 M_entries[15][2][0] +/M/15/2/1 integer -1 M_entries[15][2][1] +/M/15/3 array_length 2 M_entries[15][3] +/M/15/3/0 integer 65 M_entries[15][3][0] +/M/15/3/1 integer 1 M_entries[15][3][1] +/M/16 array_length 4 M_entries[16] +/M/16/0 array_length 2 M_entries[16][0] +/M/16/0/0 integer 1 M_entries[16][0][0] +/M/16/0/1 integer 1 M_entries[16][0][1] +/M/16/1 array_length 2 M_entries[16][1] +/M/16/1/0 integer 3 M_entries[16][1][0] +/M/16/1/1 integer -1 M_entries[16][1][1] +/M/16/2 array_length 2 M_entries[16][2] +/M/16/2/0 integer 68 M_entries[16][2][0] +/M/16/2/1 integer -1 M_entries[16][2][1] +/M/16/3 array_length 2 M_entries[16][3] +/M/16/3/0 integer 69 M_entries[16][3][0] +/M/16/3/1 integer 1 M_entries[16][3][1] +/M/17 array_length 4 M_entries[17] +/M/17/0 array_length 2 M_entries[17][0] +/M/17/0/0 integer 1 M_entries[17][0][0] +/M/17/0/1 integer 1 M_entries[17][0][1] +/M/17/1 array_length 2 M_entries[17][1] +/M/17/1/0 integer 3 M_entries[17][1][0] +/M/17/1/1 integer -1 M_entries[17][1][1] +/M/17/2 array_length 2 M_entries[17][2] +/M/17/2/0 integer 72 M_entries[17][2][0] +/M/17/2/1 integer -1 M_entries[17][2][1] +/M/17/3 array_length 2 M_entries[17][3] +/M/17/3/0 integer 73 M_entries[17][3][0] +/M/17/3/1 integer 1 M_entries[17][3][1] +/M/18 array_length 4 M_entries[18] +/M/18/0 array_length 2 M_entries[18][0] +/M/18/0/0 integer 1 M_entries[18][0][0] +/M/18/0/1 integer 1 M_entries[18][0][1] +/M/18/1 array_length 2 M_entries[18][1] +/M/18/1/0 integer 3 M_entries[18][1][0] +/M/18/1/1 integer -1 M_entries[18][1][1] +/M/18/2 array_length 2 M_entries[18][2] +/M/18/2/0 integer 76 M_entries[18][2][0] +/M/18/2/1 integer -1 M_entries[18][2][1] +/M/18/3 array_length 2 M_entries[18][3] +/M/18/3/0 integer 77 M_entries[18][3][0] +/M/18/3/1 integer 1 M_entries[18][3][1] +/M/19 array_length 4 M_entries[19] +/M/19/0 array_length 2 M_entries[19][0] +/M/19/0/0 integer 1 M_entries[19][0][0] +/M/19/0/1 integer 1 M_entries[19][0][1] +/M/19/1 array_length 2 M_entries[19][1] +/M/19/1/0 integer 3 M_entries[19][1][0] +/M/19/1/1 integer -1 M_entries[19][1][1] +/M/19/2 array_length 2 M_entries[19][2] +/M/19/2/0 integer 80 M_entries[19][2][0] +/M/19/2/1 integer -1 M_entries[19][2][1] +/M/19/3 array_length 2 M_entries[19][3] +/M/19/3/0 integer 81 M_entries[19][3][0] +/M/19/3/1 integer 1 M_entries[19][3][1] +/M/20 array_length 4 M_entries[20] +/M/20/0 array_length 2 M_entries[20][0] +/M/20/0/0 integer 2 M_entries[20][0][0] +/M/20/0/1 integer 1 M_entries[20][0][1] +/M/20/1 array_length 2 M_entries[20][1] +/M/20/1/0 integer 3 M_entries[20][1][0] +/M/20/1/1 integer -1 M_entries[20][1][1] +/M/20/2 array_length 2 M_entries[20][2] +/M/20/2/0 integer 84 M_entries[20][2][0] +/M/20/2/1 integer -1 M_entries[20][2][1] +/M/20/3 array_length 2 M_entries[20][3] +/M/20/3/0 integer 85 M_entries[20][3][0] +/M/20/3/1 integer 1 M_entries[20][3][1] +/M/21 array_length 4 M_entries[21] +/M/21/0 array_length 2 M_entries[21][0] +/M/21/0/0 integer 2 M_entries[21][0][0] +/M/21/0/1 integer 1 M_entries[21][0][1] +/M/21/1 array_length 2 M_entries[21][1] +/M/21/1/0 integer 3 M_entries[21][1][0] +/M/21/1/1 integer -1 M_entries[21][1][1] +/M/21/2 array_length 2 M_entries[21][2] +/M/21/2/0 integer 88 M_entries[21][2][0] +/M/21/2/1 integer -1 M_entries[21][2][1] +/M/21/3 array_length 2 M_entries[21][3] +/M/21/3/0 integer 89 M_entries[21][3][0] +/M/21/3/1 integer 1 M_entries[21][3][1] +/M/22 array_length 4 M_entries[22] +/M/22/0 array_length 2 M_entries[22][0] +/M/22/0/0 integer 2 M_entries[22][0][0] +/M/22/0/1 integer 1 M_entries[22][0][1] +/M/22/1 array_length 2 M_entries[22][1] +/M/22/1/0 integer 3 M_entries[22][1][0] +/M/22/1/1 integer -1 M_entries[22][1][1] +/M/22/2 array_length 2 M_entries[22][2] +/M/22/2/0 integer 92 M_entries[22][2][0] +/M/22/2/1 integer -1 M_entries[22][2][1] +/M/22/3 array_length 2 M_entries[22][3] +/M/22/3/0 integer 93 M_entries[22][3][0] +/M/22/3/1 integer 1 M_entries[22][3][1] +/M/23 array_length 4 M_entries[23] +/M/23/0 array_length 2 M_entries[23][0] +/M/23/0/0 integer 2 M_entries[23][0][0] +/M/23/0/1 integer 1 M_entries[23][0][1] +/M/23/1 array_length 2 M_entries[23][1] +/M/23/1/0 integer 3 M_entries[23][1][0] +/M/23/1/1 integer -1 M_entries[23][1][1] +/M/23/2 array_length 2 M_entries[23][2] +/M/23/2/0 integer 96 M_entries[23][2][0] +/M/23/2/1 integer -1 M_entries[23][2][1] +/M/23/3 array_length 2 M_entries[23][3] +/M/23/3/0 integer 97 M_entries[23][3][0] +/M/23/3/1 integer 1 M_entries[23][3][1] +/M/24 array_length 4 M_entries[24] +/M/24/0 array_length 2 M_entries[24][0] +/M/24/0/0 integer 4 M_entries[24][0][0] +/M/24/0/1 integer 1 M_entries[24][0][1] +/M/24/1 array_length 2 M_entries[24][1] +/M/24/1/0 integer 5 M_entries[24][1][0] +/M/24/1/1 integer -1 M_entries[24][1][1] +/M/24/2 array_length 2 M_entries[24][2] +/M/24/2/0 integer 12 M_entries[24][2][0] +/M/24/2/1 integer -1 M_entries[24][2][1] +/M/24/3 array_length 2 M_entries[24][3] +/M/24/3/0 integer 13 M_entries[24][3][0] +/M/24/3/1 integer 1 M_entries[24][3][1] +/M/25 array_length 4 M_entries[25] +/M/25/0 array_length 2 M_entries[25][0] +/M/25/0/0 integer 4 M_entries[25][0][0] +/M/25/0/1 integer 1 M_entries[25][0][1] +/M/25/1 array_length 2 M_entries[25][1] +/M/25/1/0 integer 5 M_entries[25][1][0] +/M/25/1/1 integer -1 M_entries[25][1][1] +/M/25/2 array_length 2 M_entries[25][2] +/M/25/2/0 integer 16 M_entries[25][2][0] +/M/25/2/1 integer -1 M_entries[25][2][1] +/M/25/3 array_length 2 M_entries[25][3] +/M/25/3/0 integer 17 M_entries[25][3][0] +/M/25/3/1 integer 1 M_entries[25][3][1] +/M/26 array_length 4 M_entries[26] +/M/26/0 array_length 2 M_entries[26][0] +/M/26/0/0 integer 4 M_entries[26][0][0] +/M/26/0/1 integer 1 M_entries[26][0][1] +/M/26/1 array_length 2 M_entries[26][1] +/M/26/1/0 integer 6 M_entries[26][1][0] +/M/26/1/1 integer -1 M_entries[26][1][1] +/M/26/2 array_length 2 M_entries[26][2] +/M/26/2/0 integer 20 M_entries[26][2][0] +/M/26/2/1 integer -1 M_entries[26][2][1] +/M/26/3 array_length 2 M_entries[26][3] +/M/26/3/0 integer 22 M_entries[26][3][0] +/M/26/3/1 integer 1 M_entries[26][3][1] +/M/27 array_length 4 M_entries[27] +/M/27/0 array_length 2 M_entries[27][0] +/M/27/0/0 integer 4 M_entries[27][0][0] +/M/27/0/1 integer 1 M_entries[27][0][1] +/M/27/1 array_length 2 M_entries[27][1] +/M/27/1/0 integer 6 M_entries[27][1][0] +/M/27/1/1 integer -1 M_entries[27][1][1] +/M/27/2 array_length 2 M_entries[27][2] +/M/27/2/0 integer 24 M_entries[27][2][0] +/M/27/2/1 integer -1 M_entries[27][2][1] +/M/27/3 array_length 2 M_entries[27][3] +/M/27/3/0 integer 26 M_entries[27][3][0] +/M/27/3/1 integer 1 M_entries[27][3][1] +/M/28 array_length 4 M_entries[28] +/M/28/0 array_length 2 M_entries[28][0] +/M/28/0/0 integer 4 M_entries[28][0][0] +/M/28/0/1 integer 1 M_entries[28][0][1] +/M/28/1 array_length 2 M_entries[28][1] +/M/28/1/0 integer 7 M_entries[28][1][0] +/M/28/1/1 integer -1 M_entries[28][1][1] +/M/28/2 array_length 2 M_entries[28][2] +/M/28/2/0 integer 28 M_entries[28][2][0] +/M/28/2/1 integer -1 M_entries[28][2][1] +/M/28/3 array_length 2 M_entries[28][3] +/M/28/3/0 integer 30 M_entries[28][3][0] +/M/28/3/1 integer 1 M_entries[28][3][1] +/M/29 array_length 4 M_entries[29] +/M/29/0 array_length 2 M_entries[29][0] +/M/29/0/0 integer 4 M_entries[29][0][0] +/M/29/0/1 integer 1 M_entries[29][0][1] +/M/29/1 array_length 2 M_entries[29][1] +/M/29/1/0 integer 7 M_entries[29][1][0] +/M/29/1/1 integer -1 M_entries[29][1][1] +/M/29/2 array_length 2 M_entries[29][2] +/M/29/2/0 integer 32 M_entries[29][2][0] +/M/29/2/1 integer -1 M_entries[29][2][1] +/M/29/3 array_length 2 M_entries[29][3] +/M/29/3/0 integer 34 M_entries[29][3][0] +/M/29/3/1 integer 1 M_entries[29][3][1] +/M/30 array_length 4 M_entries[30] +/M/30/0 array_length 2 M_entries[30][0] +/M/30/0/0 integer 4 M_entries[30][0][0] +/M/30/0/1 integer 1 M_entries[30][0][1] +/M/30/1 array_length 2 M_entries[30][1] +/M/30/1/0 integer 6 M_entries[30][1][0] +/M/30/1/1 integer -1 M_entries[30][1][1] +/M/30/2 array_length 2 M_entries[30][2] +/M/30/2/0 integer 36 M_entries[30][2][0] +/M/30/2/1 integer -1 M_entries[30][2][1] +/M/30/3 array_length 2 M_entries[30][3] +/M/30/3/0 integer 38 M_entries[30][3][0] +/M/30/3/1 integer 1 M_entries[30][3][1] +/M/31 array_length 4 M_entries[31] +/M/31/0 array_length 2 M_entries[31][0] +/M/31/0/0 integer 4 M_entries[31][0][0] +/M/31/0/1 integer 1 M_entries[31][0][1] +/M/31/1 array_length 2 M_entries[31][1] +/M/31/1/0 integer 6 M_entries[31][1][0] +/M/31/1/1 integer -1 M_entries[31][1][1] +/M/31/2 array_length 2 M_entries[31][2] +/M/31/2/0 integer 40 M_entries[31][2][0] +/M/31/2/1 integer -1 M_entries[31][2][1] +/M/31/3 array_length 2 M_entries[31][3] +/M/31/3/0 integer 42 M_entries[31][3][0] +/M/31/3/1 integer 1 M_entries[31][3][1] +/M/32 array_length 4 M_entries[32] +/M/32/0 array_length 2 M_entries[32][0] +/M/32/0/0 integer 4 M_entries[32][0][0] +/M/32/0/1 integer 1 M_entries[32][0][1] +/M/32/1 array_length 2 M_entries[32][1] +/M/32/1/0 integer 7 M_entries[32][1][0] +/M/32/1/1 integer -1 M_entries[32][1][1] +/M/32/2 array_length 2 M_entries[32][2] +/M/32/2/0 integer 44 M_entries[32][2][0] +/M/32/2/1 integer -1 M_entries[32][2][1] +/M/32/3 array_length 2 M_entries[32][3] +/M/32/3/0 integer 46 M_entries[32][3][0] +/M/32/3/1 integer 1 M_entries[32][3][1] +/M/33 array_length 4 M_entries[33] +/M/33/0 array_length 2 M_entries[33][0] +/M/33/0/0 integer 4 M_entries[33][0][0] +/M/33/0/1 integer 1 M_entries[33][0][1] +/M/33/1 array_length 2 M_entries[33][1] +/M/33/1/0 integer 7 M_entries[33][1][0] +/M/33/1/1 integer -1 M_entries[33][1][1] +/M/33/2 array_length 2 M_entries[33][2] +/M/33/2/0 integer 48 M_entries[33][2][0] +/M/33/2/1 integer -1 M_entries[33][2][1] +/M/33/3 array_length 2 M_entries[33][3] +/M/33/3/0 integer 50 M_entries[33][3][0] +/M/33/3/1 integer 1 M_entries[33][3][1] +/M/34 array_length 4 M_entries[34] +/M/34/0 array_length 2 M_entries[34][0] +/M/34/0/0 integer 5 M_entries[34][0][0] +/M/34/0/1 integer 1 M_entries[34][0][1] +/M/34/1 array_length 2 M_entries[34][1] +/M/34/1/0 integer 6 M_entries[34][1][0] +/M/34/1/1 integer -1 M_entries[34][1][1] +/M/34/2 array_length 2 M_entries[34][2] +/M/34/2/0 integer 52 M_entries[34][2][0] +/M/34/2/1 integer -1 M_entries[34][2][1] +/M/34/3 array_length 2 M_entries[34][3] +/M/34/3/0 integer 54 M_entries[34][3][0] +/M/34/3/1 integer 1 M_entries[34][3][1] +/M/35 array_length 4 M_entries[35] +/M/35/0 array_length 2 M_entries[35][0] +/M/35/0/0 integer 5 M_entries[35][0][0] +/M/35/0/1 integer 1 M_entries[35][0][1] +/M/35/1 array_length 2 M_entries[35][1] +/M/35/1/0 integer 6 M_entries[35][1][0] +/M/35/1/1 integer -1 M_entries[35][1][1] +/M/35/2 array_length 2 M_entries[35][2] +/M/35/2/0 integer 56 M_entries[35][2][0] +/M/35/2/1 integer -1 M_entries[35][2][1] +/M/35/3 array_length 2 M_entries[35][3] +/M/35/3/0 integer 58 M_entries[35][3][0] +/M/35/3/1 integer 1 M_entries[35][3][1] +/M/36 array_length 4 M_entries[36] +/M/36/0 array_length 2 M_entries[36][0] +/M/36/0/0 integer 5 M_entries[36][0][0] +/M/36/0/1 integer 1 M_entries[36][0][1] +/M/36/1 array_length 2 M_entries[36][1] +/M/36/1/0 integer 7 M_entries[36][1][0] +/M/36/1/1 integer -1 M_entries[36][1][1] +/M/36/2 array_length 2 M_entries[36][2] +/M/36/2/0 integer 60 M_entries[36][2][0] +/M/36/2/1 integer -1 M_entries[36][2][1] +/M/36/3 array_length 2 M_entries[36][3] +/M/36/3/0 integer 62 M_entries[36][3][0] +/M/36/3/1 integer 1 M_entries[36][3][1] +/M/37 array_length 4 M_entries[37] +/M/37/0 array_length 2 M_entries[37][0] +/M/37/0/0 integer 5 M_entries[37][0][0] +/M/37/0/1 integer 1 M_entries[37][0][1] +/M/37/1 array_length 2 M_entries[37][1] +/M/37/1/0 integer 7 M_entries[37][1][0] +/M/37/1/1 integer -1 M_entries[37][1][1] +/M/37/2 array_length 2 M_entries[37][2] +/M/37/2/0 integer 64 M_entries[37][2][0] +/M/37/2/1 integer -1 M_entries[37][2][1] +/M/37/3 array_length 2 M_entries[37][3] +/M/37/3/0 integer 66 M_entries[37][3][0] +/M/37/3/1 integer 1 M_entries[37][3][1] +/M/38 array_length 4 M_entries[38] +/M/38/0 array_length 2 M_entries[38][0] +/M/38/0/0 integer 5 M_entries[38][0][0] +/M/38/0/1 integer 1 M_entries[38][0][1] +/M/38/1 array_length 2 M_entries[38][1] +/M/38/1/0 integer 6 M_entries[38][1][0] +/M/38/1/1 integer -1 M_entries[38][1][1] +/M/38/2 array_length 2 M_entries[38][2] +/M/38/2/0 integer 68 M_entries[38][2][0] +/M/38/2/1 integer -1 M_entries[38][2][1] +/M/38/3 array_length 2 M_entries[38][3] +/M/38/3/0 integer 70 M_entries[38][3][0] +/M/38/3/1 integer 1 M_entries[38][3][1] +/M/39 array_length 4 M_entries[39] +/M/39/0 array_length 2 M_entries[39][0] +/M/39/0/0 integer 5 M_entries[39][0][0] +/M/39/0/1 integer 1 M_entries[39][0][1] +/M/39/1 array_length 2 M_entries[39][1] +/M/39/1/0 integer 6 M_entries[39][1][0] +/M/39/1/1 integer -1 M_entries[39][1][1] +/M/39/2 array_length 2 M_entries[39][2] +/M/39/2/0 integer 72 M_entries[39][2][0] +/M/39/2/1 integer -1 M_entries[39][2][1] +/M/39/3 array_length 2 M_entries[39][3] +/M/39/3/0 integer 74 M_entries[39][3][0] +/M/39/3/1 integer 1 M_entries[39][3][1] +/M/40 array_length 4 M_entries[40] +/M/40/0 array_length 2 M_entries[40][0] +/M/40/0/0 integer 5 M_entries[40][0][0] +/M/40/0/1 integer 1 M_entries[40][0][1] +/M/40/1 array_length 2 M_entries[40][1] +/M/40/1/0 integer 7 M_entries[40][1][0] +/M/40/1/1 integer -1 M_entries[40][1][1] +/M/40/2 array_length 2 M_entries[40][2] +/M/40/2/0 integer 76 M_entries[40][2][0] +/M/40/2/1 integer -1 M_entries[40][2][1] +/M/40/3 array_length 2 M_entries[40][3] +/M/40/3/0 integer 78 M_entries[40][3][0] +/M/40/3/1 integer 1 M_entries[40][3][1] +/M/41 array_length 4 M_entries[41] +/M/41/0 array_length 2 M_entries[41][0] +/M/41/0/0 integer 5 M_entries[41][0][0] +/M/41/0/1 integer 1 M_entries[41][0][1] +/M/41/1 array_length 2 M_entries[41][1] +/M/41/1/0 integer 7 M_entries[41][1][0] +/M/41/1/1 integer -1 M_entries[41][1][1] +/M/41/2 array_length 2 M_entries[41][2] +/M/41/2/0 integer 80 M_entries[41][2][0] +/M/41/2/1 integer -1 M_entries[41][2][1] +/M/41/3 array_length 2 M_entries[41][3] +/M/41/3/0 integer 82 M_entries[41][3][0] +/M/41/3/1 integer 1 M_entries[41][3][1] +/M/42 array_length 4 M_entries[42] +/M/42/0 array_length 2 M_entries[42][0] +/M/42/0/0 integer 6 M_entries[42][0][0] +/M/42/0/1 integer 1 M_entries[42][0][1] +/M/42/1 array_length 2 M_entries[42][1] +/M/42/1/0 integer 7 M_entries[42][1][0] +/M/42/1/1 integer -1 M_entries[42][1][1] +/M/42/2 array_length 2 M_entries[42][2] +/M/42/2/0 integer 86 M_entries[42][2][0] +/M/42/2/1 integer -1 M_entries[42][2][1] +/M/42/3 array_length 2 M_entries[42][3] +/M/42/3/0 integer 87 M_entries[42][3][0] +/M/42/3/1 integer 1 M_entries[42][3][1] +/M/43 array_length 4 M_entries[43] +/M/43/0 array_length 2 M_entries[43][0] +/M/43/0/0 integer 6 M_entries[43][0][0] +/M/43/0/1 integer 1 M_entries[43][0][1] +/M/43/1 array_length 2 M_entries[43][1] +/M/43/1/0 integer 7 M_entries[43][1][0] +/M/43/1/1 integer -1 M_entries[43][1][1] +/M/43/2 array_length 2 M_entries[43][2] +/M/43/2/0 integer 90 M_entries[43][2][0] +/M/43/2/1 integer -1 M_entries[43][2][1] +/M/43/3 array_length 2 M_entries[43][3] +/M/43/3/0 integer 91 M_entries[43][3][0] +/M/43/3/1 integer 1 M_entries[43][3][1] +/M/44 array_length 4 M_entries[44] +/M/44/0 array_length 2 M_entries[44][0] +/M/44/0/0 integer 6 M_entries[44][0][0] +/M/44/0/1 integer 1 M_entries[44][0][1] +/M/44/1 array_length 2 M_entries[44][1] +/M/44/1/0 integer 7 M_entries[44][1][0] +/M/44/1/1 integer -1 M_entries[44][1][1] +/M/44/2 array_length 2 M_entries[44][2] +/M/44/2/0 integer 100 M_entries[44][2][0] +/M/44/2/1 integer -1 M_entries[44][2][1] +/M/44/3 array_length 2 M_entries[44][3] +/M/44/3/0 integer 101 M_entries[44][3][0] +/M/44/3/1 integer 1 M_entries[44][3][1] +/M/45 array_length 4 M_entries[45] +/M/45/0 array_length 2 M_entries[45][0] +/M/45/0/0 integer 8 M_entries[45][0][0] +/M/45/0/1 integer 1 M_entries[45][0][1] +/M/45/1 array_length 2 M_entries[45][1] +/M/45/1/0 integer 9 M_entries[45][1][0] +/M/45/1/1 integer -1 M_entries[45][1][1] +/M/45/2 array_length 2 M_entries[45][2] +/M/45/2/0 integer 12 M_entries[45][2][0] +/M/45/2/1 integer -1 M_entries[45][2][1] +/M/45/3 array_length 2 M_entries[45][3] +/M/45/3/0 integer 13 M_entries[45][3][0] +/M/45/3/1 integer 1 M_entries[45][3][1] +/M/46 array_length 4 M_entries[46] +/M/46/0 array_length 2 M_entries[46][0] +/M/46/0/0 integer 8 M_entries[46][0][0] +/M/46/0/1 integer 1 M_entries[46][0][1] +/M/46/1 array_length 2 M_entries[46][1] +/M/46/1/0 integer 9 M_entries[46][1][0] +/M/46/1/1 integer -1 M_entries[46][1][1] +/M/46/2 array_length 2 M_entries[46][2] +/M/46/2/0 integer 16 M_entries[46][2][0] +/M/46/2/1 integer -1 M_entries[46][2][1] +/M/46/3 array_length 2 M_entries[46][3] +/M/46/3/0 integer 17 M_entries[46][3][0] +/M/46/3/1 integer 1 M_entries[46][3][1] +/M/47 array_length 4 M_entries[47] +/M/47/0 array_length 2 M_entries[47][0] +/M/47/0/0 integer 8 M_entries[47][0][0] +/M/47/0/1 integer 1 M_entries[47][0][1] +/M/47/1 array_length 2 M_entries[47][1] +/M/47/1/0 integer 10 M_entries[47][1][0] +/M/47/1/1 integer -1 M_entries[47][1][1] +/M/47/2 array_length 2 M_entries[47][2] +/M/47/2/0 integer 20 M_entries[47][2][0] +/M/47/2/1 integer -1 M_entries[47][2][1] +/M/47/3 array_length 2 M_entries[47][3] +/M/47/3/0 integer 22 M_entries[47][3][0] +/M/47/3/1 integer 1 M_entries[47][3][1] +/M/48 array_length 4 M_entries[48] +/M/48/0 array_length 2 M_entries[48][0] +/M/48/0/0 integer 8 M_entries[48][0][0] +/M/48/0/1 integer 1 M_entries[48][0][1] +/M/48/1 array_length 2 M_entries[48][1] +/M/48/1/0 integer 10 M_entries[48][1][0] +/M/48/1/1 integer -1 M_entries[48][1][1] +/M/48/2 array_length 2 M_entries[48][2] +/M/48/2/0 integer 24 M_entries[48][2][0] +/M/48/2/1 integer -1 M_entries[48][2][1] +/M/48/3 array_length 2 M_entries[48][3] +/M/48/3/0 integer 26 M_entries[48][3][0] +/M/48/3/1 integer 1 M_entries[48][3][1] +/M/49 array_length 4 M_entries[49] +/M/49/0 array_length 2 M_entries[49][0] +/M/49/0/0 integer 8 M_entries[49][0][0] +/M/49/0/1 integer 1 M_entries[49][0][1] +/M/49/1 array_length 2 M_entries[49][1] +/M/49/1/0 integer 11 M_entries[49][1][0] +/M/49/1/1 integer -1 M_entries[49][1][1] +/M/49/2 array_length 2 M_entries[49][2] +/M/49/2/0 integer 28 M_entries[49][2][0] +/M/49/2/1 integer -1 M_entries[49][2][1] +/M/49/3 array_length 2 M_entries[49][3] +/M/49/3/0 integer 30 M_entries[49][3][0] +/M/49/3/1 integer 1 M_entries[49][3][1] +/M/50 array_length 4 M_entries[50] +/M/50/0 array_length 2 M_entries[50][0] +/M/50/0/0 integer 8 M_entries[50][0][0] +/M/50/0/1 integer 1 M_entries[50][0][1] +/M/50/1 array_length 2 M_entries[50][1] +/M/50/1/0 integer 11 M_entries[50][1][0] +/M/50/1/1 integer -1 M_entries[50][1][1] +/M/50/2 array_length 2 M_entries[50][2] +/M/50/2/0 integer 32 M_entries[50][2][0] +/M/50/2/1 integer -1 M_entries[50][2][1] +/M/50/3 array_length 2 M_entries[50][3] +/M/50/3/0 integer 34 M_entries[50][3][0] +/M/50/3/1 integer 1 M_entries[50][3][1] +/M/51 array_length 4 M_entries[51] +/M/51/0 array_length 2 M_entries[51][0] +/M/51/0/0 integer 8 M_entries[51][0][0] +/M/51/0/1 integer 1 M_entries[51][0][1] +/M/51/1 array_length 2 M_entries[51][1] +/M/51/1/0 integer 10 M_entries[51][1][0] +/M/51/1/1 integer -1 M_entries[51][1][1] +/M/51/2 array_length 2 M_entries[51][2] +/M/51/2/0 integer 36 M_entries[51][2][0] +/M/51/2/1 integer -1 M_entries[51][2][1] +/M/51/3 array_length 2 M_entries[51][3] +/M/51/3/0 integer 38 M_entries[51][3][0] +/M/51/3/1 integer 1 M_entries[51][3][1] +/M/52 array_length 4 M_entries[52] +/M/52/0 array_length 2 M_entries[52][0] +/M/52/0/0 integer 8 M_entries[52][0][0] +/M/52/0/1 integer 1 M_entries[52][0][1] +/M/52/1 array_length 2 M_entries[52][1] +/M/52/1/0 integer 10 M_entries[52][1][0] +/M/52/1/1 integer -1 M_entries[52][1][1] +/M/52/2 array_length 2 M_entries[52][2] +/M/52/2/0 integer 40 M_entries[52][2][0] +/M/52/2/1 integer -1 M_entries[52][2][1] +/M/52/3 array_length 2 M_entries[52][3] +/M/52/3/0 integer 42 M_entries[52][3][0] +/M/52/3/1 integer 1 M_entries[52][3][1] +/M/53 array_length 4 M_entries[53] +/M/53/0 array_length 2 M_entries[53][0] +/M/53/0/0 integer 8 M_entries[53][0][0] +/M/53/0/1 integer 1 M_entries[53][0][1] +/M/53/1 array_length 2 M_entries[53][1] +/M/53/1/0 integer 11 M_entries[53][1][0] +/M/53/1/1 integer -1 M_entries[53][1][1] +/M/53/2 array_length 2 M_entries[53][2] +/M/53/2/0 integer 44 M_entries[53][2][0] +/M/53/2/1 integer -1 M_entries[53][2][1] +/M/53/3 array_length 2 M_entries[53][3] +/M/53/3/0 integer 46 M_entries[53][3][0] +/M/53/3/1 integer 1 M_entries[53][3][1] +/M/54 array_length 4 M_entries[54] +/M/54/0 array_length 2 M_entries[54][0] +/M/54/0/0 integer 8 M_entries[54][0][0] +/M/54/0/1 integer 1 M_entries[54][0][1] +/M/54/1 array_length 2 M_entries[54][1] +/M/54/1/0 integer 11 M_entries[54][1][0] +/M/54/1/1 integer -1 M_entries[54][1][1] +/M/54/2 array_length 2 M_entries[54][2] +/M/54/2/0 integer 48 M_entries[54][2][0] +/M/54/2/1 integer -1 M_entries[54][2][1] +/M/54/3 array_length 2 M_entries[54][3] +/M/54/3/0 integer 50 M_entries[54][3][0] +/M/54/3/1 integer 1 M_entries[54][3][1] +/M/55 array_length 4 M_entries[55] +/M/55/0 array_length 2 M_entries[55][0] +/M/55/0/0 integer 9 M_entries[55][0][0] +/M/55/0/1 integer 1 M_entries[55][0][1] +/M/55/1 array_length 2 M_entries[55][1] +/M/55/1/0 integer 10 M_entries[55][1][0] +/M/55/1/1 integer -1 M_entries[55][1][1] +/M/55/2 array_length 2 M_entries[55][2] +/M/55/2/0 integer 52 M_entries[55][2][0] +/M/55/2/1 integer -1 M_entries[55][2][1] +/M/55/3 array_length 2 M_entries[55][3] +/M/55/3/0 integer 54 M_entries[55][3][0] +/M/55/3/1 integer 1 M_entries[55][3][1] +/M/56 array_length 4 M_entries[56] +/M/56/0 array_length 2 M_entries[56][0] +/M/56/0/0 integer 9 M_entries[56][0][0] +/M/56/0/1 integer 1 M_entries[56][0][1] +/M/56/1 array_length 2 M_entries[56][1] +/M/56/1/0 integer 10 M_entries[56][1][0] +/M/56/1/1 integer -1 M_entries[56][1][1] +/M/56/2 array_length 2 M_entries[56][2] +/M/56/2/0 integer 56 M_entries[56][2][0] +/M/56/2/1 integer -1 M_entries[56][2][1] +/M/56/3 array_length 2 M_entries[56][3] +/M/56/3/0 integer 58 M_entries[56][3][0] +/M/56/3/1 integer 1 M_entries[56][3][1] +/M/57 array_length 4 M_entries[57] +/M/57/0 array_length 2 M_entries[57][0] +/M/57/0/0 integer 9 M_entries[57][0][0] +/M/57/0/1 integer 1 M_entries[57][0][1] +/M/57/1 array_length 2 M_entries[57][1] +/M/57/1/0 integer 11 M_entries[57][1][0] +/M/57/1/1 integer -1 M_entries[57][1][1] +/M/57/2 array_length 2 M_entries[57][2] +/M/57/2/0 integer 60 M_entries[57][2][0] +/M/57/2/1 integer -1 M_entries[57][2][1] +/M/57/3 array_length 2 M_entries[57][3] +/M/57/3/0 integer 62 M_entries[57][3][0] +/M/57/3/1 integer 1 M_entries[57][3][1] +/M/58 array_length 4 M_entries[58] +/M/58/0 array_length 2 M_entries[58][0] +/M/58/0/0 integer 9 M_entries[58][0][0] +/M/58/0/1 integer 1 M_entries[58][0][1] +/M/58/1 array_length 2 M_entries[58][1] +/M/58/1/0 integer 11 M_entries[58][1][0] +/M/58/1/1 integer -1 M_entries[58][1][1] +/M/58/2 array_length 2 M_entries[58][2] +/M/58/2/0 integer 64 M_entries[58][2][0] +/M/58/2/1 integer -1 M_entries[58][2][1] +/M/58/3 array_length 2 M_entries[58][3] +/M/58/3/0 integer 66 M_entries[58][3][0] +/M/58/3/1 integer 1 M_entries[58][3][1] +/M/59 array_length 4 M_entries[59] +/M/59/0 array_length 2 M_entries[59][0] +/M/59/0/0 integer 9 M_entries[59][0][0] +/M/59/0/1 integer 1 M_entries[59][0][1] +/M/59/1 array_length 2 M_entries[59][1] +/M/59/1/0 integer 10 M_entries[59][1][0] +/M/59/1/1 integer -1 M_entries[59][1][1] +/M/59/2 array_length 2 M_entries[59][2] +/M/59/2/0 integer 68 M_entries[59][2][0] +/M/59/2/1 integer -1 M_entries[59][2][1] +/M/59/3 array_length 2 M_entries[59][3] +/M/59/3/0 integer 70 M_entries[59][3][0] +/M/59/3/1 integer 1 M_entries[59][3][1] +/M/60 array_length 4 M_entries[60] +/M/60/0 array_length 2 M_entries[60][0] +/M/60/0/0 integer 9 M_entries[60][0][0] +/M/60/0/1 integer 1 M_entries[60][0][1] +/M/60/1 array_length 2 M_entries[60][1] +/M/60/1/0 integer 10 M_entries[60][1][0] +/M/60/1/1 integer -1 M_entries[60][1][1] +/M/60/2 array_length 2 M_entries[60][2] +/M/60/2/0 integer 72 M_entries[60][2][0] +/M/60/2/1 integer -1 M_entries[60][2][1] +/M/60/3 array_length 2 M_entries[60][3] +/M/60/3/0 integer 74 M_entries[60][3][0] +/M/60/3/1 integer 1 M_entries[60][3][1] +/M/61 array_length 4 M_entries[61] +/M/61/0 array_length 2 M_entries[61][0] +/M/61/0/0 integer 9 M_entries[61][0][0] +/M/61/0/1 integer 1 M_entries[61][0][1] +/M/61/1 array_length 2 M_entries[61][1] +/M/61/1/0 integer 11 M_entries[61][1][0] +/M/61/1/1 integer -1 M_entries[61][1][1] +/M/61/2 array_length 2 M_entries[61][2] +/M/61/2/0 integer 76 M_entries[61][2][0] +/M/61/2/1 integer -1 M_entries[61][2][1] +/M/61/3 array_length 2 M_entries[61][3] +/M/61/3/0 integer 78 M_entries[61][3][0] +/M/61/3/1 integer 1 M_entries[61][3][1] +/M/62 array_length 4 M_entries[62] +/M/62/0 array_length 2 M_entries[62][0] +/M/62/0/0 integer 9 M_entries[62][0][0] +/M/62/0/1 integer 1 M_entries[62][0][1] +/M/62/1 array_length 2 M_entries[62][1] +/M/62/1/0 integer 11 M_entries[62][1][0] +/M/62/1/1 integer -1 M_entries[62][1][1] +/M/62/2 array_length 2 M_entries[62][2] +/M/62/2/0 integer 80 M_entries[62][2][0] +/M/62/2/1 integer -1 M_entries[62][2][1] +/M/62/3 array_length 2 M_entries[62][3] +/M/62/3/0 integer 82 M_entries[62][3][0] +/M/62/3/1 integer 1 M_entries[62][3][1] +/M/63 array_length 4 M_entries[63] +/M/63/0 array_length 2 M_entries[63][0] +/M/63/0/0 integer 10 M_entries[63][0][0] +/M/63/0/1 integer 1 M_entries[63][0][1] +/M/63/1 array_length 2 M_entries[63][1] +/M/63/1/0 integer 11 M_entries[63][1][0] +/M/63/1/1 integer -1 M_entries[63][1][1] +/M/63/2 array_length 2 M_entries[63][2] +/M/63/2/0 integer 86 M_entries[63][2][0] +/M/63/2/1 integer -1 M_entries[63][2][1] +/M/63/3 array_length 2 M_entries[63][3] +/M/63/3/0 integer 87 M_entries[63][3][0] +/M/63/3/1 integer 1 M_entries[63][3][1] +/M/64 array_length 4 M_entries[64] +/M/64/0 array_length 2 M_entries[64][0] +/M/64/0/0 integer 10 M_entries[64][0][0] +/M/64/0/1 integer 1 M_entries[64][0][1] +/M/64/1 array_length 2 M_entries[64][1] +/M/64/1/0 integer 11 M_entries[64][1][0] +/M/64/1/1 integer -1 M_entries[64][1][1] +/M/64/2 array_length 2 M_entries[64][2] +/M/64/2/0 integer 90 M_entries[64][2][0] +/M/64/2/1 integer -1 M_entries[64][2][1] +/M/64/3 array_length 2 M_entries[64][3] +/M/64/3/0 integer 91 M_entries[64][3][0] +/M/64/3/1 integer 1 M_entries[64][3][1] +/M/65 array_length 4 M_entries[65] +/M/65/0 array_length 2 M_entries[65][0] +/M/65/0/0 integer 10 M_entries[65][0][0] +/M/65/0/1 integer 1 M_entries[65][0][1] +/M/65/1 array_length 2 M_entries[65][1] +/M/65/1/0 integer 11 M_entries[65][1][0] +/M/65/1/1 integer -1 M_entries[65][1][1] +/M/65/2 array_length 2 M_entries[65][2] +/M/65/2/0 integer 100 M_entries[65][2][0] +/M/65/2/1 integer -1 M_entries[65][2][1] +/M/65/3 array_length 2 M_entries[65][3] +/M/65/3/0 integer 101 M_entries[65][3][0] +/M/65/3/1 integer 1 M_entries[65][3][1] +/M/66 array_length 4 M_entries[66] +/M/66/0 array_length 2 M_entries[66][0] +/M/66/0/0 integer 12 M_entries[66][0][0] +/M/66/0/1 integer 1 M_entries[66][0][1] +/M/66/1 array_length 2 M_entries[66][1] +/M/66/1/0 integer 14 M_entries[66][1][0] +/M/66/1/1 integer -1 M_entries[66][1][1] +/M/66/2 array_length 2 M_entries[66][2] +/M/66/2/0 integer 20 M_entries[66][2][0] +/M/66/2/1 integer -1 M_entries[66][2][1] +/M/66/3 array_length 2 M_entries[66][3] +/M/66/3/0 integer 23 M_entries[66][3][0] +/M/66/3/1 integer 1 M_entries[66][3][1] +/M/67 array_length 4 M_entries[67] +/M/67/0 array_length 2 M_entries[67][0] +/M/67/0/0 integer 12 M_entries[67][0][0] +/M/67/0/1 integer 1 M_entries[67][0][1] +/M/67/1 array_length 2 M_entries[67][1] +/M/67/1/0 integer 14 M_entries[67][1][0] +/M/67/1/1 integer -1 M_entries[67][1][1] +/M/67/2 array_length 2 M_entries[67][2] +/M/67/2/0 integer 24 M_entries[67][2][0] +/M/67/2/1 integer -1 M_entries[67][2][1] +/M/67/3 array_length 2 M_entries[67][3] +/M/67/3/0 integer 27 M_entries[67][3][0] +/M/67/3/1 integer 1 M_entries[67][3][1] +/M/68 array_length 4 M_entries[68] +/M/68/0 array_length 2 M_entries[68][0] +/M/68/0/0 integer 12 M_entries[68][0][0] +/M/68/0/1 integer 1 M_entries[68][0][1] +/M/68/1 array_length 2 M_entries[68][1] +/M/68/1/0 integer 15 M_entries[68][1][0] +/M/68/1/1 integer -1 M_entries[68][1][1] +/M/68/2 array_length 2 M_entries[68][2] +/M/68/2/0 integer 28 M_entries[68][2][0] +/M/68/2/1 integer -1 M_entries[68][2][1] +/M/68/3 array_length 2 M_entries[68][3] +/M/68/3/0 integer 31 M_entries[68][3][0] +/M/68/3/1 integer 1 M_entries[68][3][1] +/M/69 array_length 4 M_entries[69] +/M/69/0 array_length 2 M_entries[69][0] +/M/69/0/0 integer 12 M_entries[69][0][0] +/M/69/0/1 integer 1 M_entries[69][0][1] +/M/69/1 array_length 2 M_entries[69][1] +/M/69/1/0 integer 15 M_entries[69][1][0] +/M/69/1/1 integer -1 M_entries[69][1][1] +/M/69/2 array_length 2 M_entries[69][2] +/M/69/2/0 integer 32 M_entries[69][2][0] +/M/69/2/1 integer -1 M_entries[69][2][1] +/M/69/3 array_length 2 M_entries[69][3] +/M/69/3/0 integer 35 M_entries[69][3][0] +/M/69/3/1 integer 1 M_entries[69][3][1] +/M/70 array_length 4 M_entries[70] +/M/70/0 array_length 2 M_entries[70][0] +/M/70/0/0 integer 12 M_entries[70][0][0] +/M/70/0/1 integer 1 M_entries[70][0][1] +/M/70/1 array_length 2 M_entries[70][1] +/M/70/1/0 integer 15 M_entries[70][1][0] +/M/70/1/1 integer -1 M_entries[70][1][1] +/M/70/2 array_length 2 M_entries[70][2] +/M/70/2/0 integer 36 M_entries[70][2][0] +/M/70/2/1 integer -1 M_entries[70][2][1] +/M/70/3 array_length 2 M_entries[70][3] +/M/70/3/0 integer 39 M_entries[70][3][0] +/M/70/3/1 integer 1 M_entries[70][3][1] +/M/71 array_length 4 M_entries[71] +/M/71/0 array_length 2 M_entries[71][0] +/M/71/0/0 integer 12 M_entries[71][0][0] +/M/71/0/1 integer 1 M_entries[71][0][1] +/M/71/1 array_length 2 M_entries[71][1] +/M/71/1/0 integer 15 M_entries[71][1][0] +/M/71/1/1 integer -1 M_entries[71][1][1] +/M/71/2 array_length 2 M_entries[71][2] +/M/71/2/0 integer 40 M_entries[71][2][0] +/M/71/2/1 integer -1 M_entries[71][2][1] +/M/71/3 array_length 2 M_entries[71][3] +/M/71/3/0 integer 43 M_entries[71][3][0] +/M/71/3/1 integer 1 M_entries[71][3][1] +/M/72 array_length 4 M_entries[72] +/M/72/0 array_length 2 M_entries[72][0] +/M/72/0/0 integer 12 M_entries[72][0][0] +/M/72/0/1 integer 1 M_entries[72][0][1] +/M/72/1 array_length 2 M_entries[72][1] +/M/72/1/0 integer 14 M_entries[72][1][0] +/M/72/1/1 integer -1 M_entries[72][1][1] +/M/72/2 array_length 2 M_entries[72][2] +/M/72/2/0 integer 44 M_entries[72][2][0] +/M/72/2/1 integer -1 M_entries[72][2][1] +/M/72/3 array_length 2 M_entries[72][3] +/M/72/3/0 integer 47 M_entries[72][3][0] +/M/72/3/1 integer 1 M_entries[72][3][1] +/M/73 array_length 4 M_entries[73] +/M/73/0 array_length 2 M_entries[73][0] +/M/73/0/0 integer 12 M_entries[73][0][0] +/M/73/0/1 integer 1 M_entries[73][0][1] +/M/73/1 array_length 2 M_entries[73][1] +/M/73/1/0 integer 14 M_entries[73][1][0] +/M/73/1/1 integer -1 M_entries[73][1][1] +/M/73/2 array_length 2 M_entries[73][2] +/M/73/2/0 integer 48 M_entries[73][2][0] +/M/73/2/1 integer -1 M_entries[73][2][1] +/M/73/3 array_length 2 M_entries[73][3] +/M/73/3/0 integer 51 M_entries[73][3][0] +/M/73/3/1 integer 1 M_entries[73][3][1] +/M/74 array_length 4 M_entries[74] +/M/74/0 array_length 2 M_entries[74][0] +/M/74/0/0 integer 13 M_entries[74][0][0] +/M/74/0/1 integer 1 M_entries[74][0][1] +/M/74/1 array_length 2 M_entries[74][1] +/M/74/1/0 integer 15 M_entries[74][1][0] +/M/74/1/1 integer -1 M_entries[74][1][1] +/M/74/2 array_length 2 M_entries[74][2] +/M/74/2/0 integer 52 M_entries[74][2][0] +/M/74/2/1 integer -1 M_entries[74][2][1] +/M/74/3 array_length 2 M_entries[74][3] +/M/74/3/0 integer 55 M_entries[74][3][0] +/M/74/3/1 integer 1 M_entries[74][3][1] +/M/75 array_length 4 M_entries[75] +/M/75/0 array_length 2 M_entries[75][0] +/M/75/0/0 integer 13 M_entries[75][0][0] +/M/75/0/1 integer 1 M_entries[75][0][1] +/M/75/1 array_length 2 M_entries[75][1] +/M/75/1/0 integer 15 M_entries[75][1][0] +/M/75/1/1 integer -1 M_entries[75][1][1] +/M/75/2 array_length 2 M_entries[75][2] +/M/75/2/0 integer 56 M_entries[75][2][0] +/M/75/2/1 integer -1 M_entries[75][2][1] +/M/75/3 array_length 2 M_entries[75][3] +/M/75/3/0 integer 59 M_entries[75][3][0] +/M/75/3/1 integer 1 M_entries[75][3][1] +/M/76 array_length 4 M_entries[76] +/M/76/0 array_length 2 M_entries[76][0] +/M/76/0/0 integer 13 M_entries[76][0][0] +/M/76/0/1 integer 1 M_entries[76][0][1] +/M/76/1 array_length 2 M_entries[76][1] +/M/76/1/0 integer 14 M_entries[76][1][0] +/M/76/1/1 integer -1 M_entries[76][1][1] +/M/76/2 array_length 2 M_entries[76][2] +/M/76/2/0 integer 60 M_entries[76][2][0] +/M/76/2/1 integer -1 M_entries[76][2][1] +/M/76/3 array_length 2 M_entries[76][3] +/M/76/3/0 integer 63 M_entries[76][3][0] +/M/76/3/1 integer 1 M_entries[76][3][1] +/M/77 array_length 4 M_entries[77] +/M/77/0 array_length 2 M_entries[77][0] +/M/77/0/0 integer 13 M_entries[77][0][0] +/M/77/0/1 integer 1 M_entries[77][0][1] +/M/77/1 array_length 2 M_entries[77][1] +/M/77/1/0 integer 14 M_entries[77][1][0] +/M/77/1/1 integer -1 M_entries[77][1][1] +/M/77/2 array_length 2 M_entries[77][2] +/M/77/2/0 integer 64 M_entries[77][2][0] +/M/77/2/1 integer -1 M_entries[77][2][1] +/M/77/3 array_length 2 M_entries[77][3] +/M/77/3/0 integer 67 M_entries[77][3][0] +/M/77/3/1 integer 1 M_entries[77][3][1] +/M/78 array_length 4 M_entries[78] +/M/78/0 array_length 2 M_entries[78][0] +/M/78/0/0 integer 13 M_entries[78][0][0] +/M/78/0/1 integer 1 M_entries[78][0][1] +/M/78/1 array_length 2 M_entries[78][1] +/M/78/1/0 integer 14 M_entries[78][1][0] +/M/78/1/1 integer -1 M_entries[78][1][1] +/M/78/2 array_length 2 M_entries[78][2] +/M/78/2/0 integer 68 M_entries[78][2][0] +/M/78/2/1 integer -1 M_entries[78][2][1] +/M/78/3 array_length 2 M_entries[78][3] +/M/78/3/0 integer 71 M_entries[78][3][0] +/M/78/3/1 integer 1 M_entries[78][3][1] +/M/79 array_length 4 M_entries[79] +/M/79/0 array_length 2 M_entries[79][0] +/M/79/0/0 integer 13 M_entries[79][0][0] +/M/79/0/1 integer 1 M_entries[79][0][1] +/M/79/1 array_length 2 M_entries[79][1] +/M/79/1/0 integer 14 M_entries[79][1][0] +/M/79/1/1 integer -1 M_entries[79][1][1] +/M/79/2 array_length 2 M_entries[79][2] +/M/79/2/0 integer 72 M_entries[79][2][0] +/M/79/2/1 integer -1 M_entries[79][2][1] +/M/79/3 array_length 2 M_entries[79][3] +/M/79/3/0 integer 75 M_entries[79][3][0] +/M/79/3/1 integer 1 M_entries[79][3][1] +/M/80 array_length 4 M_entries[80] +/M/80/0 array_length 2 M_entries[80][0] +/M/80/0/0 integer 13 M_entries[80][0][0] +/M/80/0/1 integer 1 M_entries[80][0][1] +/M/80/1 array_length 2 M_entries[80][1] +/M/80/1/0 integer 15 M_entries[80][1][0] +/M/80/1/1 integer -1 M_entries[80][1][1] +/M/80/2 array_length 2 M_entries[80][2] +/M/80/2/0 integer 76 M_entries[80][2][0] +/M/80/2/1 integer -1 M_entries[80][2][1] +/M/80/3 array_length 2 M_entries[80][3] +/M/80/3/0 integer 79 M_entries[80][3][0] +/M/80/3/1 integer 1 M_entries[80][3][1] +/M/81 array_length 4 M_entries[81] +/M/81/0 array_length 2 M_entries[81][0] +/M/81/0/0 integer 13 M_entries[81][0][0] +/M/81/0/1 integer 1 M_entries[81][0][1] +/M/81/1 array_length 2 M_entries[81][1] +/M/81/1/0 integer 15 M_entries[81][1][0] +/M/81/1/1 integer -1 M_entries[81][1][1] +/M/81/2 array_length 2 M_entries[81][2] +/M/81/2/0 integer 80 M_entries[81][2][0] +/M/81/2/1 integer -1 M_entries[81][2][1] +/M/81/3 array_length 2 M_entries[81][3] +/M/81/3/0 integer 83 M_entries[81][3][0] +/M/81/3/1 integer 1 M_entries[81][3][1] +/M/82 array_length 4 M_entries[82] +/M/82/0 array_length 2 M_entries[82][0] +/M/82/0/0 integer 14 M_entries[82][0][0] +/M/82/0/1 integer 1 M_entries[82][0][1] +/M/82/1 array_length 2 M_entries[82][1] +/M/82/1/0 integer 15 M_entries[82][1][0] +/M/82/1/1 integer -1 M_entries[82][1][1] +/M/82/2 array_length 2 M_entries[82][2] +/M/82/2/0 integer 94 M_entries[82][2][0] +/M/82/2/1 integer -1 M_entries[82][2][1] +/M/82/3 array_length 2 M_entries[82][3] +/M/82/3/0 integer 95 M_entries[82][3][0] +/M/82/3/1 integer 1 M_entries[82][3][1] +/M/83 array_length 4 M_entries[83] +/M/83/0 array_length 2 M_entries[83][0] +/M/83/0/0 integer 14 M_entries[83][0][0] +/M/83/0/1 integer 1 M_entries[83][0][1] +/M/83/1 array_length 2 M_entries[83][1] +/M/83/1/0 integer 15 M_entries[83][1][0] +/M/83/1/1 integer -1 M_entries[83][1][1] +/M/83/2 array_length 2 M_entries[83][2] +/M/83/2/0 integer 98 M_entries[83][2][0] +/M/83/2/1 integer -1 M_entries[83][2][1] +/M/83/3 array_length 2 M_entries[83][3] +/M/83/3/0 integer 99 M_entries[83][3][0] +/M/83/3/1 integer 1 M_entries[83][3][1] +/M/84 array_length 4 M_entries[84] +/M/84/0 array_length 2 M_entries[84][0] +/M/84/0/0 integer 14 M_entries[84][0][0] +/M/84/0/1 integer 1 M_entries[84][0][1] +/M/84/1 array_length 2 M_entries[84][1] +/M/84/1/0 integer 15 M_entries[84][1][0] +/M/84/1/1 integer -1 M_entries[84][1][1] +/M/84/2 array_length 2 M_entries[84][2] +/M/84/2/0 integer 102 M_entries[84][2][0] +/M/84/2/1 integer -1 M_entries[84][2][1] +/M/84/3 array_length 2 M_entries[84][3] +/M/84/3/0 integer 103 M_entries[84][3][0] +/M/84/3/1 integer 1 M_entries[84][3][1] +/M/85 array_length 4 M_entries[85] +/M/85/0 array_length 2 M_entries[85][0] +/M/85/0/0 integer 16 M_entries[85][0][0] +/M/85/0/1 integer 1 M_entries[85][0][1] +/M/85/1 array_length 2 M_entries[85][1] +/M/85/1/0 integer 18 M_entries[85][1][0] +/M/85/1/1 integer -1 M_entries[85][1][1] +/M/85/2 array_length 2 M_entries[85][2] +/M/85/2/0 integer 20 M_entries[85][2][0] +/M/85/2/1 integer -1 M_entries[85][2][1] +/M/85/3 array_length 2 M_entries[85][3] +/M/85/3/0 integer 23 M_entries[85][3][0] +/M/85/3/1 integer 1 M_entries[85][3][1] +/M/86 array_length 4 M_entries[86] +/M/86/0 array_length 2 M_entries[86][0] +/M/86/0/0 integer 16 M_entries[86][0][0] +/M/86/0/1 integer 1 M_entries[86][0][1] +/M/86/1 array_length 2 M_entries[86][1] +/M/86/1/0 integer 18 M_entries[86][1][0] +/M/86/1/1 integer -1 M_entries[86][1][1] +/M/86/2 array_length 2 M_entries[86][2] +/M/86/2/0 integer 24 M_entries[86][2][0] +/M/86/2/1 integer -1 M_entries[86][2][1] +/M/86/3 array_length 2 M_entries[86][3] +/M/86/3/0 integer 27 M_entries[86][3][0] +/M/86/3/1 integer 1 M_entries[86][3][1] +/M/87 array_length 4 M_entries[87] +/M/87/0 array_length 2 M_entries[87][0] +/M/87/0/0 integer 16 M_entries[87][0][0] +/M/87/0/1 integer 1 M_entries[87][0][1] +/M/87/1 array_length 2 M_entries[87][1] +/M/87/1/0 integer 19 M_entries[87][1][0] +/M/87/1/1 integer -1 M_entries[87][1][1] +/M/87/2 array_length 2 M_entries[87][2] +/M/87/2/0 integer 28 M_entries[87][2][0] +/M/87/2/1 integer -1 M_entries[87][2][1] +/M/87/3 array_length 2 M_entries[87][3] +/M/87/3/0 integer 31 M_entries[87][3][0] +/M/87/3/1 integer 1 M_entries[87][3][1] +/M/88 array_length 4 M_entries[88] +/M/88/0 array_length 2 M_entries[88][0] +/M/88/0/0 integer 16 M_entries[88][0][0] +/M/88/0/1 integer 1 M_entries[88][0][1] +/M/88/1 array_length 2 M_entries[88][1] +/M/88/1/0 integer 19 M_entries[88][1][0] +/M/88/1/1 integer -1 M_entries[88][1][1] +/M/88/2 array_length 2 M_entries[88][2] +/M/88/2/0 integer 32 M_entries[88][2][0] +/M/88/2/1 integer -1 M_entries[88][2][1] +/M/88/3 array_length 2 M_entries[88][3] +/M/88/3/0 integer 35 M_entries[88][3][0] +/M/88/3/1 integer 1 M_entries[88][3][1] +/M/89 array_length 4 M_entries[89] +/M/89/0 array_length 2 M_entries[89][0] +/M/89/0/0 integer 16 M_entries[89][0][0] +/M/89/0/1 integer 1 M_entries[89][0][1] +/M/89/1 array_length 2 M_entries[89][1] +/M/89/1/0 integer 19 M_entries[89][1][0] +/M/89/1/1 integer -1 M_entries[89][1][1] +/M/89/2 array_length 2 M_entries[89][2] +/M/89/2/0 integer 36 M_entries[89][2][0] +/M/89/2/1 integer -1 M_entries[89][2][1] +/M/89/3 array_length 2 M_entries[89][3] +/M/89/3/0 integer 39 M_entries[89][3][0] +/M/89/3/1 integer 1 M_entries[89][3][1] +/M/90 array_length 4 M_entries[90] +/M/90/0 array_length 2 M_entries[90][0] +/M/90/0/0 integer 16 M_entries[90][0][0] +/M/90/0/1 integer 1 M_entries[90][0][1] +/M/90/1 array_length 2 M_entries[90][1] +/M/90/1/0 integer 19 M_entries[90][1][0] +/M/90/1/1 integer -1 M_entries[90][1][1] +/M/90/2 array_length 2 M_entries[90][2] +/M/90/2/0 integer 40 M_entries[90][2][0] +/M/90/2/1 integer -1 M_entries[90][2][1] +/M/90/3 array_length 2 M_entries[90][3] +/M/90/3/0 integer 43 M_entries[90][3][0] +/M/90/3/1 integer 1 M_entries[90][3][1] +/M/91 array_length 4 M_entries[91] +/M/91/0 array_length 2 M_entries[91][0] +/M/91/0/0 integer 16 M_entries[91][0][0] +/M/91/0/1 integer 1 M_entries[91][0][1] +/M/91/1 array_length 2 M_entries[91][1] +/M/91/1/0 integer 18 M_entries[91][1][0] +/M/91/1/1 integer -1 M_entries[91][1][1] +/M/91/2 array_length 2 M_entries[91][2] +/M/91/2/0 integer 44 M_entries[91][2][0] +/M/91/2/1 integer -1 M_entries[91][2][1] +/M/91/3 array_length 2 M_entries[91][3] +/M/91/3/0 integer 47 M_entries[91][3][0] +/M/91/3/1 integer 1 M_entries[91][3][1] +/M/92 array_length 4 M_entries[92] +/M/92/0 array_length 2 M_entries[92][0] +/M/92/0/0 integer 16 M_entries[92][0][0] +/M/92/0/1 integer 1 M_entries[92][0][1] +/M/92/1 array_length 2 M_entries[92][1] +/M/92/1/0 integer 18 M_entries[92][1][0] +/M/92/1/1 integer -1 M_entries[92][1][1] +/M/92/2 array_length 2 M_entries[92][2] +/M/92/2/0 integer 48 M_entries[92][2][0] +/M/92/2/1 integer -1 M_entries[92][2][1] +/M/92/3 array_length 2 M_entries[92][3] +/M/92/3/0 integer 51 M_entries[92][3][0] +/M/92/3/1 integer 1 M_entries[92][3][1] +/M/93 array_length 4 M_entries[93] +/M/93/0 array_length 2 M_entries[93][0] +/M/93/0/0 integer 17 M_entries[93][0][0] +/M/93/0/1 integer 1 M_entries[93][0][1] +/M/93/1 array_length 2 M_entries[93][1] +/M/93/1/0 integer 19 M_entries[93][1][0] +/M/93/1/1 integer -1 M_entries[93][1][1] +/M/93/2 array_length 2 M_entries[93][2] +/M/93/2/0 integer 52 M_entries[93][2][0] +/M/93/2/1 integer -1 M_entries[93][2][1] +/M/93/3 array_length 2 M_entries[93][3] +/M/93/3/0 integer 55 M_entries[93][3][0] +/M/93/3/1 integer 1 M_entries[93][3][1] +/M/94 array_length 4 M_entries[94] +/M/94/0 array_length 2 M_entries[94][0] +/M/94/0/0 integer 17 M_entries[94][0][0] +/M/94/0/1 integer 1 M_entries[94][0][1] +/M/94/1 array_length 2 M_entries[94][1] +/M/94/1/0 integer 19 M_entries[94][1][0] +/M/94/1/1 integer -1 M_entries[94][1][1] +/M/94/2 array_length 2 M_entries[94][2] +/M/94/2/0 integer 56 M_entries[94][2][0] +/M/94/2/1 integer -1 M_entries[94][2][1] +/M/94/3 array_length 2 M_entries[94][3] +/M/94/3/0 integer 59 M_entries[94][3][0] +/M/94/3/1 integer 1 M_entries[94][3][1] +/M/95 array_length 4 M_entries[95] +/M/95/0 array_length 2 M_entries[95][0] +/M/95/0/0 integer 17 M_entries[95][0][0] +/M/95/0/1 integer 1 M_entries[95][0][1] +/M/95/1 array_length 2 M_entries[95][1] +/M/95/1/0 integer 18 M_entries[95][1][0] +/M/95/1/1 integer -1 M_entries[95][1][1] +/M/95/2 array_length 2 M_entries[95][2] +/M/95/2/0 integer 60 M_entries[95][2][0] +/M/95/2/1 integer -1 M_entries[95][2][1] +/M/95/3 array_length 2 M_entries[95][3] +/M/95/3/0 integer 63 M_entries[95][3][0] +/M/95/3/1 integer 1 M_entries[95][3][1] +/M/96 array_length 4 M_entries[96] +/M/96/0 array_length 2 M_entries[96][0] +/M/96/0/0 integer 17 M_entries[96][0][0] +/M/96/0/1 integer 1 M_entries[96][0][1] +/M/96/1 array_length 2 M_entries[96][1] +/M/96/1/0 integer 18 M_entries[96][1][0] +/M/96/1/1 integer -1 M_entries[96][1][1] +/M/96/2 array_length 2 M_entries[96][2] +/M/96/2/0 integer 64 M_entries[96][2][0] +/M/96/2/1 integer -1 M_entries[96][2][1] +/M/96/3 array_length 2 M_entries[96][3] +/M/96/3/0 integer 67 M_entries[96][3][0] +/M/96/3/1 integer 1 M_entries[96][3][1] +/M/97 array_length 4 M_entries[97] +/M/97/0 array_length 2 M_entries[97][0] +/M/97/0/0 integer 17 M_entries[97][0][0] +/M/97/0/1 integer 1 M_entries[97][0][1] +/M/97/1 array_length 2 M_entries[97][1] +/M/97/1/0 integer 18 M_entries[97][1][0] +/M/97/1/1 integer -1 M_entries[97][1][1] +/M/97/2 array_length 2 M_entries[97][2] +/M/97/2/0 integer 68 M_entries[97][2][0] +/M/97/2/1 integer -1 M_entries[97][2][1] +/M/97/3 array_length 2 M_entries[97][3] +/M/97/3/0 integer 71 M_entries[97][3][0] +/M/97/3/1 integer 1 M_entries[97][3][1] +/M/98 array_length 4 M_entries[98] +/M/98/0 array_length 2 M_entries[98][0] +/M/98/0/0 integer 17 M_entries[98][0][0] +/M/98/0/1 integer 1 M_entries[98][0][1] +/M/98/1 array_length 2 M_entries[98][1] +/M/98/1/0 integer 18 M_entries[98][1][0] +/M/98/1/1 integer -1 M_entries[98][1][1] +/M/98/2 array_length 2 M_entries[98][2] +/M/98/2/0 integer 72 M_entries[98][2][0] +/M/98/2/1 integer -1 M_entries[98][2][1] +/M/98/3 array_length 2 M_entries[98][3] +/M/98/3/0 integer 75 M_entries[98][3][0] +/M/98/3/1 integer 1 M_entries[98][3][1] +/M/99 array_length 4 M_entries[99] +/M/99/0 array_length 2 M_entries[99][0] +/M/99/0/0 integer 17 M_entries[99][0][0] +/M/99/0/1 integer 1 M_entries[99][0][1] +/M/99/1 array_length 2 M_entries[99][1] +/M/99/1/0 integer 19 M_entries[99][1][0] +/M/99/1/1 integer -1 M_entries[99][1][1] +/M/99/2 array_length 2 M_entries[99][2] +/M/99/2/0 integer 76 M_entries[99][2][0] +/M/99/2/1 integer -1 M_entries[99][2][1] +/M/99/3 array_length 2 M_entries[99][3] +/M/99/3/0 integer 79 M_entries[99][3][0] +/M/99/3/1 integer 1 M_entries[99][3][1] +/M/100 array_length 4 M_entries[100] +/M/100/0 array_length 2 M_entries[100][0] +/M/100/0/0 integer 17 M_entries[100][0][0] +/M/100/0/1 integer 1 M_entries[100][0][1] +/M/100/1 array_length 2 M_entries[100][1] +/M/100/1/0 integer 19 M_entries[100][1][0] +/M/100/1/1 integer -1 M_entries[100][1][1] +/M/100/2 array_length 2 M_entries[100][2] +/M/100/2/0 integer 80 M_entries[100][2][0] +/M/100/2/1 integer -1 M_entries[100][2][1] +/M/100/3 array_length 2 M_entries[100][3] +/M/100/3/0 integer 83 M_entries[100][3][0] +/M/100/3/1 integer 1 M_entries[100][3][1] +/M/101 array_length 4 M_entries[101] +/M/101/0 array_length 2 M_entries[101][0] +/M/101/0/0 integer 18 M_entries[101][0][0] +/M/101/0/1 integer 1 M_entries[101][0][1] +/M/101/1 array_length 2 M_entries[101][1] +/M/101/1/0 integer 19 M_entries[101][1][0] +/M/101/1/1 integer -1 M_entries[101][1][1] +/M/101/2 array_length 2 M_entries[101][2] +/M/101/2/0 integer 94 M_entries[101][2][0] +/M/101/2/1 integer -1 M_entries[101][2][1] +/M/101/3 array_length 2 M_entries[101][3] +/M/101/3/0 integer 95 M_entries[101][3][0] +/M/101/3/1 integer 1 M_entries[101][3][1] +/M/102 array_length 4 M_entries[102] +/M/102/0 array_length 2 M_entries[102][0] +/M/102/0/0 integer 18 M_entries[102][0][0] +/M/102/0/1 integer 1 M_entries[102][0][1] +/M/102/1 array_length 2 M_entries[102][1] +/M/102/1/0 integer 19 M_entries[102][1][0] +/M/102/1/1 integer -1 M_entries[102][1][1] +/M/102/2 array_length 2 M_entries[102][2] +/M/102/2/0 integer 98 M_entries[102][2][0] +/M/102/2/1 integer -1 M_entries[102][2][1] +/M/102/3 array_length 2 M_entries[102][3] +/M/102/3/0 integer 99 M_entries[102][3][0] +/M/102/3/1 integer 1 M_entries[102][3][1] +/M/103 array_length 4 M_entries[103] +/M/103/0 array_length 2 M_entries[103][0] +/M/103/0/0 integer 18 M_entries[103][0][0] +/M/103/0/1 integer 1 M_entries[103][0][1] +/M/103/1 array_length 2 M_entries[103][1] +/M/103/1/0 integer 19 M_entries[103][1][0] +/M/103/1/1 integer -1 M_entries[103][1][1] +/M/103/2 array_length 2 M_entries[103][2] +/M/103/2/0 integer 102 M_entries[103][2][0] +/M/103/2/1 integer -1 M_entries[103][2][1] +/M/103/3 array_length 2 M_entries[103][3] +/M/103/3/0 integer 103 M_entries[103][3][0] +/M/103/3/1 integer 1 M_entries[103][3][1] +/M/104 array_length 4 M_entries[104] +/M/104/0 array_length 2 M_entries[104][0] +/M/104/0/0 integer 20 M_entries[104][0][0] +/M/104/0/1 integer 1 M_entries[104][0][1] +/M/104/1 array_length 2 M_entries[104][1] +/M/104/1/0 integer 21 M_entries[104][1][0] +/M/104/1/1 integer -1 M_entries[104][1][1] +/M/104/2 array_length 2 M_entries[104][2] +/M/104/2/0 integer 28 M_entries[104][2][0] +/M/104/2/1 integer -1 M_entries[104][2][1] +/M/104/3 array_length 2 M_entries[104][3] +/M/104/3/0 integer 29 M_entries[104][3][0] +/M/104/3/1 integer 1 M_entries[104][3][1] +/M/105 array_length 4 M_entries[105] +/M/105/0 array_length 2 M_entries[105][0] +/M/105/0/0 integer 20 M_entries[105][0][0] +/M/105/0/1 integer 1 M_entries[105][0][1] +/M/105/1 array_length 2 M_entries[105][1] +/M/105/1/0 integer 21 M_entries[105][1][0] +/M/105/1/1 integer -1 M_entries[105][1][1] +/M/105/2 array_length 2 M_entries[105][2] +/M/105/2/0 integer 32 M_entries[105][2][0] +/M/105/2/1 integer -1 M_entries[105][2][1] +/M/105/3 array_length 2 M_entries[105][3] +/M/105/3/0 integer 33 M_entries[105][3][0] +/M/105/3/1 integer 1 M_entries[105][3][1] +/M/106 array_length 4 M_entries[106] +/M/106/0 array_length 2 M_entries[106][0] +/M/106/0/0 integer 20 M_entries[106][0][0] +/M/106/0/1 integer 1 M_entries[106][0][1] +/M/106/1 array_length 2 M_entries[106][1] +/M/106/1/0 integer 22 M_entries[106][1][0] +/M/106/1/1 integer -1 M_entries[106][1][1] +/M/106/2 array_length 2 M_entries[106][2] +/M/106/2/0 integer 36 M_entries[106][2][0] +/M/106/2/1 integer -1 M_entries[106][2][1] +/M/106/3 array_length 2 M_entries[106][3] +/M/106/3/0 integer 38 M_entries[106][3][0] +/M/106/3/1 integer 1 M_entries[106][3][1] +/M/107 array_length 4 M_entries[107] +/M/107/0 array_length 2 M_entries[107][0] +/M/107/0/0 integer 20 M_entries[107][0][0] +/M/107/0/1 integer 1 M_entries[107][0][1] +/M/107/1 array_length 2 M_entries[107][1] +/M/107/1/0 integer 22 M_entries[107][1][0] +/M/107/1/1 integer -1 M_entries[107][1][1] +/M/107/2 array_length 2 M_entries[107][2] +/M/107/2/0 integer 40 M_entries[107][2][0] +/M/107/2/1 integer -1 M_entries[107][2][1] +/M/107/3 array_length 2 M_entries[107][3] +/M/107/3/0 integer 42 M_entries[107][3][0] +/M/107/3/1 integer 1 M_entries[107][3][1] +/M/108 array_length 4 M_entries[108] +/M/108/0 array_length 2 M_entries[108][0] +/M/108/0/0 integer 20 M_entries[108][0][0] +/M/108/0/1 integer 1 M_entries[108][0][1] +/M/108/1 array_length 2 M_entries[108][1] +/M/108/1/0 integer 23 M_entries[108][1][0] +/M/108/1/1 integer -1 M_entries[108][1][1] +/M/108/2 array_length 2 M_entries[108][2] +/M/108/2/0 integer 44 M_entries[108][2][0] +/M/108/2/1 integer -1 M_entries[108][2][1] +/M/108/3 array_length 2 M_entries[108][3] +/M/108/3/0 integer 47 M_entries[108][3][0] +/M/108/3/1 integer 1 M_entries[108][3][1] +/M/109 array_length 4 M_entries[109] +/M/109/0 array_length 2 M_entries[109][0] +/M/109/0/0 integer 20 M_entries[109][0][0] +/M/109/0/1 integer 1 M_entries[109][0][1] +/M/109/1 array_length 2 M_entries[109][1] +/M/109/1/0 integer 23 M_entries[109][1][0] +/M/109/1/1 integer -1 M_entries[109][1][1] +/M/109/2 array_length 2 M_entries[109][2] +/M/109/2/0 integer 48 M_entries[109][2][0] +/M/109/2/1 integer -1 M_entries[109][2][1] +/M/109/3 array_length 2 M_entries[109][3] +/M/109/3/0 integer 51 M_entries[109][3][0] +/M/109/3/1 integer 1 M_entries[109][3][1] +/M/110 array_length 4 M_entries[110] +/M/110/0 array_length 2 M_entries[110][0] +/M/110/0/0 integer 21 M_entries[110][0][0] +/M/110/0/1 integer 1 M_entries[110][0][1] +/M/110/1 array_length 2 M_entries[110][1] +/M/110/1/0 integer 22 M_entries[110][1][0] +/M/110/1/1 integer -1 M_entries[110][1][1] +/M/110/2 array_length 2 M_entries[110][2] +/M/110/2/0 integer 53 M_entries[110][2][0] +/M/110/2/1 integer -1 M_entries[110][2][1] +/M/110/3 array_length 2 M_entries[110][3] +/M/110/3/0 integer 54 M_entries[110][3][0] +/M/110/3/1 integer 1 M_entries[110][3][1] +/M/111 array_length 4 M_entries[111] +/M/111/0 array_length 2 M_entries[111][0] +/M/111/0/0 integer 21 M_entries[111][0][0] +/M/111/0/1 integer 1 M_entries[111][0][1] +/M/111/1 array_length 2 M_entries[111][1] +/M/111/1/0 integer 22 M_entries[111][1][0] +/M/111/1/1 integer -1 M_entries[111][1][1] +/M/111/2 array_length 2 M_entries[111][2] +/M/111/2/0 integer 57 M_entries[111][2][0] +/M/111/2/1 integer -1 M_entries[111][2][1] +/M/111/3 array_length 2 M_entries[111][3] +/M/111/3/0 integer 58 M_entries[111][3][0] +/M/111/3/1 integer 1 M_entries[111][3][1] +/M/112 array_length 4 M_entries[112] +/M/112/0 array_length 2 M_entries[112][0] +/M/112/0/0 integer 21 M_entries[112][0][0] +/M/112/0/1 integer 1 M_entries[112][0][1] +/M/112/1 array_length 2 M_entries[112][1] +/M/112/1/0 integer 23 M_entries[112][1][0] +/M/112/1/1 integer -1 M_entries[112][1][1] +/M/112/2 array_length 2 M_entries[112][2] +/M/112/2/0 integer 61 M_entries[112][2][0] +/M/112/2/1 integer -1 M_entries[112][2][1] +/M/112/3 array_length 2 M_entries[112][3] +/M/112/3/0 integer 63 M_entries[112][3][0] +/M/112/3/1 integer 1 M_entries[112][3][1] +/M/113 array_length 4 M_entries[113] +/M/113/0 array_length 2 M_entries[113][0] +/M/113/0/0 integer 21 M_entries[113][0][0] +/M/113/0/1 integer 1 M_entries[113][0][1] +/M/113/1 array_length 2 M_entries[113][1] +/M/113/1/0 integer 23 M_entries[113][1][0] +/M/113/1/1 integer -1 M_entries[113][1][1] +/M/113/2 array_length 2 M_entries[113][2] +/M/113/2/0 integer 65 M_entries[113][2][0] +/M/113/2/1 integer -1 M_entries[113][2][1] +/M/113/3 array_length 2 M_entries[113][3] +/M/113/3/0 integer 67 M_entries[113][3][0] +/M/113/3/1 integer 1 M_entries[113][3][1] +/M/114 array_length 4 M_entries[114] +/M/114/0 array_length 2 M_entries[114][0] +/M/114/0/0 integer 22 M_entries[114][0][0] +/M/114/0/1 integer 1 M_entries[114][0][1] +/M/114/1 array_length 2 M_entries[114][1] +/M/114/1/0 integer 23 M_entries[114][1][0] +/M/114/1/1 integer -1 M_entries[114][1][1] +/M/114/2 array_length 2 M_entries[114][2] +/M/114/2/0 integer 70 M_entries[114][2][0] +/M/114/2/1 integer -1 M_entries[114][2][1] +/M/114/3 array_length 2 M_entries[114][3] +/M/114/3/0 integer 71 M_entries[114][3][0] +/M/114/3/1 integer 1 M_entries[114][3][1] +/M/115 array_length 4 M_entries[115] +/M/115/0 array_length 2 M_entries[115][0] +/M/115/0/0 integer 22 M_entries[115][0][0] +/M/115/0/1 integer 1 M_entries[115][0][1] +/M/115/1 array_length 2 M_entries[115][1] +/M/115/1/0 integer 23 M_entries[115][1][0] +/M/115/1/1 integer -1 M_entries[115][1][1] +/M/115/2 array_length 2 M_entries[115][2] +/M/115/2/0 integer 74 M_entries[115][2][0] +/M/115/2/1 integer -1 M_entries[115][2][1] +/M/115/3 array_length 2 M_entries[115][3] +/M/115/3/0 integer 75 M_entries[115][3][0] +/M/115/3/1 integer 1 M_entries[115][3][1] +/M/116 array_length 4 M_entries[116] +/M/116/0 array_length 2 M_entries[116][0] +/M/116/0/0 integer 21 M_entries[116][0][0] +/M/116/0/1 integer 1 M_entries[116][0][1] +/M/116/1 array_length 2 M_entries[116][1] +/M/116/1/0 integer 22 M_entries[116][1][0] +/M/116/1/1 integer -1 M_entries[116][1][1] +/M/116/2 array_length 2 M_entries[116][2] +/M/116/2/0 integer 84 M_entries[116][2][0] +/M/116/2/1 integer -1 M_entries[116][2][1] +/M/116/3 array_length 2 M_entries[116][3] +/M/116/3/0 integer 86 M_entries[116][3][0] +/M/116/3/1 integer 1 M_entries[116][3][1] +/M/117 array_length 4 M_entries[117] +/M/117/0 array_length 2 M_entries[117][0] +/M/117/0/0 integer 21 M_entries[117][0][0] +/M/117/0/1 integer 1 M_entries[117][0][1] +/M/117/1 array_length 2 M_entries[117][1] +/M/117/1/0 integer 22 M_entries[117][1][0] +/M/117/1/1 integer -1 M_entries[117][1][1] +/M/117/2 array_length 2 M_entries[117][2] +/M/117/2/0 integer 88 M_entries[117][2][0] +/M/117/2/1 integer -1 M_entries[117][2][1] +/M/117/3 array_length 2 M_entries[117][3] +/M/117/3/0 integer 90 M_entries[117][3][0] +/M/117/3/1 integer 1 M_entries[117][3][1] +/M/118 array_length 4 M_entries[118] +/M/118/0 array_length 2 M_entries[118][0] +/M/118/0/0 integer 21 M_entries[118][0][0] +/M/118/0/1 integer 1 M_entries[118][0][1] +/M/118/1 array_length 2 M_entries[118][1] +/M/118/1/0 integer 23 M_entries[118][1][0] +/M/118/1/1 integer -1 M_entries[118][1][1] +/M/118/2 array_length 2 M_entries[118][2] +/M/118/2/0 integer 92 M_entries[118][2][0] +/M/118/2/1 integer -1 M_entries[118][2][1] +/M/118/3 array_length 2 M_entries[118][3] +/M/118/3/0 integer 94 M_entries[118][3][0] +/M/118/3/1 integer 1 M_entries[118][3][1] +/M/119 array_length 4 M_entries[119] +/M/119/0 array_length 2 M_entries[119][0] +/M/119/0/0 integer 21 M_entries[119][0][0] +/M/119/0/1 integer 1 M_entries[119][0][1] +/M/119/1 array_length 2 M_entries[119][1] +/M/119/1/0 integer 23 M_entries[119][1][0] +/M/119/1/1 integer -1 M_entries[119][1][1] +/M/119/2 array_length 2 M_entries[119][2] +/M/119/2/0 integer 96 M_entries[119][2][0] +/M/119/2/1 integer -1 M_entries[119][2][1] +/M/119/3 array_length 2 M_entries[119][3] +/M/119/3/0 integer 98 M_entries[119][3][0] +/M/119/3/1 integer 1 M_entries[119][3][1] +/M/120 array_length 4 M_entries[120] +/M/120/0 array_length 2 M_entries[120][0] +/M/120/0/0 integer 22 M_entries[120][0][0] +/M/120/0/1 integer 1 M_entries[120][0][1] +/M/120/1 array_length 2 M_entries[120][1] +/M/120/1/0 integer 23 M_entries[120][1][0] +/M/120/1/1 integer -1 M_entries[120][1][1] +/M/120/2 array_length 2 M_entries[120][2] +/M/120/2/0 integer 100 M_entries[120][2][0] +/M/120/2/1 integer -1 M_entries[120][2][1] +/M/120/3 array_length 2 M_entries[120][3] +/M/120/3/0 integer 102 M_entries[120][3][0] +/M/120/3/1 integer 1 M_entries[120][3][1] +/M/121 array_length 4 M_entries[121] +/M/121/0 array_length 2 M_entries[121][0] +/M/121/0/0 integer 24 M_entries[121][0][0] +/M/121/0/1 integer 1 M_entries[121][0][1] +/M/121/1 array_length 2 M_entries[121][1] +/M/121/1/0 integer 25 M_entries[121][1][0] +/M/121/1/1 integer -1 M_entries[121][1][1] +/M/121/2 array_length 2 M_entries[121][2] +/M/121/2/0 integer 28 M_entries[121][2][0] +/M/121/2/1 integer -1 M_entries[121][2][1] +/M/121/3 array_length 2 M_entries[121][3] +/M/121/3/0 integer 29 M_entries[121][3][0] +/M/121/3/1 integer 1 M_entries[121][3][1] +/M/122 array_length 4 M_entries[122] +/M/122/0 array_length 2 M_entries[122][0] +/M/122/0/0 integer 24 M_entries[122][0][0] +/M/122/0/1 integer 1 M_entries[122][0][1] +/M/122/1 array_length 2 M_entries[122][1] +/M/122/1/0 integer 25 M_entries[122][1][0] +/M/122/1/1 integer -1 M_entries[122][1][1] +/M/122/2 array_length 2 M_entries[122][2] +/M/122/2/0 integer 32 M_entries[122][2][0] +/M/122/2/1 integer -1 M_entries[122][2][1] +/M/122/3 array_length 2 M_entries[122][3] +/M/122/3/0 integer 33 M_entries[122][3][0] +/M/122/3/1 integer 1 M_entries[122][3][1] +/M/123 array_length 4 M_entries[123] +/M/123/0 array_length 2 M_entries[123][0] +/M/123/0/0 integer 24 M_entries[123][0][0] +/M/123/0/1 integer 1 M_entries[123][0][1] +/M/123/1 array_length 2 M_entries[123][1] +/M/123/1/0 integer 26 M_entries[123][1][0] +/M/123/1/1 integer -1 M_entries[123][1][1] +/M/123/2 array_length 2 M_entries[123][2] +/M/123/2/0 integer 36 M_entries[123][2][0] +/M/123/2/1 integer -1 M_entries[123][2][1] +/M/123/3 array_length 2 M_entries[123][3] +/M/123/3/0 integer 38 M_entries[123][3][0] +/M/123/3/1 integer 1 M_entries[123][3][1] +/M/124 array_length 4 M_entries[124] +/M/124/0 array_length 2 M_entries[124][0] +/M/124/0/0 integer 24 M_entries[124][0][0] +/M/124/0/1 integer 1 M_entries[124][0][1] +/M/124/1 array_length 2 M_entries[124][1] +/M/124/1/0 integer 26 M_entries[124][1][0] +/M/124/1/1 integer -1 M_entries[124][1][1] +/M/124/2 array_length 2 M_entries[124][2] +/M/124/2/0 integer 40 M_entries[124][2][0] +/M/124/2/1 integer -1 M_entries[124][2][1] +/M/124/3 array_length 2 M_entries[124][3] +/M/124/3/0 integer 42 M_entries[124][3][0] +/M/124/3/1 integer 1 M_entries[124][3][1] +/M/125 array_length 4 M_entries[125] +/M/125/0 array_length 2 M_entries[125][0] +/M/125/0/0 integer 24 M_entries[125][0][0] +/M/125/0/1 integer 1 M_entries[125][0][1] +/M/125/1 array_length 2 M_entries[125][1] +/M/125/1/0 integer 27 M_entries[125][1][0] +/M/125/1/1 integer -1 M_entries[125][1][1] +/M/125/2 array_length 2 M_entries[125][2] +/M/125/2/0 integer 44 M_entries[125][2][0] +/M/125/2/1 integer -1 M_entries[125][2][1] +/M/125/3 array_length 2 M_entries[125][3] +/M/125/3/0 integer 47 M_entries[125][3][0] +/M/125/3/1 integer 1 M_entries[125][3][1] +/M/126 array_length 4 M_entries[126] +/M/126/0 array_length 2 M_entries[126][0] +/M/126/0/0 integer 24 M_entries[126][0][0] +/M/126/0/1 integer 1 M_entries[126][0][1] +/M/126/1 array_length 2 M_entries[126][1] +/M/126/1/0 integer 27 M_entries[126][1][0] +/M/126/1/1 integer -1 M_entries[126][1][1] +/M/126/2 array_length 2 M_entries[126][2] +/M/126/2/0 integer 48 M_entries[126][2][0] +/M/126/2/1 integer -1 M_entries[126][2][1] +/M/126/3 array_length 2 M_entries[126][3] +/M/126/3/0 integer 51 M_entries[126][3][0] +/M/126/3/1 integer 1 M_entries[126][3][1] +/M/127 array_length 4 M_entries[127] +/M/127/0 array_length 2 M_entries[127][0] +/M/127/0/0 integer 25 M_entries[127][0][0] +/M/127/0/1 integer 1 M_entries[127][0][1] +/M/127/1 array_length 2 M_entries[127][1] +/M/127/1/0 integer 26 M_entries[127][1][0] +/M/127/1/1 integer -1 M_entries[127][1][1] +/M/127/2 array_length 2 M_entries[127][2] +/M/127/2/0 integer 53 M_entries[127][2][0] +/M/127/2/1 integer -1 M_entries[127][2][1] +/M/127/3 array_length 2 M_entries[127][3] +/M/127/3/0 integer 54 M_entries[127][3][0] +/M/127/3/1 integer 1 M_entries[127][3][1] +/M/128 array_length 4 M_entries[128] +/M/128/0 array_length 2 M_entries[128][0] +/M/128/0/0 integer 25 M_entries[128][0][0] +/M/128/0/1 integer 1 M_entries[128][0][1] +/M/128/1 array_length 2 M_entries[128][1] +/M/128/1/0 integer 26 M_entries[128][1][0] +/M/128/1/1 integer -1 M_entries[128][1][1] +/M/128/2 array_length 2 M_entries[128][2] +/M/128/2/0 integer 57 M_entries[128][2][0] +/M/128/2/1 integer -1 M_entries[128][2][1] +/M/128/3 array_length 2 M_entries[128][3] +/M/128/3/0 integer 58 M_entries[128][3][0] +/M/128/3/1 integer 1 M_entries[128][3][1] +/M/129 array_length 4 M_entries[129] +/M/129/0 array_length 2 M_entries[129][0] +/M/129/0/0 integer 25 M_entries[129][0][0] +/M/129/0/1 integer 1 M_entries[129][0][1] +/M/129/1 array_length 2 M_entries[129][1] +/M/129/1/0 integer 27 M_entries[129][1][0] +/M/129/1/1 integer -1 M_entries[129][1][1] +/M/129/2 array_length 2 M_entries[129][2] +/M/129/2/0 integer 61 M_entries[129][2][0] +/M/129/2/1 integer -1 M_entries[129][2][1] +/M/129/3 array_length 2 M_entries[129][3] +/M/129/3/0 integer 63 M_entries[129][3][0] +/M/129/3/1 integer 1 M_entries[129][3][1] +/M/130 array_length 4 M_entries[130] +/M/130/0 array_length 2 M_entries[130][0] +/M/130/0/0 integer 25 M_entries[130][0][0] +/M/130/0/1 integer 1 M_entries[130][0][1] +/M/130/1 array_length 2 M_entries[130][1] +/M/130/1/0 integer 27 M_entries[130][1][0] +/M/130/1/1 integer -1 M_entries[130][1][1] +/M/130/2 array_length 2 M_entries[130][2] +/M/130/2/0 integer 65 M_entries[130][2][0] +/M/130/2/1 integer -1 M_entries[130][2][1] +/M/130/3 array_length 2 M_entries[130][3] +/M/130/3/0 integer 67 M_entries[130][3][0] +/M/130/3/1 integer 1 M_entries[130][3][1] +/M/131 array_length 4 M_entries[131] +/M/131/0 array_length 2 M_entries[131][0] +/M/131/0/0 integer 26 M_entries[131][0][0] +/M/131/0/1 integer 1 M_entries[131][0][1] +/M/131/1 array_length 2 M_entries[131][1] +/M/131/1/0 integer 27 M_entries[131][1][0] +/M/131/1/1 integer -1 M_entries[131][1][1] +/M/131/2 array_length 2 M_entries[131][2] +/M/131/2/0 integer 70 M_entries[131][2][0] +/M/131/2/1 integer -1 M_entries[131][2][1] +/M/131/3 array_length 2 M_entries[131][3] +/M/131/3/0 integer 71 M_entries[131][3][0] +/M/131/3/1 integer 1 M_entries[131][3][1] +/M/132 array_length 4 M_entries[132] +/M/132/0 array_length 2 M_entries[132][0] +/M/132/0/0 integer 26 M_entries[132][0][0] +/M/132/0/1 integer 1 M_entries[132][0][1] +/M/132/1 array_length 2 M_entries[132][1] +/M/132/1/0 integer 27 M_entries[132][1][0] +/M/132/1/1 integer -1 M_entries[132][1][1] +/M/132/2 array_length 2 M_entries[132][2] +/M/132/2/0 integer 74 M_entries[132][2][0] +/M/132/2/1 integer -1 M_entries[132][2][1] +/M/132/3 array_length 2 M_entries[132][3] +/M/132/3/0 integer 75 M_entries[132][3][0] +/M/132/3/1 integer 1 M_entries[132][3][1] +/M/133 array_length 4 M_entries[133] +/M/133/0 array_length 2 M_entries[133][0] +/M/133/0/0 integer 25 M_entries[133][0][0] +/M/133/0/1 integer 1 M_entries[133][0][1] +/M/133/1 array_length 2 M_entries[133][1] +/M/133/1/0 integer 26 M_entries[133][1][0] +/M/133/1/1 integer -1 M_entries[133][1][1] +/M/133/2 array_length 2 M_entries[133][2] +/M/133/2/0 integer 84 M_entries[133][2][0] +/M/133/2/1 integer -1 M_entries[133][2][1] +/M/133/3 array_length 2 M_entries[133][3] +/M/133/3/0 integer 86 M_entries[133][3][0] +/M/133/3/1 integer 1 M_entries[133][3][1] +/M/134 array_length 4 M_entries[134] +/M/134/0 array_length 2 M_entries[134][0] +/M/134/0/0 integer 25 M_entries[134][0][0] +/M/134/0/1 integer 1 M_entries[134][0][1] +/M/134/1 array_length 2 M_entries[134][1] +/M/134/1/0 integer 26 M_entries[134][1][0] +/M/134/1/1 integer -1 M_entries[134][1][1] +/M/134/2 array_length 2 M_entries[134][2] +/M/134/2/0 integer 88 M_entries[134][2][0] +/M/134/2/1 integer -1 M_entries[134][2][1] +/M/134/3 array_length 2 M_entries[134][3] +/M/134/3/0 integer 90 M_entries[134][3][0] +/M/134/3/1 integer 1 M_entries[134][3][1] +/M/135 array_length 4 M_entries[135] +/M/135/0 array_length 2 M_entries[135][0] +/M/135/0/0 integer 25 M_entries[135][0][0] +/M/135/0/1 integer 1 M_entries[135][0][1] +/M/135/1 array_length 2 M_entries[135][1] +/M/135/1/0 integer 27 M_entries[135][1][0] +/M/135/1/1 integer -1 M_entries[135][1][1] +/M/135/2 array_length 2 M_entries[135][2] +/M/135/2/0 integer 92 M_entries[135][2][0] +/M/135/2/1 integer -1 M_entries[135][2][1] +/M/135/3 array_length 2 M_entries[135][3] +/M/135/3/0 integer 94 M_entries[135][3][0] +/M/135/3/1 integer 1 M_entries[135][3][1] +/M/136 array_length 4 M_entries[136] +/M/136/0 array_length 2 M_entries[136][0] +/M/136/0/0 integer 25 M_entries[136][0][0] +/M/136/0/1 integer 1 M_entries[136][0][1] +/M/136/1 array_length 2 M_entries[136][1] +/M/136/1/0 integer 27 M_entries[136][1][0] +/M/136/1/1 integer -1 M_entries[136][1][1] +/M/136/2 array_length 2 M_entries[136][2] +/M/136/2/0 integer 96 M_entries[136][2][0] +/M/136/2/1 integer -1 M_entries[136][2][1] +/M/136/3 array_length 2 M_entries[136][3] +/M/136/3/0 integer 98 M_entries[136][3][0] +/M/136/3/1 integer 1 M_entries[136][3][1] +/M/137 array_length 4 M_entries[137] +/M/137/0 array_length 2 M_entries[137][0] +/M/137/0/0 integer 26 M_entries[137][0][0] +/M/137/0/1 integer 1 M_entries[137][0][1] +/M/137/1 array_length 2 M_entries[137][1] +/M/137/1/0 integer 27 M_entries[137][1][0] +/M/137/1/1 integer -1 M_entries[137][1][1] +/M/137/2 array_length 2 M_entries[137][2] +/M/137/2/0 integer 100 M_entries[137][2][0] +/M/137/2/1 integer -1 M_entries[137][2][1] +/M/137/3 array_length 2 M_entries[137][3] +/M/137/3/0 integer 102 M_entries[137][3][0] +/M/137/3/1 integer 1 M_entries[137][3][1] +/M/138 array_length 4 M_entries[138] +/M/138/0 array_length 2 M_entries[138][0] +/M/138/0/0 integer 28 M_entries[138][0][0] +/M/138/0/1 integer 1 M_entries[138][0][1] +/M/138/1 array_length 2 M_entries[138][1] +/M/138/1/0 integer 31 M_entries[138][1][0] +/M/138/1/1 integer -1 M_entries[138][1][1] +/M/138/2 array_length 2 M_entries[138][2] +/M/138/2/0 integer 36 M_entries[138][2][0] +/M/138/2/1 integer -1 M_entries[138][2][1] +/M/138/3 array_length 2 M_entries[138][3] +/M/138/3/0 integer 39 M_entries[138][3][0] +/M/138/3/1 integer 1 M_entries[138][3][1] +/M/139 array_length 4 M_entries[139] +/M/139/0 array_length 2 M_entries[139][0] +/M/139/0/0 integer 28 M_entries[139][0][0] +/M/139/0/1 integer 1 M_entries[139][0][1] +/M/139/1 array_length 2 M_entries[139][1] +/M/139/1/0 integer 31 M_entries[139][1][0] +/M/139/1/1 integer -1 M_entries[139][1][1] +/M/139/2 array_length 2 M_entries[139][2] +/M/139/2/0 integer 40 M_entries[139][2][0] +/M/139/2/1 integer -1 M_entries[139][2][1] +/M/139/3 array_length 2 M_entries[139][3] +/M/139/3/0 integer 43 M_entries[139][3][0] +/M/139/3/1 integer 1 M_entries[139][3][1] +/M/140 array_length 4 M_entries[140] +/M/140/0 array_length 2 M_entries[140][0] +/M/140/0/0 integer 28 M_entries[140][0][0] +/M/140/0/1 integer 1 M_entries[140][0][1] +/M/140/1 array_length 2 M_entries[140][1] +/M/140/1/0 integer 30 M_entries[140][1][0] +/M/140/1/1 integer -1 M_entries[140][1][1] +/M/140/2 array_length 2 M_entries[140][2] +/M/140/2/0 integer 44 M_entries[140][2][0] +/M/140/2/1 integer -1 M_entries[140][2][1] +/M/140/3 array_length 2 M_entries[140][3] +/M/140/3/0 integer 46 M_entries[140][3][0] +/M/140/3/1 integer 1 M_entries[140][3][1] +/M/141 array_length 4 M_entries[141] +/M/141/0 array_length 2 M_entries[141][0] +/M/141/0/0 integer 28 M_entries[141][0][0] +/M/141/0/1 integer 1 M_entries[141][0][1] +/M/141/1 array_length 2 M_entries[141][1] +/M/141/1/0 integer 30 M_entries[141][1][0] +/M/141/1/1 integer -1 M_entries[141][1][1] +/M/141/2 array_length 2 M_entries[141][2] +/M/141/2/0 integer 48 M_entries[141][2][0] +/M/141/2/1 integer -1 M_entries[141][2][1] +/M/141/3 array_length 2 M_entries[141][3] +/M/141/3/0 integer 50 M_entries[141][3][0] +/M/141/3/1 integer 1 M_entries[141][3][1] +/M/142 array_length 4 M_entries[142] +/M/142/0 array_length 2 M_entries[142][0] +/M/142/0/0 integer 29 M_entries[142][0][0] +/M/142/0/1 integer 1 M_entries[142][0][1] +/M/142/1 array_length 2 M_entries[142][1] +/M/142/1/0 integer 31 M_entries[142][1][0] +/M/142/1/1 integer -1 M_entries[142][1][1] +/M/142/2 array_length 2 M_entries[142][2] +/M/142/2/0 integer 53 M_entries[142][2][0] +/M/142/2/1 integer -1 M_entries[142][2][1] +/M/142/3 array_length 2 M_entries[142][3] +/M/142/3/0 integer 55 M_entries[142][3][0] +/M/142/3/1 integer 1 M_entries[142][3][1] +/M/143 array_length 4 M_entries[143] +/M/143/0 array_length 2 M_entries[143][0] +/M/143/0/0 integer 29 M_entries[143][0][0] +/M/143/0/1 integer 1 M_entries[143][0][1] +/M/143/1 array_length 2 M_entries[143][1] +/M/143/1/0 integer 31 M_entries[143][1][0] +/M/143/1/1 integer -1 M_entries[143][1][1] +/M/143/2 array_length 2 M_entries[143][2] +/M/143/2/0 integer 57 M_entries[143][2][0] +/M/143/2/1 integer -1 M_entries[143][2][1] +/M/143/3 array_length 2 M_entries[143][3] +/M/143/3/0 integer 59 M_entries[143][3][0] +/M/143/3/1 integer 1 M_entries[143][3][1] +/M/144 array_length 4 M_entries[144] +/M/144/0 array_length 2 M_entries[144][0] +/M/144/0/0 integer 29 M_entries[144][0][0] +/M/144/0/1 integer 1 M_entries[144][0][1] +/M/144/1 array_length 2 M_entries[144][1] +/M/144/1/0 integer 30 M_entries[144][1][0] +/M/144/1/1 integer -1 M_entries[144][1][1] +/M/144/2 array_length 2 M_entries[144][2] +/M/144/2/0 integer 61 M_entries[144][2][0] +/M/144/2/1 integer -1 M_entries[144][2][1] +/M/144/3 array_length 2 M_entries[144][3] +/M/144/3/0 integer 62 M_entries[144][3][0] +/M/144/3/1 integer 1 M_entries[144][3][1] +/M/145 array_length 4 M_entries[145] +/M/145/0 array_length 2 M_entries[145][0] +/M/145/0/0 integer 29 M_entries[145][0][0] +/M/145/0/1 integer 1 M_entries[145][0][1] +/M/145/1 array_length 2 M_entries[145][1] +/M/145/1/0 integer 30 M_entries[145][1][0] +/M/145/1/1 integer -1 M_entries[145][1][1] +/M/145/2 array_length 2 M_entries[145][2] +/M/145/2/0 integer 65 M_entries[145][2][0] +/M/145/2/1 integer -1 M_entries[145][2][1] +/M/145/3 array_length 2 M_entries[145][3] +/M/145/3/0 integer 66 M_entries[145][3][0] +/M/145/3/1 integer 1 M_entries[145][3][1] +/M/146 array_length 4 M_entries[146] +/M/146/0 array_length 2 M_entries[146][0] +/M/146/0/0 integer 30 M_entries[146][0][0] +/M/146/0/1 integer 1 M_entries[146][0][1] +/M/146/1 array_length 2 M_entries[146][1] +/M/146/1/0 integer 31 M_entries[146][1][0] +/M/146/1/1 integer -1 M_entries[146][1][1] +/M/146/2 array_length 2 M_entries[146][2] +/M/146/2/0 integer 78 M_entries[146][2][0] +/M/146/2/1 integer -1 M_entries[146][2][1] +/M/146/3 array_length 2 M_entries[146][3] +/M/146/3/0 integer 79 M_entries[146][3][0] +/M/146/3/1 integer 1 M_entries[146][3][1] +/M/147 array_length 4 M_entries[147] +/M/147/0 array_length 2 M_entries[147][0] +/M/147/0/0 integer 30 M_entries[147][0][0] +/M/147/0/1 integer 1 M_entries[147][0][1] +/M/147/1 array_length 2 M_entries[147][1] +/M/147/1/0 integer 31 M_entries[147][1][0] +/M/147/1/1 integer -1 M_entries[147][1][1] +/M/147/2 array_length 2 M_entries[147][2] +/M/147/2/0 integer 82 M_entries[147][2][0] +/M/147/2/1 integer -1 M_entries[147][2][1] +/M/147/3 array_length 2 M_entries[147][3] +/M/147/3/0 integer 83 M_entries[147][3][0] +/M/147/3/1 integer 1 M_entries[147][3][1] +/M/148 array_length 4 M_entries[148] +/M/148/0 array_length 2 M_entries[148][0] +/M/148/0/0 integer 29 M_entries[148][0][0] +/M/148/0/1 integer 1 M_entries[148][0][1] +/M/148/1 array_length 2 M_entries[148][1] +/M/148/1/0 integer 30 M_entries[148][1][0] +/M/148/1/1 integer -1 M_entries[148][1][1] +/M/148/2 array_length 2 M_entries[148][2] +/M/148/2/0 integer 84 M_entries[148][2][0] +/M/148/2/1 integer -1 M_entries[148][2][1] +/M/148/3 array_length 2 M_entries[148][3] +/M/148/3/0 integer 87 M_entries[148][3][0] +/M/148/3/1 integer 1 M_entries[148][3][1] +/M/149 array_length 4 M_entries[149] +/M/149/0 array_length 2 M_entries[149][0] +/M/149/0/0 integer 29 M_entries[149][0][0] +/M/149/0/1 integer 1 M_entries[149][0][1] +/M/149/1 array_length 2 M_entries[149][1] +/M/149/1/0 integer 30 M_entries[149][1][0] +/M/149/1/1 integer -1 M_entries[149][1][1] +/M/149/2 array_length 2 M_entries[149][2] +/M/149/2/0 integer 88 M_entries[149][2][0] +/M/149/2/1 integer -1 M_entries[149][2][1] +/M/149/3 array_length 2 M_entries[149][3] +/M/149/3/0 integer 91 M_entries[149][3][0] +/M/149/3/1 integer 1 M_entries[149][3][1] +/M/150 array_length 4 M_entries[150] +/M/150/0 array_length 2 M_entries[150][0] +/M/150/0/0 integer 29 M_entries[150][0][0] +/M/150/0/1 integer 1 M_entries[150][0][1] +/M/150/1 array_length 2 M_entries[150][1] +/M/150/1/0 integer 31 M_entries[150][1][0] +/M/150/1/1 integer -1 M_entries[150][1][1] +/M/150/2 array_length 2 M_entries[150][2] +/M/150/2/0 integer 92 M_entries[150][2][0] +/M/150/2/1 integer -1 M_entries[150][2][1] +/M/150/3 array_length 2 M_entries[150][3] +/M/150/3/0 integer 95 M_entries[150][3][0] +/M/150/3/1 integer 1 M_entries[150][3][1] +/M/151 array_length 4 M_entries[151] +/M/151/0 array_length 2 M_entries[151][0] +/M/151/0/0 integer 29 M_entries[151][0][0] +/M/151/0/1 integer 1 M_entries[151][0][1] +/M/151/1 array_length 2 M_entries[151][1] +/M/151/1/0 integer 31 M_entries[151][1][0] +/M/151/1/1 integer -1 M_entries[151][1][1] +/M/151/2 array_length 2 M_entries[151][2] +/M/151/2/0 integer 96 M_entries[151][2][0] +/M/151/2/1 integer -1 M_entries[151][2][1] +/M/151/3 array_length 2 M_entries[151][3] +/M/151/3/0 integer 99 M_entries[151][3][0] +/M/151/3/1 integer 1 M_entries[151][3][1] +/M/152 array_length 4 M_entries[152] +/M/152/0 array_length 2 M_entries[152][0] +/M/152/0/0 integer 30 M_entries[152][0][0] +/M/152/0/1 integer 1 M_entries[152][0][1] +/M/152/1 array_length 2 M_entries[152][1] +/M/152/1/0 integer 31 M_entries[152][1][0] +/M/152/1/1 integer -1 M_entries[152][1][1] +/M/152/2 array_length 2 M_entries[152][2] +/M/152/2/0 integer 101 M_entries[152][2][0] +/M/152/2/1 integer -1 M_entries[152][2][1] +/M/152/3 array_length 2 M_entries[152][3] +/M/152/3/0 integer 103 M_entries[152][3][0] +/M/152/3/1 integer 1 M_entries[152][3][1] +/M/153 array_length 4 M_entries[153] +/M/153/0 array_length 2 M_entries[153][0] +/M/153/0/0 integer 32 M_entries[153][0][0] +/M/153/0/1 integer 1 M_entries[153][0][1] +/M/153/1 array_length 2 M_entries[153][1] +/M/153/1/0 integer 35 M_entries[153][1][0] +/M/153/1/1 integer -1 M_entries[153][1][1] +/M/153/2 array_length 2 M_entries[153][2] +/M/153/2/0 integer 36 M_entries[153][2][0] +/M/153/2/1 integer -1 M_entries[153][2][1] +/M/153/3 array_length 2 M_entries[153][3] +/M/153/3/0 integer 39 M_entries[153][3][0] +/M/153/3/1 integer 1 M_entries[153][3][1] +/M/154 array_length 4 M_entries[154] +/M/154/0 array_length 2 M_entries[154][0] +/M/154/0/0 integer 32 M_entries[154][0][0] +/M/154/0/1 integer 1 M_entries[154][0][1] +/M/154/1 array_length 2 M_entries[154][1] +/M/154/1/0 integer 35 M_entries[154][1][0] +/M/154/1/1 integer -1 M_entries[154][1][1] +/M/154/2 array_length 2 M_entries[154][2] +/M/154/2/0 integer 40 M_entries[154][2][0] +/M/154/2/1 integer -1 M_entries[154][2][1] +/M/154/3 array_length 2 M_entries[154][3] +/M/154/3/0 integer 43 M_entries[154][3][0] +/M/154/3/1 integer 1 M_entries[154][3][1] +/M/155 array_length 4 M_entries[155] +/M/155/0 array_length 2 M_entries[155][0] +/M/155/0/0 integer 32 M_entries[155][0][0] +/M/155/0/1 integer 1 M_entries[155][0][1] +/M/155/1 array_length 2 M_entries[155][1] +/M/155/1/0 integer 34 M_entries[155][1][0] +/M/155/1/1 integer -1 M_entries[155][1][1] +/M/155/2 array_length 2 M_entries[155][2] +/M/155/2/0 integer 44 M_entries[155][2][0] +/M/155/2/1 integer -1 M_entries[155][2][1] +/M/155/3 array_length 2 M_entries[155][3] +/M/155/3/0 integer 46 M_entries[155][3][0] +/M/155/3/1 integer 1 M_entries[155][3][1] +/M/156 array_length 4 M_entries[156] +/M/156/0 array_length 2 M_entries[156][0] +/M/156/0/0 integer 32 M_entries[156][0][0] +/M/156/0/1 integer 1 M_entries[156][0][1] +/M/156/1 array_length 2 M_entries[156][1] +/M/156/1/0 integer 34 M_entries[156][1][0] +/M/156/1/1 integer -1 M_entries[156][1][1] +/M/156/2 array_length 2 M_entries[156][2] +/M/156/2/0 integer 48 M_entries[156][2][0] +/M/156/2/1 integer -1 M_entries[156][2][1] +/M/156/3 array_length 2 M_entries[156][3] +/M/156/3/0 integer 50 M_entries[156][3][0] +/M/156/3/1 integer 1 M_entries[156][3][1] +/M/157 array_length 4 M_entries[157] +/M/157/0 array_length 2 M_entries[157][0] +/M/157/0/0 integer 33 M_entries[157][0][0] +/M/157/0/1 integer 1 M_entries[157][0][1] +/M/157/1 array_length 2 M_entries[157][1] +/M/157/1/0 integer 35 M_entries[157][1][0] +/M/157/1/1 integer -1 M_entries[157][1][1] +/M/157/2 array_length 2 M_entries[157][2] +/M/157/2/0 integer 53 M_entries[157][2][0] +/M/157/2/1 integer -1 M_entries[157][2][1] +/M/157/3 array_length 2 M_entries[157][3] +/M/157/3/0 integer 55 M_entries[157][3][0] +/M/157/3/1 integer 1 M_entries[157][3][1] +/M/158 array_length 4 M_entries[158] +/M/158/0 array_length 2 M_entries[158][0] +/M/158/0/0 integer 33 M_entries[158][0][0] +/M/158/0/1 integer 1 M_entries[158][0][1] +/M/158/1 array_length 2 M_entries[158][1] +/M/158/1/0 integer 35 M_entries[158][1][0] +/M/158/1/1 integer -1 M_entries[158][1][1] +/M/158/2 array_length 2 M_entries[158][2] +/M/158/2/0 integer 57 M_entries[158][2][0] +/M/158/2/1 integer -1 M_entries[158][2][1] +/M/158/3 array_length 2 M_entries[158][3] +/M/158/3/0 integer 59 M_entries[158][3][0] +/M/158/3/1 integer 1 M_entries[158][3][1] +/M/159 array_length 4 M_entries[159] +/M/159/0 array_length 2 M_entries[159][0] +/M/159/0/0 integer 33 M_entries[159][0][0] +/M/159/0/1 integer 1 M_entries[159][0][1] +/M/159/1 array_length 2 M_entries[159][1] +/M/159/1/0 integer 34 M_entries[159][1][0] +/M/159/1/1 integer -1 M_entries[159][1][1] +/M/159/2 array_length 2 M_entries[159][2] +/M/159/2/0 integer 61 M_entries[159][2][0] +/M/159/2/1 integer -1 M_entries[159][2][1] +/M/159/3 array_length 2 M_entries[159][3] +/M/159/3/0 integer 62 M_entries[159][3][0] +/M/159/3/1 integer 1 M_entries[159][3][1] +/M/160 array_length 4 M_entries[160] +/M/160/0 array_length 2 M_entries[160][0] +/M/160/0/0 integer 33 M_entries[160][0][0] +/M/160/0/1 integer 1 M_entries[160][0][1] +/M/160/1 array_length 2 M_entries[160][1] +/M/160/1/0 integer 34 M_entries[160][1][0] +/M/160/1/1 integer -1 M_entries[160][1][1] +/M/160/2 array_length 2 M_entries[160][2] +/M/160/2/0 integer 65 M_entries[160][2][0] +/M/160/2/1 integer -1 M_entries[160][2][1] +/M/160/3 array_length 2 M_entries[160][3] +/M/160/3/0 integer 66 M_entries[160][3][0] +/M/160/3/1 integer 1 M_entries[160][3][1] +/M/161 array_length 4 M_entries[161] +/M/161/0 array_length 2 M_entries[161][0] +/M/161/0/0 integer 34 M_entries[161][0][0] +/M/161/0/1 integer 1 M_entries[161][0][1] +/M/161/1 array_length 2 M_entries[161][1] +/M/161/1/0 integer 35 M_entries[161][1][0] +/M/161/1/1 integer -1 M_entries[161][1][1] +/M/161/2 array_length 2 M_entries[161][2] +/M/161/2/0 integer 78 M_entries[161][2][0] +/M/161/2/1 integer -1 M_entries[161][2][1] +/M/161/3 array_length 2 M_entries[161][3] +/M/161/3/0 integer 79 M_entries[161][3][0] +/M/161/3/1 integer 1 M_entries[161][3][1] +/M/162 array_length 4 M_entries[162] +/M/162/0 array_length 2 M_entries[162][0] +/M/162/0/0 integer 34 M_entries[162][0][0] +/M/162/0/1 integer 1 M_entries[162][0][1] +/M/162/1 array_length 2 M_entries[162][1] +/M/162/1/0 integer 35 M_entries[162][1][0] +/M/162/1/1 integer -1 M_entries[162][1][1] +/M/162/2 array_length 2 M_entries[162][2] +/M/162/2/0 integer 82 M_entries[162][2][0] +/M/162/2/1 integer -1 M_entries[162][2][1] +/M/162/3 array_length 2 M_entries[162][3] +/M/162/3/0 integer 83 M_entries[162][3][0] +/M/162/3/1 integer 1 M_entries[162][3][1] +/M/163 array_length 4 M_entries[163] +/M/163/0 array_length 2 M_entries[163][0] +/M/163/0/0 integer 33 M_entries[163][0][0] +/M/163/0/1 integer 1 M_entries[163][0][1] +/M/163/1 array_length 2 M_entries[163][1] +/M/163/1/0 integer 34 M_entries[163][1][0] +/M/163/1/1 integer -1 M_entries[163][1][1] +/M/163/2 array_length 2 M_entries[163][2] +/M/163/2/0 integer 84 M_entries[163][2][0] +/M/163/2/1 integer -1 M_entries[163][2][1] +/M/163/3 array_length 2 M_entries[163][3] +/M/163/3/0 integer 87 M_entries[163][3][0] +/M/163/3/1 integer 1 M_entries[163][3][1] +/M/164 array_length 4 M_entries[164] +/M/164/0 array_length 2 M_entries[164][0] +/M/164/0/0 integer 33 M_entries[164][0][0] +/M/164/0/1 integer 1 M_entries[164][0][1] +/M/164/1 array_length 2 M_entries[164][1] +/M/164/1/0 integer 34 M_entries[164][1][0] +/M/164/1/1 integer -1 M_entries[164][1][1] +/M/164/2 array_length 2 M_entries[164][2] +/M/164/2/0 integer 88 M_entries[164][2][0] +/M/164/2/1 integer -1 M_entries[164][2][1] +/M/164/3 array_length 2 M_entries[164][3] +/M/164/3/0 integer 91 M_entries[164][3][0] +/M/164/3/1 integer 1 M_entries[164][3][1] +/M/165 array_length 4 M_entries[165] +/M/165/0 array_length 2 M_entries[165][0] +/M/165/0/0 integer 33 M_entries[165][0][0] +/M/165/0/1 integer 1 M_entries[165][0][1] +/M/165/1 array_length 2 M_entries[165][1] +/M/165/1/0 integer 35 M_entries[165][1][0] +/M/165/1/1 integer -1 M_entries[165][1][1] +/M/165/2 array_length 2 M_entries[165][2] +/M/165/2/0 integer 92 M_entries[165][2][0] +/M/165/2/1 integer -1 M_entries[165][2][1] +/M/165/3 array_length 2 M_entries[165][3] +/M/165/3/0 integer 95 M_entries[165][3][0] +/M/165/3/1 integer 1 M_entries[165][3][1] +/M/166 array_length 4 M_entries[166] +/M/166/0 array_length 2 M_entries[166][0] +/M/166/0/0 integer 33 M_entries[166][0][0] +/M/166/0/1 integer 1 M_entries[166][0][1] +/M/166/1 array_length 2 M_entries[166][1] +/M/166/1/0 integer 35 M_entries[166][1][0] +/M/166/1/1 integer -1 M_entries[166][1][1] +/M/166/2 array_length 2 M_entries[166][2] +/M/166/2/0 integer 96 M_entries[166][2][0] +/M/166/2/1 integer -1 M_entries[166][2][1] +/M/166/3 array_length 2 M_entries[166][3] +/M/166/3/0 integer 99 M_entries[166][3][0] +/M/166/3/1 integer 1 M_entries[166][3][1] +/M/167 array_length 4 M_entries[167] +/M/167/0 array_length 2 M_entries[167][0] +/M/167/0/0 integer 34 M_entries[167][0][0] +/M/167/0/1 integer 1 M_entries[167][0][1] +/M/167/1 array_length 2 M_entries[167][1] +/M/167/1/0 integer 35 M_entries[167][1][0] +/M/167/1/1 integer -1 M_entries[167][1][1] +/M/167/2 array_length 2 M_entries[167][2] +/M/167/2/0 integer 101 M_entries[167][2][0] +/M/167/2/1 integer -1 M_entries[167][2][1] +/M/167/3 array_length 2 M_entries[167][3] +/M/167/3/0 integer 103 M_entries[167][3][0] +/M/167/3/1 integer 1 M_entries[167][3][1] +/M/168 array_length 4 M_entries[168] +/M/168/0 array_length 2 M_entries[168][0] +/M/168/0/0 integer 36 M_entries[168][0][0] +/M/168/0/1 integer 1 M_entries[168][0][1] +/M/168/1 array_length 2 M_entries[168][1] +/M/168/1/0 integer 37 M_entries[168][1][0] +/M/168/1/1 integer -1 M_entries[168][1][1] +/M/168/2 array_length 2 M_entries[168][2] +/M/168/2/0 integer 44 M_entries[168][2][0] +/M/168/2/1 integer -1 M_entries[168][2][1] +/M/168/3 array_length 2 M_entries[168][3] +/M/168/3/0 integer 45 M_entries[168][3][0] +/M/168/3/1 integer 1 M_entries[168][3][1] +/M/169 array_length 4 M_entries[169] +/M/169/0 array_length 2 M_entries[169][0] +/M/169/0/0 integer 36 M_entries[169][0][0] +/M/169/0/1 integer 1 M_entries[169][0][1] +/M/169/1 array_length 2 M_entries[169][1] +/M/169/1/0 integer 37 M_entries[169][1][0] +/M/169/1/1 integer -1 M_entries[169][1][1] +/M/169/2 array_length 2 M_entries[169][2] +/M/169/2/0 integer 48 M_entries[169][2][0] +/M/169/2/1 integer -1 M_entries[169][2][1] +/M/169/3 array_length 2 M_entries[169][3] +/M/169/3/0 integer 49 M_entries[169][3][0] +/M/169/3/1 integer 1 M_entries[169][3][1] +/M/170 array_length 4 M_entries[170] +/M/170/0 array_length 2 M_entries[170][0] +/M/170/0/0 integer 38 M_entries[170][0][0] +/M/170/0/1 integer 1 M_entries[170][0][1] +/M/170/1 array_length 2 M_entries[170][1] +/M/170/1/0 integer 39 M_entries[170][1][0] +/M/170/1/1 integer -1 M_entries[170][1][1] +/M/170/2 array_length 2 M_entries[170][2] +/M/170/2/0 integer 54 M_entries[170][2][0] +/M/170/2/1 integer -1 M_entries[170][2][1] +/M/170/3 array_length 2 M_entries[170][3] +/M/170/3/0 integer 55 M_entries[170][3][0] +/M/170/3/1 integer 1 M_entries[170][3][1] +/M/171 array_length 4 M_entries[171] +/M/171/0 array_length 2 M_entries[171][0] +/M/171/0/0 integer 38 M_entries[171][0][0] +/M/171/0/1 integer 1 M_entries[171][0][1] +/M/171/1 array_length 2 M_entries[171][1] +/M/171/1/0 integer 39 M_entries[171][1][0] +/M/171/1/1 integer -1 M_entries[171][1][1] +/M/171/2 array_length 2 M_entries[171][2] +/M/171/2/0 integer 58 M_entries[171][2][0] +/M/171/2/1 integer -1 M_entries[171][2][1] +/M/171/3 array_length 2 M_entries[171][3] +/M/171/3/0 integer 59 M_entries[171][3][0] +/M/171/3/1 integer 1 M_entries[171][3][1] +/M/172 array_length 4 M_entries[172] +/M/172/0 array_length 2 M_entries[172][0] +/M/172/0/0 integer 37 M_entries[172][0][0] +/M/172/0/1 integer 1 M_entries[172][0][1] +/M/172/1 array_length 2 M_entries[172][1] +/M/172/1/0 integer 38 M_entries[172][1][0] +/M/172/1/1 integer -1 M_entries[172][1][1] +/M/172/2 array_length 2 M_entries[172][2] +/M/172/2/0 integer 69 M_entries[172][2][0] +/M/172/2/1 integer -1 M_entries[172][2][1] +/M/172/3 array_length 2 M_entries[172][3] +/M/172/3/0 integer 70 M_entries[172][3][0] +/M/172/3/1 integer 1 M_entries[172][3][1] +/M/173 array_length 4 M_entries[173] +/M/173/0 array_length 2 M_entries[173][0] +/M/173/0/0 integer 37 M_entries[173][0][0] +/M/173/0/1 integer 1 M_entries[173][0][1] +/M/173/1 array_length 2 M_entries[173][1] +/M/173/1/0 integer 38 M_entries[173][1][0] +/M/173/1/1 integer -1 M_entries[173][1][1] +/M/173/2 array_length 2 M_entries[173][2] +/M/173/2/0 integer 73 M_entries[173][2][0] +/M/173/2/1 integer -1 M_entries[173][2][1] +/M/173/3 array_length 2 M_entries[173][3] +/M/173/3/0 integer 74 M_entries[173][3][0] +/M/173/3/1 integer 1 M_entries[173][3][1] +/M/174 array_length 4 M_entries[174] +/M/174/0 array_length 2 M_entries[174][0] +/M/174/0/0 integer 37 M_entries[174][0][0] +/M/174/0/1 integer 1 M_entries[174][0][1] +/M/174/1 array_length 2 M_entries[174][1] +/M/174/1/0 integer 39 M_entries[174][1][0] +/M/174/1/1 integer -1 M_entries[174][1][1] +/M/174/2 array_length 2 M_entries[174][2] +/M/174/2/0 integer 77 M_entries[174][2][0] +/M/174/2/1 integer -1 M_entries[174][2][1] +/M/174/3 array_length 2 M_entries[174][3] +/M/174/3/0 integer 79 M_entries[174][3][0] +/M/174/3/1 integer 1 M_entries[174][3][1] +/M/175 array_length 4 M_entries[175] +/M/175/0 array_length 2 M_entries[175][0] +/M/175/0/0 integer 37 M_entries[175][0][0] +/M/175/0/1 integer 1 M_entries[175][0][1] +/M/175/1 array_length 2 M_entries[175][1] +/M/175/1/0 integer 39 M_entries[175][1][0] +/M/175/1/1 integer -1 M_entries[175][1][1] +/M/175/2 array_length 2 M_entries[175][2] +/M/175/2/0 integer 81 M_entries[175][2][0] +/M/175/2/1 integer -1 M_entries[175][2][1] +/M/175/3 array_length 2 M_entries[175][3] +/M/175/3/0 integer 83 M_entries[175][3][0] +/M/175/3/1 integer 1 M_entries[175][3][1] +/M/176 array_length 4 M_entries[176] +/M/176/0 array_length 2 M_entries[176][0] +/M/176/0/0 integer 37 M_entries[176][0][0] +/M/176/0/1 integer 1 M_entries[176][0][1] +/M/176/1 array_length 2 M_entries[176][1] +/M/176/1/0 integer 38 M_entries[176][1][0] +/M/176/1/1 integer -1 M_entries[176][1][1] +/M/176/2 array_length 2 M_entries[176][2] +/M/176/2/0 integer 85 M_entries[176][2][0] +/M/176/2/1 integer -1 M_entries[176][2][1] +/M/176/3 array_length 2 M_entries[176][3] +/M/176/3/0 integer 86 M_entries[176][3][0] +/M/176/3/1 integer 1 M_entries[176][3][1] +/M/177 array_length 4 M_entries[177] +/M/177/0 array_length 2 M_entries[177][0] +/M/177/0/0 integer 37 M_entries[177][0][0] +/M/177/0/1 integer 1 M_entries[177][0][1] +/M/177/1 array_length 2 M_entries[177][1] +/M/177/1/0 integer 38 M_entries[177][1][0] +/M/177/1/1 integer -1 M_entries[177][1][1] +/M/177/2 array_length 2 M_entries[177][2] +/M/177/2/0 integer 89 M_entries[177][2][0] +/M/177/2/1 integer -1 M_entries[177][2][1] +/M/177/3 array_length 2 M_entries[177][3] +/M/177/3/0 integer 90 M_entries[177][3][0] +/M/177/3/1 integer 1 M_entries[177][3][1] +/M/178 array_length 4 M_entries[178] +/M/178/0 array_length 2 M_entries[178][0] +/M/178/0/0 integer 37 M_entries[178][0][0] +/M/178/0/1 integer 1 M_entries[178][0][1] +/M/178/1 array_length 2 M_entries[178][1] +/M/178/1/0 integer 39 M_entries[178][1][0] +/M/178/1/1 integer -1 M_entries[178][1][1] +/M/178/2 array_length 2 M_entries[178][2] +/M/178/2/0 integer 93 M_entries[178][2][0] +/M/178/2/1 integer -1 M_entries[178][2][1] +/M/178/3 array_length 2 M_entries[178][3] +/M/178/3/0 integer 95 M_entries[178][3][0] +/M/178/3/1 integer 1 M_entries[178][3][1] +/M/179 array_length 4 M_entries[179] +/M/179/0 array_length 2 M_entries[179][0] +/M/179/0/0 integer 37 M_entries[179][0][0] +/M/179/0/1 integer 1 M_entries[179][0][1] +/M/179/1 array_length 2 M_entries[179][1] +/M/179/1/0 integer 39 M_entries[179][1][0] +/M/179/1/1 integer -1 M_entries[179][1][1] +/M/179/2 array_length 2 M_entries[179][2] +/M/179/2/0 integer 97 M_entries[179][2][0] +/M/179/2/1 integer -1 M_entries[179][2][1] +/M/179/3 array_length 2 M_entries[179][3] +/M/179/3/0 integer 99 M_entries[179][3][0] +/M/179/3/1 integer 1 M_entries[179][3][1] +/M/180 array_length 4 M_entries[180] +/M/180/0 array_length 2 M_entries[180][0] +/M/180/0/0 integer 38 M_entries[180][0][0] +/M/180/0/1 integer 1 M_entries[180][0][1] +/M/180/1 array_length 2 M_entries[180][1] +/M/180/1/0 integer 39 M_entries[180][1][0] +/M/180/1/1 integer -1 M_entries[180][1][1] +/M/180/2 array_length 2 M_entries[180][2] +/M/180/2/0 integer 100 M_entries[180][2][0] +/M/180/2/1 integer -1 M_entries[180][2][1] +/M/180/3 array_length 2 M_entries[180][3] +/M/180/3/0 integer 103 M_entries[180][3][0] +/M/180/3/1 integer 1 M_entries[180][3][1] +/M/181 array_length 4 M_entries[181] +/M/181/0 array_length 2 M_entries[181][0] +/M/181/0/0 integer 40 M_entries[181][0][0] +/M/181/0/1 integer 1 M_entries[181][0][1] +/M/181/1 array_length 2 M_entries[181][1] +/M/181/1/0 integer 41 M_entries[181][1][0] +/M/181/1/1 integer -1 M_entries[181][1][1] +/M/181/2 array_length 2 M_entries[181][2] +/M/181/2/0 integer 44 M_entries[181][2][0] +/M/181/2/1 integer -1 M_entries[181][2][1] +/M/181/3 array_length 2 M_entries[181][3] +/M/181/3/0 integer 45 M_entries[181][3][0] +/M/181/3/1 integer 1 M_entries[181][3][1] +/M/182 array_length 4 M_entries[182] +/M/182/0 array_length 2 M_entries[182][0] +/M/182/0/0 integer 40 M_entries[182][0][0] +/M/182/0/1 integer 1 M_entries[182][0][1] +/M/182/1 array_length 2 M_entries[182][1] +/M/182/1/0 integer 41 M_entries[182][1][0] +/M/182/1/1 integer -1 M_entries[182][1][1] +/M/182/2 array_length 2 M_entries[182][2] +/M/182/2/0 integer 48 M_entries[182][2][0] +/M/182/2/1 integer -1 M_entries[182][2][1] +/M/182/3 array_length 2 M_entries[182][3] +/M/182/3/0 integer 49 M_entries[182][3][0] +/M/182/3/1 integer 1 M_entries[182][3][1] +/M/183 array_length 4 M_entries[183] +/M/183/0 array_length 2 M_entries[183][0] +/M/183/0/0 integer 42 M_entries[183][0][0] +/M/183/0/1 integer 1 M_entries[183][0][1] +/M/183/1 array_length 2 M_entries[183][1] +/M/183/1/0 integer 43 M_entries[183][1][0] +/M/183/1/1 integer -1 M_entries[183][1][1] +/M/183/2 array_length 2 M_entries[183][2] +/M/183/2/0 integer 54 M_entries[183][2][0] +/M/183/2/1 integer -1 M_entries[183][2][1] +/M/183/3 array_length 2 M_entries[183][3] +/M/183/3/0 integer 55 M_entries[183][3][0] +/M/183/3/1 integer 1 M_entries[183][3][1] +/M/184 array_length 4 M_entries[184] +/M/184/0 array_length 2 M_entries[184][0] +/M/184/0/0 integer 42 M_entries[184][0][0] +/M/184/0/1 integer 1 M_entries[184][0][1] +/M/184/1 array_length 2 M_entries[184][1] +/M/184/1/0 integer 43 M_entries[184][1][0] +/M/184/1/1 integer -1 M_entries[184][1][1] +/M/184/2 array_length 2 M_entries[184][2] +/M/184/2/0 integer 58 M_entries[184][2][0] +/M/184/2/1 integer -1 M_entries[184][2][1] +/M/184/3 array_length 2 M_entries[184][3] +/M/184/3/0 integer 59 M_entries[184][3][0] +/M/184/3/1 integer 1 M_entries[184][3][1] +/M/185 array_length 4 M_entries[185] +/M/185/0 array_length 2 M_entries[185][0] +/M/185/0/0 integer 41 M_entries[185][0][0] +/M/185/0/1 integer 1 M_entries[185][0][1] +/M/185/1 array_length 2 M_entries[185][1] +/M/185/1/0 integer 42 M_entries[185][1][0] +/M/185/1/1 integer -1 M_entries[185][1][1] +/M/185/2 array_length 2 M_entries[185][2] +/M/185/2/0 integer 69 M_entries[185][2][0] +/M/185/2/1 integer -1 M_entries[185][2][1] +/M/185/3 array_length 2 M_entries[185][3] +/M/185/3/0 integer 70 M_entries[185][3][0] +/M/185/3/1 integer 1 M_entries[185][3][1] +/M/186 array_length 4 M_entries[186] +/M/186/0 array_length 2 M_entries[186][0] +/M/186/0/0 integer 41 M_entries[186][0][0] +/M/186/0/1 integer 1 M_entries[186][0][1] +/M/186/1 array_length 2 M_entries[186][1] +/M/186/1/0 integer 42 M_entries[186][1][0] +/M/186/1/1 integer -1 M_entries[186][1][1] +/M/186/2 array_length 2 M_entries[186][2] +/M/186/2/0 integer 73 M_entries[186][2][0] +/M/186/2/1 integer -1 M_entries[186][2][1] +/M/186/3 array_length 2 M_entries[186][3] +/M/186/3/0 integer 74 M_entries[186][3][0] +/M/186/3/1 integer 1 M_entries[186][3][1] +/M/187 array_length 4 M_entries[187] +/M/187/0 array_length 2 M_entries[187][0] +/M/187/0/0 integer 41 M_entries[187][0][0] +/M/187/0/1 integer 1 M_entries[187][0][1] +/M/187/1 array_length 2 M_entries[187][1] +/M/187/1/0 integer 43 M_entries[187][1][0] +/M/187/1/1 integer -1 M_entries[187][1][1] +/M/187/2 array_length 2 M_entries[187][2] +/M/187/2/0 integer 77 M_entries[187][2][0] +/M/187/2/1 integer -1 M_entries[187][2][1] +/M/187/3 array_length 2 M_entries[187][3] +/M/187/3/0 integer 79 M_entries[187][3][0] +/M/187/3/1 integer 1 M_entries[187][3][1] +/M/188 array_length 4 M_entries[188] +/M/188/0 array_length 2 M_entries[188][0] +/M/188/0/0 integer 41 M_entries[188][0][0] +/M/188/0/1 integer 1 M_entries[188][0][1] +/M/188/1 array_length 2 M_entries[188][1] +/M/188/1/0 integer 43 M_entries[188][1][0] +/M/188/1/1 integer -1 M_entries[188][1][1] +/M/188/2 array_length 2 M_entries[188][2] +/M/188/2/0 integer 81 M_entries[188][2][0] +/M/188/2/1 integer -1 M_entries[188][2][1] +/M/188/3 array_length 2 M_entries[188][3] +/M/188/3/0 integer 83 M_entries[188][3][0] +/M/188/3/1 integer 1 M_entries[188][3][1] +/M/189 array_length 4 M_entries[189] +/M/189/0 array_length 2 M_entries[189][0] +/M/189/0/0 integer 41 M_entries[189][0][0] +/M/189/0/1 integer 1 M_entries[189][0][1] +/M/189/1 array_length 2 M_entries[189][1] +/M/189/1/0 integer 42 M_entries[189][1][0] +/M/189/1/1 integer -1 M_entries[189][1][1] +/M/189/2 array_length 2 M_entries[189][2] +/M/189/2/0 integer 85 M_entries[189][2][0] +/M/189/2/1 integer -1 M_entries[189][2][1] +/M/189/3 array_length 2 M_entries[189][3] +/M/189/3/0 integer 86 M_entries[189][3][0] +/M/189/3/1 integer 1 M_entries[189][3][1] +/M/190 array_length 4 M_entries[190] +/M/190/0 array_length 2 M_entries[190][0] +/M/190/0/0 integer 41 M_entries[190][0][0] +/M/190/0/1 integer 1 M_entries[190][0][1] +/M/190/1 array_length 2 M_entries[190][1] +/M/190/1/0 integer 42 M_entries[190][1][0] +/M/190/1/1 integer -1 M_entries[190][1][1] +/M/190/2 array_length 2 M_entries[190][2] +/M/190/2/0 integer 89 M_entries[190][2][0] +/M/190/2/1 integer -1 M_entries[190][2][1] +/M/190/3 array_length 2 M_entries[190][3] +/M/190/3/0 integer 90 M_entries[190][3][0] +/M/190/3/1 integer 1 M_entries[190][3][1] +/M/191 array_length 4 M_entries[191] +/M/191/0 array_length 2 M_entries[191][0] +/M/191/0/0 integer 41 M_entries[191][0][0] +/M/191/0/1 integer 1 M_entries[191][0][1] +/M/191/1 array_length 2 M_entries[191][1] +/M/191/1/0 integer 43 M_entries[191][1][0] +/M/191/1/1 integer -1 M_entries[191][1][1] +/M/191/2 array_length 2 M_entries[191][2] +/M/191/2/0 integer 93 M_entries[191][2][0] +/M/191/2/1 integer -1 M_entries[191][2][1] +/M/191/3 array_length 2 M_entries[191][3] +/M/191/3/0 integer 95 M_entries[191][3][0] +/M/191/3/1 integer 1 M_entries[191][3][1] +/M/192 array_length 4 M_entries[192] +/M/192/0 array_length 2 M_entries[192][0] +/M/192/0/0 integer 41 M_entries[192][0][0] +/M/192/0/1 integer 1 M_entries[192][0][1] +/M/192/1 array_length 2 M_entries[192][1] +/M/192/1/0 integer 43 M_entries[192][1][0] +/M/192/1/1 integer -1 M_entries[192][1][1] +/M/192/2 array_length 2 M_entries[192][2] +/M/192/2/0 integer 97 M_entries[192][2][0] +/M/192/2/1 integer -1 M_entries[192][2][1] +/M/192/3 array_length 2 M_entries[192][3] +/M/192/3/0 integer 99 M_entries[192][3][0] +/M/192/3/1 integer 1 M_entries[192][3][1] +/M/193 array_length 4 M_entries[193] +/M/193/0 array_length 2 M_entries[193][0] +/M/193/0/0 integer 42 M_entries[193][0][0] +/M/193/0/1 integer 1 M_entries[193][0][1] +/M/193/1 array_length 2 M_entries[193][1] +/M/193/1/0 integer 43 M_entries[193][1][0] +/M/193/1/1 integer -1 M_entries[193][1][1] +/M/193/2 array_length 2 M_entries[193][2] +/M/193/2/0 integer 100 M_entries[193][2][0] +/M/193/2/1 integer -1 M_entries[193][2][1] +/M/193/3 array_length 2 M_entries[193][3] +/M/193/3/0 integer 103 M_entries[193][3][0] +/M/193/3/1 integer 1 M_entries[193][3][1] +/M/194 array_length 4 M_entries[194] +/M/194/0 array_length 2 M_entries[194][0] +/M/194/0/0 integer 46 M_entries[194][0][0] +/M/194/0/1 integer 1 M_entries[194][0][1] +/M/194/1 array_length 2 M_entries[194][1] +/M/194/1/0 integer 47 M_entries[194][1][0] +/M/194/1/1 integer -1 M_entries[194][1][1] +/M/194/2 array_length 2 M_entries[194][2] +/M/194/2/0 integer 62 M_entries[194][2][0] +/M/194/2/1 integer -1 M_entries[194][2][1] +/M/194/3 array_length 2 M_entries[194][3] +/M/194/3/0 integer 63 M_entries[194][3][0] +/M/194/3/1 integer 1 M_entries[194][3][1] +/M/195 array_length 4 M_entries[195] +/M/195/0 array_length 2 M_entries[195][0] +/M/195/0/0 integer 46 M_entries[195][0][0] +/M/195/0/1 integer 1 M_entries[195][0][1] +/M/195/1 array_length 2 M_entries[195][1] +/M/195/1/0 integer 47 M_entries[195][1][0] +/M/195/1/1 integer -1 M_entries[195][1][1] +/M/195/2 array_length 2 M_entries[195][2] +/M/195/2/0 integer 66 M_entries[195][2][0] +/M/195/2/1 integer -1 M_entries[195][2][1] +/M/195/3 array_length 2 M_entries[195][3] +/M/195/3/0 integer 67 M_entries[195][3][0] +/M/195/3/1 integer 1 M_entries[195][3][1] +/M/196 array_length 4 M_entries[196] +/M/196/0 array_length 2 M_entries[196][0] +/M/196/0/0 integer 45 M_entries[196][0][0] +/M/196/0/1 integer 1 M_entries[196][0][1] +/M/196/1 array_length 2 M_entries[196][1] +/M/196/1/0 integer 47 M_entries[196][1][0] +/M/196/1/1 integer -1 M_entries[196][1][1] +/M/196/2 array_length 2 M_entries[196][2] +/M/196/2/0 integer 69 M_entries[196][2][0] +/M/196/2/1 integer -1 M_entries[196][2][1] +/M/196/3 array_length 2 M_entries[196][3] +/M/196/3/0 integer 71 M_entries[196][3][0] +/M/196/3/1 integer 1 M_entries[196][3][1] +/M/197 array_length 4 M_entries[197] +/M/197/0 array_length 2 M_entries[197][0] +/M/197/0/0 integer 45 M_entries[197][0][0] +/M/197/0/1 integer 1 M_entries[197][0][1] +/M/197/1 array_length 2 M_entries[197][1] +/M/197/1/0 integer 47 M_entries[197][1][0] +/M/197/1/1 integer -1 M_entries[197][1][1] +/M/197/2 array_length 2 M_entries[197][2] +/M/197/2/0 integer 73 M_entries[197][2][0] +/M/197/2/1 integer -1 M_entries[197][2][1] +/M/197/3 array_length 2 M_entries[197][3] +/M/197/3/0 integer 75 M_entries[197][3][0] +/M/197/3/1 integer 1 M_entries[197][3][1] +/M/198 array_length 4 M_entries[198] +/M/198/0 array_length 2 M_entries[198][0] +/M/198/0/0 integer 45 M_entries[198][0][0] +/M/198/0/1 integer 1 M_entries[198][0][1] +/M/198/1 array_length 2 M_entries[198][1] +/M/198/1/0 integer 46 M_entries[198][1][0] +/M/198/1/1 integer -1 M_entries[198][1][1] +/M/198/2 array_length 2 M_entries[198][2] +/M/198/2/0 integer 77 M_entries[198][2][0] +/M/198/2/1 integer -1 M_entries[198][2][1] +/M/198/3 array_length 2 M_entries[198][3] +/M/198/3/0 integer 78 M_entries[198][3][0] +/M/198/3/1 integer 1 M_entries[198][3][1] +/M/199 array_length 4 M_entries[199] +/M/199/0 array_length 2 M_entries[199][0] +/M/199/0/0 integer 45 M_entries[199][0][0] +/M/199/0/1 integer 1 M_entries[199][0][1] +/M/199/1 array_length 2 M_entries[199][1] +/M/199/1/0 integer 46 M_entries[199][1][0] +/M/199/1/1 integer -1 M_entries[199][1][1] +/M/199/2 array_length 2 M_entries[199][2] +/M/199/2/0 integer 81 M_entries[199][2][0] +/M/199/2/1 integer -1 M_entries[199][2][1] +/M/199/3 array_length 2 M_entries[199][3] +/M/199/3/0 integer 82 M_entries[199][3][0] +/M/199/3/1 integer 1 M_entries[199][3][1] +/M/200 array_length 4 M_entries[200] +/M/200/0 array_length 2 M_entries[200][0] +/M/200/0/0 integer 45 M_entries[200][0][0] +/M/200/0/1 integer 1 M_entries[200][0][1] +/M/200/1 array_length 2 M_entries[200][1] +/M/200/1/0 integer 46 M_entries[200][1][0] +/M/200/1/1 integer -1 M_entries[200][1][1] +/M/200/2 array_length 2 M_entries[200][2] +/M/200/2/0 integer 85 M_entries[200][2][0] +/M/200/2/1 integer -1 M_entries[200][2][1] +/M/200/3 array_length 2 M_entries[200][3] +/M/200/3/0 integer 87 M_entries[200][3][0] +/M/200/3/1 integer 1 M_entries[200][3][1] +/M/201 array_length 4 M_entries[201] +/M/201/0 array_length 2 M_entries[201][0] +/M/201/0/0 integer 45 M_entries[201][0][0] +/M/201/0/1 integer 1 M_entries[201][0][1] +/M/201/1 array_length 2 M_entries[201][1] +/M/201/1/0 integer 46 M_entries[201][1][0] +/M/201/1/1 integer -1 M_entries[201][1][1] +/M/201/2 array_length 2 M_entries[201][2] +/M/201/2/0 integer 89 M_entries[201][2][0] +/M/201/2/1 integer -1 M_entries[201][2][1] +/M/201/3 array_length 2 M_entries[201][3] +/M/201/3/0 integer 91 M_entries[201][3][0] +/M/201/3/1 integer 1 M_entries[201][3][1] +/M/202 array_length 4 M_entries[202] +/M/202/0 array_length 2 M_entries[202][0] +/M/202/0/0 integer 45 M_entries[202][0][0] +/M/202/0/1 integer 1 M_entries[202][0][1] +/M/202/1 array_length 2 M_entries[202][1] +/M/202/1/0 integer 47 M_entries[202][1][0] +/M/202/1/1 integer -1 M_entries[202][1][1] +/M/202/2 array_length 2 M_entries[202][2] +/M/202/2/0 integer 93 M_entries[202][2][0] +/M/202/2/1 integer -1 M_entries[202][2][1] +/M/202/3 array_length 2 M_entries[202][3] +/M/202/3/0 integer 94 M_entries[202][3][0] +/M/202/3/1 integer 1 M_entries[202][3][1] +/M/203 array_length 4 M_entries[203] +/M/203/0 array_length 2 M_entries[203][0] +/M/203/0/0 integer 45 M_entries[203][0][0] +/M/203/0/1 integer 1 M_entries[203][0][1] +/M/203/1 array_length 2 M_entries[203][1] +/M/203/1/0 integer 47 M_entries[203][1][0] +/M/203/1/1 integer -1 M_entries[203][1][1] +/M/203/2 array_length 2 M_entries[203][2] +/M/203/2/0 integer 97 M_entries[203][2][0] +/M/203/2/1 integer -1 M_entries[203][2][1] +/M/203/3 array_length 2 M_entries[203][3] +/M/203/3/0 integer 98 M_entries[203][3][0] +/M/203/3/1 integer 1 M_entries[203][3][1] +/M/204 array_length 4 M_entries[204] +/M/204/0 array_length 2 M_entries[204][0] +/M/204/0/0 integer 46 M_entries[204][0][0] +/M/204/0/1 integer 1 M_entries[204][0][1] +/M/204/1 array_length 2 M_entries[204][1] +/M/204/1/0 integer 47 M_entries[204][1][0] +/M/204/1/1 integer -1 M_entries[204][1][1] +/M/204/2 array_length 2 M_entries[204][2] +/M/204/2/0 integer 101 M_entries[204][2][0] +/M/204/2/1 integer -1 M_entries[204][2][1] +/M/204/3 array_length 2 M_entries[204][3] +/M/204/3/0 integer 102 M_entries[204][3][0] +/M/204/3/1 integer 1 M_entries[204][3][1] +/M/205 array_length 4 M_entries[205] +/M/205/0 array_length 2 M_entries[205][0] +/M/205/0/0 integer 50 M_entries[205][0][0] +/M/205/0/1 integer 1 M_entries[205][0][1] +/M/205/1 array_length 2 M_entries[205][1] +/M/205/1/0 integer 51 M_entries[205][1][0] +/M/205/1/1 integer -1 M_entries[205][1][1] +/M/205/2 array_length 2 M_entries[205][2] +/M/205/2/0 integer 62 M_entries[205][2][0] +/M/205/2/1 integer -1 M_entries[205][2][1] +/M/205/3 array_length 2 M_entries[205][3] +/M/205/3/0 integer 63 M_entries[205][3][0] +/M/205/3/1 integer 1 M_entries[205][3][1] +/M/206 array_length 4 M_entries[206] +/M/206/0 array_length 2 M_entries[206][0] +/M/206/0/0 integer 50 M_entries[206][0][0] +/M/206/0/1 integer 1 M_entries[206][0][1] +/M/206/1 array_length 2 M_entries[206][1] +/M/206/1/0 integer 51 M_entries[206][1][0] +/M/206/1/1 integer -1 M_entries[206][1][1] +/M/206/2 array_length 2 M_entries[206][2] +/M/206/2/0 integer 66 M_entries[206][2][0] +/M/206/2/1 integer -1 M_entries[206][2][1] +/M/206/3 array_length 2 M_entries[206][3] +/M/206/3/0 integer 67 M_entries[206][3][0] +/M/206/3/1 integer 1 M_entries[206][3][1] +/M/207 array_length 4 M_entries[207] +/M/207/0 array_length 2 M_entries[207][0] +/M/207/0/0 integer 49 M_entries[207][0][0] +/M/207/0/1 integer 1 M_entries[207][0][1] +/M/207/1 array_length 2 M_entries[207][1] +/M/207/1/0 integer 51 M_entries[207][1][0] +/M/207/1/1 integer -1 M_entries[207][1][1] +/M/207/2 array_length 2 M_entries[207][2] +/M/207/2/0 integer 69 M_entries[207][2][0] +/M/207/2/1 integer -1 M_entries[207][2][1] +/M/207/3 array_length 2 M_entries[207][3] +/M/207/3/0 integer 71 M_entries[207][3][0] +/M/207/3/1 integer 1 M_entries[207][3][1] +/M/208 array_length 4 M_entries[208] +/M/208/0 array_length 2 M_entries[208][0] +/M/208/0/0 integer 49 M_entries[208][0][0] +/M/208/0/1 integer 1 M_entries[208][0][1] +/M/208/1 array_length 2 M_entries[208][1] +/M/208/1/0 integer 51 M_entries[208][1][0] +/M/208/1/1 integer -1 M_entries[208][1][1] +/M/208/2 array_length 2 M_entries[208][2] +/M/208/2/0 integer 73 M_entries[208][2][0] +/M/208/2/1 integer -1 M_entries[208][2][1] +/M/208/3 array_length 2 M_entries[208][3] +/M/208/3/0 integer 75 M_entries[208][3][0] +/M/208/3/1 integer 1 M_entries[208][3][1] +/M/209 array_length 4 M_entries[209] +/M/209/0 array_length 2 M_entries[209][0] +/M/209/0/0 integer 49 M_entries[209][0][0] +/M/209/0/1 integer 1 M_entries[209][0][1] +/M/209/1 array_length 2 M_entries[209][1] +/M/209/1/0 integer 50 M_entries[209][1][0] +/M/209/1/1 integer -1 M_entries[209][1][1] +/M/209/2 array_length 2 M_entries[209][2] +/M/209/2/0 integer 77 M_entries[209][2][0] +/M/209/2/1 integer -1 M_entries[209][2][1] +/M/209/3 array_length 2 M_entries[209][3] +/M/209/3/0 integer 78 M_entries[209][3][0] +/M/209/3/1 integer 1 M_entries[209][3][1] +/M/210 array_length 4 M_entries[210] +/M/210/0 array_length 2 M_entries[210][0] +/M/210/0/0 integer 49 M_entries[210][0][0] +/M/210/0/1 integer 1 M_entries[210][0][1] +/M/210/1 array_length 2 M_entries[210][1] +/M/210/1/0 integer 50 M_entries[210][1][0] +/M/210/1/1 integer -1 M_entries[210][1][1] +/M/210/2 array_length 2 M_entries[210][2] +/M/210/2/0 integer 81 M_entries[210][2][0] +/M/210/2/1 integer -1 M_entries[210][2][1] +/M/210/3 array_length 2 M_entries[210][3] +/M/210/3/0 integer 82 M_entries[210][3][0] +/M/210/3/1 integer 1 M_entries[210][3][1] +/M/211 array_length 4 M_entries[211] +/M/211/0 array_length 2 M_entries[211][0] +/M/211/0/0 integer 49 M_entries[211][0][0] +/M/211/0/1 integer 1 M_entries[211][0][1] +/M/211/1 array_length 2 M_entries[211][1] +/M/211/1/0 integer 50 M_entries[211][1][0] +/M/211/1/1 integer -1 M_entries[211][1][1] +/M/211/2 array_length 2 M_entries[211][2] +/M/211/2/0 integer 85 M_entries[211][2][0] +/M/211/2/1 integer -1 M_entries[211][2][1] +/M/211/3 array_length 2 M_entries[211][3] +/M/211/3/0 integer 87 M_entries[211][3][0] +/M/211/3/1 integer 1 M_entries[211][3][1] +/M/212 array_length 4 M_entries[212] +/M/212/0 array_length 2 M_entries[212][0] +/M/212/0/0 integer 49 M_entries[212][0][0] +/M/212/0/1 integer 1 M_entries[212][0][1] +/M/212/1 array_length 2 M_entries[212][1] +/M/212/1/0 integer 50 M_entries[212][1][0] +/M/212/1/1 integer -1 M_entries[212][1][1] +/M/212/2 array_length 2 M_entries[212][2] +/M/212/2/0 integer 89 M_entries[212][2][0] +/M/212/2/1 integer -1 M_entries[212][2][1] +/M/212/3 array_length 2 M_entries[212][3] +/M/212/3/0 integer 91 M_entries[212][3][0] +/M/212/3/1 integer 1 M_entries[212][3][1] +/M/213 array_length 4 M_entries[213] +/M/213/0 array_length 2 M_entries[213][0] +/M/213/0/0 integer 49 M_entries[213][0][0] +/M/213/0/1 integer 1 M_entries[213][0][1] +/M/213/1 array_length 2 M_entries[213][1] +/M/213/1/0 integer 51 M_entries[213][1][0] +/M/213/1/1 integer -1 M_entries[213][1][1] +/M/213/2 array_length 2 M_entries[213][2] +/M/213/2/0 integer 93 M_entries[213][2][0] +/M/213/2/1 integer -1 M_entries[213][2][1] +/M/213/3 array_length 2 M_entries[213][3] +/M/213/3/0 integer 94 M_entries[213][3][0] +/M/213/3/1 integer 1 M_entries[213][3][1] +/M/214 array_length 4 M_entries[214] +/M/214/0 array_length 2 M_entries[214][0] +/M/214/0/0 integer 49 M_entries[214][0][0] +/M/214/0/1 integer 1 M_entries[214][0][1] +/M/214/1 array_length 2 M_entries[214][1] +/M/214/1/0 integer 51 M_entries[214][1][0] +/M/214/1/1 integer -1 M_entries[214][1][1] +/M/214/2 array_length 2 M_entries[214][2] +/M/214/2/0 integer 97 M_entries[214][2][0] +/M/214/2/1 integer -1 M_entries[214][2][1] +/M/214/3 array_length 2 M_entries[214][3] +/M/214/3/0 integer 98 M_entries[214][3][0] +/M/214/3/1 integer 1 M_entries[214][3][1] +/M/215 array_length 4 M_entries[215] +/M/215/0 array_length 2 M_entries[215][0] +/M/215/0/0 integer 50 M_entries[215][0][0] +/M/215/0/1 integer 1 M_entries[215][0][1] +/M/215/1 array_length 2 M_entries[215][1] +/M/215/1/0 integer 51 M_entries[215][1][0] +/M/215/1/1 integer -1 M_entries[215][1][1] +/M/215/2 array_length 2 M_entries[215][2] +/M/215/2/0 integer 101 M_entries[215][2][0] +/M/215/2/1 integer -1 M_entries[215][2][1] +/M/215/3 array_length 2 M_entries[215][3] +/M/215/3/0 integer 102 M_entries[215][3][0] +/M/215/3/1 integer 1 M_entries[215][3][1] +/M/216 array_length 4 M_entries[216] +/M/216/0 array_length 2 M_entries[216][0] +/M/216/0/0 integer 52 M_entries[216][0][0] +/M/216/0/1 integer 1 M_entries[216][0][1] +/M/216/1 array_length 2 M_entries[216][1] +/M/216/1/0 integer 53 M_entries[216][1][0] +/M/216/1/1 integer -1 M_entries[216][1][1] +/M/216/2 array_length 2 M_entries[216][2] +/M/216/2/0 integer 60 M_entries[216][2][0] +/M/216/2/1 integer -1 M_entries[216][2][1] +/M/216/3 array_length 2 M_entries[216][3] +/M/216/3/0 integer 61 M_entries[216][3][0] +/M/216/3/1 integer 1 M_entries[216][3][1] +/M/217 array_length 4 M_entries[217] +/M/217/0 array_length 2 M_entries[217][0] +/M/217/0/0 integer 52 M_entries[217][0][0] +/M/217/0/1 integer 1 M_entries[217][0][1] +/M/217/1 array_length 2 M_entries[217][1] +/M/217/1/0 integer 53 M_entries[217][1][0] +/M/217/1/1 integer -1 M_entries[217][1][1] +/M/217/2 array_length 2 M_entries[217][2] +/M/217/2/0 integer 64 M_entries[217][2][0] +/M/217/2/1 integer -1 M_entries[217][2][1] +/M/217/3 array_length 2 M_entries[217][3] +/M/217/3/0 integer 65 M_entries[217][3][0] +/M/217/3/1 integer 1 M_entries[217][3][1] +/M/218 array_length 4 M_entries[218] +/M/218/0 array_length 2 M_entries[218][0] +/M/218/0/0 integer 52 M_entries[218][0][0] +/M/218/0/1 integer 1 M_entries[218][0][1] +/M/218/1 array_length 2 M_entries[218][1] +/M/218/1/0 integer 54 M_entries[218][1][0] +/M/218/1/1 integer -1 M_entries[218][1][1] +/M/218/2 array_length 2 M_entries[218][2] +/M/218/2/0 integer 68 M_entries[218][2][0] +/M/218/2/1 integer -1 M_entries[218][2][1] +/M/218/3 array_length 2 M_entries[218][3] +/M/218/3/0 integer 70 M_entries[218][3][0] +/M/218/3/1 integer 1 M_entries[218][3][1] +/M/219 array_length 4 M_entries[219] +/M/219/0 array_length 2 M_entries[219][0] +/M/219/0/0 integer 52 M_entries[219][0][0] +/M/219/0/1 integer 1 M_entries[219][0][1] +/M/219/1 array_length 2 M_entries[219][1] +/M/219/1/0 integer 54 M_entries[219][1][0] +/M/219/1/1 integer -1 M_entries[219][1][1] +/M/219/2 array_length 2 M_entries[219][2] +/M/219/2/0 integer 72 M_entries[219][2][0] +/M/219/2/1 integer -1 M_entries[219][2][1] +/M/219/3 array_length 2 M_entries[219][3] +/M/219/3/0 integer 74 M_entries[219][3][0] +/M/219/3/1 integer 1 M_entries[219][3][1] +/M/220 array_length 4 M_entries[220] +/M/220/0 array_length 2 M_entries[220][0] +/M/220/0/0 integer 52 M_entries[220][0][0] +/M/220/0/1 integer 1 M_entries[220][0][1] +/M/220/1 array_length 2 M_entries[220][1] +/M/220/1/0 integer 55 M_entries[220][1][0] +/M/220/1/1 integer -1 M_entries[220][1][1] +/M/220/2 array_length 2 M_entries[220][2] +/M/220/2/0 integer 76 M_entries[220][2][0] +/M/220/2/1 integer -1 M_entries[220][2][1] +/M/220/3 array_length 2 M_entries[220][3] +/M/220/3/0 integer 79 M_entries[220][3][0] +/M/220/3/1 integer 1 M_entries[220][3][1] +/M/221 array_length 4 M_entries[221] +/M/221/0 array_length 2 M_entries[221][0] +/M/221/0/0 integer 52 M_entries[221][0][0] +/M/221/0/1 integer 1 M_entries[221][0][1] +/M/221/1 array_length 2 M_entries[221][1] +/M/221/1/0 integer 55 M_entries[221][1][0] +/M/221/1/1 integer -1 M_entries[221][1][1] +/M/221/2 array_length 2 M_entries[221][2] +/M/221/2/0 integer 80 M_entries[221][2][0] +/M/221/2/1 integer -1 M_entries[221][2][1] +/M/221/3 array_length 2 M_entries[221][3] +/M/221/3/0 integer 83 M_entries[221][3][0] +/M/221/3/1 integer 1 M_entries[221][3][1] +/M/222 array_length 4 M_entries[222] +/M/222/0 array_length 2 M_entries[222][0] +/M/222/0/0 integer 53 M_entries[222][0][0] +/M/222/0/1 integer 1 M_entries[222][0][1] +/M/222/1 array_length 2 M_entries[222][1] +/M/222/1/0 integer 54 M_entries[222][1][0] +/M/222/1/1 integer -1 M_entries[222][1][1] +/M/222/2 array_length 2 M_entries[222][2] +/M/222/2/0 integer 84 M_entries[222][2][0] +/M/222/2/1 integer -1 M_entries[222][2][1] +/M/222/3 array_length 2 M_entries[222][3] +/M/222/3/0 integer 86 M_entries[222][3][0] +/M/222/3/1 integer 1 M_entries[222][3][1] +/M/223 array_length 4 M_entries[223] +/M/223/0 array_length 2 M_entries[223][0] +/M/223/0/0 integer 53 M_entries[223][0][0] +/M/223/0/1 integer 1 M_entries[223][0][1] +/M/223/1 array_length 2 M_entries[223][1] +/M/223/1/0 integer 54 M_entries[223][1][0] +/M/223/1/1 integer -1 M_entries[223][1][1] +/M/223/2 array_length 2 M_entries[223][2] +/M/223/2/0 integer 88 M_entries[223][2][0] +/M/223/2/1 integer -1 M_entries[223][2][1] +/M/223/3 array_length 2 M_entries[223][3] +/M/223/3/0 integer 90 M_entries[223][3][0] +/M/223/3/1 integer 1 M_entries[223][3][1] +/M/224 array_length 4 M_entries[224] +/M/224/0 array_length 2 M_entries[224][0] +/M/224/0/0 integer 53 M_entries[224][0][0] +/M/224/0/1 integer 1 M_entries[224][0][1] +/M/224/1 array_length 2 M_entries[224][1] +/M/224/1/0 integer 55 M_entries[224][1][0] +/M/224/1/1 integer -1 M_entries[224][1][1] +/M/224/2 array_length 2 M_entries[224][2] +/M/224/2/0 integer 92 M_entries[224][2][0] +/M/224/2/1 integer -1 M_entries[224][2][1] +/M/224/3 array_length 2 M_entries[224][3] +/M/224/3/0 integer 95 M_entries[224][3][0] +/M/224/3/1 integer 1 M_entries[224][3][1] +/M/225 array_length 4 M_entries[225] +/M/225/0 array_length 2 M_entries[225][0] +/M/225/0/0 integer 53 M_entries[225][0][0] +/M/225/0/1 integer 1 M_entries[225][0][1] +/M/225/1 array_length 2 M_entries[225][1] +/M/225/1/0 integer 55 M_entries[225][1][0] +/M/225/1/1 integer -1 M_entries[225][1][1] +/M/225/2 array_length 2 M_entries[225][2] +/M/225/2/0 integer 96 M_entries[225][2][0] +/M/225/2/1 integer -1 M_entries[225][2][1] +/M/225/3 array_length 2 M_entries[225][3] +/M/225/3/0 integer 99 M_entries[225][3][0] +/M/225/3/1 integer 1 M_entries[225][3][1] +/M/226 array_length 4 M_entries[226] +/M/226/0 array_length 2 M_entries[226][0] +/M/226/0/0 integer 54 M_entries[226][0][0] +/M/226/0/1 integer 1 M_entries[226][0][1] +/M/226/1 array_length 2 M_entries[226][1] +/M/226/1/0 integer 55 M_entries[226][1][0] +/M/226/1/1 integer -1 M_entries[226][1][1] +/M/226/2 array_length 2 M_entries[226][2] +/M/226/2/0 integer 100 M_entries[226][2][0] +/M/226/2/1 integer -1 M_entries[226][2][1] +/M/226/3 array_length 2 M_entries[226][3] +/M/226/3/0 integer 103 M_entries[226][3][0] +/M/226/3/1 integer 1 M_entries[226][3][1] +/M/227 array_length 4 M_entries[227] +/M/227/0 array_length 2 M_entries[227][0] +/M/227/0/0 integer 56 M_entries[227][0][0] +/M/227/0/1 integer 1 M_entries[227][0][1] +/M/227/1 array_length 2 M_entries[227][1] +/M/227/1/0 integer 57 M_entries[227][1][0] +/M/227/1/1 integer -1 M_entries[227][1][1] +/M/227/2 array_length 2 M_entries[227][2] +/M/227/2/0 integer 60 M_entries[227][2][0] +/M/227/2/1 integer -1 M_entries[227][2][1] +/M/227/3 array_length 2 M_entries[227][3] +/M/227/3/0 integer 61 M_entries[227][3][0] +/M/227/3/1 integer 1 M_entries[227][3][1] +/M/228 array_length 4 M_entries[228] +/M/228/0 array_length 2 M_entries[228][0] +/M/228/0/0 integer 56 M_entries[228][0][0] +/M/228/0/1 integer 1 M_entries[228][0][1] +/M/228/1 array_length 2 M_entries[228][1] +/M/228/1/0 integer 57 M_entries[228][1][0] +/M/228/1/1 integer -1 M_entries[228][1][1] +/M/228/2 array_length 2 M_entries[228][2] +/M/228/2/0 integer 64 M_entries[228][2][0] +/M/228/2/1 integer -1 M_entries[228][2][1] +/M/228/3 array_length 2 M_entries[228][3] +/M/228/3/0 integer 65 M_entries[228][3][0] +/M/228/3/1 integer 1 M_entries[228][3][1] +/M/229 array_length 4 M_entries[229] +/M/229/0 array_length 2 M_entries[229][0] +/M/229/0/0 integer 56 M_entries[229][0][0] +/M/229/0/1 integer 1 M_entries[229][0][1] +/M/229/1 array_length 2 M_entries[229][1] +/M/229/1/0 integer 58 M_entries[229][1][0] +/M/229/1/1 integer -1 M_entries[229][1][1] +/M/229/2 array_length 2 M_entries[229][2] +/M/229/2/0 integer 68 M_entries[229][2][0] +/M/229/2/1 integer -1 M_entries[229][2][1] +/M/229/3 array_length 2 M_entries[229][3] +/M/229/3/0 integer 70 M_entries[229][3][0] +/M/229/3/1 integer 1 M_entries[229][3][1] +/M/230 array_length 4 M_entries[230] +/M/230/0 array_length 2 M_entries[230][0] +/M/230/0/0 integer 56 M_entries[230][0][0] +/M/230/0/1 integer 1 M_entries[230][0][1] +/M/230/1 array_length 2 M_entries[230][1] +/M/230/1/0 integer 58 M_entries[230][1][0] +/M/230/1/1 integer -1 M_entries[230][1][1] +/M/230/2 array_length 2 M_entries[230][2] +/M/230/2/0 integer 72 M_entries[230][2][0] +/M/230/2/1 integer -1 M_entries[230][2][1] +/M/230/3 array_length 2 M_entries[230][3] +/M/230/3/0 integer 74 M_entries[230][3][0] +/M/230/3/1 integer 1 M_entries[230][3][1] +/M/231 array_length 4 M_entries[231] +/M/231/0 array_length 2 M_entries[231][0] +/M/231/0/0 integer 56 M_entries[231][0][0] +/M/231/0/1 integer 1 M_entries[231][0][1] +/M/231/1 array_length 2 M_entries[231][1] +/M/231/1/0 integer 59 M_entries[231][1][0] +/M/231/1/1 integer -1 M_entries[231][1][1] +/M/231/2 array_length 2 M_entries[231][2] +/M/231/2/0 integer 76 M_entries[231][2][0] +/M/231/2/1 integer -1 M_entries[231][2][1] +/M/231/3 array_length 2 M_entries[231][3] +/M/231/3/0 integer 79 M_entries[231][3][0] +/M/231/3/1 integer 1 M_entries[231][3][1] +/M/232 array_length 4 M_entries[232] +/M/232/0 array_length 2 M_entries[232][0] +/M/232/0/0 integer 56 M_entries[232][0][0] +/M/232/0/1 integer 1 M_entries[232][0][1] +/M/232/1 array_length 2 M_entries[232][1] +/M/232/1/0 integer 59 M_entries[232][1][0] +/M/232/1/1 integer -1 M_entries[232][1][1] +/M/232/2 array_length 2 M_entries[232][2] +/M/232/2/0 integer 80 M_entries[232][2][0] +/M/232/2/1 integer -1 M_entries[232][2][1] +/M/232/3 array_length 2 M_entries[232][3] +/M/232/3/0 integer 83 M_entries[232][3][0] +/M/232/3/1 integer 1 M_entries[232][3][1] +/M/233 array_length 4 M_entries[233] +/M/233/0 array_length 2 M_entries[233][0] +/M/233/0/0 integer 57 M_entries[233][0][0] +/M/233/0/1 integer 1 M_entries[233][0][1] +/M/233/1 array_length 2 M_entries[233][1] +/M/233/1/0 integer 58 M_entries[233][1][0] +/M/233/1/1 integer -1 M_entries[233][1][1] +/M/233/2 array_length 2 M_entries[233][2] +/M/233/2/0 integer 84 M_entries[233][2][0] +/M/233/2/1 integer -1 M_entries[233][2][1] +/M/233/3 array_length 2 M_entries[233][3] +/M/233/3/0 integer 86 M_entries[233][3][0] +/M/233/3/1 integer 1 M_entries[233][3][1] +/M/234 array_length 4 M_entries[234] +/M/234/0 array_length 2 M_entries[234][0] +/M/234/0/0 integer 57 M_entries[234][0][0] +/M/234/0/1 integer 1 M_entries[234][0][1] +/M/234/1 array_length 2 M_entries[234][1] +/M/234/1/0 integer 58 M_entries[234][1][0] +/M/234/1/1 integer -1 M_entries[234][1][1] +/M/234/2 array_length 2 M_entries[234][2] +/M/234/2/0 integer 88 M_entries[234][2][0] +/M/234/2/1 integer -1 M_entries[234][2][1] +/M/234/3 array_length 2 M_entries[234][3] +/M/234/3/0 integer 90 M_entries[234][3][0] +/M/234/3/1 integer 1 M_entries[234][3][1] +/M/235 array_length 4 M_entries[235] +/M/235/0 array_length 2 M_entries[235][0] +/M/235/0/0 integer 57 M_entries[235][0][0] +/M/235/0/1 integer 1 M_entries[235][0][1] +/M/235/1 array_length 2 M_entries[235][1] +/M/235/1/0 integer 59 M_entries[235][1][0] +/M/235/1/1 integer -1 M_entries[235][1][1] +/M/235/2 array_length 2 M_entries[235][2] +/M/235/2/0 integer 92 M_entries[235][2][0] +/M/235/2/1 integer -1 M_entries[235][2][1] +/M/235/3 array_length 2 M_entries[235][3] +/M/235/3/0 integer 95 M_entries[235][3][0] +/M/235/3/1 integer 1 M_entries[235][3][1] +/M/236 array_length 4 M_entries[236] +/M/236/0 array_length 2 M_entries[236][0] +/M/236/0/0 integer 57 M_entries[236][0][0] +/M/236/0/1 integer 1 M_entries[236][0][1] +/M/236/1 array_length 2 M_entries[236][1] +/M/236/1/0 integer 59 M_entries[236][1][0] +/M/236/1/1 integer -1 M_entries[236][1][1] +/M/236/2 array_length 2 M_entries[236][2] +/M/236/2/0 integer 96 M_entries[236][2][0] +/M/236/2/1 integer -1 M_entries[236][2][1] +/M/236/3 array_length 2 M_entries[236][3] +/M/236/3/0 integer 99 M_entries[236][3][0] +/M/236/3/1 integer 1 M_entries[236][3][1] +/M/237 array_length 4 M_entries[237] +/M/237/0 array_length 2 M_entries[237][0] +/M/237/0/0 integer 58 M_entries[237][0][0] +/M/237/0/1 integer 1 M_entries[237][0][1] +/M/237/1 array_length 2 M_entries[237][1] +/M/237/1/0 integer 59 M_entries[237][1][0] +/M/237/1/1 integer -1 M_entries[237][1][1] +/M/237/2 array_length 2 M_entries[237][2] +/M/237/2/0 integer 100 M_entries[237][2][0] +/M/237/2/1 integer -1 M_entries[237][2][1] +/M/237/3 array_length 2 M_entries[237][3] +/M/237/3/0 integer 103 M_entries[237][3][0] +/M/237/3/1 integer 1 M_entries[237][3][1] +/M/238 array_length 4 M_entries[238] +/M/238/0 array_length 2 M_entries[238][0] +/M/238/0/0 integer 60 M_entries[238][0][0] +/M/238/0/1 integer 1 M_entries[238][0][1] +/M/238/1 array_length 2 M_entries[238][1] +/M/238/1/0 integer 63 M_entries[238][1][0] +/M/238/1/1 integer -1 M_entries[238][1][1] +/M/238/2 array_length 2 M_entries[238][2] +/M/238/2/0 integer 68 M_entries[238][2][0] +/M/238/2/1 integer -1 M_entries[238][2][1] +/M/238/3 array_length 2 M_entries[238][3] +/M/238/3/0 integer 71 M_entries[238][3][0] +/M/238/3/1 integer 1 M_entries[238][3][1] +/M/239 array_length 4 M_entries[239] +/M/239/0 array_length 2 M_entries[239][0] +/M/239/0/0 integer 60 M_entries[239][0][0] +/M/239/0/1 integer 1 M_entries[239][0][1] +/M/239/1 array_length 2 M_entries[239][1] +/M/239/1/0 integer 63 M_entries[239][1][0] +/M/239/1/1 integer -1 M_entries[239][1][1] +/M/239/2 array_length 2 M_entries[239][2] +/M/239/2/0 integer 72 M_entries[239][2][0] +/M/239/2/1 integer -1 M_entries[239][2][1] +/M/239/3 array_length 2 M_entries[239][3] +/M/239/3/0 integer 75 M_entries[239][3][0] +/M/239/3/1 integer 1 M_entries[239][3][1] +/M/240 array_length 4 M_entries[240] +/M/240/0 array_length 2 M_entries[240][0] +/M/240/0/0 integer 60 M_entries[240][0][0] +/M/240/0/1 integer 1 M_entries[240][0][1] +/M/240/1 array_length 2 M_entries[240][1] +/M/240/1/0 integer 62 M_entries[240][1][0] +/M/240/1/1 integer -1 M_entries[240][1][1] +/M/240/2 array_length 2 M_entries[240][2] +/M/240/2/0 integer 76 M_entries[240][2][0] +/M/240/2/1 integer -1 M_entries[240][2][1] +/M/240/3 array_length 2 M_entries[240][3] +/M/240/3/0 integer 78 M_entries[240][3][0] +/M/240/3/1 integer 1 M_entries[240][3][1] +/M/241 array_length 4 M_entries[241] +/M/241/0 array_length 2 M_entries[241][0] +/M/241/0/0 integer 60 M_entries[241][0][0] +/M/241/0/1 integer 1 M_entries[241][0][1] +/M/241/1 array_length 2 M_entries[241][1] +/M/241/1/0 integer 62 M_entries[241][1][0] +/M/241/1/1 integer -1 M_entries[241][1][1] +/M/241/2 array_length 2 M_entries[241][2] +/M/241/2/0 integer 80 M_entries[241][2][0] +/M/241/2/1 integer -1 M_entries[241][2][1] +/M/241/3 array_length 2 M_entries[241][3] +/M/241/3/0 integer 82 M_entries[241][3][0] +/M/241/3/1 integer 1 M_entries[241][3][1] +/M/242 array_length 4 M_entries[242] +/M/242/0 array_length 2 M_entries[242][0] +/M/242/0/0 integer 61 M_entries[242][0][0] +/M/242/0/1 integer 1 M_entries[242][0][1] +/M/242/1 array_length 2 M_entries[242][1] +/M/242/1/0 integer 62 M_entries[242][1][0] +/M/242/1/1 integer -1 M_entries[242][1][1] +/M/242/2 array_length 2 M_entries[242][2] +/M/242/2/0 integer 84 M_entries[242][2][0] +/M/242/2/1 integer -1 M_entries[242][2][1] +/M/242/3 array_length 2 M_entries[242][3] +/M/242/3/0 integer 87 M_entries[242][3][0] +/M/242/3/1 integer 1 M_entries[242][3][1] +/M/243 array_length 4 M_entries[243] +/M/243/0 array_length 2 M_entries[243][0] +/M/243/0/0 integer 61 M_entries[243][0][0] +/M/243/0/1 integer 1 M_entries[243][0][1] +/M/243/1 array_length 2 M_entries[243][1] +/M/243/1/0 integer 62 M_entries[243][1][0] +/M/243/1/1 integer -1 M_entries[243][1][1] +/M/243/2 array_length 2 M_entries[243][2] +/M/243/2/0 integer 88 M_entries[243][2][0] +/M/243/2/1 integer -1 M_entries[243][2][1] +/M/243/3 array_length 2 M_entries[243][3] +/M/243/3/0 integer 91 M_entries[243][3][0] +/M/243/3/1 integer 1 M_entries[243][3][1] +/M/244 array_length 4 M_entries[244] +/M/244/0 array_length 2 M_entries[244][0] +/M/244/0/0 integer 61 M_entries[244][0][0] +/M/244/0/1 integer 1 M_entries[244][0][1] +/M/244/1 array_length 2 M_entries[244][1] +/M/244/1/0 integer 63 M_entries[244][1][0] +/M/244/1/1 integer -1 M_entries[244][1][1] +/M/244/2 array_length 2 M_entries[244][2] +/M/244/2/0 integer 92 M_entries[244][2][0] +/M/244/2/1 integer -1 M_entries[244][2][1] +/M/244/3 array_length 2 M_entries[244][3] +/M/244/3/0 integer 94 M_entries[244][3][0] +/M/244/3/1 integer 1 M_entries[244][3][1] +/M/245 array_length 4 M_entries[245] +/M/245/0 array_length 2 M_entries[245][0] +/M/245/0/0 integer 61 M_entries[245][0][0] +/M/245/0/1 integer 1 M_entries[245][0][1] +/M/245/1 array_length 2 M_entries[245][1] +/M/245/1/0 integer 63 M_entries[245][1][0] +/M/245/1/1 integer -1 M_entries[245][1][1] +/M/245/2 array_length 2 M_entries[245][2] +/M/245/2/0 integer 96 M_entries[245][2][0] +/M/245/2/1 integer -1 M_entries[245][2][1] +/M/245/3 array_length 2 M_entries[245][3] +/M/245/3/0 integer 98 M_entries[245][3][0] +/M/245/3/1 integer 1 M_entries[245][3][1] +/M/246 array_length 4 M_entries[246] +/M/246/0 array_length 2 M_entries[246][0] +/M/246/0/0 integer 62 M_entries[246][0][0] +/M/246/0/1 integer 1 M_entries[246][0][1] +/M/246/1 array_length 2 M_entries[246][1] +/M/246/1/0 integer 63 M_entries[246][1][0] +/M/246/1/1 integer -1 M_entries[246][1][1] +/M/246/2 array_length 2 M_entries[246][2] +/M/246/2/0 integer 101 M_entries[246][2][0] +/M/246/2/1 integer -1 M_entries[246][2][1] +/M/246/3 array_length 2 M_entries[246][3] +/M/246/3/0 integer 102 M_entries[246][3][0] +/M/246/3/1 integer 1 M_entries[246][3][1] +/M/247 array_length 4 M_entries[247] +/M/247/0 array_length 2 M_entries[247][0] +/M/247/0/0 integer 64 M_entries[247][0][0] +/M/247/0/1 integer 1 M_entries[247][0][1] +/M/247/1 array_length 2 M_entries[247][1] +/M/247/1/0 integer 67 M_entries[247][1][0] +/M/247/1/1 integer -1 M_entries[247][1][1] +/M/247/2 array_length 2 M_entries[247][2] +/M/247/2/0 integer 68 M_entries[247][2][0] +/M/247/2/1 integer -1 M_entries[247][2][1] +/M/247/3 array_length 2 M_entries[247][3] +/M/247/3/0 integer 71 M_entries[247][3][0] +/M/247/3/1 integer 1 M_entries[247][3][1] +/M/248 array_length 4 M_entries[248] +/M/248/0 array_length 2 M_entries[248][0] +/M/248/0/0 integer 64 M_entries[248][0][0] +/M/248/0/1 integer 1 M_entries[248][0][1] +/M/248/1 array_length 2 M_entries[248][1] +/M/248/1/0 integer 67 M_entries[248][1][0] +/M/248/1/1 integer -1 M_entries[248][1][1] +/M/248/2 array_length 2 M_entries[248][2] +/M/248/2/0 integer 72 M_entries[248][2][0] +/M/248/2/1 integer -1 M_entries[248][2][1] +/M/248/3 array_length 2 M_entries[248][3] +/M/248/3/0 integer 75 M_entries[248][3][0] +/M/248/3/1 integer 1 M_entries[248][3][1] +/M/249 array_length 4 M_entries[249] +/M/249/0 array_length 2 M_entries[249][0] +/M/249/0/0 integer 64 M_entries[249][0][0] +/M/249/0/1 integer 1 M_entries[249][0][1] +/M/249/1 array_length 2 M_entries[249][1] +/M/249/1/0 integer 66 M_entries[249][1][0] +/M/249/1/1 integer -1 M_entries[249][1][1] +/M/249/2 array_length 2 M_entries[249][2] +/M/249/2/0 integer 76 M_entries[249][2][0] +/M/249/2/1 integer -1 M_entries[249][2][1] +/M/249/3 array_length 2 M_entries[249][3] +/M/249/3/0 integer 78 M_entries[249][3][0] +/M/249/3/1 integer 1 M_entries[249][3][1] +/M/250 array_length 4 M_entries[250] +/M/250/0 array_length 2 M_entries[250][0] +/M/250/0/0 integer 64 M_entries[250][0][0] +/M/250/0/1 integer 1 M_entries[250][0][1] +/M/250/1 array_length 2 M_entries[250][1] +/M/250/1/0 integer 66 M_entries[250][1][0] +/M/250/1/1 integer -1 M_entries[250][1][1] +/M/250/2 array_length 2 M_entries[250][2] +/M/250/2/0 integer 80 M_entries[250][2][0] +/M/250/2/1 integer -1 M_entries[250][2][1] +/M/250/3 array_length 2 M_entries[250][3] +/M/250/3/0 integer 82 M_entries[250][3][0] +/M/250/3/1 integer 1 M_entries[250][3][1] +/M/251 array_length 4 M_entries[251] +/M/251/0 array_length 2 M_entries[251][0] +/M/251/0/0 integer 65 M_entries[251][0][0] +/M/251/0/1 integer 1 M_entries[251][0][1] +/M/251/1 array_length 2 M_entries[251][1] +/M/251/1/0 integer 66 M_entries[251][1][0] +/M/251/1/1 integer -1 M_entries[251][1][1] +/M/251/2 array_length 2 M_entries[251][2] +/M/251/2/0 integer 84 M_entries[251][2][0] +/M/251/2/1 integer -1 M_entries[251][2][1] +/M/251/3 array_length 2 M_entries[251][3] +/M/251/3/0 integer 87 M_entries[251][3][0] +/M/251/3/1 integer 1 M_entries[251][3][1] +/M/252 array_length 4 M_entries[252] +/M/252/0 array_length 2 M_entries[252][0] +/M/252/0/0 integer 65 M_entries[252][0][0] +/M/252/0/1 integer 1 M_entries[252][0][1] +/M/252/1 array_length 2 M_entries[252][1] +/M/252/1/0 integer 66 M_entries[252][1][0] +/M/252/1/1 integer -1 M_entries[252][1][1] +/M/252/2 array_length 2 M_entries[252][2] +/M/252/2/0 integer 88 M_entries[252][2][0] +/M/252/2/1 integer -1 M_entries[252][2][1] +/M/252/3 array_length 2 M_entries[252][3] +/M/252/3/0 integer 91 M_entries[252][3][0] +/M/252/3/1 integer 1 M_entries[252][3][1] +/M/253 array_length 4 M_entries[253] +/M/253/0 array_length 2 M_entries[253][0] +/M/253/0/0 integer 65 M_entries[253][0][0] +/M/253/0/1 integer 1 M_entries[253][0][1] +/M/253/1 array_length 2 M_entries[253][1] +/M/253/1/0 integer 67 M_entries[253][1][0] +/M/253/1/1 integer -1 M_entries[253][1][1] +/M/253/2 array_length 2 M_entries[253][2] +/M/253/2/0 integer 92 M_entries[253][2][0] +/M/253/2/1 integer -1 M_entries[253][2][1] +/M/253/3 array_length 2 M_entries[253][3] +/M/253/3/0 integer 94 M_entries[253][3][0] +/M/253/3/1 integer 1 M_entries[253][3][1] +/M/254 array_length 4 M_entries[254] +/M/254/0 array_length 2 M_entries[254][0] +/M/254/0/0 integer 65 M_entries[254][0][0] +/M/254/0/1 integer 1 M_entries[254][0][1] +/M/254/1 array_length 2 M_entries[254][1] +/M/254/1/0 integer 67 M_entries[254][1][0] +/M/254/1/1 integer -1 M_entries[254][1][1] +/M/254/2 array_length 2 M_entries[254][2] +/M/254/2/0 integer 96 M_entries[254][2][0] +/M/254/2/1 integer -1 M_entries[254][2][1] +/M/254/3 array_length 2 M_entries[254][3] +/M/254/3/0 integer 98 M_entries[254][3][0] +/M/254/3/1 integer 1 M_entries[254][3][1] +/M/255 array_length 4 M_entries[255] +/M/255/0 array_length 2 M_entries[255][0] +/M/255/0/0 integer 66 M_entries[255][0][0] +/M/255/0/1 integer 1 M_entries[255][0][1] +/M/255/1 array_length 2 M_entries[255][1] +/M/255/1/0 integer 67 M_entries[255][1][0] +/M/255/1/1 integer -1 M_entries[255][1][1] +/M/255/2 array_length 2 M_entries[255][2] +/M/255/2/0 integer 101 M_entries[255][2][0] +/M/255/2/1 integer -1 M_entries[255][2][1] +/M/255/3 array_length 2 M_entries[255][3] +/M/255/3/0 integer 102 M_entries[255][3][0] +/M/255/3/1 integer 1 M_entries[255][3][1] +/M/256 array_length 4 M_entries[256] +/M/256/0 array_length 2 M_entries[256][0] +/M/256/0/0 integer 68 M_entries[256][0][0] +/M/256/0/1 integer 1 M_entries[256][0][1] +/M/256/1 array_length 2 M_entries[256][1] +/M/256/1/0 integer 69 M_entries[256][1][0] +/M/256/1/1 integer -1 M_entries[256][1][1] +/M/256/2 array_length 2 M_entries[256][2] +/M/256/2/0 integer 76 M_entries[256][2][0] +/M/256/2/1 integer -1 M_entries[256][2][1] +/M/256/3 array_length 2 M_entries[256][3] +/M/256/3/0 integer 77 M_entries[256][3][0] +/M/256/3/1 integer 1 M_entries[256][3][1] +/M/257 array_length 4 M_entries[257] +/M/257/0 array_length 2 M_entries[257][0] +/M/257/0/0 integer 68 M_entries[257][0][0] +/M/257/0/1 integer 1 M_entries[257][0][1] +/M/257/1 array_length 2 M_entries[257][1] +/M/257/1/0 integer 69 M_entries[257][1][0] +/M/257/1/1 integer -1 M_entries[257][1][1] +/M/257/2 array_length 2 M_entries[257][2] +/M/257/2/0 integer 80 M_entries[257][2][0] +/M/257/2/1 integer -1 M_entries[257][2][1] +/M/257/3 array_length 2 M_entries[257][3] +/M/257/3/0 integer 81 M_entries[257][3][0] +/M/257/3/1 integer 1 M_entries[257][3][1] +/M/258 array_length 4 M_entries[258] +/M/258/0 array_length 2 M_entries[258][0] +/M/258/0/0 integer 69 M_entries[258][0][0] +/M/258/0/1 integer 1 M_entries[258][0][1] +/M/258/1 array_length 2 M_entries[258][1] +/M/258/1/0 integer 70 M_entries[258][1][0] +/M/258/1/1 integer -1 M_entries[258][1][1] +/M/258/2 array_length 2 M_entries[258][2] +/M/258/2/0 integer 85 M_entries[258][2][0] +/M/258/2/1 integer -1 M_entries[258][2][1] +/M/258/3 array_length 2 M_entries[258][3] +/M/258/3/0 integer 86 M_entries[258][3][0] +/M/258/3/1 integer 1 M_entries[258][3][1] +/M/259 array_length 4 M_entries[259] +/M/259/0 array_length 2 M_entries[259][0] +/M/259/0/0 integer 69 M_entries[259][0][0] +/M/259/0/1 integer 1 M_entries[259][0][1] +/M/259/1 array_length 2 M_entries[259][1] +/M/259/1/0 integer 70 M_entries[259][1][0] +/M/259/1/1 integer -1 M_entries[259][1][1] +/M/259/2 array_length 2 M_entries[259][2] +/M/259/2/0 integer 89 M_entries[259][2][0] +/M/259/2/1 integer -1 M_entries[259][2][1] +/M/259/3 array_length 2 M_entries[259][3] +/M/259/3/0 integer 90 M_entries[259][3][0] +/M/259/3/1 integer 1 M_entries[259][3][1] +/M/260 array_length 4 M_entries[260] +/M/260/0 array_length 2 M_entries[260][0] +/M/260/0/0 integer 69 M_entries[260][0][0] +/M/260/0/1 integer 1 M_entries[260][0][1] +/M/260/1 array_length 2 M_entries[260][1] +/M/260/1/0 integer 71 M_entries[260][1][0] +/M/260/1/1 integer -1 M_entries[260][1][1] +/M/260/2 array_length 2 M_entries[260][2] +/M/260/2/0 integer 93 M_entries[260][2][0] +/M/260/2/1 integer -1 M_entries[260][2][1] +/M/260/3 array_length 2 M_entries[260][3] +/M/260/3/0 integer 94 M_entries[260][3][0] +/M/260/3/1 integer 1 M_entries[260][3][1] +/M/261 array_length 4 M_entries[261] +/M/261/0 array_length 2 M_entries[261][0] +/M/261/0/0 integer 69 M_entries[261][0][0] +/M/261/0/1 integer 1 M_entries[261][0][1] +/M/261/1 array_length 2 M_entries[261][1] +/M/261/1/0 integer 71 M_entries[261][1][0] +/M/261/1/1 integer -1 M_entries[261][1][1] +/M/261/2 array_length 2 M_entries[261][2] +/M/261/2/0 integer 97 M_entries[261][2][0] +/M/261/2/1 integer -1 M_entries[261][2][1] +/M/261/3 array_length 2 M_entries[261][3] +/M/261/3/0 integer 98 M_entries[261][3][0] +/M/261/3/1 integer 1 M_entries[261][3][1] +/M/262 array_length 4 M_entries[262] +/M/262/0 array_length 2 M_entries[262][0] +/M/262/0/0 integer 70 M_entries[262][0][0] +/M/262/0/1 integer 1 M_entries[262][0][1] +/M/262/1 array_length 2 M_entries[262][1] +/M/262/1/0 integer 71 M_entries[262][1][0] +/M/262/1/1 integer -1 M_entries[262][1][1] +/M/262/2 array_length 2 M_entries[262][2] +/M/262/2/0 integer 100 M_entries[262][2][0] +/M/262/2/1 integer -1 M_entries[262][2][1] +/M/262/3 array_length 2 M_entries[262][3] +/M/262/3/0 integer 102 M_entries[262][3][0] +/M/262/3/1 integer 1 M_entries[262][3][1] +/M/263 array_length 4 M_entries[263] +/M/263/0 array_length 2 M_entries[263][0] +/M/263/0/0 integer 72 M_entries[263][0][0] +/M/263/0/1 integer 1 M_entries[263][0][1] +/M/263/1 array_length 2 M_entries[263][1] +/M/263/1/0 integer 73 M_entries[263][1][0] +/M/263/1/1 integer -1 M_entries[263][1][1] +/M/263/2 array_length 2 M_entries[263][2] +/M/263/2/0 integer 76 M_entries[263][2][0] +/M/263/2/1 integer -1 M_entries[263][2][1] +/M/263/3 array_length 2 M_entries[263][3] +/M/263/3/0 integer 77 M_entries[263][3][0] +/M/263/3/1 integer 1 M_entries[263][3][1] +/M/264 array_length 4 M_entries[264] +/M/264/0 array_length 2 M_entries[264][0] +/M/264/0/0 integer 72 M_entries[264][0][0] +/M/264/0/1 integer 1 M_entries[264][0][1] +/M/264/1 array_length 2 M_entries[264][1] +/M/264/1/0 integer 73 M_entries[264][1][0] +/M/264/1/1 integer -1 M_entries[264][1][1] +/M/264/2 array_length 2 M_entries[264][2] +/M/264/2/0 integer 80 M_entries[264][2][0] +/M/264/2/1 integer -1 M_entries[264][2][1] +/M/264/3 array_length 2 M_entries[264][3] +/M/264/3/0 integer 81 M_entries[264][3][0] +/M/264/3/1 integer 1 M_entries[264][3][1] +/M/265 array_length 4 M_entries[265] +/M/265/0 array_length 2 M_entries[265][0] +/M/265/0/0 integer 73 M_entries[265][0][0] +/M/265/0/1 integer 1 M_entries[265][0][1] +/M/265/1 array_length 2 M_entries[265][1] +/M/265/1/0 integer 74 M_entries[265][1][0] +/M/265/1/1 integer -1 M_entries[265][1][1] +/M/265/2 array_length 2 M_entries[265][2] +/M/265/2/0 integer 85 M_entries[265][2][0] +/M/265/2/1 integer -1 M_entries[265][2][1] +/M/265/3 array_length 2 M_entries[265][3] +/M/265/3/0 integer 86 M_entries[265][3][0] +/M/265/3/1 integer 1 M_entries[265][3][1] +/M/266 array_length 4 M_entries[266] +/M/266/0 array_length 2 M_entries[266][0] +/M/266/0/0 integer 73 M_entries[266][0][0] +/M/266/0/1 integer 1 M_entries[266][0][1] +/M/266/1 array_length 2 M_entries[266][1] +/M/266/1/0 integer 74 M_entries[266][1][0] +/M/266/1/1 integer -1 M_entries[266][1][1] +/M/266/2 array_length 2 M_entries[266][2] +/M/266/2/0 integer 89 M_entries[266][2][0] +/M/266/2/1 integer -1 M_entries[266][2][1] +/M/266/3 array_length 2 M_entries[266][3] +/M/266/3/0 integer 90 M_entries[266][3][0] +/M/266/3/1 integer 1 M_entries[266][3][1] +/M/267 array_length 4 M_entries[267] +/M/267/0 array_length 2 M_entries[267][0] +/M/267/0/0 integer 73 M_entries[267][0][0] +/M/267/0/1 integer 1 M_entries[267][0][1] +/M/267/1 array_length 2 M_entries[267][1] +/M/267/1/0 integer 75 M_entries[267][1][0] +/M/267/1/1 integer -1 M_entries[267][1][1] +/M/267/2 array_length 2 M_entries[267][2] +/M/267/2/0 integer 93 M_entries[267][2][0] +/M/267/2/1 integer -1 M_entries[267][2][1] +/M/267/3 array_length 2 M_entries[267][3] +/M/267/3/0 integer 94 M_entries[267][3][0] +/M/267/3/1 integer 1 M_entries[267][3][1] +/M/268 array_length 4 M_entries[268] +/M/268/0 array_length 2 M_entries[268][0] +/M/268/0/0 integer 73 M_entries[268][0][0] +/M/268/0/1 integer 1 M_entries[268][0][1] +/M/268/1 array_length 2 M_entries[268][1] +/M/268/1/0 integer 75 M_entries[268][1][0] +/M/268/1/1 integer -1 M_entries[268][1][1] +/M/268/2 array_length 2 M_entries[268][2] +/M/268/2/0 integer 97 M_entries[268][2][0] +/M/268/2/1 integer -1 M_entries[268][2][1] +/M/268/3 array_length 2 M_entries[268][3] +/M/268/3/0 integer 98 M_entries[268][3][0] +/M/268/3/1 integer 1 M_entries[268][3][1] +/M/269 array_length 4 M_entries[269] +/M/269/0 array_length 2 M_entries[269][0] +/M/269/0/0 integer 74 M_entries[269][0][0] +/M/269/0/1 integer 1 M_entries[269][0][1] +/M/269/1 array_length 2 M_entries[269][1] +/M/269/1/0 integer 75 M_entries[269][1][0] +/M/269/1/1 integer -1 M_entries[269][1][1] +/M/269/2 array_length 2 M_entries[269][2] +/M/269/2/0 integer 100 M_entries[269][2][0] +/M/269/2/1 integer -1 M_entries[269][2][1] +/M/269/3 array_length 2 M_entries[269][3] +/M/269/3/0 integer 102 M_entries[269][3][0] +/M/269/3/1 integer 1 M_entries[269][3][1] +/M/270 array_length 4 M_entries[270] +/M/270/0 array_length 2 M_entries[270][0] +/M/270/0/0 integer 77 M_entries[270][0][0] +/M/270/0/1 integer 1 M_entries[270][0][1] +/M/270/1 array_length 2 M_entries[270][1] +/M/270/1/0 integer 78 M_entries[270][1][0] +/M/270/1/1 integer -1 M_entries[270][1][1] +/M/270/2 array_length 2 M_entries[270][2] +/M/270/2/0 integer 85 M_entries[270][2][0] +/M/270/2/1 integer -1 M_entries[270][2][1] +/M/270/3 array_length 2 M_entries[270][3] +/M/270/3/0 integer 87 M_entries[270][3][0] +/M/270/3/1 integer 1 M_entries[270][3][1] +/M/271 array_length 4 M_entries[271] +/M/271/0 array_length 2 M_entries[271][0] +/M/271/0/0 integer 77 M_entries[271][0][0] +/M/271/0/1 integer 1 M_entries[271][0][1] +/M/271/1 array_length 2 M_entries[271][1] +/M/271/1/0 integer 78 M_entries[271][1][0] +/M/271/1/1 integer -1 M_entries[271][1][1] +/M/271/2 array_length 2 M_entries[271][2] +/M/271/2/0 integer 89 M_entries[271][2][0] +/M/271/2/1 integer -1 M_entries[271][2][1] +/M/271/3 array_length 2 M_entries[271][3] +/M/271/3/0 integer 91 M_entries[271][3][0] +/M/271/3/1 integer 1 M_entries[271][3][1] +/M/272 array_length 4 M_entries[272] +/M/272/0 array_length 2 M_entries[272][0] +/M/272/0/0 integer 77 M_entries[272][0][0] +/M/272/0/1 integer 1 M_entries[272][0][1] +/M/272/1 array_length 2 M_entries[272][1] +/M/272/1/0 integer 79 M_entries[272][1][0] +/M/272/1/1 integer -1 M_entries[272][1][1] +/M/272/2 array_length 2 M_entries[272][2] +/M/272/2/0 integer 93 M_entries[272][2][0] +/M/272/2/1 integer -1 M_entries[272][2][1] +/M/272/3 array_length 2 M_entries[272][3] +/M/272/3/0 integer 95 M_entries[272][3][0] +/M/272/3/1 integer 1 M_entries[272][3][1] +/M/273 array_length 4 M_entries[273] +/M/273/0 array_length 2 M_entries[273][0] +/M/273/0/0 integer 77 M_entries[273][0][0] +/M/273/0/1 integer 1 M_entries[273][0][1] +/M/273/1 array_length 2 M_entries[273][1] +/M/273/1/0 integer 79 M_entries[273][1][0] +/M/273/1/1 integer -1 M_entries[273][1][1] +/M/273/2 array_length 2 M_entries[273][2] +/M/273/2/0 integer 97 M_entries[273][2][0] +/M/273/2/1 integer -1 M_entries[273][2][1] +/M/273/3 array_length 2 M_entries[273][3] +/M/273/3/0 integer 99 M_entries[273][3][0] +/M/273/3/1 integer 1 M_entries[273][3][1] +/M/274 array_length 4 M_entries[274] +/M/274/0 array_length 2 M_entries[274][0] +/M/274/0/0 integer 78 M_entries[274][0][0] +/M/274/0/1 integer 1 M_entries[274][0][1] +/M/274/1 array_length 2 M_entries[274][1] +/M/274/1/0 integer 79 M_entries[274][1][0] +/M/274/1/1 integer -1 M_entries[274][1][1] +/M/274/2 array_length 2 M_entries[274][2] +/M/274/2/0 integer 101 M_entries[274][2][0] +/M/274/2/1 integer -1 M_entries[274][2][1] +/M/274/3 array_length 2 M_entries[274][3] +/M/274/3/0 integer 103 M_entries[274][3][0] +/M/274/3/1 integer 1 M_entries[274][3][1] +/M/275 array_length 4 M_entries[275] +/M/275/0 array_length 2 M_entries[275][0] +/M/275/0/0 integer 81 M_entries[275][0][0] +/M/275/0/1 integer 1 M_entries[275][0][1] +/M/275/1 array_length 2 M_entries[275][1] +/M/275/1/0 integer 82 M_entries[275][1][0] +/M/275/1/1 integer -1 M_entries[275][1][1] +/M/275/2 array_length 2 M_entries[275][2] +/M/275/2/0 integer 85 M_entries[275][2][0] +/M/275/2/1 integer -1 M_entries[275][2][1] +/M/275/3 array_length 2 M_entries[275][3] +/M/275/3/0 integer 87 M_entries[275][3][0] +/M/275/3/1 integer 1 M_entries[275][3][1] +/M/276 array_length 4 M_entries[276] +/M/276/0 array_length 2 M_entries[276][0] +/M/276/0/0 integer 81 M_entries[276][0][0] +/M/276/0/1 integer 1 M_entries[276][0][1] +/M/276/1 array_length 2 M_entries[276][1] +/M/276/1/0 integer 82 M_entries[276][1][0] +/M/276/1/1 integer -1 M_entries[276][1][1] +/M/276/2 array_length 2 M_entries[276][2] +/M/276/2/0 integer 89 M_entries[276][2][0] +/M/276/2/1 integer -1 M_entries[276][2][1] +/M/276/3 array_length 2 M_entries[276][3] +/M/276/3/0 integer 91 M_entries[276][3][0] +/M/276/3/1 integer 1 M_entries[276][3][1] +/M/277 array_length 4 M_entries[277] +/M/277/0 array_length 2 M_entries[277][0] +/M/277/0/0 integer 81 M_entries[277][0][0] +/M/277/0/1 integer 1 M_entries[277][0][1] +/M/277/1 array_length 2 M_entries[277][1] +/M/277/1/0 integer 83 M_entries[277][1][0] +/M/277/1/1 integer -1 M_entries[277][1][1] +/M/277/2 array_length 2 M_entries[277][2] +/M/277/2/0 integer 93 M_entries[277][2][0] +/M/277/2/1 integer -1 M_entries[277][2][1] +/M/277/3 array_length 2 M_entries[277][3] +/M/277/3/0 integer 95 M_entries[277][3][0] +/M/277/3/1 integer 1 M_entries[277][3][1] +/M/278 array_length 4 M_entries[278] +/M/278/0 array_length 2 M_entries[278][0] +/M/278/0/0 integer 81 M_entries[278][0][0] +/M/278/0/1 integer 1 M_entries[278][0][1] +/M/278/1 array_length 2 M_entries[278][1] +/M/278/1/0 integer 83 M_entries[278][1][0] +/M/278/1/1 integer -1 M_entries[278][1][1] +/M/278/2 array_length 2 M_entries[278][2] +/M/278/2/0 integer 97 M_entries[278][2][0] +/M/278/2/1 integer -1 M_entries[278][2][1] +/M/278/3 array_length 2 M_entries[278][3] +/M/278/3/0 integer 99 M_entries[278][3][0] +/M/278/3/1 integer 1 M_entries[278][3][1] +/M/279 array_length 4 M_entries[279] +/M/279/0 array_length 2 M_entries[279][0] +/M/279/0/0 integer 82 M_entries[279][0][0] +/M/279/0/1 integer 1 M_entries[279][0][1] +/M/279/1 array_length 2 M_entries[279][1] +/M/279/1/0 integer 83 M_entries[279][1][0] +/M/279/1/1 integer -1 M_entries[279][1][1] +/M/279/2 array_length 2 M_entries[279][2] +/M/279/2/0 integer 101 M_entries[279][2][0] +/M/279/2/1 integer -1 M_entries[279][2][1] +/M/279/3 array_length 2 M_entries[279][3] +/M/279/3/0 integer 103 M_entries[279][3][0] +/M/279/3/1 integer 1 M_entries[279][3][1] +/M/280 array_length 4 M_entries[280] +/M/280/0 array_length 2 M_entries[280][0] +/M/280/0/0 integer 84 M_entries[280][0][0] +/M/280/0/1 integer 1 M_entries[280][0][1] +/M/280/1 array_length 2 M_entries[280][1] +/M/280/1/0 integer 85 M_entries[280][1][0] +/M/280/1/1 integer -1 M_entries[280][1][1] +/M/280/2 array_length 2 M_entries[280][2] +/M/280/2/0 integer 92 M_entries[280][2][0] +/M/280/2/1 integer -1 M_entries[280][2][1] +/M/280/3 array_length 2 M_entries[280][3] +/M/280/3/0 integer 93 M_entries[280][3][0] +/M/280/3/1 integer 1 M_entries[280][3][1] +/M/281 array_length 4 M_entries[281] +/M/281/0 array_length 2 M_entries[281][0] +/M/281/0/0 integer 84 M_entries[281][0][0] +/M/281/0/1 integer 1 M_entries[281][0][1] +/M/281/1 array_length 2 M_entries[281][1] +/M/281/1/0 integer 85 M_entries[281][1][0] +/M/281/1/1 integer -1 M_entries[281][1][1] +/M/281/2 array_length 2 M_entries[281][2] +/M/281/2/0 integer 96 M_entries[281][2][0] +/M/281/2/1 integer -1 M_entries[281][2][1] +/M/281/3 array_length 2 M_entries[281][3] +/M/281/3/0 integer 97 M_entries[281][3][0] +/M/281/3/1 integer 1 M_entries[281][3][1] +/M/282 array_length 4 M_entries[282] +/M/282/0 array_length 2 M_entries[282][0] +/M/282/0/0 integer 86 M_entries[282][0][0] +/M/282/0/1 integer 1 M_entries[282][0][1] +/M/282/1 array_length 2 M_entries[282][1] +/M/282/1/0 integer 87 M_entries[282][1][0] +/M/282/1/1 integer -1 M_entries[282][1][1] +/M/282/2 array_length 2 M_entries[282][2] +/M/282/2/0 integer 100 M_entries[282][2][0] +/M/282/2/1 integer -1 M_entries[282][2][1] +/M/282/3 array_length 2 M_entries[282][3] +/M/282/3/0 integer 101 M_entries[282][3][0] +/M/282/3/1 integer 1 M_entries[282][3][1] +/M/283 array_length 4 M_entries[283] +/M/283/0 array_length 2 M_entries[283][0] +/M/283/0/0 integer 88 M_entries[283][0][0] +/M/283/0/1 integer 1 M_entries[283][0][1] +/M/283/1 array_length 2 M_entries[283][1] +/M/283/1/0 integer 89 M_entries[283][1][0] +/M/283/1/1 integer -1 M_entries[283][1][1] +/M/283/2 array_length 2 M_entries[283][2] +/M/283/2/0 integer 92 M_entries[283][2][0] +/M/283/2/1 integer -1 M_entries[283][2][1] +/M/283/3 array_length 2 M_entries[283][3] +/M/283/3/0 integer 93 M_entries[283][3][0] +/M/283/3/1 integer 1 M_entries[283][3][1] +/M/284 array_length 4 M_entries[284] +/M/284/0 array_length 2 M_entries[284][0] +/M/284/0/0 integer 88 M_entries[284][0][0] +/M/284/0/1 integer 1 M_entries[284][0][1] +/M/284/1 array_length 2 M_entries[284][1] +/M/284/1/0 integer 89 M_entries[284][1][0] +/M/284/1/1 integer -1 M_entries[284][1][1] +/M/284/2 array_length 2 M_entries[284][2] +/M/284/2/0 integer 96 M_entries[284][2][0] +/M/284/2/1 integer -1 M_entries[284][2][1] +/M/284/3 array_length 2 M_entries[284][3] +/M/284/3/0 integer 97 M_entries[284][3][0] +/M/284/3/1 integer 1 M_entries[284][3][1] +/M/285 array_length 4 M_entries[285] +/M/285/0 array_length 2 M_entries[285][0] +/M/285/0/0 integer 90 M_entries[285][0][0] +/M/285/0/1 integer 1 M_entries[285][0][1] +/M/285/1 array_length 2 M_entries[285][1] +/M/285/1/0 integer 91 M_entries[285][1][0] +/M/285/1/1 integer -1 M_entries[285][1][1] +/M/285/2 array_length 2 M_entries[285][2] +/M/285/2/0 integer 100 M_entries[285][2][0] +/M/285/2/1 integer -1 M_entries[285][2][1] +/M/285/3 array_length 2 M_entries[285][3] +/M/285/3/0 integer 101 M_entries[285][3][0] +/M/285/3/1 integer 1 M_entries[285][3][1] +/M/286 array_length 4 M_entries[286] +/M/286/0 array_length 2 M_entries[286][0] +/M/286/0/0 integer 94 M_entries[286][0][0] +/M/286/0/1 integer 1 M_entries[286][0][1] +/M/286/1 array_length 2 M_entries[286][1] +/M/286/1/0 integer 95 M_entries[286][1][0] +/M/286/1/1 integer -1 M_entries[286][1][1] +/M/286/2 array_length 2 M_entries[286][2] +/M/286/2/0 integer 102 M_entries[286][2][0] +/M/286/2/1 integer -1 M_entries[286][2][1] +/M/286/3 array_length 2 M_entries[286][3] +/M/286/3/0 integer 103 M_entries[286][3][0] +/M/286/3/1 integer 1 M_entries[286][3][1] +/M/287 array_length 4 M_entries[287] +/M/287/0 array_length 2 M_entries[287][0] +/M/287/0/0 integer 98 M_entries[287][0][0] +/M/287/0/1 integer 1 M_entries[287][0][1] +/M/287/1 array_length 2 M_entries[287][1] +/M/287/1/0 integer 99 M_entries[287][1][0] +/M/287/1/1 integer -1 M_entries[287][1][1] +/M/287/2 array_length 2 M_entries[287][2] +/M/287/2/0 integer 102 M_entries[287][2][0] +/M/287/2/1 integer -1 M_entries[287][2][1] +/M/287/3 array_length 2 M_entries[287][3] +/M/287/3/0 integer 103 M_entries[287][3][0] +/M/287/3/1 integer 1 M_entries[287][3][1] +/P array_length 104 P_entries +/P/0 array_length 1 P_entries[0] +/P/0/0 array_length 2 P_entries[0][0] +/P/0/0/0 integer 0 P_entries[0][0][0] +/P/0/0/1 integer 1 P_entries[0][0][1] +/P/1 array_length 2 P_entries[1] +/P/1/0 array_length 2 P_entries[1][0] +/P/1/0/0 integer 0 P_entries[1][0][0] +/P/1/0/1 integer 1 P_entries[1][0][1] +/P/1/1 array_length 2 P_entries[1][1] +/P/1/1/0 integer 26 P_entries[1][1][0] +/P/1/1/1 integer 1 P_entries[1][1][1] +/P/2 array_length 2 P_entries[2] +/P/2/0 array_length 2 P_entries[2][0] +/P/2/0/0 integer 0 P_entries[2][0][0] +/P/2/0/1 integer 1 P_entries[2][0][1] +/P/2/1 array_length 2 P_entries[2][1] +/P/2/1/0 integer 27 P_entries[2][1][0] +/P/2/1/1 integer 1 P_entries[2][1][1] +/P/3 array_length 2 P_entries[3] +/P/3/0 array_length 2 P_entries[3][0] +/P/3/0/0 integer 0 P_entries[3][0][0] +/P/3/0/1 integer 1 P_entries[3][0][1] +/P/3/1 array_length 2 P_entries[3][1] +/P/3/1/0 integer 28 P_entries[3][1][0] +/P/3/1/1 integer 1 P_entries[3][1][1] +/P/4 array_length 1 P_entries[4] +/P/4/0 array_length 2 P_entries[4][0] +/P/4/0/0 integer 1 P_entries[4][0][0] +/P/4/0/1 integer 1 P_entries[4][0][1] +/P/5 array_length 2 P_entries[5] +/P/5/0 array_length 2 P_entries[5][0] +/P/5/0/0 integer 1 P_entries[5][0][0] +/P/5/0/1 integer 1 P_entries[5][0][1] +/P/5/1 array_length 2 P_entries[5][1] +/P/5/1/0 integer 26 P_entries[5][1][0] +/P/5/1/1 integer 1 P_entries[5][1][1] +/P/6 array_length 2 P_entries[6] +/P/6/0 array_length 2 P_entries[6][0] +/P/6/0/0 integer 1 P_entries[6][0][0] +/P/6/0/1 integer 1 P_entries[6][0][1] +/P/6/1 array_length 2 P_entries[6][1] +/P/6/1/0 integer 29 P_entries[6][1][0] +/P/6/1/1 integer 1 P_entries[6][1][1] +/P/7 array_length 2 P_entries[7] +/P/7/0 array_length 2 P_entries[7][0] +/P/7/0/0 integer 1 P_entries[7][0][0] +/P/7/0/1 integer 1 P_entries[7][0][1] +/P/7/1 array_length 2 P_entries[7][1] +/P/7/1/0 integer 30 P_entries[7][1][0] +/P/7/1/1 integer 1 P_entries[7][1][1] +/P/8 array_length 1 P_entries[8] +/P/8/0 array_length 2 P_entries[8][0] +/P/8/0/0 integer 2 P_entries[8][0][0] +/P/8/0/1 integer 1 P_entries[8][0][1] +/P/9 array_length 2 P_entries[9] +/P/9/0 array_length 2 P_entries[9][0] +/P/9/0/0 integer 2 P_entries[9][0][0] +/P/9/0/1 integer 1 P_entries[9][0][1] +/P/9/1 array_length 2 P_entries[9][1] +/P/9/1/0 integer 26 P_entries[9][1][0] +/P/9/1/1 integer 1 P_entries[9][1][1] +/P/10 array_length 2 P_entries[10] +/P/10/0 array_length 2 P_entries[10][0] +/P/10/0/0 integer 2 P_entries[10][0][0] +/P/10/0/1 integer 1 P_entries[10][0][1] +/P/10/1 array_length 2 P_entries[10][1] +/P/10/1/0 integer 29 P_entries[10][1][0] +/P/10/1/1 integer 1 P_entries[10][1][1] +/P/11 array_length 2 P_entries[11] +/P/11/0 array_length 2 P_entries[11][0] +/P/11/0/0 integer 2 P_entries[11][0][0] +/P/11/0/1 integer 1 P_entries[11][0][1] +/P/11/1 array_length 2 P_entries[11][1] +/P/11/1/0 integer 30 P_entries[11][1][0] +/P/11/1/1 integer 1 P_entries[11][1][1] +/P/12 array_length 1 P_entries[12] +/P/12/0 array_length 2 P_entries[12][0] +/P/12/0/0 integer 3 P_entries[12][0][0] +/P/12/0/1 integer 1 P_entries[12][0][1] +/P/13 array_length 2 P_entries[13] +/P/13/0 array_length 2 P_entries[13][0] +/P/13/0/0 integer 3 P_entries[13][0][0] +/P/13/0/1 integer 1 P_entries[13][0][1] +/P/13/1 array_length 2 P_entries[13][1] +/P/13/1/0 integer 26 P_entries[13][1][0] +/P/13/1/1 integer 1 P_entries[13][1][1] +/P/14 array_length 2 P_entries[14] +/P/14/0 array_length 2 P_entries[14][0] +/P/14/0/0 integer 3 P_entries[14][0][0] +/P/14/0/1 integer 1 P_entries[14][0][1] +/P/14/1 array_length 2 P_entries[14][1] +/P/14/1/0 integer 31 P_entries[14][1][0] +/P/14/1/1 integer 1 P_entries[14][1][1] +/P/15 array_length 2 P_entries[15] +/P/15/0 array_length 2 P_entries[15][0] +/P/15/0/0 integer 3 P_entries[15][0][0] +/P/15/0/1 integer 1 P_entries[15][0][1] +/P/15/1 array_length 2 P_entries[15][1] +/P/15/1/0 integer 32 P_entries[15][1][0] +/P/15/1/1 integer 1 P_entries[15][1][1] +/P/16 array_length 1 P_entries[16] +/P/16/0 array_length 2 P_entries[16][0] +/P/16/0/0 integer 4 P_entries[16][0][0] +/P/16/0/1 integer 1 P_entries[16][0][1] +/P/17 array_length 2 P_entries[17] +/P/17/0 array_length 2 P_entries[17][0] +/P/17/0/0 integer 4 P_entries[17][0][0] +/P/17/0/1 integer 1 P_entries[17][0][1] +/P/17/1 array_length 2 P_entries[17][1] +/P/17/1/0 integer 26 P_entries[17][1][0] +/P/17/1/1 integer 1 P_entries[17][1][1] +/P/18 array_length 2 P_entries[18] +/P/18/0 array_length 2 P_entries[18][0] +/P/18/0/0 integer 4 P_entries[18][0][0] +/P/18/0/1 integer 1 P_entries[18][0][1] +/P/18/1 array_length 2 P_entries[18][1] +/P/18/1/0 integer 31 P_entries[18][1][0] +/P/18/1/1 integer 1 P_entries[18][1][1] +/P/19 array_length 2 P_entries[19] +/P/19/0 array_length 2 P_entries[19][0] +/P/19/0/0 integer 4 P_entries[19][0][0] +/P/19/0/1 integer 1 P_entries[19][0][1] +/P/19/1 array_length 2 P_entries[19][1] +/P/19/1/0 integer 32 P_entries[19][1][0] +/P/19/1/1 integer 1 P_entries[19][1][1] +/P/20 array_length 1 P_entries[20] +/P/20/0 array_length 2 P_entries[20][0] +/P/20/0/0 integer 5 P_entries[20][0][0] +/P/20/0/1 integer 1 P_entries[20][0][1] +/P/21 array_length 2 P_entries[21] +/P/21/0 array_length 2 P_entries[21][0] +/P/21/0/0 integer 5 P_entries[21][0][0] +/P/21/0/1 integer 1 P_entries[21][0][1] +/P/21/1 array_length 2 P_entries[21][1] +/P/21/1/0 integer 27 P_entries[21][1][0] +/P/21/1/1 integer 1 P_entries[21][1][1] +/P/22 array_length 2 P_entries[22] +/P/22/0 array_length 2 P_entries[22][0] +/P/22/0/0 integer 5 P_entries[22][0][0] +/P/22/0/1 integer 1 P_entries[22][0][1] +/P/22/1 array_length 2 P_entries[22][1] +/P/22/1/0 integer 29 P_entries[22][1][0] +/P/22/1/1 integer 1 P_entries[22][1][1] +/P/23 array_length 2 P_entries[23] +/P/23/0 array_length 2 P_entries[23][0] +/P/23/0/0 integer 5 P_entries[23][0][0] +/P/23/0/1 integer 1 P_entries[23][0][1] +/P/23/1 array_length 2 P_entries[23][1] +/P/23/1/0 integer 31 P_entries[23][1][0] +/P/23/1/1 integer 1 P_entries[23][1][1] +/P/24 array_length 1 P_entries[24] +/P/24/0 array_length 2 P_entries[24][0] +/P/24/0/0 integer 6 P_entries[24][0][0] +/P/24/0/1 integer 1 P_entries[24][0][1] +/P/25 array_length 2 P_entries[25] +/P/25/0 array_length 2 P_entries[25][0] +/P/25/0/0 integer 6 P_entries[25][0][0] +/P/25/0/1 integer 1 P_entries[25][0][1] +/P/25/1 array_length 2 P_entries[25][1] +/P/25/1/0 integer 27 P_entries[25][1][0] +/P/25/1/1 integer 1 P_entries[25][1][1] +/P/26 array_length 2 P_entries[26] +/P/26/0 array_length 2 P_entries[26][0] +/P/26/0/0 integer 6 P_entries[26][0][0] +/P/26/0/1 integer 1 P_entries[26][0][1] +/P/26/1 array_length 2 P_entries[26][1] +/P/26/1/0 integer 29 P_entries[26][1][0] +/P/26/1/1 integer 1 P_entries[26][1][1] +/P/27 array_length 2 P_entries[27] +/P/27/0 array_length 2 P_entries[27][0] +/P/27/0/0 integer 6 P_entries[27][0][0] +/P/27/0/1 integer 1 P_entries[27][0][1] +/P/27/1 array_length 2 P_entries[27][1] +/P/27/1/0 integer 31 P_entries[27][1][0] +/P/27/1/1 integer 1 P_entries[27][1][1] +/P/28 array_length 1 P_entries[28] +/P/28/0 array_length 2 P_entries[28][0] +/P/28/0/0 integer 7 P_entries[28][0][0] +/P/28/0/1 integer 1 P_entries[28][0][1] +/P/29 array_length 2 P_entries[29] +/P/29/0 array_length 2 P_entries[29][0] +/P/29/0/0 integer 7 P_entries[29][0][0] +/P/29/0/1 integer 1 P_entries[29][0][1] +/P/29/1 array_length 2 P_entries[29][1] +/P/29/1/0 integer 27 P_entries[29][1][0] +/P/29/1/1 integer 1 P_entries[29][1][1] +/P/30 array_length 2 P_entries[30] +/P/30/0 array_length 2 P_entries[30][0] +/P/30/0/0 integer 7 P_entries[30][0][0] +/P/30/0/1 integer 1 P_entries[30][0][1] +/P/30/1 array_length 2 P_entries[30][1] +/P/30/1/0 integer 30 P_entries[30][1][0] +/P/30/1/1 integer 1 P_entries[30][1][1] +/P/31 array_length 2 P_entries[31] +/P/31/0 array_length 2 P_entries[31][0] +/P/31/0/0 integer 7 P_entries[31][0][0] +/P/31/0/1 integer 1 P_entries[31][0][1] +/P/31/1 array_length 2 P_entries[31][1] +/P/31/1/0 integer 32 P_entries[31][1][0] +/P/31/1/1 integer 1 P_entries[31][1][1] +/P/32 array_length 1 P_entries[32] +/P/32/0 array_length 2 P_entries[32][0] +/P/32/0/0 integer 8 P_entries[32][0][0] +/P/32/0/1 integer 1 P_entries[32][0][1] +/P/33 array_length 2 P_entries[33] +/P/33/0 array_length 2 P_entries[33][0] +/P/33/0/0 integer 8 P_entries[33][0][0] +/P/33/0/1 integer 1 P_entries[33][0][1] +/P/33/1 array_length 2 P_entries[33][1] +/P/33/1/0 integer 27 P_entries[33][1][0] +/P/33/1/1 integer 1 P_entries[33][1][1] +/P/34 array_length 2 P_entries[34] +/P/34/0 array_length 2 P_entries[34][0] +/P/34/0/0 integer 8 P_entries[34][0][0] +/P/34/0/1 integer 1 P_entries[34][0][1] +/P/34/1 array_length 2 P_entries[34][1] +/P/34/1/0 integer 30 P_entries[34][1][0] +/P/34/1/1 integer 1 P_entries[34][1][1] +/P/35 array_length 2 P_entries[35] +/P/35/0 array_length 2 P_entries[35][0] +/P/35/0/0 integer 8 P_entries[35][0][0] +/P/35/0/1 integer 1 P_entries[35][0][1] +/P/35/1 array_length 2 P_entries[35][1] +/P/35/1/0 integer 32 P_entries[35][1][0] +/P/35/1/1 integer 1 P_entries[35][1][1] +/P/36 array_length 1 P_entries[36] +/P/36/0 array_length 2 P_entries[36][0] +/P/36/0/0 integer 9 P_entries[36][0][0] +/P/36/0/1 integer 1 P_entries[36][0][1] +/P/37 array_length 2 P_entries[37] +/P/37/0 array_length 2 P_entries[37][0] +/P/37/0/0 integer 9 P_entries[37][0][0] +/P/37/0/1 integer 1 P_entries[37][0][1] +/P/37/1 array_length 2 P_entries[37][1] +/P/37/1/0 integer 28 P_entries[37][1][0] +/P/37/1/1 integer 1 P_entries[37][1][1] +/P/38 array_length 2 P_entries[38] +/P/38/0 array_length 2 P_entries[38][0] +/P/38/0/0 integer 9 P_entries[38][0][0] +/P/38/0/1 integer 1 P_entries[38][0][1] +/P/38/1 array_length 2 P_entries[38][1] +/P/38/1/0 integer 29 P_entries[38][1][0] +/P/38/1/1 integer 1 P_entries[38][1][1] +/P/39 array_length 2 P_entries[39] +/P/39/0 array_length 2 P_entries[39][0] +/P/39/0/0 integer 9 P_entries[39][0][0] +/P/39/0/1 integer 1 P_entries[39][0][1] +/P/39/1 array_length 2 P_entries[39][1] +/P/39/1/0 integer 32 P_entries[39][1][0] +/P/39/1/1 integer 1 P_entries[39][1][1] +/P/40 array_length 1 P_entries[40] +/P/40/0 array_length 2 P_entries[40][0] +/P/40/0/0 integer 10 P_entries[40][0][0] +/P/40/0/1 integer 1 P_entries[40][0][1] +/P/41 array_length 2 P_entries[41] +/P/41/0 array_length 2 P_entries[41][0] +/P/41/0/0 integer 10 P_entries[41][0][0] +/P/41/0/1 integer 1 P_entries[41][0][1] +/P/41/1 array_length 2 P_entries[41][1] +/P/41/1/0 integer 28 P_entries[41][1][0] +/P/41/1/1 integer 1 P_entries[41][1][1] +/P/42 array_length 2 P_entries[42] +/P/42/0 array_length 2 P_entries[42][0] +/P/42/0/0 integer 10 P_entries[42][0][0] +/P/42/0/1 integer 1 P_entries[42][0][1] +/P/42/1 array_length 2 P_entries[42][1] +/P/42/1/0 integer 29 P_entries[42][1][0] +/P/42/1/1 integer 1 P_entries[42][1][1] +/P/43 array_length 2 P_entries[43] +/P/43/0 array_length 2 P_entries[43][0] +/P/43/0/0 integer 10 P_entries[43][0][0] +/P/43/0/1 integer 1 P_entries[43][0][1] +/P/43/1 array_length 2 P_entries[43][1] +/P/43/1/0 integer 32 P_entries[43][1][0] +/P/43/1/1 integer 1 P_entries[43][1][1] +/P/44 array_length 1 P_entries[44] +/P/44/0 array_length 2 P_entries[44][0] +/P/44/0/0 integer 11 P_entries[44][0][0] +/P/44/0/1 integer 1 P_entries[44][0][1] +/P/45 array_length 2 P_entries[45] +/P/45/0 array_length 2 P_entries[45][0] +/P/45/0/0 integer 11 P_entries[45][0][0] +/P/45/0/1 integer 1 P_entries[45][0][1] +/P/45/1 array_length 2 P_entries[45][1] +/P/45/1/0 integer 28 P_entries[45][1][0] +/P/45/1/1 integer 1 P_entries[45][1][1] +/P/46 array_length 2 P_entries[46] +/P/46/0 array_length 2 P_entries[46][0] +/P/46/0/0 integer 11 P_entries[46][0][0] +/P/46/0/1 integer 1 P_entries[46][0][1] +/P/46/1 array_length 2 P_entries[46][1] +/P/46/1/0 integer 30 P_entries[46][1][0] +/P/46/1/1 integer 1 P_entries[46][1][1] +/P/47 array_length 2 P_entries[47] +/P/47/0 array_length 2 P_entries[47][0] +/P/47/0/0 integer 11 P_entries[47][0][0] +/P/47/0/1 integer 1 P_entries[47][0][1] +/P/47/1 array_length 2 P_entries[47][1] +/P/47/1/0 integer 31 P_entries[47][1][0] +/P/47/1/1 integer 1 P_entries[47][1][1] +/P/48 array_length 1 P_entries[48] +/P/48/0 array_length 2 P_entries[48][0] +/P/48/0/0 integer 12 P_entries[48][0][0] +/P/48/0/1 integer 1 P_entries[48][0][1] +/P/49 array_length 2 P_entries[49] +/P/49/0 array_length 2 P_entries[49][0] +/P/49/0/0 integer 12 P_entries[49][0][0] +/P/49/0/1 integer 1 P_entries[49][0][1] +/P/49/1 array_length 2 P_entries[49][1] +/P/49/1/0 integer 28 P_entries[49][1][0] +/P/49/1/1 integer 1 P_entries[49][1][1] +/P/50 array_length 2 P_entries[50] +/P/50/0 array_length 2 P_entries[50][0] +/P/50/0/0 integer 12 P_entries[50][0][0] +/P/50/0/1 integer 1 P_entries[50][0][1] +/P/50/1 array_length 2 P_entries[50][1] +/P/50/1/0 integer 30 P_entries[50][1][0] +/P/50/1/1 integer 1 P_entries[50][1][1] +/P/51 array_length 2 P_entries[51] +/P/51/0 array_length 2 P_entries[51][0] +/P/51/0/0 integer 12 P_entries[51][0][0] +/P/51/0/1 integer 1 P_entries[51][0][1] +/P/51/1 array_length 2 P_entries[51][1] +/P/51/1/0 integer 31 P_entries[51][1][0] +/P/51/1/1 integer 1 P_entries[51][1][1] +/P/52 array_length 2 P_entries[52] +/P/52/0 array_length 2 P_entries[52][0] +/P/52/0/0 integer 13 P_entries[52][0][0] +/P/52/0/1 integer 1 P_entries[52][0][1] +/P/52/1 array_length 2 P_entries[52][1] +/P/52/1/0 integer 26 P_entries[52][1][0] +/P/52/1/1 integer 1 P_entries[52][1][1] +/P/53 array_length 2 P_entries[53] +/P/53/0 array_length 2 P_entries[53][0] +/P/53/0/0 integer 13 P_entries[53][0][0] +/P/53/0/1 integer 1 P_entries[53][0][1] +/P/53/1 array_length 2 P_entries[53][1] +/P/53/1/0 integer 27 P_entries[53][1][0] +/P/53/1/1 integer 1 P_entries[53][1][1] +/P/54 array_length 2 P_entries[54] +/P/54/0 array_length 2 P_entries[54][0] +/P/54/0/0 integer 13 P_entries[54][0][0] +/P/54/0/1 integer 1 P_entries[54][0][1] +/P/54/1 array_length 2 P_entries[54][1] +/P/54/1/0 integer 29 P_entries[54][1][0] +/P/54/1/1 integer 1 P_entries[54][1][1] +/P/55 array_length 2 P_entries[55] +/P/55/0 array_length 2 P_entries[55][0] +/P/55/0/0 integer 13 P_entries[55][0][0] +/P/55/0/1 integer 1 P_entries[55][0][1] +/P/55/1 array_length 2 P_entries[55][1] +/P/55/1/0 integer 32 P_entries[55][1][0] +/P/55/1/1 integer 1 P_entries[55][1][1] +/P/56 array_length 2 P_entries[56] +/P/56/0 array_length 2 P_entries[56][0] +/P/56/0/0 integer 14 P_entries[56][0][0] +/P/56/0/1 integer 1 P_entries[56][0][1] +/P/56/1 array_length 2 P_entries[56][1] +/P/56/1/0 integer 26 P_entries[56][1][0] +/P/56/1/1 integer 1 P_entries[56][1][1] +/P/57 array_length 2 P_entries[57] +/P/57/0 array_length 2 P_entries[57][0] +/P/57/0/0 integer 14 P_entries[57][0][0] +/P/57/0/1 integer 1 P_entries[57][0][1] +/P/57/1 array_length 2 P_entries[57][1] +/P/57/1/0 integer 27 P_entries[57][1][0] +/P/57/1/1 integer 1 P_entries[57][1][1] +/P/58 array_length 2 P_entries[58] +/P/58/0 array_length 2 P_entries[58][0] +/P/58/0/0 integer 14 P_entries[58][0][0] +/P/58/0/1 integer 1 P_entries[58][0][1] +/P/58/1 array_length 2 P_entries[58][1] +/P/58/1/0 integer 29 P_entries[58][1][0] +/P/58/1/1 integer 1 P_entries[58][1][1] +/P/59 array_length 2 P_entries[59] +/P/59/0 array_length 2 P_entries[59][0] +/P/59/0/0 integer 14 P_entries[59][0][0] +/P/59/0/1 integer 1 P_entries[59][0][1] +/P/59/1 array_length 2 P_entries[59][1] +/P/59/1/0 integer 32 P_entries[59][1][0] +/P/59/1/1 integer 1 P_entries[59][1][1] +/P/60 array_length 2 P_entries[60] +/P/60/0 array_length 2 P_entries[60][0] +/P/60/0/0 integer 15 P_entries[60][0][0] +/P/60/0/1 integer 1 P_entries[60][0][1] +/P/60/1 array_length 2 P_entries[60][1] +/P/60/1/0 integer 26 P_entries[60][1][0] +/P/60/1/1 integer 1 P_entries[60][1][1] +/P/61 array_length 2 P_entries[61] +/P/61/0 array_length 2 P_entries[61][0] +/P/61/0/0 integer 15 P_entries[61][0][0] +/P/61/0/1 integer 1 P_entries[61][0][1] +/P/61/1 array_length 2 P_entries[61][1] +/P/61/1/0 integer 27 P_entries[61][1][0] +/P/61/1/1 integer 1 P_entries[61][1][1] +/P/62 array_length 2 P_entries[62] +/P/62/0 array_length 2 P_entries[62][0] +/P/62/0/0 integer 15 P_entries[62][0][0] +/P/62/0/1 integer 1 P_entries[62][0][1] +/P/62/1 array_length 2 P_entries[62][1] +/P/62/1/0 integer 30 P_entries[62][1][0] +/P/62/1/1 integer 1 P_entries[62][1][1] +/P/63 array_length 2 P_entries[63] +/P/63/0 array_length 2 P_entries[63][0] +/P/63/0/0 integer 15 P_entries[63][0][0] +/P/63/0/1 integer 1 P_entries[63][0][1] +/P/63/1 array_length 2 P_entries[63][1] +/P/63/1/0 integer 31 P_entries[63][1][0] +/P/63/1/1 integer 1 P_entries[63][1][1] +/P/64 array_length 2 P_entries[64] +/P/64/0 array_length 2 P_entries[64][0] +/P/64/0/0 integer 16 P_entries[64][0][0] +/P/64/0/1 integer 1 P_entries[64][0][1] +/P/64/1 array_length 2 P_entries[64][1] +/P/64/1/0 integer 26 P_entries[64][1][0] +/P/64/1/1 integer 1 P_entries[64][1][1] +/P/65 array_length 2 P_entries[65] +/P/65/0 array_length 2 P_entries[65][0] +/P/65/0/0 integer 16 P_entries[65][0][0] +/P/65/0/1 integer 1 P_entries[65][0][1] +/P/65/1 array_length 2 P_entries[65][1] +/P/65/1/0 integer 27 P_entries[65][1][0] +/P/65/1/1 integer 1 P_entries[65][1][1] +/P/66 array_length 2 P_entries[66] +/P/66/0 array_length 2 P_entries[66][0] +/P/66/0/0 integer 16 P_entries[66][0][0] +/P/66/0/1 integer 1 P_entries[66][0][1] +/P/66/1 array_length 2 P_entries[66][1] +/P/66/1/0 integer 30 P_entries[66][1][0] +/P/66/1/1 integer 1 P_entries[66][1][1] +/P/67 array_length 2 P_entries[67] +/P/67/0 array_length 2 P_entries[67][0] +/P/67/0/0 integer 16 P_entries[67][0][0] +/P/67/0/1 integer 1 P_entries[67][0][1] +/P/67/1 array_length 2 P_entries[67][1] +/P/67/1/0 integer 31 P_entries[67][1][0] +/P/67/1/1 integer 1 P_entries[67][1][1] +/P/68 array_length 2 P_entries[68] +/P/68/0 array_length 2 P_entries[68][0] +/P/68/0/0 integer 17 P_entries[68][0][0] +/P/68/0/1 integer 1 P_entries[68][0][1] +/P/68/1 array_length 2 P_entries[68][1] +/P/68/1/0 integer 26 P_entries[68][1][0] +/P/68/1/1 integer 1 P_entries[68][1][1] +/P/69 array_length 2 P_entries[69] +/P/69/0 array_length 2 P_entries[69][0] +/P/69/0/0 integer 17 P_entries[69][0][0] +/P/69/0/1 integer 1 P_entries[69][0][1] +/P/69/1 array_length 2 P_entries[69][1] +/P/69/1/0 integer 28 P_entries[69][1][0] +/P/69/1/1 integer 1 P_entries[69][1][1] +/P/70 array_length 2 P_entries[70] +/P/70/0 array_length 2 P_entries[70][0] +/P/70/0/0 integer 17 P_entries[70][0][0] +/P/70/0/1 integer 1 P_entries[70][0][1] +/P/70/1 array_length 2 P_entries[70][1] +/P/70/1/0 integer 29 P_entries[70][1][0] +/P/70/1/1 integer 1 P_entries[70][1][1] +/P/71 array_length 2 P_entries[71] +/P/71/0 array_length 2 P_entries[71][0] +/P/71/0/0 integer 17 P_entries[71][0][0] +/P/71/0/1 integer 1 P_entries[71][0][1] +/P/71/1 array_length 2 P_entries[71][1] +/P/71/1/0 integer 31 P_entries[71][1][0] +/P/71/1/1 integer 1 P_entries[71][1][1] +/P/72 array_length 2 P_entries[72] +/P/72/0 array_length 2 P_entries[72][0] +/P/72/0/0 integer 18 P_entries[72][0][0] +/P/72/0/1 integer 1 P_entries[72][0][1] +/P/72/1 array_length 2 P_entries[72][1] +/P/72/1/0 integer 26 P_entries[72][1][0] +/P/72/1/1 integer 1 P_entries[72][1][1] +/P/73 array_length 2 P_entries[73] +/P/73/0 array_length 2 P_entries[73][0] +/P/73/0/0 integer 18 P_entries[73][0][0] +/P/73/0/1 integer 1 P_entries[73][0][1] +/P/73/1 array_length 2 P_entries[73][1] +/P/73/1/0 integer 28 P_entries[73][1][0] +/P/73/1/1 integer 1 P_entries[73][1][1] +/P/74 array_length 2 P_entries[74] +/P/74/0 array_length 2 P_entries[74][0] +/P/74/0/0 integer 18 P_entries[74][0][0] +/P/74/0/1 integer 1 P_entries[74][0][1] +/P/74/1 array_length 2 P_entries[74][1] +/P/74/1/0 integer 29 P_entries[74][1][0] +/P/74/1/1 integer 1 P_entries[74][1][1] +/P/75 array_length 2 P_entries[75] +/P/75/0 array_length 2 P_entries[75][0] +/P/75/0/0 integer 18 P_entries[75][0][0] +/P/75/0/1 integer 1 P_entries[75][0][1] +/P/75/1 array_length 2 P_entries[75][1] +/P/75/1/0 integer 31 P_entries[75][1][0] +/P/75/1/1 integer 1 P_entries[75][1][1] +/P/76 array_length 2 P_entries[76] +/P/76/0 array_length 2 P_entries[76][0] +/P/76/0/0 integer 19 P_entries[76][0][0] +/P/76/0/1 integer 1 P_entries[76][0][1] +/P/76/1 array_length 2 P_entries[76][1] +/P/76/1/0 integer 26 P_entries[76][1][0] +/P/76/1/1 integer 1 P_entries[76][1][1] +/P/77 array_length 2 P_entries[77] +/P/77/0 array_length 2 P_entries[77][0] +/P/77/0/0 integer 19 P_entries[77][0][0] +/P/77/0/1 integer 1 P_entries[77][0][1] +/P/77/1 array_length 2 P_entries[77][1] +/P/77/1/0 integer 28 P_entries[77][1][0] +/P/77/1/1 integer 1 P_entries[77][1][1] +/P/78 array_length 2 P_entries[78] +/P/78/0 array_length 2 P_entries[78][0] +/P/78/0/0 integer 19 P_entries[78][0][0] +/P/78/0/1 integer 1 P_entries[78][0][1] +/P/78/1 array_length 2 P_entries[78][1] +/P/78/1/0 integer 30 P_entries[78][1][0] +/P/78/1/1 integer 1 P_entries[78][1][1] +/P/79 array_length 2 P_entries[79] +/P/79/0 array_length 2 P_entries[79][0] +/P/79/0/0 integer 19 P_entries[79][0][0] +/P/79/0/1 integer 1 P_entries[79][0][1] +/P/79/1 array_length 2 P_entries[79][1] +/P/79/1/0 integer 32 P_entries[79][1][0] +/P/79/1/1 integer 1 P_entries[79][1][1] +/P/80 array_length 2 P_entries[80] +/P/80/0 array_length 2 P_entries[80][0] +/P/80/0/0 integer 20 P_entries[80][0][0] +/P/80/0/1 integer 1 P_entries[80][0][1] +/P/80/1 array_length 2 P_entries[80][1] +/P/80/1/0 integer 26 P_entries[80][1][0] +/P/80/1/1 integer 1 P_entries[80][1][1] +/P/81 array_length 2 P_entries[81] +/P/81/0 array_length 2 P_entries[81][0] +/P/81/0/0 integer 20 P_entries[81][0][0] +/P/81/0/1 integer 1 P_entries[81][0][1] +/P/81/1 array_length 2 P_entries[81][1] +/P/81/1/0 integer 28 P_entries[81][1][0] +/P/81/1/1 integer 1 P_entries[81][1][1] +/P/82 array_length 2 P_entries[82] +/P/82/0 array_length 2 P_entries[82][0] +/P/82/0/0 integer 20 P_entries[82][0][0] +/P/82/0/1 integer 1 P_entries[82][0][1] +/P/82/1 array_length 2 P_entries[82][1] +/P/82/1/0 integer 30 P_entries[82][1][0] +/P/82/1/1 integer 1 P_entries[82][1][1] +/P/83 array_length 2 P_entries[83] +/P/83/0 array_length 2 P_entries[83][0] +/P/83/0/0 integer 20 P_entries[83][0][0] +/P/83/0/1 integer 1 P_entries[83][0][1] +/P/83/1 array_length 2 P_entries[83][1] +/P/83/1/0 integer 32 P_entries[83][1][0] +/P/83/1/1 integer 1 P_entries[83][1][1] +/P/84 array_length 2 P_entries[84] +/P/84/0 array_length 2 P_entries[84][0] +/P/84/0/0 integer 21 P_entries[84][0][0] +/P/84/0/1 integer 1 P_entries[84][0][1] +/P/84/1 array_length 2 P_entries[84][1] +/P/84/1/0 integer 27 P_entries[84][1][0] +/P/84/1/1 integer 1 P_entries[84][1][1] +/P/85 array_length 2 P_entries[85] +/P/85/0 array_length 2 P_entries[85][0] +/P/85/0/0 integer 21 P_entries[85][0][0] +/P/85/0/1 integer 1 P_entries[85][0][1] +/P/85/1 array_length 2 P_entries[85][1] +/P/85/1/0 integer 28 P_entries[85][1][0] +/P/85/1/1 integer 1 P_entries[85][1][1] +/P/86 array_length 2 P_entries[86] +/P/86/0 array_length 2 P_entries[86][0] +/P/86/0/0 integer 21 P_entries[86][0][0] +/P/86/0/1 integer 1 P_entries[86][0][1] +/P/86/1 array_length 2 P_entries[86][1] +/P/86/1/0 integer 29 P_entries[86][1][0] +/P/86/1/1 integer 1 P_entries[86][1][1] +/P/87 array_length 2 P_entries[87] +/P/87/0 array_length 2 P_entries[87][0] +/P/87/0/0 integer 21 P_entries[87][0][0] +/P/87/0/1 integer 1 P_entries[87][0][1] +/P/87/1 array_length 2 P_entries[87][1] +/P/87/1/0 integer 30 P_entries[87][1][0] +/P/87/1/1 integer 1 P_entries[87][1][1] +/P/88 array_length 2 P_entries[88] +/P/88/0 array_length 2 P_entries[88][0] +/P/88/0/0 integer 22 P_entries[88][0][0] +/P/88/0/1 integer 1 P_entries[88][0][1] +/P/88/1 array_length 2 P_entries[88][1] +/P/88/1/0 integer 27 P_entries[88][1][0] +/P/88/1/1 integer 1 P_entries[88][1][1] +/P/89 array_length 2 P_entries[89] +/P/89/0 array_length 2 P_entries[89][0] +/P/89/0/0 integer 22 P_entries[89][0][0] +/P/89/0/1 integer 1 P_entries[89][0][1] +/P/89/1 array_length 2 P_entries[89][1] +/P/89/1/0 integer 28 P_entries[89][1][0] +/P/89/1/1 integer 1 P_entries[89][1][1] +/P/90 array_length 2 P_entries[90] +/P/90/0 array_length 2 P_entries[90][0] +/P/90/0/0 integer 22 P_entries[90][0][0] +/P/90/0/1 integer 1 P_entries[90][0][1] +/P/90/1 array_length 2 P_entries[90][1] +/P/90/1/0 integer 29 P_entries[90][1][0] +/P/90/1/1 integer 1 P_entries[90][1][1] +/P/91 array_length 2 P_entries[91] +/P/91/0 array_length 2 P_entries[91][0] +/P/91/0/0 integer 22 P_entries[91][0][0] +/P/91/0/1 integer 1 P_entries[91][0][1] +/P/91/1 array_length 2 P_entries[91][1] +/P/91/1/0 integer 30 P_entries[91][1][0] +/P/91/1/1 integer 1 P_entries[91][1][1] +/P/92 array_length 2 P_entries[92] +/P/92/0 array_length 2 P_entries[92][0] +/P/92/0/0 integer 23 P_entries[92][0][0] +/P/92/0/1 integer 1 P_entries[92][0][1] +/P/92/1 array_length 2 P_entries[92][1] +/P/92/1/0 integer 27 P_entries[92][1][0] +/P/92/1/1 integer 1 P_entries[92][1][1] +/P/93 array_length 2 P_entries[93] +/P/93/0 array_length 2 P_entries[93][0] +/P/93/0/0 integer 23 P_entries[93][0][0] +/P/93/0/1 integer 1 P_entries[93][0][1] +/P/93/1 array_length 2 P_entries[93][1] +/P/93/1/0 integer 28 P_entries[93][1][0] +/P/93/1/1 integer 1 P_entries[93][1][1] +/P/94 array_length 2 P_entries[94] +/P/94/0 array_length 2 P_entries[94][0] +/P/94/0/0 integer 23 P_entries[94][0][0] +/P/94/0/1 integer 1 P_entries[94][0][1] +/P/94/1 array_length 2 P_entries[94][1] +/P/94/1/0 integer 31 P_entries[94][1][0] +/P/94/1/1 integer 1 P_entries[94][1][1] +/P/95 array_length 2 P_entries[95] +/P/95/0 array_length 2 P_entries[95][0] +/P/95/0/0 integer 23 P_entries[95][0][0] +/P/95/0/1 integer 1 P_entries[95][0][1] +/P/95/1 array_length 2 P_entries[95][1] +/P/95/1/0 integer 32 P_entries[95][1][0] +/P/95/1/1 integer 1 P_entries[95][1][1] +/P/96 array_length 2 P_entries[96] +/P/96/0 array_length 2 P_entries[96][0] +/P/96/0/0 integer 24 P_entries[96][0][0] +/P/96/0/1 integer 1 P_entries[96][0][1] +/P/96/1 array_length 2 P_entries[96][1] +/P/96/1/0 integer 27 P_entries[96][1][0] +/P/96/1/1 integer 1 P_entries[96][1][1] +/P/97 array_length 2 P_entries[97] +/P/97/0 array_length 2 P_entries[97][0] +/P/97/0/0 integer 24 P_entries[97][0][0] +/P/97/0/1 integer 1 P_entries[97][0][1] +/P/97/1 array_length 2 P_entries[97][1] +/P/97/1/0 integer 28 P_entries[97][1][0] +/P/97/1/1 integer 1 P_entries[97][1][1] +/P/98 array_length 2 P_entries[98] +/P/98/0 array_length 2 P_entries[98][0] +/P/98/0/0 integer 24 P_entries[98][0][0] +/P/98/0/1 integer 1 P_entries[98][0][1] +/P/98/1 array_length 2 P_entries[98][1] +/P/98/1/0 integer 31 P_entries[98][1][0] +/P/98/1/1 integer 1 P_entries[98][1][1] +/P/99 array_length 2 P_entries[99] +/P/99/0 array_length 2 P_entries[99][0] +/P/99/0/0 integer 24 P_entries[99][0][0] +/P/99/0/1 integer 1 P_entries[99][0][1] +/P/99/1 array_length 2 P_entries[99][1] +/P/99/1/0 integer 32 P_entries[99][1][0] +/P/99/1/1 integer 1 P_entries[99][1][1] +/P/100 array_length 2 P_entries[100] +/P/100/0 array_length 2 P_entries[100][0] +/P/100/0/0 integer 25 P_entries[100][0][0] +/P/100/0/1 integer 1 P_entries[100][0][1] +/P/100/1 array_length 2 P_entries[100][1] +/P/100/1/0 integer 29 P_entries[100][1][0] +/P/100/1/1 integer 1 P_entries[100][1][1] +/P/101 array_length 2 P_entries[101] +/P/101/0 array_length 2 P_entries[101][0] +/P/101/0/0 integer 25 P_entries[101][0][0] +/P/101/0/1 integer 1 P_entries[101][0][1] +/P/101/1 array_length 2 P_entries[101][1] +/P/101/1/0 integer 30 P_entries[101][1][0] +/P/101/1/1 integer 1 P_entries[101][1][1] +/P/102 array_length 2 P_entries[102] +/P/102/0 array_length 2 P_entries[102][0] +/P/102/0/0 integer 25 P_entries[102][0][0] +/P/102/0/1 integer 1 P_entries[102][0][1] +/P/102/1 array_length 2 P_entries[102][1] +/P/102/1/0 integer 31 P_entries[102][1][0] +/P/102/1/1 integer 1 P_entries[102][1][1] +/P/103 array_length 2 P_entries[103] +/P/103/0 array_length 2 P_entries[103][0] +/P/103/0/0 integer 25 P_entries[103][0][0] +/P/103/0/1 integer 1 P_entries[103][0][1] +/P/103/1 array_length 2 P_entries[103][1] +/P/103/1/0 integer 32 P_entries[103][1][0] +/P/103/1/1 integer 1 P_entries[103][1][1] +/Q array_length 33 Q_entries +/Q/0 array_length 1 Q_entries[0] +/Q/0/0 array_length 2 Q_entries[0][0] +/Q/0/0/0 integer 0 Q_entries[0][0][0] +/Q/0/0/1 integer 1 Q_entries[0][0][1] +/Q/1 array_length 1 Q_entries[1] +/Q/1/0 array_length 2 Q_entries[1][0] +/Q/1/0/0 integer 4 Q_entries[1][0][0] +/Q/1/0/1 integer 1 Q_entries[1][0][1] +/Q/2 array_length 1 Q_entries[2] +/Q/2/0 array_length 2 Q_entries[2][0] +/Q/2/0/0 integer 8 Q_entries[2][0][0] +/Q/2/0/1 integer 1 Q_entries[2][0][1] +/Q/3 array_length 1 Q_entries[3] +/Q/3/0 array_length 2 Q_entries[3][0] +/Q/3/0/0 integer 12 Q_entries[3][0][0] +/Q/3/0/1 integer 1 Q_entries[3][0][1] +/Q/4 array_length 1 Q_entries[4] +/Q/4/0 array_length 2 Q_entries[4][0] +/Q/4/0/0 integer 16 Q_entries[4][0][0] +/Q/4/0/1 integer 1 Q_entries[4][0][1] +/Q/5 array_length 1 Q_entries[5] +/Q/5/0 array_length 2 Q_entries[5][0] +/Q/5/0/0 integer 20 Q_entries[5][0][0] +/Q/5/0/1 integer 1 Q_entries[5][0][1] +/Q/6 array_length 1 Q_entries[6] +/Q/6/0 array_length 2 Q_entries[6][0] +/Q/6/0/0 integer 24 Q_entries[6][0][0] +/Q/6/0/1 integer 1 Q_entries[6][0][1] +/Q/7 array_length 1 Q_entries[7] +/Q/7/0 array_length 2 Q_entries[7][0] +/Q/7/0/0 integer 28 Q_entries[7][0][0] +/Q/7/0/1 integer 1 Q_entries[7][0][1] +/Q/8 array_length 1 Q_entries[8] +/Q/8/0 array_length 2 Q_entries[8][0] +/Q/8/0/0 integer 32 Q_entries[8][0][0] +/Q/8/0/1 integer 1 Q_entries[8][0][1] +/Q/9 array_length 1 Q_entries[9] +/Q/9/0 array_length 2 Q_entries[9][0] +/Q/9/0/0 integer 36 Q_entries[9][0][0] +/Q/9/0/1 integer 1 Q_entries[9][0][1] +/Q/10 array_length 1 Q_entries[10] +/Q/10/0 array_length 2 Q_entries[10][0] +/Q/10/0/0 integer 40 Q_entries[10][0][0] +/Q/10/0/1 integer 1 Q_entries[10][0][1] +/Q/11 array_length 1 Q_entries[11] +/Q/11/0 array_length 2 Q_entries[11][0] +/Q/11/0/0 integer 44 Q_entries[11][0][0] +/Q/11/0/1 integer 1 Q_entries[11][0][1] +/Q/12 array_length 1 Q_entries[12] +/Q/12/0 array_length 2 Q_entries[12][0] +/Q/12/0/0 integer 48 Q_entries[12][0][0] +/Q/12/0/1 integer 1 Q_entries[12][0][1] +/Q/13 array_length 3 Q_entries[13] +/Q/13/0 array_length 2 Q_entries[13][0] +/Q/13/0/0 integer 0 Q_entries[13][0][0] +/Q/13/0/1 integer 1 Q_entries[13][0][1] +/Q/13/1 array_length 2 Q_entries[13][1] +/Q/13/1/0 integer 1 Q_entries[13][1][0] +/Q/13/1/1 integer -1 Q_entries[13][1][1] +/Q/13/2 array_length 2 Q_entries[13][2] +/Q/13/2/0 integer 52 Q_entries[13][2][0] +/Q/13/2/1 integer 1 Q_entries[13][2][1] +/Q/14 array_length 3 Q_entries[14] +/Q/14/0 array_length 2 Q_entries[14][0] +/Q/14/0/0 integer 0 Q_entries[14][0][0] +/Q/14/0/1 integer 1 Q_entries[14][0][1] +/Q/14/1 array_length 2 Q_entries[14][1] +/Q/14/1/0 integer 1 Q_entries[14][1][0] +/Q/14/1/1 integer -1 Q_entries[14][1][1] +/Q/14/2 array_length 2 Q_entries[14][2] +/Q/14/2/0 integer 56 Q_entries[14][2][0] +/Q/14/2/1 integer 1 Q_entries[14][2][1] +/Q/15 array_length 3 Q_entries[15] +/Q/15/0 array_length 2 Q_entries[15][0] +/Q/15/0/0 integer 0 Q_entries[15][0][0] +/Q/15/0/1 integer 1 Q_entries[15][0][1] +/Q/15/1 array_length 2 Q_entries[15][1] +/Q/15/1/0 integer 1 Q_entries[15][1][0] +/Q/15/1/1 integer -1 Q_entries[15][1][1] +/Q/15/2 array_length 2 Q_entries[15][2] +/Q/15/2/0 integer 60 Q_entries[15][2][0] +/Q/15/2/1 integer 1 Q_entries[15][2][1] +/Q/16 array_length 3 Q_entries[16] +/Q/16/0 array_length 2 Q_entries[16][0] +/Q/16/0/0 integer 0 Q_entries[16][0][0] +/Q/16/0/1 integer 1 Q_entries[16][0][1] +/Q/16/1 array_length 2 Q_entries[16][1] +/Q/16/1/0 integer 1 Q_entries[16][1][0] +/Q/16/1/1 integer -1 Q_entries[16][1][1] +/Q/16/2 array_length 2 Q_entries[16][2] +/Q/16/2/0 integer 64 Q_entries[16][2][0] +/Q/16/2/1 integer 1 Q_entries[16][2][1] +/Q/17 array_length 3 Q_entries[17] +/Q/17/0 array_length 2 Q_entries[17][0] +/Q/17/0/0 integer 0 Q_entries[17][0][0] +/Q/17/0/1 integer 1 Q_entries[17][0][1] +/Q/17/1 array_length 2 Q_entries[17][1] +/Q/17/1/0 integer 1 Q_entries[17][1][0] +/Q/17/1/1 integer -1 Q_entries[17][1][1] +/Q/17/2 array_length 2 Q_entries[17][2] +/Q/17/2/0 integer 68 Q_entries[17][2][0] +/Q/17/2/1 integer 1 Q_entries[17][2][1] +/Q/18 array_length 3 Q_entries[18] +/Q/18/0 array_length 2 Q_entries[18][0] +/Q/18/0/0 integer 0 Q_entries[18][0][0] +/Q/18/0/1 integer 1 Q_entries[18][0][1] +/Q/18/1 array_length 2 Q_entries[18][1] +/Q/18/1/0 integer 1 Q_entries[18][1][0] +/Q/18/1/1 integer -1 Q_entries[18][1][1] +/Q/18/2 array_length 2 Q_entries[18][2] +/Q/18/2/0 integer 72 Q_entries[18][2][0] +/Q/18/2/1 integer 1 Q_entries[18][2][1] +/Q/19 array_length 3 Q_entries[19] +/Q/19/0 array_length 2 Q_entries[19][0] +/Q/19/0/0 integer 0 Q_entries[19][0][0] +/Q/19/0/1 integer 1 Q_entries[19][0][1] +/Q/19/1 array_length 2 Q_entries[19][1] +/Q/19/1/0 integer 1 Q_entries[19][1][0] +/Q/19/1/1 integer -1 Q_entries[19][1][1] +/Q/19/2 array_length 2 Q_entries[19][2] +/Q/19/2/0 integer 76 Q_entries[19][2][0] +/Q/19/2/1 integer 1 Q_entries[19][2][1] +/Q/20 array_length 3 Q_entries[20] +/Q/20/0 array_length 2 Q_entries[20][0] +/Q/20/0/0 integer 0 Q_entries[20][0][0] +/Q/20/0/1 integer 1 Q_entries[20][0][1] +/Q/20/1 array_length 2 Q_entries[20][1] +/Q/20/1/0 integer 1 Q_entries[20][1][0] +/Q/20/1/1 integer -1 Q_entries[20][1][1] +/Q/20/2 array_length 2 Q_entries[20][2] +/Q/20/2/0 integer 80 Q_entries[20][2][0] +/Q/20/2/1 integer 1 Q_entries[20][2][1] +/Q/21 array_length 3 Q_entries[21] +/Q/21/0 array_length 2 Q_entries[21][0] +/Q/21/0/0 integer 0 Q_entries[21][0][0] +/Q/21/0/1 integer 1 Q_entries[21][0][1] +/Q/21/1 array_length 2 Q_entries[21][1] +/Q/21/1/0 integer 2 Q_entries[21][1][0] +/Q/21/1/1 integer -1 Q_entries[21][1][1] +/Q/21/2 array_length 2 Q_entries[21][2] +/Q/21/2/0 integer 84 Q_entries[21][2][0] +/Q/21/2/1 integer 1 Q_entries[21][2][1] +/Q/22 array_length 3 Q_entries[22] +/Q/22/0 array_length 2 Q_entries[22][0] +/Q/22/0/0 integer 0 Q_entries[22][0][0] +/Q/22/0/1 integer 1 Q_entries[22][0][1] +/Q/22/1 array_length 2 Q_entries[22][1] +/Q/22/1/0 integer 2 Q_entries[22][1][0] +/Q/22/1/1 integer -1 Q_entries[22][1][1] +/Q/22/2 array_length 2 Q_entries[22][2] +/Q/22/2/0 integer 88 Q_entries[22][2][0] +/Q/22/2/1 integer 1 Q_entries[22][2][1] +/Q/23 array_length 3 Q_entries[23] +/Q/23/0 array_length 2 Q_entries[23][0] +/Q/23/0/0 integer 0 Q_entries[23][0][0] +/Q/23/0/1 integer 1 Q_entries[23][0][1] +/Q/23/1 array_length 2 Q_entries[23][1] +/Q/23/1/0 integer 2 Q_entries[23][1][0] +/Q/23/1/1 integer -1 Q_entries[23][1][1] +/Q/23/2 array_length 2 Q_entries[23][2] +/Q/23/2/0 integer 92 Q_entries[23][2][0] +/Q/23/2/1 integer 1 Q_entries[23][2][1] +/Q/24 array_length 3 Q_entries[24] +/Q/24/0 array_length 2 Q_entries[24][0] +/Q/24/0/0 integer 0 Q_entries[24][0][0] +/Q/24/0/1 integer 1 Q_entries[24][0][1] +/Q/24/1 array_length 2 Q_entries[24][1] +/Q/24/1/0 integer 2 Q_entries[24][1][0] +/Q/24/1/1 integer -1 Q_entries[24][1][1] +/Q/24/2 array_length 2 Q_entries[24][2] +/Q/24/2/0 integer 96 Q_entries[24][2][0] +/Q/24/2/1 integer 1 Q_entries[24][2][1] +/Q/25 array_length 3 Q_entries[25] +/Q/25/0 array_length 2 Q_entries[25][0] +/Q/25/0/0 integer 4 Q_entries[25][0][0] +/Q/25/0/1 integer 1 Q_entries[25][0][1] +/Q/25/1 array_length 2 Q_entries[25][1] +/Q/25/1/0 integer 6 Q_entries[25][1][0] +/Q/25/1/1 integer -1 Q_entries[25][1][1] +/Q/25/2 array_length 2 Q_entries[25][2] +/Q/25/2/0 integer 100 Q_entries[25][2][0] +/Q/25/2/1 integer 1 Q_entries[25][2][1] +/Q/26 array_length 2 Q_entries[26] +/Q/26/0 array_length 2 Q_entries[26][0] +/Q/26/0/0 integer 0 Q_entries[26][0][0] +/Q/26/0/1 integer -1 Q_entries[26][0][1] +/Q/26/1 array_length 2 Q_entries[26][1] +/Q/26/1/0 integer 1 Q_entries[26][1][0] +/Q/26/1/1 integer 1 Q_entries[26][1][1] +/Q/27 array_length 2 Q_entries[27] +/Q/27/0 array_length 2 Q_entries[27][0] +/Q/27/0/0 integer 0 Q_entries[27][0][0] +/Q/27/0/1 integer -1 Q_entries[27][0][1] +/Q/27/1 array_length 2 Q_entries[27][1] +/Q/27/1/0 integer 2 Q_entries[27][1][0] +/Q/27/1/1 integer 1 Q_entries[27][1][1] +/Q/28 array_length 2 Q_entries[28] +/Q/28/0 array_length 2 Q_entries[28][0] +/Q/28/0/0 integer 0 Q_entries[28][0][0] +/Q/28/0/1 integer -1 Q_entries[28][0][1] +/Q/28/1 array_length 2 Q_entries[28][1] +/Q/28/1/0 integer 3 Q_entries[28][1][0] +/Q/28/1/1 integer 1 Q_entries[28][1][1] +/Q/29 array_length 2 Q_entries[29] +/Q/29/0 array_length 2 Q_entries[29][0] +/Q/29/0/0 integer 4 Q_entries[29][0][0] +/Q/29/0/1 integer -1 Q_entries[29][0][1] +/Q/29/1 array_length 2 Q_entries[29][1] +/Q/29/1/0 integer 6 Q_entries[29][1][0] +/Q/29/1/1 integer 1 Q_entries[29][1][1] +/Q/30 array_length 2 Q_entries[30] +/Q/30/0 array_length 2 Q_entries[30][0] +/Q/30/0/0 integer 4 Q_entries[30][0][0] +/Q/30/0/1 integer -1 Q_entries[30][0][1] +/Q/30/1 array_length 2 Q_entries[30][1] +/Q/30/1/0 integer 7 Q_entries[30][1][0] +/Q/30/1/1 integer 1 Q_entries[30][1][1] +/Q/31 array_length 2 Q_entries[31] +/Q/31/0 array_length 2 Q_entries[31][0] +/Q/31/0/0 integer 12 Q_entries[31][0][0] +/Q/31/0/1 integer -1 Q_entries[31][0][1] +/Q/31/1 array_length 2 Q_entries[31][1] +/Q/31/1/0 integer 14 Q_entries[31][1][0] +/Q/31/1/1 integer 1 Q_entries[31][1][1] +/Q/32 array_length 2 Q_entries[32] +/Q/32/0 array_length 2 Q_entries[32][0] +/Q/32/0/0 integer 12 Q_entries[32][0][0] +/Q/32/0/1 integer -1 Q_entries[32][0][1] +/Q/32/1 array_length 2 Q_entries[32][1] +/Q/32/1/0 integer 15 Q_entries[32][1][0] +/Q/32/1/1 integer 1 Q_entries[32][1][1] +/W array_length 104 W_entries +/W/0 array_length 0 W_entries[0] +/W/1 array_length 0 W_entries[1] +/W/2 array_length 0 W_entries[2] +/W/3 array_length 0 W_entries[3] +/W/4 array_length 0 W_entries[4] +/W/5 array_length 1 W_entries[5] +/W/5/0 array_length 2 W_entries[5][0] +/W/5/0/0 integer 0 W_entries[5][0][0] +/W/5/0/1 integer 1 W_entries[5][0][1] +/W/6 array_length 0 W_entries[6] +/W/7 array_length 0 W_entries[7] +/W/8 array_length 0 W_entries[8] +/W/9 array_length 1 W_entries[9] +/W/9/0 array_length 2 W_entries[9][0] +/W/9/0/0 integer 1 W_entries[9][0][0] +/W/9/0/1 integer 1 W_entries[9][0][1] +/W/10 array_length 2 W_entries[10] +/W/10/0 array_length 2 W_entries[10][0] +/W/10/0/0 integer 26 W_entries[10][0][0] +/W/10/0/1 integer 1 W_entries[10][0][1] +/W/10/1 array_length 2 W_entries[10][1] +/W/10/1/0 integer 47 W_entries[10][1][0] +/W/10/1/1 integer -1 W_entries[10][1][1] +/W/11 array_length 2 W_entries[11] +/W/11/0 array_length 2 W_entries[11][0] +/W/11/0/0 integer 28 W_entries[11][0][0] +/W/11/0/1 integer 1 W_entries[11][0][1] +/W/11/1 array_length 2 W_entries[11][1] +/W/11/1/0 integer 49 W_entries[11][1][0] +/W/11/1/1 integer -1 W_entries[11][1][1] +/W/12 array_length 0 W_entries[12] +/W/13 array_length 1 W_entries[13] +/W/13/0 array_length 2 W_entries[13][0] +/W/13/0/0 integer 2 W_entries[13][0][0] +/W/13/0/1 integer 1 W_entries[13][0][1] +/W/14 array_length 0 W_entries[14] +/W/15 array_length 0 W_entries[15] +/W/16 array_length 0 W_entries[16] +/W/17 array_length 1 W_entries[17] +/W/17/0 array_length 2 W_entries[17][0] +/W/17/0/0 integer 3 W_entries[17][0][0] +/W/17/0/1 integer 1 W_entries[17][0][1] +/W/18 array_length 2 W_entries[18] +/W/18/0 array_length 2 W_entries[18][0] +/W/18/0/0 integer 66 W_entries[18][0][0] +/W/18/0/1 integer 1 W_entries[18][0][1] +/W/18/1 array_length 2 W_entries[18][1] +/W/18/1/0 integer 85 W_entries[18][1][0] +/W/18/1/1 integer -1 W_entries[18][1][1] +/W/19 array_length 2 W_entries[19] +/W/19/0 array_length 2 W_entries[19][0] +/W/19/0/0 integer 68 W_entries[19][0][0] +/W/19/0/1 integer 1 W_entries[19][0][1] +/W/19/1 array_length 2 W_entries[19][1] +/W/19/1/0 integer 87 W_entries[19][1][0] +/W/19/1/1 integer -1 W_entries[19][1][1] +/W/20 array_length 0 W_entries[20] +/W/21 array_length 1 W_entries[21] +/W/21/0 array_length 2 W_entries[21][0] +/W/21/0/0 integer 4 W_entries[21][0][0] +/W/21/0/1 integer 1 W_entries[21][0][1] +/W/22 array_length 1 W_entries[22] +/W/22/0 array_length 2 W_entries[22][0] +/W/22/0/0 integer 26 W_entries[22][0][0] +/W/22/0/1 integer 1 W_entries[22][0][1] +/W/23 array_length 1 W_entries[23] +/W/23/0 array_length 2 W_entries[23][0] +/W/23/0/0 integer 66 W_entries[23][0][0] +/W/23/0/1 integer 1 W_entries[23][0][1] +/W/24 array_length 0 W_entries[24] +/W/25 array_length 1 W_entries[25] +/W/25/0 array_length 2 W_entries[25][0] +/W/25/0/0 integer 5 W_entries[25][0][0] +/W/25/0/1 integer 1 W_entries[25][0][1] +/W/26 array_length 1 W_entries[26] +/W/26/0 array_length 2 W_entries[26][0] +/W/26/0/0 integer 27 W_entries[26][0][0] +/W/26/0/1 integer 1 W_entries[26][0][1] +/W/27 array_length 1 W_entries[27] +/W/27/0 array_length 2 W_entries[27][0] +/W/27/0/0 integer 67 W_entries[27][0][0] +/W/27/0/1 integer 1 W_entries[27][0][1] +/W/28 array_length 0 W_entries[28] +/W/29 array_length 1 W_entries[29] +/W/29/0 array_length 2 W_entries[29][0] +/W/29/0/0 integer 6 W_entries[29][0][0] +/W/29/0/1 integer 1 W_entries[29][0][1] +/W/30 array_length 1 W_entries[30] +/W/30/0 array_length 2 W_entries[30][0] +/W/30/0/0 integer 28 W_entries[30][0][0] +/W/30/0/1 integer 1 W_entries[30][0][1] +/W/31 array_length 1 W_entries[31] +/W/31/0 array_length 2 W_entries[31][0] +/W/31/0/0 integer 68 W_entries[31][0][0] +/W/31/0/1 integer 1 W_entries[31][0][1] +/W/32 array_length 0 W_entries[32] +/W/33 array_length 1 W_entries[33] +/W/33/0 array_length 2 W_entries[33][0] +/W/33/0/0 integer 7 W_entries[33][0][0] +/W/33/0/1 integer 1 W_entries[33][0][1] +/W/34 array_length 1 W_entries[34] +/W/34/0 array_length 2 W_entries[34][0] +/W/34/0/0 integer 29 W_entries[34][0][0] +/W/34/0/1 integer 1 W_entries[34][0][1] +/W/35 array_length 1 W_entries[35] +/W/35/0 array_length 2 W_entries[35][0] +/W/35/0/0 integer 69 W_entries[35][0][0] +/W/35/0/1 integer 1 W_entries[35][0][1] +/W/36 array_length 0 W_entries[36] +/W/37 array_length 1 W_entries[37] +/W/37/0 array_length 2 W_entries[37][0] +/W/37/0/0 integer 8 W_entries[37][0][0] +/W/37/0/1 integer 1 W_entries[37][0][1] +/W/38 array_length 1 W_entries[38] +/W/38/0 array_length 2 W_entries[38][0] +/W/38/0/0 integer 30 W_entries[38][0][0] +/W/38/0/1 integer 1 W_entries[38][0][1] +/W/39 array_length 1 W_entries[39] +/W/39/0 array_length 2 W_entries[39][0] +/W/39/0/0 integer 70 W_entries[39][0][0] +/W/39/0/1 integer 1 W_entries[39][0][1] +/W/40 array_length 0 W_entries[40] +/W/41 array_length 1 W_entries[41] +/W/41/0 array_length 2 W_entries[41][0] +/W/41/0/0 integer 9 W_entries[41][0][0] +/W/41/0/1 integer 1 W_entries[41][0][1] +/W/42 array_length 1 W_entries[42] +/W/42/0 array_length 2 W_entries[42][0] +/W/42/0/0 integer 31 W_entries[42][0][0] +/W/42/0/1 integer 1 W_entries[42][0][1] +/W/43 array_length 1 W_entries[43] +/W/43/0 array_length 2 W_entries[43][0] +/W/43/0/0 integer 71 W_entries[43][0][0] +/W/43/0/1 integer 1 W_entries[43][0][1] +/W/44 array_length 0 W_entries[44] +/W/45 array_length 1 W_entries[45] +/W/45/0 array_length 2 W_entries[45][0] +/W/45/0/0 integer 10 W_entries[45][0][0] +/W/45/0/1 integer 1 W_entries[45][0][1] +/W/46 array_length 1 W_entries[46] +/W/46/0 array_length 2 W_entries[46][0] +/W/46/0/0 integer 32 W_entries[46][0][0] +/W/46/0/1 integer 1 W_entries[46][0][1] +/W/47 array_length 1 W_entries[47] +/W/47/0 array_length 2 W_entries[47][0] +/W/47/0/0 integer 72 W_entries[47][0][0] +/W/47/0/1 integer 1 W_entries[47][0][1] +/W/48 array_length 0 W_entries[48] +/W/49 array_length 1 W_entries[49] +/W/49/0 array_length 2 W_entries[49][0] +/W/49/0/0 integer 11 W_entries[49][0][0] +/W/49/0/1 integer 1 W_entries[49][0][1] +/W/50 array_length 1 W_entries[50] +/W/50/0 array_length 2 W_entries[50][0] +/W/50/0/0 integer 33 W_entries[50][0][0] +/W/50/0/1 integer 1 W_entries[50][0][1] +/W/51 array_length 1 W_entries[51] +/W/51/0 array_length 2 W_entries[51][0] +/W/51/0/0 integer 73 W_entries[51][0][0] +/W/51/0/1 integer 1 W_entries[51][0][1] +/W/52 array_length 0 W_entries[52] +/W/53 array_length 1 W_entries[53] +/W/53/0 array_length 2 W_entries[53][0] +/W/53/0/0 integer 12 W_entries[53][0][0] +/W/53/0/1 integer 1 W_entries[53][0][1] +/W/54 array_length 2 W_entries[54] +/W/54/0 array_length 2 W_entries[54][0] +/W/54/0/0 integer 0 W_entries[54][0][0] +/W/54/0/1 integer -1 W_entries[54][0][1] +/W/54/1 array_length 2 W_entries[54][1] +/W/54/1/0 integer 34 W_entries[54][1][0] +/W/54/1/1 integer 1 W_entries[54][1][1] +/W/55 array_length 2 W_entries[55] +/W/55/0 array_length 2 W_entries[55][0] +/W/55/0/0 integer 2 W_entries[55][0][0] +/W/55/0/1 integer -1 W_entries[55][0][1] +/W/55/1 array_length 2 W_entries[55][1] +/W/55/1/0 integer 74 W_entries[55][1][0] +/W/55/1/1 integer 1 W_entries[55][1][1] +/W/56 array_length 0 W_entries[56] +/W/57 array_length 1 W_entries[57] +/W/57/0 array_length 2 W_entries[57][0] +/W/57/0/0 integer 13 W_entries[57][0][0] +/W/57/0/1 integer 1 W_entries[57][0][1] +/W/58 array_length 2 W_entries[58] +/W/58/0 array_length 2 W_entries[58][0] +/W/58/0/0 integer 0 W_entries[58][0][0] +/W/58/0/1 integer -1 W_entries[58][0][1] +/W/58/1 array_length 2 W_entries[58][1] +/W/58/1/0 integer 35 W_entries[58][1][0] +/W/58/1/1 integer 1 W_entries[58][1][1] +/W/59 array_length 2 W_entries[59] +/W/59/0 array_length 2 W_entries[59][0] +/W/59/0/0 integer 2 W_entries[59][0][0] +/W/59/0/1 integer -1 W_entries[59][0][1] +/W/59/1 array_length 2 W_entries[59][1] +/W/59/1/0 integer 75 W_entries[59][1][0] +/W/59/1/1 integer 1 W_entries[59][1][1] +/W/60 array_length 0 W_entries[60] +/W/61 array_length 1 W_entries[61] +/W/61/0 array_length 2 W_entries[61][0] +/W/61/0/0 integer 14 W_entries[61][0][0] +/W/61/0/1 integer 1 W_entries[61][0][1] +/W/62 array_length 2 W_entries[62] +/W/62/0 array_length 2 W_entries[62][0] +/W/62/0/0 integer 0 W_entries[62][0][0] +/W/62/0/1 integer -1 W_entries[62][0][1] +/W/62/1 array_length 2 W_entries[62][1] +/W/62/1/0 integer 36 W_entries[62][1][0] +/W/62/1/1 integer 1 W_entries[62][1][1] +/W/63 array_length 2 W_entries[63] +/W/63/0 array_length 2 W_entries[63][0] +/W/63/0/0 integer 2 W_entries[63][0][0] +/W/63/0/1 integer -1 W_entries[63][0][1] +/W/63/1 array_length 2 W_entries[63][1] +/W/63/1/0 integer 76 W_entries[63][1][0] +/W/63/1/1 integer 1 W_entries[63][1][1] +/W/64 array_length 0 W_entries[64] +/W/65 array_length 1 W_entries[65] +/W/65/0 array_length 2 W_entries[65][0] +/W/65/0/0 integer 15 W_entries[65][0][0] +/W/65/0/1 integer 1 W_entries[65][0][1] +/W/66 array_length 2 W_entries[66] +/W/66/0 array_length 2 W_entries[66][0] +/W/66/0/0 integer 0 W_entries[66][0][0] +/W/66/0/1 integer -1 W_entries[66][0][1] +/W/66/1 array_length 2 W_entries[66][1] +/W/66/1/0 integer 37 W_entries[66][1][0] +/W/66/1/1 integer 1 W_entries[66][1][1] +/W/67 array_length 2 W_entries[67] +/W/67/0 array_length 2 W_entries[67][0] +/W/67/0/0 integer 2 W_entries[67][0][0] +/W/67/0/1 integer -1 W_entries[67][0][1] +/W/67/1 array_length 2 W_entries[67][1] +/W/67/1/0 integer 77 W_entries[67][1][0] +/W/67/1/1 integer 1 W_entries[67][1][1] +/W/68 array_length 0 W_entries[68] +/W/69 array_length 1 W_entries[69] +/W/69/0 array_length 2 W_entries[69][0] +/W/69/0/0 integer 16 W_entries[69][0][0] +/W/69/0/1 integer 1 W_entries[69][0][1] +/W/70 array_length 2 W_entries[70] +/W/70/0 array_length 2 W_entries[70][0] +/W/70/0/0 integer 0 W_entries[70][0][0] +/W/70/0/1 integer -1 W_entries[70][0][1] +/W/70/1 array_length 2 W_entries[70][1] +/W/70/1/0 integer 38 W_entries[70][1][0] +/W/70/1/1 integer 1 W_entries[70][1][1] +/W/71 array_length 2 W_entries[71] +/W/71/0 array_length 2 W_entries[71][0] +/W/71/0/0 integer 2 W_entries[71][0][0] +/W/71/0/1 integer -1 W_entries[71][0][1] +/W/71/1 array_length 2 W_entries[71][1] +/W/71/1/0 integer 78 W_entries[71][1][0] +/W/71/1/1 integer 1 W_entries[71][1][1] +/W/72 array_length 0 W_entries[72] +/W/73 array_length 1 W_entries[73] +/W/73/0 array_length 2 W_entries[73][0] +/W/73/0/0 integer 17 W_entries[73][0][0] +/W/73/0/1 integer 1 W_entries[73][0][1] +/W/74 array_length 2 W_entries[74] +/W/74/0 array_length 2 W_entries[74][0] +/W/74/0/0 integer 0 W_entries[74][0][0] +/W/74/0/1 integer -1 W_entries[74][0][1] +/W/74/1 array_length 2 W_entries[74][1] +/W/74/1/0 integer 39 W_entries[74][1][0] +/W/74/1/1 integer 1 W_entries[74][1][1] +/W/75 array_length 2 W_entries[75] +/W/75/0 array_length 2 W_entries[75][0] +/W/75/0/0 integer 2 W_entries[75][0][0] +/W/75/0/1 integer -1 W_entries[75][0][1] +/W/75/1 array_length 2 W_entries[75][1] +/W/75/1/0 integer 79 W_entries[75][1][0] +/W/75/1/1 integer 1 W_entries[75][1][1] +/W/76 array_length 0 W_entries[76] +/W/77 array_length 1 W_entries[77] +/W/77/0 array_length 2 W_entries[77][0] +/W/77/0/0 integer 18 W_entries[77][0][0] +/W/77/0/1 integer 1 W_entries[77][0][1] +/W/78 array_length 2 W_entries[78] +/W/78/0 array_length 2 W_entries[78][0] +/W/78/0/0 integer 0 W_entries[78][0][0] +/W/78/0/1 integer -1 W_entries[78][0][1] +/W/78/1 array_length 2 W_entries[78][1] +/W/78/1/0 integer 40 W_entries[78][1][0] +/W/78/1/1 integer 1 W_entries[78][1][1] +/W/79 array_length 2 W_entries[79] +/W/79/0 array_length 2 W_entries[79][0] +/W/79/0/0 integer 2 W_entries[79][0][0] +/W/79/0/1 integer -1 W_entries[79][0][1] +/W/79/1 array_length 2 W_entries[79][1] +/W/79/1/0 integer 80 W_entries[79][1][0] +/W/79/1/1 integer 1 W_entries[79][1][1] +/W/80 array_length 0 W_entries[80] +/W/81 array_length 1 W_entries[81] +/W/81/0 array_length 2 W_entries[81][0] +/W/81/0/0 integer 19 W_entries[81][0][0] +/W/81/0/1 integer 1 W_entries[81][0][1] +/W/82 array_length 2 W_entries[82] +/W/82/0 array_length 2 W_entries[82][0] +/W/82/0/0 integer 0 W_entries[82][0][0] +/W/82/0/1 integer -1 W_entries[82][0][1] +/W/82/1 array_length 2 W_entries[82][1] +/W/82/1/0 integer 41 W_entries[82][1][0] +/W/82/1/1 integer 1 W_entries[82][1][1] +/W/83 array_length 2 W_entries[83] +/W/83/0 array_length 2 W_entries[83][0] +/W/83/0/0 integer 2 W_entries[83][0][0] +/W/83/0/1 integer -1 W_entries[83][0][1] +/W/83/1 array_length 2 W_entries[83][1] +/W/83/1/0 integer 81 W_entries[83][1][0] +/W/83/1/1 integer 1 W_entries[83][1][1] +/W/84 array_length 0 W_entries[84] +/W/85 array_length 1 W_entries[85] +/W/85/0 array_length 2 W_entries[85][0] +/W/85/0/0 integer 20 W_entries[85][0][0] +/W/85/0/1 integer 1 W_entries[85][0][1] +/W/86 array_length 3 W_entries[86] +/W/86/0 array_length 2 W_entries[86][0] +/W/86/0/0 integer 4 W_entries[86][0][0] +/W/86/0/1 integer -1 W_entries[86][0][1] +/W/86/1 array_length 2 W_entries[86][1] +/W/86/1/0 integer 26 W_entries[86][1][0] +/W/86/1/1 integer 1 W_entries[86][1][1] +/W/86/2 array_length 2 W_entries[86][2] +/W/86/2/0 integer 116 W_entries[86][2][0] +/W/86/2/1 integer 1 W_entries[86][2][1] +/W/87 array_length 3 W_entries[87] +/W/87/0 array_length 2 W_entries[87][0] +/W/87/0/0 integer 6 W_entries[87][0][0] +/W/87/0/1 integer -1 W_entries[87][0][1] +/W/87/1 array_length 2 W_entries[87][1] +/W/87/1/0 integer 28 W_entries[87][1][0] +/W/87/1/1 integer 1 W_entries[87][1][1] +/W/87/2 array_length 2 W_entries[87][2] +/W/87/2/0 integer 148 W_entries[87][2][0] +/W/87/2/1 integer 1 W_entries[87][2][1] +/W/88 array_length 0 W_entries[88] +/W/89 array_length 1 W_entries[89] +/W/89/0 array_length 2 W_entries[89][0] +/W/89/0/0 integer 21 W_entries[89][0][0] +/W/89/0/1 integer 1 W_entries[89][0][1] +/W/90 array_length 3 W_entries[90] +/W/90/0 array_length 2 W_entries[90][0] +/W/90/0/0 integer 4 W_entries[90][0][0] +/W/90/0/1 integer -1 W_entries[90][0][1] +/W/90/1 array_length 2 W_entries[90][1] +/W/90/1/0 integer 26 W_entries[90][1][0] +/W/90/1/1 integer 1 W_entries[90][1][1] +/W/90/2 array_length 2 W_entries[90][2] +/W/90/2/0 integer 117 W_entries[90][2][0] +/W/90/2/1 integer 1 W_entries[90][2][1] +/W/91 array_length 3 W_entries[91] +/W/91/0 array_length 2 W_entries[91][0] +/W/91/0/0 integer 6 W_entries[91][0][0] +/W/91/0/1 integer -1 W_entries[91][0][1] +/W/91/1 array_length 2 W_entries[91][1] +/W/91/1/0 integer 28 W_entries[91][1][0] +/W/91/1/1 integer 1 W_entries[91][1][1] +/W/91/2 array_length 2 W_entries[91][2] +/W/91/2/0 integer 149 W_entries[91][2][0] +/W/91/2/1 integer 1 W_entries[91][2][1] +/W/92 array_length 0 W_entries[92] +/W/93 array_length 1 W_entries[93] +/W/93/0 array_length 2 W_entries[93][0] +/W/93/0/0 integer 22 W_entries[93][0][0] +/W/93/0/1 integer 1 W_entries[93][0][1] +/W/94 array_length 3 W_entries[94] +/W/94/0 array_length 2 W_entries[94][0] +/W/94/0/0 integer 4 W_entries[94][0][0] +/W/94/0/1 integer -1 W_entries[94][0][1] +/W/94/1 array_length 2 W_entries[94][1] +/W/94/1/0 integer 66 W_entries[94][1][0] +/W/94/1/1 integer 1 W_entries[94][1][1] +/W/94/2 array_length 2 W_entries[94][2] +/W/94/2/0 integer 118 W_entries[94][2][0] +/W/94/2/1 integer 1 W_entries[94][2][1] +/W/95 array_length 3 W_entries[95] +/W/95/0 array_length 2 W_entries[95][0] +/W/95/0/0 integer 6 W_entries[95][0][0] +/W/95/0/1 integer -1 W_entries[95][0][1] +/W/95/1 array_length 2 W_entries[95][1] +/W/95/1/0 integer 68 W_entries[95][1][0] +/W/95/1/1 integer 1 W_entries[95][1][1] +/W/95/2 array_length 2 W_entries[95][2] +/W/95/2/0 integer 150 W_entries[95][2][0] +/W/95/2/1 integer 1 W_entries[95][2][1] +/W/96 array_length 0 W_entries[96] +/W/97 array_length 1 W_entries[97] +/W/97/0 array_length 2 W_entries[97][0] +/W/97/0/0 integer 23 W_entries[97][0][0] +/W/97/0/1 integer 1 W_entries[97][0][1] +/W/98 array_length 3 W_entries[98] +/W/98/0 array_length 2 W_entries[98][0] +/W/98/0/0 integer 4 W_entries[98][0][0] +/W/98/0/1 integer -1 W_entries[98][0][1] +/W/98/1 array_length 2 W_entries[98][1] +/W/98/1/0 integer 66 W_entries[98][1][0] +/W/98/1/1 integer 1 W_entries[98][1][1] +/W/98/2 array_length 2 W_entries[98][2] +/W/98/2/0 integer 119 W_entries[98][2][0] +/W/98/2/1 integer 1 W_entries[98][2][1] +/W/99 array_length 3 W_entries[99] +/W/99/0 array_length 2 W_entries[99][0] +/W/99/0/0 integer 6 W_entries[99][0][0] +/W/99/0/1 integer -1 W_entries[99][0][1] +/W/99/1 array_length 2 W_entries[99][1] +/W/99/1/0 integer 68 W_entries[99][1][0] +/W/99/1/1 integer 1 W_entries[99][1][1] +/W/99/2 array_length 2 W_entries[99][2] +/W/99/2/0 integer 151 W_entries[99][2][0] +/W/99/2/1 integer 1 W_entries[99][2][1] +/W/100 array_length 0 W_entries[100] +/W/101 array_length 1 W_entries[101] +/W/101/0 array_length 2 W_entries[101][0] +/W/101/0/0 integer 44 W_entries[101][0][0] +/W/101/0/1 integer 1 W_entries[101][0][1] +/W/102 array_length 3 W_entries[102] +/W/102/0 array_length 2 W_entries[102][0] +/W/102/0/0 integer 26 W_entries[102][0][0] +/W/102/0/1 integer -1 W_entries[102][0][1] +/W/102/1 array_length 2 W_entries[102][1] +/W/102/1/0 integer 66 W_entries[102][1][0] +/W/102/1/1 integer 1 W_entries[102][1][1] +/W/102/2 array_length 2 W_entries[102][2] +/W/102/2/0 integer 120 W_entries[102][2][0] +/W/102/2/1 integer 1 W_entries[102][2][1] +/W/103 array_length 3 W_entries[103] +/W/103/0 array_length 2 W_entries[103][0] +/W/103/0/0 integer 30 W_entries[103][0][0] +/W/103/0/1 integer -1 W_entries[103][0][1] +/W/103/1 array_length 2 W_entries[103][1] +/W/103/1/0 integer 70 W_entries[103][1][0] +/W/103/1/1 integer 1 W_entries[103][1][1] +/W/103/2 array_length 2 W_entries[103][2] +/W/103/2/0 integer 180 W_entries[103][2][0] +/W/103/2/1 integer 1 W_entries[103][2][1] +/anchors array_length 26 anchors +/anchors/0 integer 0 anchors[0] +/anchors/1 integer 0 anchors[1] +/anchors/2 integer 0 anchors[2] +/anchors/3 integer 0 anchors[3] +/anchors/4 integer 0 anchors[4] +/anchors/5 integer 0 anchors[5] +/anchors/6 integer 0 anchors[6] +/anchors/7 integer 0 anchors[7] +/anchors/8 integer 0 anchors[8] +/anchors/9 integer 0 anchors[9] +/anchors/10 integer 0 anchors[10] +/anchors/11 integer 0 anchors[11] +/anchors/12 integer 0 anchors[12] +/anchors/13 integer 1 anchors[13] +/anchors/14 integer 1 anchors[14] +/anchors/15 integer 1 anchors[15] +/anchors/16 integer 1 anchors[16] +/anchors/17 integer 1 anchors[17] +/anchors/18 integer 1 anchors[18] +/anchors/19 integer 1 anchors[19] +/anchors/20 integer 1 anchors[20] +/anchors/21 integer 2 anchors[21] +/anchors/22 integer 2 anchors[22] +/anchors/23 integer 2 anchors[23] +/anchors/24 integer 2 anchors[24] +/anchors/25 integer 4 anchors[25] +/base_pair_representatives object_keys ["1","2","3","4","5","6","7"] basePairRepresentatives +/base_pair_representatives/1 integer 0 basePairRepresentatives["1"] +/base_pair_representatives/2 integer 0 basePairRepresentatives["2"] +/base_pair_representatives/3 integer 0 basePairRepresentatives["3"] +/base_pair_representatives/4 integer 1 basePairRepresentatives["4"] +/base_pair_representatives/5 integer 1 basePairRepresentatives["5"] +/base_pair_representatives/6 integer 3 basePairRepresentatives["6"] +/base_pair_representatives/7 integer 3 basePairRepresentatives["7"] +/coordinates array_length 104 coordinateLabels +/coordinates/0 array_length 2 coordinateLabels[0] +/coordinates/0/0 integer 0 coordinateLabels[0][0] +/coordinates/0/1 integer 0 coordinateLabels[0][1] +/coordinates/1 array_length 2 coordinateLabels[1] +/coordinates/1/0 integer 0 coordinateLabels[1][0] +/coordinates/1/1 integer 1 coordinateLabels[1][1] +/coordinates/2 array_length 2 coordinateLabels[2] +/coordinates/2/0 integer 0 coordinateLabels[2][0] +/coordinates/2/1 integer 2 coordinateLabels[2][1] +/coordinates/3 array_length 2 coordinateLabels[3] +/coordinates/3/0 integer 0 coordinateLabels[3][0] +/coordinates/3/1 integer 3 coordinateLabels[3][1] +/coordinates/4 array_length 2 coordinateLabels[4] +/coordinates/4/0 integer 1 coordinateLabels[4][0] +/coordinates/4/1 integer 0 coordinateLabels[4][1] +/coordinates/5 array_length 2 coordinateLabels[5] +/coordinates/5/0 integer 1 coordinateLabels[5][0] +/coordinates/5/1 integer 1 coordinateLabels[5][1] +/coordinates/6 array_length 2 coordinateLabels[6] +/coordinates/6/0 integer 1 coordinateLabels[6][0] +/coordinates/6/1 integer 4 coordinateLabels[6][1] +/coordinates/7 array_length 2 coordinateLabels[7] +/coordinates/7/0 integer 1 coordinateLabels[7][0] +/coordinates/7/1 integer 5 coordinateLabels[7][1] +/coordinates/8 array_length 2 coordinateLabels[8] +/coordinates/8/0 integer 2 coordinateLabels[8][0] +/coordinates/8/1 integer 0 coordinateLabels[8][1] +/coordinates/9 array_length 2 coordinateLabels[9] +/coordinates/9/0 integer 2 coordinateLabels[9][0] +/coordinates/9/1 integer 1 coordinateLabels[9][1] +/coordinates/10 array_length 2 coordinateLabels[10] +/coordinates/10/0 integer 2 coordinateLabels[10][0] +/coordinates/10/1 integer 4 coordinateLabels[10][1] +/coordinates/11 array_length 2 coordinateLabels[11] +/coordinates/11/0 integer 2 coordinateLabels[11][0] +/coordinates/11/1 integer 5 coordinateLabels[11][1] +/coordinates/12 array_length 2 coordinateLabels[12] +/coordinates/12/0 integer 3 coordinateLabels[12][0] +/coordinates/12/1 integer 0 coordinateLabels[12][1] +/coordinates/13 array_length 2 coordinateLabels[13] +/coordinates/13/0 integer 3 coordinateLabels[13][0] +/coordinates/13/1 integer 1 coordinateLabels[13][1] +/coordinates/14 array_length 2 coordinateLabels[14] +/coordinates/14/0 integer 3 coordinateLabels[14][0] +/coordinates/14/1 integer 6 coordinateLabels[14][1] +/coordinates/15 array_length 2 coordinateLabels[15] +/coordinates/15/0 integer 3 coordinateLabels[15][0] +/coordinates/15/1 integer 7 coordinateLabels[15][1] +/coordinates/16 array_length 2 coordinateLabels[16] +/coordinates/16/0 integer 4 coordinateLabels[16][0] +/coordinates/16/1 integer 0 coordinateLabels[16][1] +/coordinates/17 array_length 2 coordinateLabels[17] +/coordinates/17/0 integer 4 coordinateLabels[17][0] +/coordinates/17/1 integer 1 coordinateLabels[17][1] +/coordinates/18 array_length 2 coordinateLabels[18] +/coordinates/18/0 integer 4 coordinateLabels[18][0] +/coordinates/18/1 integer 6 coordinateLabels[18][1] +/coordinates/19 array_length 2 coordinateLabels[19] +/coordinates/19/0 integer 4 coordinateLabels[19][0] +/coordinates/19/1 integer 7 coordinateLabels[19][1] +/coordinates/20 array_length 2 coordinateLabels[20] +/coordinates/20/0 integer 5 coordinateLabels[20][0] +/coordinates/20/1 integer 0 coordinateLabels[20][1] +/coordinates/21 array_length 2 coordinateLabels[21] +/coordinates/21/0 integer 5 coordinateLabels[21][0] +/coordinates/21/1 integer 2 coordinateLabels[21][1] +/coordinates/22 array_length 2 coordinateLabels[22] +/coordinates/22/0 integer 5 coordinateLabels[22][0] +/coordinates/22/1 integer 4 coordinateLabels[22][1] +/coordinates/23 array_length 2 coordinateLabels[23] +/coordinates/23/0 integer 5 coordinateLabels[23][0] +/coordinates/23/1 integer 6 coordinateLabels[23][1] +/coordinates/24 array_length 2 coordinateLabels[24] +/coordinates/24/0 integer 6 coordinateLabels[24][0] +/coordinates/24/1 integer 0 coordinateLabels[24][1] +/coordinates/25 array_length 2 coordinateLabels[25] +/coordinates/25/0 integer 6 coordinateLabels[25][0] +/coordinates/25/1 integer 2 coordinateLabels[25][1] +/coordinates/26 array_length 2 coordinateLabels[26] +/coordinates/26/0 integer 6 coordinateLabels[26][0] +/coordinates/26/1 integer 4 coordinateLabels[26][1] +/coordinates/27 array_length 2 coordinateLabels[27] +/coordinates/27/0 integer 6 coordinateLabels[27][0] +/coordinates/27/1 integer 6 coordinateLabels[27][1] +/coordinates/28 array_length 2 coordinateLabels[28] +/coordinates/28/0 integer 7 coordinateLabels[28][0] +/coordinates/28/1 integer 0 coordinateLabels[28][1] +/coordinates/29 array_length 2 coordinateLabels[29] +/coordinates/29/0 integer 7 coordinateLabels[29][0] +/coordinates/29/1 integer 2 coordinateLabels[29][1] +/coordinates/30 array_length 2 coordinateLabels[30] +/coordinates/30/0 integer 7 coordinateLabels[30][0] +/coordinates/30/1 integer 5 coordinateLabels[30][1] +/coordinates/31 array_length 2 coordinateLabels[31] +/coordinates/31/0 integer 7 coordinateLabels[31][0] +/coordinates/31/1 integer 7 coordinateLabels[31][1] +/coordinates/32 array_length 2 coordinateLabels[32] +/coordinates/32/0 integer 8 coordinateLabels[32][0] +/coordinates/32/1 integer 0 coordinateLabels[32][1] +/coordinates/33 array_length 2 coordinateLabels[33] +/coordinates/33/0 integer 8 coordinateLabels[33][0] +/coordinates/33/1 integer 2 coordinateLabels[33][1] +/coordinates/34 array_length 2 coordinateLabels[34] +/coordinates/34/0 integer 8 coordinateLabels[34][0] +/coordinates/34/1 integer 5 coordinateLabels[34][1] +/coordinates/35 array_length 2 coordinateLabels[35] +/coordinates/35/0 integer 8 coordinateLabels[35][0] +/coordinates/35/1 integer 7 coordinateLabels[35][1] +/coordinates/36 array_length 2 coordinateLabels[36] +/coordinates/36/0 integer 9 coordinateLabels[36][0] +/coordinates/36/1 integer 0 coordinateLabels[36][1] +/coordinates/37 array_length 2 coordinateLabels[37] +/coordinates/37/0 integer 9 coordinateLabels[37][0] +/coordinates/37/1 integer 3 coordinateLabels[37][1] +/coordinates/38 array_length 2 coordinateLabels[38] +/coordinates/38/0 integer 9 coordinateLabels[38][0] +/coordinates/38/1 integer 4 coordinateLabels[38][1] +/coordinates/39 array_length 2 coordinateLabels[39] +/coordinates/39/0 integer 9 coordinateLabels[39][0] +/coordinates/39/1 integer 7 coordinateLabels[39][1] +/coordinates/40 array_length 2 coordinateLabels[40] +/coordinates/40/0 integer 10 coordinateLabels[40][0] +/coordinates/40/1 integer 0 coordinateLabels[40][1] +/coordinates/41 array_length 2 coordinateLabels[41] +/coordinates/41/0 integer 10 coordinateLabels[41][0] +/coordinates/41/1 integer 3 coordinateLabels[41][1] +/coordinates/42 array_length 2 coordinateLabels[42] +/coordinates/42/0 integer 10 coordinateLabels[42][0] +/coordinates/42/1 integer 4 coordinateLabels[42][1] +/coordinates/43 array_length 2 coordinateLabels[43] +/coordinates/43/0 integer 10 coordinateLabels[43][0] +/coordinates/43/1 integer 7 coordinateLabels[43][1] +/coordinates/44 array_length 2 coordinateLabels[44] +/coordinates/44/0 integer 11 coordinateLabels[44][0] +/coordinates/44/1 integer 0 coordinateLabels[44][1] +/coordinates/45 array_length 2 coordinateLabels[45] +/coordinates/45/0 integer 11 coordinateLabels[45][0] +/coordinates/45/1 integer 3 coordinateLabels[45][1] +/coordinates/46 array_length 2 coordinateLabels[46] +/coordinates/46/0 integer 11 coordinateLabels[46][0] +/coordinates/46/1 integer 5 coordinateLabels[46][1] +/coordinates/47 array_length 2 coordinateLabels[47] +/coordinates/47/0 integer 11 coordinateLabels[47][0] +/coordinates/47/1 integer 6 coordinateLabels[47][1] +/coordinates/48 array_length 2 coordinateLabels[48] +/coordinates/48/0 integer 12 coordinateLabels[48][0] +/coordinates/48/1 integer 0 coordinateLabels[48][1] +/coordinates/49 array_length 2 coordinateLabels[49] +/coordinates/49/0 integer 12 coordinateLabels[49][0] +/coordinates/49/1 integer 3 coordinateLabels[49][1] +/coordinates/50 array_length 2 coordinateLabels[50] +/coordinates/50/0 integer 12 coordinateLabels[50][0] +/coordinates/50/1 integer 5 coordinateLabels[50][1] +/coordinates/51 array_length 2 coordinateLabels[51] +/coordinates/51/0 integer 12 coordinateLabels[51][0] +/coordinates/51/1 integer 6 coordinateLabels[51][1] +/coordinates/52 array_length 2 coordinateLabels[52] +/coordinates/52/0 integer 13 coordinateLabels[52][0] +/coordinates/52/1 integer 1 coordinateLabels[52][1] +/coordinates/53 array_length 2 coordinateLabels[53] +/coordinates/53/0 integer 13 coordinateLabels[53][0] +/coordinates/53/1 integer 2 coordinateLabels[53][1] +/coordinates/54 array_length 2 coordinateLabels[54] +/coordinates/54/0 integer 13 coordinateLabels[54][0] +/coordinates/54/1 integer 4 coordinateLabels[54][1] +/coordinates/55 array_length 2 coordinateLabels[55] +/coordinates/55/0 integer 13 coordinateLabels[55][0] +/coordinates/55/1 integer 7 coordinateLabels[55][1] +/coordinates/56 array_length 2 coordinateLabels[56] +/coordinates/56/0 integer 14 coordinateLabels[56][0] +/coordinates/56/1 integer 1 coordinateLabels[56][1] +/coordinates/57 array_length 2 coordinateLabels[57] +/coordinates/57/0 integer 14 coordinateLabels[57][0] +/coordinates/57/1 integer 2 coordinateLabels[57][1] +/coordinates/58 array_length 2 coordinateLabels[58] +/coordinates/58/0 integer 14 coordinateLabels[58][0] +/coordinates/58/1 integer 4 coordinateLabels[58][1] +/coordinates/59 array_length 2 coordinateLabels[59] +/coordinates/59/0 integer 14 coordinateLabels[59][0] +/coordinates/59/1 integer 7 coordinateLabels[59][1] +/coordinates/60 array_length 2 coordinateLabels[60] +/coordinates/60/0 integer 15 coordinateLabels[60][0] +/coordinates/60/1 integer 1 coordinateLabels[60][1] +/coordinates/61 array_length 2 coordinateLabels[61] +/coordinates/61/0 integer 15 coordinateLabels[61][0] +/coordinates/61/1 integer 2 coordinateLabels[61][1] +/coordinates/62 array_length 2 coordinateLabels[62] +/coordinates/62/0 integer 15 coordinateLabels[62][0] +/coordinates/62/1 integer 5 coordinateLabels[62][1] +/coordinates/63 array_length 2 coordinateLabels[63] +/coordinates/63/0 integer 15 coordinateLabels[63][0] +/coordinates/63/1 integer 6 coordinateLabels[63][1] +/coordinates/64 array_length 2 coordinateLabels[64] +/coordinates/64/0 integer 16 coordinateLabels[64][0] +/coordinates/64/1 integer 1 coordinateLabels[64][1] +/coordinates/65 array_length 2 coordinateLabels[65] +/coordinates/65/0 integer 16 coordinateLabels[65][0] +/coordinates/65/1 integer 2 coordinateLabels[65][1] +/coordinates/66 array_length 2 coordinateLabels[66] +/coordinates/66/0 integer 16 coordinateLabels[66][0] +/coordinates/66/1 integer 5 coordinateLabels[66][1] +/coordinates/67 array_length 2 coordinateLabels[67] +/coordinates/67/0 integer 16 coordinateLabels[67][0] +/coordinates/67/1 integer 6 coordinateLabels[67][1] +/coordinates/68 array_length 2 coordinateLabels[68] +/coordinates/68/0 integer 17 coordinateLabels[68][0] +/coordinates/68/1 integer 1 coordinateLabels[68][1] +/coordinates/69 array_length 2 coordinateLabels[69] +/coordinates/69/0 integer 17 coordinateLabels[69][0] +/coordinates/69/1 integer 3 coordinateLabels[69][1] +/coordinates/70 array_length 2 coordinateLabels[70] +/coordinates/70/0 integer 17 coordinateLabels[70][0] +/coordinates/70/1 integer 4 coordinateLabels[70][1] +/coordinates/71 array_length 2 coordinateLabels[71] +/coordinates/71/0 integer 17 coordinateLabels[71][0] +/coordinates/71/1 integer 6 coordinateLabels[71][1] +/coordinates/72 array_length 2 coordinateLabels[72] +/coordinates/72/0 integer 18 coordinateLabels[72][0] +/coordinates/72/1 integer 1 coordinateLabels[72][1] +/coordinates/73 array_length 2 coordinateLabels[73] +/coordinates/73/0 integer 18 coordinateLabels[73][0] +/coordinates/73/1 integer 3 coordinateLabels[73][1] +/coordinates/74 array_length 2 coordinateLabels[74] +/coordinates/74/0 integer 18 coordinateLabels[74][0] +/coordinates/74/1 integer 4 coordinateLabels[74][1] +/coordinates/75 array_length 2 coordinateLabels[75] +/coordinates/75/0 integer 18 coordinateLabels[75][0] +/coordinates/75/1 integer 6 coordinateLabels[75][1] +/coordinates/76 array_length 2 coordinateLabels[76] +/coordinates/76/0 integer 19 coordinateLabels[76][0] +/coordinates/76/1 integer 1 coordinateLabels[76][1] +/coordinates/77 array_length 2 coordinateLabels[77] +/coordinates/77/0 integer 19 coordinateLabels[77][0] +/coordinates/77/1 integer 3 coordinateLabels[77][1] +/coordinates/78 array_length 2 coordinateLabels[78] +/coordinates/78/0 integer 19 coordinateLabels[78][0] +/coordinates/78/1 integer 5 coordinateLabels[78][1] +/coordinates/79 array_length 2 coordinateLabels[79] +/coordinates/79/0 integer 19 coordinateLabels[79][0] +/coordinates/79/1 integer 7 coordinateLabels[79][1] +/coordinates/80 array_length 2 coordinateLabels[80] +/coordinates/80/0 integer 20 coordinateLabels[80][0] +/coordinates/80/1 integer 1 coordinateLabels[80][1] +/coordinates/81 array_length 2 coordinateLabels[81] +/coordinates/81/0 integer 20 coordinateLabels[81][0] +/coordinates/81/1 integer 3 coordinateLabels[81][1] +/coordinates/82 array_length 2 coordinateLabels[82] +/coordinates/82/0 integer 20 coordinateLabels[82][0] +/coordinates/82/1 integer 5 coordinateLabels[82][1] +/coordinates/83 array_length 2 coordinateLabels[83] +/coordinates/83/0 integer 20 coordinateLabels[83][0] +/coordinates/83/1 integer 7 coordinateLabels[83][1] +/coordinates/84 array_length 2 coordinateLabels[84] +/coordinates/84/0 integer 21 coordinateLabels[84][0] +/coordinates/84/1 integer 2 coordinateLabels[84][1] +/coordinates/85 array_length 2 coordinateLabels[85] +/coordinates/85/0 integer 21 coordinateLabels[85][0] +/coordinates/85/1 integer 3 coordinateLabels[85][1] +/coordinates/86 array_length 2 coordinateLabels[86] +/coordinates/86/0 integer 21 coordinateLabels[86][0] +/coordinates/86/1 integer 4 coordinateLabels[86][1] +/coordinates/87 array_length 2 coordinateLabels[87] +/coordinates/87/0 integer 21 coordinateLabels[87][0] +/coordinates/87/1 integer 5 coordinateLabels[87][1] +/coordinates/88 array_length 2 coordinateLabels[88] +/coordinates/88/0 integer 22 coordinateLabels[88][0] +/coordinates/88/1 integer 2 coordinateLabels[88][1] +/coordinates/89 array_length 2 coordinateLabels[89] +/coordinates/89/0 integer 22 coordinateLabels[89][0] +/coordinates/89/1 integer 3 coordinateLabels[89][1] +/coordinates/90 array_length 2 coordinateLabels[90] +/coordinates/90/0 integer 22 coordinateLabels[90][0] +/coordinates/90/1 integer 4 coordinateLabels[90][1] +/coordinates/91 array_length 2 coordinateLabels[91] +/coordinates/91/0 integer 22 coordinateLabels[91][0] +/coordinates/91/1 integer 5 coordinateLabels[91][1] +/coordinates/92 array_length 2 coordinateLabels[92] +/coordinates/92/0 integer 23 coordinateLabels[92][0] +/coordinates/92/1 integer 2 coordinateLabels[92][1] +/coordinates/93 array_length 2 coordinateLabels[93] +/coordinates/93/0 integer 23 coordinateLabels[93][0] +/coordinates/93/1 integer 3 coordinateLabels[93][1] +/coordinates/94 array_length 2 coordinateLabels[94] +/coordinates/94/0 integer 23 coordinateLabels[94][0] +/coordinates/94/1 integer 6 coordinateLabels[94][1] +/coordinates/95 array_length 2 coordinateLabels[95] +/coordinates/95/0 integer 23 coordinateLabels[95][0] +/coordinates/95/1 integer 7 coordinateLabels[95][1] +/coordinates/96 array_length 2 coordinateLabels[96] +/coordinates/96/0 integer 24 coordinateLabels[96][0] +/coordinates/96/1 integer 2 coordinateLabels[96][1] +/coordinates/97 array_length 2 coordinateLabels[97] +/coordinates/97/0 integer 24 coordinateLabels[97][0] +/coordinates/97/1 integer 3 coordinateLabels[97][1] +/coordinates/98 array_length 2 coordinateLabels[98] +/coordinates/98/0 integer 24 coordinateLabels[98][0] +/coordinates/98/1 integer 6 coordinateLabels[98][1] +/coordinates/99 array_length 2 coordinateLabels[99] +/coordinates/99/0 integer 24 coordinateLabels[99][0] +/coordinates/99/1 integer 7 coordinateLabels[99][1] +/coordinates/100 array_length 2 coordinateLabels[100] +/coordinates/100/0 integer 25 coordinateLabels[100][0] +/coordinates/100/1 integer 4 coordinateLabels[100][1] +/coordinates/101 array_length 2 coordinateLabels[101] +/coordinates/101/0 integer 25 coordinateLabels[101][0] +/coordinates/101/1 integer 5 coordinateLabels[101][1] +/coordinates/102 array_length 2 coordinateLabels[102] +/coordinates/102/0 integer 25 coordinateLabels[102][0] +/coordinates/102/1 integer 6 coordinateLabels[102][1] +/coordinates/103 array_length 2 coordinateLabels[103] +/coordinates/103/0 integer 25 coordinateLabels[103][0] +/coordinates/103/1 integer 7 coordinateLabels[103][1] +/free_parameters integer 33 freeParameters +/parameter_order object_keys ["class_parameters","g_points"] parameter_order (split below) +/parameter_order/class_parameters integer 26 parameterClassCount +/parameter_order/g_points array_length 7 gPoints +/parameter_order/g_points/0 integer 1 gPoints[0] +/parameter_order/g_points/1 integer 2 gPoints[1] +/parameter_order/g_points/2 integer 3 gPoints[2] +/parameter_order/g_points/3 integer 4 gPoints[3] +/parameter_order/g_points/4 integer 5 gPoints[4] +/parameter_order/g_points/5 integer 6 gPoints[5] +/parameter_order/g_points/6 integer 7 gPoints[6] +/rank integer 71 rankMetadata diff --git a/research/p112-integral-retraction-instance/source/DECLARATIONS.tsv b/research/p112-integral-retraction-instance/source/DECLARATIONS.tsv new file mode 100644 index 0000000000..8a68704980 --- /dev/null +++ b/research/p112-integral-retraction-instance/source/DECLARATIONS.tsv @@ -0,0 +1,637 @@ +file line kind declaration origin +P112/MP00.lean 18 theorem P112Cert.mp_row_000 new +P112/MP00.lean 23 theorem P112Cert.mp_row_001 new +P112/MP00.lean 28 theorem P112Cert.mp_row_002 new +P112/MP00.lean 33 theorem P112Cert.mp_row_003 new +P112/MP00.lean 38 theorem P112Cert.mp_row_004 new +P112/MP00.lean 43 theorem P112Cert.mp_row_005 new +P112/MP00.lean 48 theorem P112Cert.mp_row_006 new +P112/MP00.lean 53 theorem P112Cert.mp_row_007 new +P112/MP00.lean 58 theorem P112Cert.mp_row_008 new +P112/MP00.lean 63 theorem P112Cert.mp_row_009 new +P112/MP00.lean 68 theorem P112Cert.mp_row_010 new +P112/MP00.lean 73 theorem P112Cert.mp_row_011 new +P112/MP00.lean 78 theorem P112Cert.mp_row_012 new +P112/MP00.lean 83 theorem P112Cert.mp_row_013 new +P112/MP00.lean 88 theorem P112Cert.mp_row_014 new +P112/MP00.lean 93 theorem P112Cert.mp_row_015 new +P112/MP01.lean 18 theorem P112Cert.mp_row_016 new +P112/MP01.lean 23 theorem P112Cert.mp_row_017 new +P112/MP01.lean 28 theorem P112Cert.mp_row_018 new +P112/MP01.lean 33 theorem P112Cert.mp_row_019 new +P112/MP01.lean 38 theorem P112Cert.mp_row_020 new +P112/MP01.lean 43 theorem P112Cert.mp_row_021 new +P112/MP01.lean 48 theorem P112Cert.mp_row_022 new +P112/MP01.lean 53 theorem P112Cert.mp_row_023 new +P112/MP01.lean 58 theorem P112Cert.mp_row_024 new +P112/MP01.lean 63 theorem P112Cert.mp_row_025 new +P112/MP01.lean 68 theorem P112Cert.mp_row_026 new +P112/MP01.lean 73 theorem P112Cert.mp_row_027 new +P112/MP01.lean 78 theorem P112Cert.mp_row_028 new +P112/MP01.lean 83 theorem P112Cert.mp_row_029 new +P112/MP01.lean 88 theorem P112Cert.mp_row_030 new +P112/MP01.lean 93 theorem P112Cert.mp_row_031 new +P112/MP02.lean 18 theorem P112Cert.mp_row_032 new +P112/MP02.lean 23 theorem P112Cert.mp_row_033 new +P112/MP02.lean 28 theorem P112Cert.mp_row_034 new +P112/MP02.lean 33 theorem P112Cert.mp_row_035 new +P112/MP02.lean 38 theorem P112Cert.mp_row_036 new +P112/MP02.lean 43 theorem P112Cert.mp_row_037 new +P112/MP02.lean 48 theorem P112Cert.mp_row_038 new +P112/MP02.lean 53 theorem P112Cert.mp_row_039 new +P112/MP02.lean 58 theorem P112Cert.mp_row_040 new +P112/MP02.lean 63 theorem P112Cert.mp_row_041 new +P112/MP02.lean 68 theorem P112Cert.mp_row_042 new +P112/MP02.lean 73 theorem P112Cert.mp_row_043 new +P112/MP02.lean 78 theorem P112Cert.mp_row_044 new +P112/MP02.lean 83 theorem P112Cert.mp_row_045 new +P112/MP02.lean 88 theorem P112Cert.mp_row_046 new +P112/MP02.lean 93 theorem P112Cert.mp_row_047 new +P112/MP03.lean 18 theorem P112Cert.mp_row_048 new +P112/MP03.lean 23 theorem P112Cert.mp_row_049 new +P112/MP03.lean 28 theorem P112Cert.mp_row_050 new +P112/MP03.lean 33 theorem P112Cert.mp_row_051 new +P112/MP03.lean 38 theorem P112Cert.mp_row_052 new +P112/MP03.lean 43 theorem P112Cert.mp_row_053 new +P112/MP03.lean 48 theorem P112Cert.mp_row_054 new +P112/MP03.lean 53 theorem P112Cert.mp_row_055 new +P112/MP03.lean 58 theorem P112Cert.mp_row_056 new +P112/MP03.lean 63 theorem P112Cert.mp_row_057 new +P112/MP03.lean 68 theorem P112Cert.mp_row_058 new +P112/MP03.lean 73 theorem P112Cert.mp_row_059 new +P112/MP03.lean 78 theorem P112Cert.mp_row_060 new +P112/MP03.lean 83 theorem P112Cert.mp_row_061 new +P112/MP03.lean 88 theorem P112Cert.mp_row_062 new +P112/MP03.lean 93 theorem P112Cert.mp_row_063 new +P112/MP04.lean 18 theorem P112Cert.mp_row_064 new +P112/MP04.lean 23 theorem P112Cert.mp_row_065 new +P112/MP04.lean 28 theorem P112Cert.mp_row_066 new +P112/MP04.lean 33 theorem P112Cert.mp_row_067 new +P112/MP04.lean 38 theorem P112Cert.mp_row_068 new +P112/MP04.lean 43 theorem P112Cert.mp_row_069 new +P112/MP04.lean 48 theorem P112Cert.mp_row_070 new +P112/MP04.lean 53 theorem P112Cert.mp_row_071 new +P112/MP04.lean 58 theorem P112Cert.mp_row_072 new +P112/MP04.lean 63 theorem P112Cert.mp_row_073 new +P112/MP04.lean 68 theorem P112Cert.mp_row_074 new +P112/MP04.lean 73 theorem P112Cert.mp_row_075 new +P112/MP04.lean 78 theorem P112Cert.mp_row_076 new +P112/MP04.lean 83 theorem P112Cert.mp_row_077 new +P112/MP04.lean 88 theorem P112Cert.mp_row_078 new +P112/MP04.lean 93 theorem P112Cert.mp_row_079 new +P112/MP05.lean 18 theorem P112Cert.mp_row_080 new +P112/MP05.lean 23 theorem P112Cert.mp_row_081 new +P112/MP05.lean 28 theorem P112Cert.mp_row_082 new +P112/MP05.lean 33 theorem P112Cert.mp_row_083 new +P112/MP05.lean 38 theorem P112Cert.mp_row_084 new +P112/MP05.lean 43 theorem P112Cert.mp_row_085 new +P112/MP05.lean 48 theorem P112Cert.mp_row_086 new +P112/MP05.lean 53 theorem P112Cert.mp_row_087 new +P112/MP05.lean 58 theorem P112Cert.mp_row_088 new +P112/MP05.lean 63 theorem P112Cert.mp_row_089 new +P112/MP05.lean 68 theorem P112Cert.mp_row_090 new +P112/MP05.lean 73 theorem P112Cert.mp_row_091 new +P112/MP05.lean 78 theorem P112Cert.mp_row_092 new +P112/MP05.lean 83 theorem P112Cert.mp_row_093 new +P112/MP05.lean 88 theorem P112Cert.mp_row_094 new +P112/MP05.lean 93 theorem P112Cert.mp_row_095 new +P112/MP06.lean 18 theorem P112Cert.mp_row_096 new +P112/MP06.lean 23 theorem P112Cert.mp_row_097 new +P112/MP06.lean 28 theorem P112Cert.mp_row_098 new +P112/MP06.lean 33 theorem P112Cert.mp_row_099 new +P112/MP06.lean 38 theorem P112Cert.mp_row_100 new +P112/MP06.lean 43 theorem P112Cert.mp_row_101 new +P112/MP06.lean 48 theorem P112Cert.mp_row_102 new +P112/MP06.lean 53 theorem P112Cert.mp_row_103 new +P112/MP06.lean 58 theorem P112Cert.mp_row_104 new +P112/MP06.lean 63 theorem P112Cert.mp_row_105 new +P112/MP06.lean 68 theorem P112Cert.mp_row_106 new +P112/MP06.lean 73 theorem P112Cert.mp_row_107 new +P112/MP06.lean 78 theorem P112Cert.mp_row_108 new +P112/MP06.lean 83 theorem P112Cert.mp_row_109 new +P112/MP06.lean 88 theorem P112Cert.mp_row_110 new +P112/MP06.lean 93 theorem P112Cert.mp_row_111 new +P112/MP07.lean 18 theorem P112Cert.mp_row_112 new +P112/MP07.lean 23 theorem P112Cert.mp_row_113 new +P112/MP07.lean 28 theorem P112Cert.mp_row_114 new +P112/MP07.lean 33 theorem P112Cert.mp_row_115 new +P112/MP07.lean 38 theorem P112Cert.mp_row_116 new +P112/MP07.lean 43 theorem P112Cert.mp_row_117 new +P112/MP07.lean 48 theorem P112Cert.mp_row_118 new +P112/MP07.lean 53 theorem P112Cert.mp_row_119 new +P112/MP07.lean 58 theorem P112Cert.mp_row_120 new +P112/MP07.lean 63 theorem P112Cert.mp_row_121 new +P112/MP07.lean 68 theorem P112Cert.mp_row_122 new +P112/MP07.lean 73 theorem P112Cert.mp_row_123 new +P112/MP07.lean 78 theorem P112Cert.mp_row_124 new +P112/MP07.lean 83 theorem P112Cert.mp_row_125 new +P112/MP07.lean 88 theorem P112Cert.mp_row_126 new +P112/MP07.lean 93 theorem P112Cert.mp_row_127 new +P112/MP08.lean 18 theorem P112Cert.mp_row_128 new +P112/MP08.lean 23 theorem P112Cert.mp_row_129 new +P112/MP08.lean 28 theorem P112Cert.mp_row_130 new +P112/MP08.lean 33 theorem P112Cert.mp_row_131 new +P112/MP08.lean 38 theorem P112Cert.mp_row_132 new +P112/MP08.lean 43 theorem P112Cert.mp_row_133 new +P112/MP08.lean 48 theorem P112Cert.mp_row_134 new +P112/MP08.lean 53 theorem P112Cert.mp_row_135 new +P112/MP08.lean 58 theorem P112Cert.mp_row_136 new +P112/MP08.lean 63 theorem P112Cert.mp_row_137 new +P112/MP08.lean 68 theorem P112Cert.mp_row_138 new +P112/MP08.lean 73 theorem P112Cert.mp_row_139 new +P112/MP08.lean 78 theorem P112Cert.mp_row_140 new +P112/MP08.lean 83 theorem P112Cert.mp_row_141 new +P112/MP08.lean 88 theorem P112Cert.mp_row_142 new +P112/MP08.lean 93 theorem P112Cert.mp_row_143 new +P112/MP09.lean 18 theorem P112Cert.mp_row_144 new +P112/MP09.lean 23 theorem P112Cert.mp_row_145 new +P112/MP09.lean 28 theorem P112Cert.mp_row_146 new +P112/MP09.lean 33 theorem P112Cert.mp_row_147 new +P112/MP09.lean 38 theorem P112Cert.mp_row_148 new +P112/MP09.lean 43 theorem P112Cert.mp_row_149 new +P112/MP09.lean 48 theorem P112Cert.mp_row_150 new +P112/MP09.lean 53 theorem P112Cert.mp_row_151 new +P112/MP09.lean 58 theorem P112Cert.mp_row_152 new +P112/MP09.lean 63 theorem P112Cert.mp_row_153 new +P112/MP09.lean 68 theorem P112Cert.mp_row_154 new +P112/MP09.lean 73 theorem P112Cert.mp_row_155 new +P112/MP09.lean 78 theorem P112Cert.mp_row_156 new +P112/MP09.lean 83 theorem P112Cert.mp_row_157 new +P112/MP09.lean 88 theorem P112Cert.mp_row_158 new +P112/MP09.lean 93 theorem P112Cert.mp_row_159 new +P112/MP10.lean 18 theorem P112Cert.mp_row_160 new +P112/MP10.lean 23 theorem P112Cert.mp_row_161 new +P112/MP10.lean 28 theorem P112Cert.mp_row_162 new +P112/MP10.lean 33 theorem P112Cert.mp_row_163 new +P112/MP10.lean 38 theorem P112Cert.mp_row_164 new +P112/MP10.lean 43 theorem P112Cert.mp_row_165 new +P112/MP10.lean 48 theorem P112Cert.mp_row_166 new +P112/MP10.lean 53 theorem P112Cert.mp_row_167 new +P112/MP10.lean 58 theorem P112Cert.mp_row_168 new +P112/MP10.lean 63 theorem P112Cert.mp_row_169 new +P112/MP10.lean 68 theorem P112Cert.mp_row_170 new +P112/MP10.lean 73 theorem P112Cert.mp_row_171 new +P112/MP10.lean 78 theorem P112Cert.mp_row_172 new +P112/MP10.lean 83 theorem P112Cert.mp_row_173 new +P112/MP10.lean 88 theorem P112Cert.mp_row_174 new +P112/MP10.lean 93 theorem P112Cert.mp_row_175 new +P112/MP11.lean 18 theorem P112Cert.mp_row_176 new +P112/MP11.lean 23 theorem P112Cert.mp_row_177 new +P112/MP11.lean 28 theorem P112Cert.mp_row_178 new +P112/MP11.lean 33 theorem P112Cert.mp_row_179 new +P112/MP11.lean 38 theorem P112Cert.mp_row_180 new +P112/MP11.lean 43 theorem P112Cert.mp_row_181 new +P112/MP11.lean 48 theorem P112Cert.mp_row_182 new +P112/MP11.lean 53 theorem P112Cert.mp_row_183 new +P112/MP11.lean 58 theorem P112Cert.mp_row_184 new +P112/MP11.lean 63 theorem P112Cert.mp_row_185 new +P112/MP11.lean 68 theorem P112Cert.mp_row_186 new +P112/MP11.lean 73 theorem P112Cert.mp_row_187 new +P112/MP11.lean 78 theorem P112Cert.mp_row_188 new +P112/MP11.lean 83 theorem P112Cert.mp_row_189 new +P112/MP11.lean 88 theorem P112Cert.mp_row_190 new +P112/MP11.lean 93 theorem P112Cert.mp_row_191 new +P112/MP12.lean 18 theorem P112Cert.mp_row_192 new +P112/MP12.lean 23 theorem P112Cert.mp_row_193 new +P112/MP12.lean 28 theorem P112Cert.mp_row_194 new +P112/MP12.lean 33 theorem P112Cert.mp_row_195 new +P112/MP12.lean 38 theorem P112Cert.mp_row_196 new +P112/MP12.lean 43 theorem P112Cert.mp_row_197 new +P112/MP12.lean 48 theorem P112Cert.mp_row_198 new +P112/MP12.lean 53 theorem P112Cert.mp_row_199 new +P112/MP12.lean 58 theorem P112Cert.mp_row_200 new +P112/MP12.lean 63 theorem P112Cert.mp_row_201 new +P112/MP12.lean 68 theorem P112Cert.mp_row_202 new +P112/MP12.lean 73 theorem P112Cert.mp_row_203 new +P112/MP12.lean 78 theorem P112Cert.mp_row_204 new +P112/MP12.lean 83 theorem P112Cert.mp_row_205 new +P112/MP12.lean 88 theorem P112Cert.mp_row_206 new +P112/MP12.lean 93 theorem P112Cert.mp_row_207 new +P112/MP13.lean 18 theorem P112Cert.mp_row_208 new +P112/MP13.lean 23 theorem P112Cert.mp_row_209 new +P112/MP13.lean 28 theorem P112Cert.mp_row_210 new +P112/MP13.lean 33 theorem P112Cert.mp_row_211 new +P112/MP13.lean 38 theorem P112Cert.mp_row_212 new +P112/MP13.lean 43 theorem P112Cert.mp_row_213 new +P112/MP13.lean 48 theorem P112Cert.mp_row_214 new +P112/MP13.lean 53 theorem P112Cert.mp_row_215 new +P112/MP13.lean 58 theorem P112Cert.mp_row_216 new +P112/MP13.lean 63 theorem P112Cert.mp_row_217 new +P112/MP13.lean 68 theorem P112Cert.mp_row_218 new +P112/MP13.lean 73 theorem P112Cert.mp_row_219 new +P112/MP13.lean 78 theorem P112Cert.mp_row_220 new +P112/MP13.lean 83 theorem P112Cert.mp_row_221 new +P112/MP13.lean 88 theorem P112Cert.mp_row_222 new +P112/MP13.lean 93 theorem P112Cert.mp_row_223 new +P112/MP14.lean 18 theorem P112Cert.mp_row_224 new +P112/MP14.lean 23 theorem P112Cert.mp_row_225 new +P112/MP14.lean 28 theorem P112Cert.mp_row_226 new +P112/MP14.lean 33 theorem P112Cert.mp_row_227 new +P112/MP14.lean 38 theorem P112Cert.mp_row_228 new +P112/MP14.lean 43 theorem P112Cert.mp_row_229 new +P112/MP14.lean 48 theorem P112Cert.mp_row_230 new +P112/MP14.lean 53 theorem P112Cert.mp_row_231 new +P112/MP14.lean 58 theorem P112Cert.mp_row_232 new +P112/MP14.lean 63 theorem P112Cert.mp_row_233 new +P112/MP14.lean 68 theorem P112Cert.mp_row_234 new +P112/MP14.lean 73 theorem P112Cert.mp_row_235 new +P112/MP14.lean 78 theorem P112Cert.mp_row_236 new +P112/MP14.lean 83 theorem P112Cert.mp_row_237 new +P112/MP14.lean 88 theorem P112Cert.mp_row_238 new +P112/MP14.lean 93 theorem P112Cert.mp_row_239 new +P112/MP15.lean 18 theorem P112Cert.mp_row_240 new +P112/MP15.lean 23 theorem P112Cert.mp_row_241 new +P112/MP15.lean 28 theorem P112Cert.mp_row_242 new +P112/MP15.lean 33 theorem P112Cert.mp_row_243 new +P112/MP15.lean 38 theorem P112Cert.mp_row_244 new +P112/MP15.lean 43 theorem P112Cert.mp_row_245 new +P112/MP15.lean 48 theorem P112Cert.mp_row_246 new +P112/MP15.lean 53 theorem P112Cert.mp_row_247 new +P112/MP15.lean 58 theorem P112Cert.mp_row_248 new +P112/MP15.lean 63 theorem P112Cert.mp_row_249 new +P112/MP15.lean 68 theorem P112Cert.mp_row_250 new +P112/MP15.lean 73 theorem P112Cert.mp_row_251 new +P112/MP15.lean 78 theorem P112Cert.mp_row_252 new +P112/MP15.lean 83 theorem P112Cert.mp_row_253 new +P112/MP15.lean 88 theorem P112Cert.mp_row_254 new +P112/MP15.lean 93 theorem P112Cert.mp_row_255 new +P112/MP16.lean 18 theorem P112Cert.mp_row_256 new +P112/MP16.lean 23 theorem P112Cert.mp_row_257 new +P112/MP16.lean 28 theorem P112Cert.mp_row_258 new +P112/MP16.lean 33 theorem P112Cert.mp_row_259 new +P112/MP16.lean 38 theorem P112Cert.mp_row_260 new +P112/MP16.lean 43 theorem P112Cert.mp_row_261 new +P112/MP16.lean 48 theorem P112Cert.mp_row_262 new +P112/MP16.lean 53 theorem P112Cert.mp_row_263 new +P112/MP16.lean 58 theorem P112Cert.mp_row_264 new +P112/MP16.lean 63 theorem P112Cert.mp_row_265 new +P112/MP16.lean 68 theorem P112Cert.mp_row_266 new +P112/MP16.lean 73 theorem P112Cert.mp_row_267 new +P112/MP16.lean 78 theorem P112Cert.mp_row_268 new +P112/MP16.lean 83 theorem P112Cert.mp_row_269 new +P112/MP16.lean 88 theorem P112Cert.mp_row_270 new +P112/MP16.lean 93 theorem P112Cert.mp_row_271 new +P112/MP17.lean 18 theorem P112Cert.mp_row_272 new +P112/MP17.lean 23 theorem P112Cert.mp_row_273 new +P112/MP17.lean 28 theorem P112Cert.mp_row_274 new +P112/MP17.lean 33 theorem P112Cert.mp_row_275 new +P112/MP17.lean 38 theorem P112Cert.mp_row_276 new +P112/MP17.lean 43 theorem P112Cert.mp_row_277 new +P112/MP17.lean 48 theorem P112Cert.mp_row_278 new +P112/MP17.lean 53 theorem P112Cert.mp_row_279 new +P112/MP17.lean 58 theorem P112Cert.mp_row_280 new +P112/MP17.lean 63 theorem P112Cert.mp_row_281 new +P112/MP17.lean 68 theorem P112Cert.mp_row_282 new +P112/MP17.lean 73 theorem P112Cert.mp_row_283 new +P112/MP17.lean 78 theorem P112Cert.mp_row_284 new +P112/MP17.lean 83 theorem P112Cert.mp_row_285 new +P112/MP17.lean 88 theorem P112Cert.mp_row_286 new +P112/MP17.lean 93 theorem P112Cert.mp_row_287 new +P112/QP00.lean 18 theorem P112Cert.qp_row_000 new +P112/QP00.lean 23 theorem P112Cert.qp_row_001 new +P112/QP00.lean 28 theorem P112Cert.qp_row_002 new +P112/QP00.lean 33 theorem P112Cert.qp_row_003 new +P112/QP00.lean 38 theorem P112Cert.qp_row_004 new +P112/QP00.lean 43 theorem P112Cert.qp_row_005 new +P112/QP00.lean 48 theorem P112Cert.qp_row_006 new +P112/QP00.lean 53 theorem P112Cert.qp_row_007 new +P112/QP00.lean 58 theorem P112Cert.qp_row_008 new +P112/QP00.lean 63 theorem P112Cert.qp_row_009 new +P112/QP00.lean 68 theorem P112Cert.qp_row_010 new +P112/QP00.lean 73 theorem P112Cert.qp_row_011 new +P112/QP00.lean 78 theorem P112Cert.qp_row_012 new +P112/QP00.lean 83 theorem P112Cert.qp_row_013 new +P112/QP00.lean 88 theorem P112Cert.qp_row_014 new +P112/QP00.lean 93 theorem P112Cert.qp_row_015 new +P112/QP01.lean 18 theorem P112Cert.qp_row_016 new +P112/QP01.lean 23 theorem P112Cert.qp_row_017 new +P112/QP01.lean 28 theorem P112Cert.qp_row_018 new +P112/QP01.lean 33 theorem P112Cert.qp_row_019 new +P112/QP01.lean 38 theorem P112Cert.qp_row_020 new +P112/QP01.lean 43 theorem P112Cert.qp_row_021 new +P112/QP01.lean 48 theorem P112Cert.qp_row_022 new +P112/QP01.lean 53 theorem P112Cert.qp_row_023 new +P112/QP01.lean 58 theorem P112Cert.qp_row_024 new +P112/QP01.lean 63 theorem P112Cert.qp_row_025 new +P112/QP01.lean 68 theorem P112Cert.qp_row_026 new +P112/QP01.lean 73 theorem P112Cert.qp_row_027 new +P112/QP01.lean 78 theorem P112Cert.qp_row_028 new +P112/QP01.lean 83 theorem P112Cert.qp_row_029 new +P112/QP01.lean 88 theorem P112Cert.qp_row_030 new +P112/QP01.lean 93 theorem P112Cert.qp_row_031 new +P112/QP02.lean 18 theorem P112Cert.qp_row_032 new +P112/Residual00.lean 18 theorem P112Cert.residual_row_000 new +P112/Residual00.lean 24 theorem P112Cert.residual_row_001 new +P112/Residual00.lean 30 theorem P112Cert.residual_row_002 new +P112/Residual00.lean 36 theorem P112Cert.residual_row_003 new +P112/Residual00.lean 42 theorem P112Cert.residual_row_004 new +P112/Residual00.lean 48 theorem P112Cert.residual_row_005 new +P112/Residual00.lean 54 theorem P112Cert.residual_row_006 new +P112/Residual00.lean 60 theorem P112Cert.residual_row_007 new +P112/Residual01.lean 18 theorem P112Cert.residual_row_008 new +P112/Residual01.lean 24 theorem P112Cert.residual_row_009 new +P112/Residual01.lean 30 theorem P112Cert.residual_row_010 new +P112/Residual01.lean 36 theorem P112Cert.residual_row_011 new +P112/Residual01.lean 42 theorem P112Cert.residual_row_012 new +P112/Residual01.lean 48 theorem P112Cert.residual_row_013 new +P112/Residual01.lean 54 theorem P112Cert.residual_row_014 new +P112/Residual01.lean 60 theorem P112Cert.residual_row_015 new +P112/Residual02.lean 18 theorem P112Cert.residual_row_016 new +P112/Residual02.lean 24 theorem P112Cert.residual_row_017 new +P112/Residual02.lean 30 theorem P112Cert.residual_row_018 new +P112/Residual02.lean 36 theorem P112Cert.residual_row_019 new +P112/Residual02.lean 42 theorem P112Cert.residual_row_020 new +P112/Residual02.lean 48 theorem P112Cert.residual_row_021 new +P112/Residual02.lean 54 theorem P112Cert.residual_row_022 new +P112/Residual02.lean 60 theorem P112Cert.residual_row_023 new +P112/Residual03.lean 18 theorem P112Cert.residual_row_024 new +P112/Residual03.lean 24 theorem P112Cert.residual_row_025 new +P112/Residual03.lean 30 theorem P112Cert.residual_row_026 new +P112/Residual03.lean 36 theorem P112Cert.residual_row_027 new +P112/Residual03.lean 42 theorem P112Cert.residual_row_028 new +P112/Residual03.lean 48 theorem P112Cert.residual_row_029 new +P112/Residual03.lean 54 theorem P112Cert.residual_row_030 new +P112/Residual03.lean 60 theorem P112Cert.residual_row_031 new +P112/Residual04.lean 18 theorem P112Cert.residual_row_032 new +P112/Residual04.lean 24 theorem P112Cert.residual_row_033 new +P112/Residual04.lean 30 theorem P112Cert.residual_row_034 new +P112/Residual04.lean 36 theorem P112Cert.residual_row_035 new +P112/Residual04.lean 42 theorem P112Cert.residual_row_036 new +P112/Residual04.lean 48 theorem P112Cert.residual_row_037 new +P112/Residual04.lean 54 theorem P112Cert.residual_row_038 new +P112/Residual04.lean 60 theorem P112Cert.residual_row_039 new +P112/Residual05.lean 18 theorem P112Cert.residual_row_040 new +P112/Residual05.lean 24 theorem P112Cert.residual_row_041 new +P112/Residual05.lean 30 theorem P112Cert.residual_row_042 new +P112/Residual05.lean 36 theorem P112Cert.residual_row_043 new +P112/Residual05.lean 42 theorem P112Cert.residual_row_044 new +P112/Residual05.lean 48 theorem P112Cert.residual_row_045 new +P112/Residual05.lean 54 theorem P112Cert.residual_row_046 new +P112/Residual05.lean 60 theorem P112Cert.residual_row_047 new +P112/Residual06.lean 18 theorem P112Cert.residual_row_048 new +P112/Residual06.lean 24 theorem P112Cert.residual_row_049 new +P112/Residual06.lean 30 theorem P112Cert.residual_row_050 new +P112/Residual06.lean 36 theorem P112Cert.residual_row_051 new +P112/Residual06.lean 42 theorem P112Cert.residual_row_052 new +P112/Residual06.lean 48 theorem P112Cert.residual_row_053 new +P112/Residual06.lean 54 theorem P112Cert.residual_row_054 new +P112/Residual06.lean 60 theorem P112Cert.residual_row_055 new +P112/Residual07.lean 18 theorem P112Cert.residual_row_056 new +P112/Residual07.lean 24 theorem P112Cert.residual_row_057 new +P112/Residual07.lean 30 theorem P112Cert.residual_row_058 new +P112/Residual07.lean 36 theorem P112Cert.residual_row_059 new +P112/Residual07.lean 42 theorem P112Cert.residual_row_060 new +P112/Residual07.lean 48 theorem P112Cert.residual_row_061 new +P112/Residual07.lean 54 theorem P112Cert.residual_row_062 new +P112/Residual07.lean 60 theorem P112Cert.residual_row_063 new +P112/Residual08.lean 18 theorem P112Cert.residual_row_064 new +P112/Residual08.lean 24 theorem P112Cert.residual_row_065 new +P112/Residual08.lean 30 theorem P112Cert.residual_row_066 new +P112/Residual08.lean 36 theorem P112Cert.residual_row_067 new +P112/Residual08.lean 42 theorem P112Cert.residual_row_068 new +P112/Residual08.lean 48 theorem P112Cert.residual_row_069 new +P112/Residual08.lean 54 theorem P112Cert.residual_row_070 new +P112/Residual08.lean 60 theorem P112Cert.residual_row_071 new +P112/Residual09.lean 18 theorem P112Cert.residual_row_072 new +P112/Residual09.lean 24 theorem P112Cert.residual_row_073 new +P112/Residual09.lean 30 theorem P112Cert.residual_row_074 new +P112/Residual09.lean 36 theorem P112Cert.residual_row_075 new +P112/Residual09.lean 42 theorem P112Cert.residual_row_076 new +P112/Residual09.lean 48 theorem P112Cert.residual_row_077 new +P112/Residual09.lean 54 theorem P112Cert.residual_row_078 new +P112/Residual09.lean 60 theorem P112Cert.residual_row_079 new +P112/Residual10.lean 18 theorem P112Cert.residual_row_080 new +P112/Residual10.lean 24 theorem P112Cert.residual_row_081 new +P112/Residual10.lean 30 theorem P112Cert.residual_row_082 new +P112/Residual10.lean 36 theorem P112Cert.residual_row_083 new +P112/Residual10.lean 42 theorem P112Cert.residual_row_084 new +P112/Residual10.lean 48 theorem P112Cert.residual_row_085 new +P112/Residual10.lean 54 theorem P112Cert.residual_row_086 new +P112/Residual10.lean 60 theorem P112Cert.residual_row_087 new +P112/Residual11.lean 18 theorem P112Cert.residual_row_088 new +P112/Residual11.lean 24 theorem P112Cert.residual_row_089 new +P112/Residual11.lean 30 theorem P112Cert.residual_row_090 new +P112/Residual11.lean 36 theorem P112Cert.residual_row_091 new +P112/Residual11.lean 42 theorem P112Cert.residual_row_092 new +P112/Residual11.lean 48 theorem P112Cert.residual_row_093 new +P112/Residual11.lean 54 theorem P112Cert.residual_row_094 new +P112/Residual11.lean 60 theorem P112Cert.residual_row_095 new +P112/Residual12.lean 18 theorem P112Cert.residual_row_096 new +P112/Residual12.lean 24 theorem P112Cert.residual_row_097 new +P112/Residual12.lean 30 theorem P112Cert.residual_row_098 new +P112/Residual12.lean 36 theorem P112Cert.residual_row_099 new +P112/Residual12.lean 42 theorem P112Cert.residual_row_100 new +P112/Residual12.lean 48 theorem P112Cert.residual_row_101 new +P112/Residual12.lean 54 theorem P112Cert.residual_row_102 new +P112/Residual12.lean 60 theorem P112Cert.residual_row_103 new +P112Certificate.lean 50 theorem P112Cert.mp_sparse_all new +P112Certificate.lean 629 theorem P112Cert.qp_sparse_all new +P112Certificate.lean 698 theorem P112Cert.residual_sparse_all new +P112Certificate.lean 911 theorem P112Cert.mp new +P112Certificate.lean 918 theorem P112Cert.qp new +P112Certificate.lean 925 theorem P112Cert.residual new +P112Certificate.lean 941 theorem P112Cert.certificate new +P112Consequences.lean 19 theorem P112Cert.lattice_eq_kernel new +P112Consequences.lean 23 theorem P112Cert.phi_surjective new +P112Consequences.lean 27 def P112Cert.quotientIso new +P112Consequences.lean 31 theorem P112Cert.quotient_relation new +P112Consequences.lean 36 theorem P112Cert.quotient_forward_on_representative new +P112Consequences.lean 40 theorem P112Cert.quotient_inverse_on_parameter new +P112Consequences.lean 45 theorem P112Cert.quotient_left_inverse new +P112Consequences.lean 49 theorem P112Cert.quotient_right_inverse new +P112Consequences.lean 53 theorem P112Cert.lattice_saturated new +P112Consequences.lean 60 theorem P112Cert.reconstruction new +P112Consequences.lean 65 theorem P112Cert.reconstruct_coordinate new +P112Consequences.lean 70 theorem P112Cert.converse_relations new +P112Consequences.lean 74 theorem P112Cert.parameters_recover new +P112Consequences.lean 78 theorem P112Cert.unique_parameterization new +P112Consequences.lean 87 theorem P112Cert.residual_relations_formula new +P112Damaged.lean 19 def P112Cert.Damaged.W_entries_bad new +P112Damaged.lean 22 def P112Cert.Damaged.W_bad new +P112Damaged.lean 24 theorem P112Cert.Damaged.original_coefficient new +P112Damaged.lean 27 theorem P112Cert.Damaged.damaged_coefficient new +P112Damaged.lean 30 theorem P112Cert.Damaged.unchanged_other_rows new +P112Damaged.lean 36 theorem P112Cert.Damaged.residual_entry new +P112Damaged.lean 48 theorem P112Cert.Damaged.damaged_product_entry new +P112Damaged.lean 58 theorem P112Cert.Damaged.not_residual new +P112Damaged.lean 66 theorem P112Cert.Damaged.no_certificate new +P112Data.lean 18 def P112Cert.M_entries new +P112Data.lean 882 def P112Cert.M new +P112Data.lean 885 def P112Cert.P_entries new +P112Data.lean 1197 def P112Cert.P new +P112Data.lean 1200 def P112Cert.Q_entries new +P112Data.lean 1299 def P112Cert.Q new +P112Data.lean 1302 def P112Cert.W_entries new +P112Data.lean 1614 def P112Cert.W new +P112Data.lean 1617 def P112Cert.anchors new +P112Data.lean 1619 def P112Cert.basePairRepresentatives new +P112Data.lean 1621 def P112Cert.coordinateLabels new +P112Data.lean 1623 def P112Cert.freeParameters new +P112Data.lean 1625 def P112Cert.parameterClassCount new +P112Data.lean 1627 def P112Cert.gPoints new +P112Data.lean 1630 def P112Cert.rankMetadata new +P112Sparse.lean 20 def P112Cert.Sparse.row new +P112Sparse.lean 25 def P112Cert.Sparse.eval new +P112Sparse.lean 31 theorem P112Cert.Sparse.row_apply new +P112Sparse.lean 47 theorem P112Cert.Sparse.rowMul_scale new +P112Sparse.lean 56 theorem P112Cert.Sparse.rowMul_row new +P112Sparse.lean 69 theorem P112Cert.Sparse.allFinAdd new +PR1497Bridge.lean 37 structure PR1497.AbGroup inherited +PR1497Bridge.lean 52 def PR1497.AbGroup.sub inherited +PR1497Bridge.lean 54 theorem PR1497.AbGroup.add_left_cancel inherited +PR1497Bridge.lean 59 theorem PR1497.AbGroup.add_right_cancel inherited +PR1497Bridge.lean 67 theorem PR1497.AbGroup.add_left_comm inherited +PR1497Bridge.lean 71 theorem PR1497.AbGroup.add_four inherited +PR1497Bridge.lean 77 theorem PR1497.AbGroup.neg_zero inherited +PR1497Bridge.lean 82 theorem PR1497.AbGroup.neg_neg inherited +PR1497Bridge.lean 86 theorem PR1497.AbGroup.neg_add_distrib inherited +PR1497Bridge.lean 91 theorem PR1497.AbGroup.sub_zero inherited +PR1497Bridge.lean 94 theorem PR1497.AbGroup.sub_self inherited +PR1497Bridge.lean 96 theorem PR1497.AbGroup.sub_add_cancel inherited +PR1497Bridge.lean 99 theorem PR1497.AbGroup.add_sub_cancel inherited +PR1497Bridge.lean 102 theorem PR1497.AbGroup.sub_eq_zero_iff inherited +PR1497Bridge.lean 111 theorem PR1497.AbGroup.eq_of_sub_eq inherited +PR1497Bridge.lean 119 def PR1497.AbGroup.nsmul inherited +PR1497Bridge.lean 124 def PR1497.AbGroup.zsmul inherited +PR1497Bridge.lean 128 theorem PR1497.AbGroup.nsmul_zero inherited +PR1497Bridge.lean 133 theorem PR1497.AbGroup.zsmul_zero inherited +PR1497Bridge.lean 135 theorem PR1497.AbGroup.zsmul_zero_right inherited +PR1497Bridge.lean 140 theorem PR1497.AbGroup.zsmul_one inherited +PR1497Bridge.lean 145 theorem PR1497.AbGroup.int_induction inherited +PR1497Bridge.lean 158 theorem PR1497.AbGroup.zsmul_succ inherited +PR1497Bridge.lean 175 theorem PR1497.AbGroup.zsmul_pred inherited +PR1497Bridge.lean 187 theorem PR1497.AbGroup.zsmul_add inherited +PR1497Bridge.lean 201 structure PR1497.Hom inherited +PR1497Bridge.lean 212 def PR1497.Hom.id inherited +PR1497Bridge.lean 217 def PR1497.Hom.comp inherited +PR1497Bridge.lean 222 theorem PR1497.Hom.ext inherited +PR1497Bridge.lean 231 theorem PR1497.Hom.map_neg inherited +PR1497Bridge.lean 236 theorem PR1497.Hom.map_sub inherited +PR1497Bridge.lean 240 theorem PR1497.Hom.map_nsmul inherited +PR1497Bridge.lean 247 theorem PR1497.Hom.map_zsmul inherited +PR1497Bridge.lean 259 def PR1497.fsum inherited +PR1497Bridge.lean 268 theorem PR1497.Finite.sum_congr inherited +PR1497Bridge.lean 272 theorem PR1497.Finite.sum_zero inherited +PR1497Bridge.lean 277 theorem PR1497.Finite.sum_add inherited +PR1497Bridge.lean 294 theorem PR1497.Finite.sum_neg inherited +PR1497Bridge.lean 307 theorem PR1497.Finite.sum_sub inherited +PR1497Bridge.lean 312 theorem PR1497.Finite.sum_swap inherited +PR1497Bridge.lean 328 theorem PR1497.Finite.sum_single inherited +PR1497Bridge.lean 343 theorem PR1497.Finite.map_sum inherited +PR1497Bridge.lean 360 def PR1497.intGroup inherited +PR1497Bridge.lean 372 def PR1497.functionGroup inherited +PR1497Bridge.lean 384 abbrev PR1497.Row inherited +PR1497Bridge.lean 385 abbrev PR1497.Mat inherited +PR1497Bridge.lean 387 def PR1497.rowGroup inherited +PR1497Bridge.lean 389 def PR1497.scale inherited +PR1497Bridge.lean 391 def PR1497.basis inherited +PR1497Bridge.lean 393 def PR1497.eye inherited +PR1497Bridge.lean 395 def PR1497.zeroMat inherited +PR1497Bridge.lean 397 def PR1497.matSub inherited +PR1497Bridge.lean 400 def PR1497.rowMul inherited +PR1497Bridge.lean 404 def PR1497.matMul inherited +PR1497Bridge.lean 409 theorem PR1497.Rows.sum_apply inherited +PR1497Bridge.lean 424 theorem PR1497.Rows.nsmul_apply inherited +PR1497Bridge.lean 434 theorem PR1497.Rows.zsmul_apply inherited +PR1497Bridge.lean 444 theorem PR1497.Rows.int_nsmul inherited +PR1497Bridge.lean 452 theorem PR1497.Rows.int_zsmul inherited +PR1497Bridge.lean 461 theorem PR1497.Rows.row_zsmul inherited +PR1497Bridge.lean 466 theorem PR1497.Rows.sum_mul_right inherited +PR1497Bridge.lean 479 theorem PR1497.Rows.sum_mul_left inherited +PR1497Bridge.lean 486 theorem PR1497.Rows.rowMul_zero_left inherited +PR1497Bridge.lean 493 theorem PR1497.Rows.rowMul_zero_right inherited +PR1497Bridge.lean 500 theorem PR1497.Rows.rowMul_add inherited +PR1497Bridge.lean 510 theorem PR1497.Rows.rowMul_matSub inherited +PR1497Bridge.lean 521 theorem PR1497.Rows.rowMul_assoc inherited +PR1497Bridge.lean 550 theorem PR1497.Rows.rowMul_basis inherited +PR1497Bridge.lean 564 theorem PR1497.Rows.rowMul_eye inherited +PR1497Bridge.lean 578 theorem PR1497.Rows.rowMul_linear_combination inherited +PR1497Bridge.lean 592 def PR1497.Rows.rowHom inherited +PR1497Bridge.lean 602 structure PR1497.Retraction inherited +PR1497Bridge.lean 613 structure PR1497.AddIso inherited +PR1497Bridge.lean 621 def PR1497.TorsionFree inherited +PR1497Bridge.lean 631 def PR1497.Retraction.L inherited +PR1497Bridge.lean 633 theorem PR1497.Retraction.mem_image_iff inherited +PR1497Bridge.lean 645 theorem PR1497.Retraction.image_eq_kernel inherited +PR1497Bridge.lean 649 theorem PR1497.Retraction.surjective inherited +PR1497Bridge.lean 653 theorem PR1497.Retraction.decomposition inherited +PR1497Bridge.lean 658 def PR1497.Retraction.Rel inherited +PR1497Bridge.lean 660 theorem PR1497.Retraction.rel_iff inherited +PR1497Bridge.lean 665 def PR1497.Retraction.latticeSetoid inherited +PR1497Bridge.lean 678 abbrev PR1497.Retraction.LQuot inherited +PR1497Bridge.lean 680 def PR1497.Retraction.qmk inherited +PR1497Bridge.lean 683 def PR1497.Retraction.qmap inherited +PR1497Bridge.lean 686 def PR1497.Retraction.qinv inherited +PR1497Bridge.lean 688 theorem PR1497.Retraction.qmap_mk inherited +PR1497Bridge.lean 690 theorem PR1497.Retraction.qmap_qinv inherited +PR1497Bridge.lean 692 theorem PR1497.Retraction.qinv_qmap inherited +PR1497Bridge.lean 699 theorem PR1497.Retraction.qmap_injective inherited +PR1497Bridge.lean 706 def PR1497.Retraction.qadd inherited +PR1497Bridge.lean 714 def PR1497.Retraction.qneg inherited +PR1497Bridge.lean 721 theorem PR1497.Retraction.qmap_zero inherited +PR1497Bridge.lean 723 theorem PR1497.Retraction.qmap_add inherited +PR1497Bridge.lean 731 theorem PR1497.Retraction.qmap_neg inherited +PR1497Bridge.lean 740 def PR1497.Retraction.quotientGroup inherited +PR1497Bridge.lean 770 def PR1497.Retraction.quotientMap inherited +PR1497Bridge.lean 775 def PR1497.Retraction.quotientInv inherited +PR1497Bridge.lean 787 def PR1497.Retraction.quotientIso inherited +PR1497Bridge.lean 793 theorem PR1497.Retraction.saturated inherited +PR1497Bridge.lean 804 theorem PR1497.Retraction.character_factor inherited +PR1497Bridge.lean 811 theorem PR1497.Retraction.character_unique inherited +PR1497Bridge.lean 824 structure PR1497.MatrixIdentities inherited +PR1497Bridge.lean 831 def PR1497.matrixRetraction inherited +PR1497Bridge.lean 864 def PR1497.MatrixBridge.Lattice inherited +PR1497Bridge.lean 866 theorem PR1497.MatrixBridge.lattice_iff_integer_span inherited +PR1497Bridge.lean 879 theorem PR1497.MatrixBridge.lattice_eq_kernel inherited +PR1497Bridge.lean 884 theorem PR1497.MatrixBridge.lattice_eq_kernel_as_predicate inherited +PR1497Bridge.lean 889 theorem PR1497.MatrixBridge.quotient_relation inherited +PR1497Bridge.lean 894 theorem PR1497.MatrixBridge.quotient_equal_iff inherited +PR1497Bridge.lean 904 theorem PR1497.MatrixBridge.phi_surjective inherited +PR1497Bridge.lean 908 def PR1497.MatrixBridge.quotientIso inherited +PR1497Bridge.lean 912 theorem PR1497.MatrixBridge.quotient_forward_on_representative inherited +PR1497Bridge.lean 916 theorem PR1497.MatrixBridge.quotient_inverse_on_parameter inherited +PR1497Bridge.lean 921 theorem PR1497.MatrixBridge.quotient_left_inverse inherited +PR1497Bridge.lean 926 theorem PR1497.MatrixBridge.quotient_right_inverse inherited +PR1497Bridge.lean 932 theorem PR1497.MatrixBridge.row_torsion_free inherited +PR1497Bridge.lean 940 theorem PR1497.MatrixBridge.lattice_saturated inherited +PR1497Bridge.lean 953 structure PR1497.CommGroup inherited +PR1497Bridge.lean 969 def PR1497.CommGroup.asAdd inherited +PR1497Bridge.lean 980 def PR1497.CommGroup.npow inherited +PR1497Bridge.lean 982 def PR1497.CommGroup.zpow inherited +PR1497Bridge.lean 984 def PR1497.CommGroup.prod inherited +PR1497Bridge.lean 986 def PR1497.CommGroup.div inherited +PR1497Bridge.lean 988 theorem PR1497.CommGroup.npow_zero inherited +PR1497Bridge.lean 990 theorem PR1497.CommGroup.npow_succ inherited +PR1497Bridge.lean 993 theorem PR1497.CommGroup.zpow_nat inherited +PR1497Bridge.lean 996 theorem PR1497.CommGroup.zpow_negative inherited +PR1497Bridge.lean 999 theorem PR1497.CommGroup.zpow_zero inherited +PR1497Bridge.lean 1001 theorem PR1497.CommGroup.zpow_one inherited +PR1497Bridge.lean 1003 theorem PR1497.CommGroup.one_zpow inherited +PR1497Bridge.lean 1006 theorem PR1497.CommGroup.zpow_add inherited +PR1497Bridge.lean 1010 theorem PR1497.CommGroup.prod_zero inherited +PR1497Bridge.lean 1012 theorem PR1497.CommGroup.prod_succ inherited +PR1497Bridge.lean 1015 theorem PR1497.CommGroup.prod_mul inherited +PR1497Bridge.lean 1023 def PR1497.monomial inherited +PR1497Bridge.lean 1028 def PR1497.monomialHom inherited +PR1497Bridge.lean 1048 theorem PR1497.Character.row_image inherited +PR1497Bridge.lean 1058 theorem PR1497.Character.rows_annihilate_span inherited +PR1497Bridge.lean 1075 theorem PR1497.Monomial.zero inherited +PR1497Bridge.lean 1078 theorem PR1497.Monomial.add inherited +PR1497Bridge.lean 1083 theorem PR1497.Monomial.sub inherited +PR1497Bridge.lean 1088 theorem PR1497.Monomial.scale inherited +PR1497Bridge.lean 1093 theorem PR1497.Monomial.on_basis inherited +PR1497Bridge.lean 1108 theorem PR1497.Monomial.substitution inherited +PR1497Bridge.lean 1114 theorem PR1497.Monomial.individual_rows_to_span inherited +PR1497Bridge.lean 1127 def PR1497.MonomialBridge.parameters inherited +PR1497Bridge.lean 1130 def PR1497.MonomialBridge.realization inherited +PR1497Bridge.lean 1133 def PR1497.MonomialBridge.Relations inherited +PR1497Bridge.lean 1140 theorem PR1497.MonomialBridge.reconstruction_all_exponents inherited +PR1497Bridge.lean 1154 theorem PR1497.MonomialBridge.reconstruct_coordinate inherited +PR1497Bridge.lean 1162 theorem PR1497.MonomialBridge.reconstruction inherited +PR1497Bridge.lean 1169 theorem PR1497.MonomialBridge.converse_relations inherited +PR1497Bridge.lean 1182 theorem PR1497.MonomialBridge.parameters_recover inherited +PR1497Bridge.lean 1195 theorem PR1497.MonomialBridge.parameters_unique inherited +PR1497Bridge.lean 1204 theorem PR1497.MonomialBridge.residual_exponent_formula inherited +PR1497Bridge.lean 1214 theorem PR1497.MonomialBridge.residual_relations_formula inherited +PR1497Bridge.lean 1224 theorem PR1497.MonomialBridge.residual_eq_one inherited +PR1497Bridge.lean 1231 theorem PR1497.MonomialBridge.unique_parameterization inherited diff --git a/research/p112-integral-retraction-instance/source/GENERATED_FILES.txt b/research/p112-integral-retraction-instance/source/GENERATED_FILES.txt new file mode 100644 index 0000000000..eb03b46c93 --- /dev/null +++ b/research/p112-integral-retraction-instance/source/GENERATED_FILES.txt @@ -0,0 +1,39 @@ +BINDING.tsv +GENERATED_FILES.txt +P112/MP00.lean +P112/MP01.lean +P112/MP02.lean +P112/MP03.lean +P112/MP04.lean +P112/MP05.lean +P112/MP06.lean +P112/MP07.lean +P112/MP08.lean +P112/MP09.lean +P112/MP10.lean +P112/MP11.lean +P112/MP12.lean +P112/MP13.lean +P112/MP14.lean +P112/MP15.lean +P112/MP16.lean +P112/MP17.lean +P112/QP00.lean +P112/QP01.lean +P112/QP02.lean +P112/Residual00.lean +P112/Residual01.lean +P112/Residual02.lean +P112/Residual03.lean +P112/Residual04.lean +P112/Residual05.lean +P112/Residual06.lean +P112/Residual07.lean +P112/Residual08.lean +P112/Residual09.lean +P112/Residual10.lean +P112/Residual11.lean +P112/Residual12.lean +P112Certificate.lean +P112Data.lean +REPLAY_PLAN.json diff --git a/research/p112-integral-retraction-instance/source/LICENSE b/research/p112-integral-retraction-instance/source/LICENSE new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/research/p112-integral-retraction-instance/source/LICENSE @@ -0,0 +1,202 @@ + + 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/p112-integral-retraction-instance/source/MANIFEST.tsv b/research/p112-integral-retraction-instance/source/MANIFEST.tsv new file mode 100644 index 0000000000..05f69670cc --- /dev/null +++ b/research/p112-integral-retraction-instance/source/MANIFEST.tsv @@ -0,0 +1,66 @@ +path utf8_bytes sha256 +BINDING.tsv 226603 2706652f5ab357ec00ae5d549eb750a289c10b587343ebf6695a9be756390246 +DECLARATIONS.tsv 36006 c27eed09af9db4cec1dabe690f9c81efbdb2c9a9830083b2e2656d20c1f964f0 +GENERATED_FILES.txt 672 f2d5d48ebf1f55edac441fea1b8f3a879d7d7471fa7e7b6dca63a59fb1dc927d +LICENSE 11358 cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30 +P112/MP00.lean 3678 13f94407d2f564d1df02abd05d65c789f9ef0fd146ea83f219cc2b0790530da5 +P112/MP01.lean 3698 374fac864b91f4d3be22c064933bd04fe68479e0aae3a2d47f417c053ebf7c26 +P112/MP02.lean 3698 a2d4ce0941183e59c87d89a1369bd8cae8e5aa17457a20352ecbcdd0eec847ac +P112/MP03.lean 3698 25846cbeac859682f102a4eba089f88fd6aece81538d368422b0347323d9a450 +P112/MP04.lean 3698 9c9694edc8e991dcc669d37de9116309c86bf408743993384b01c6bf7eae0e64 +P112/MP05.lean 3698 e90fd3cebc97e91d1fec063ccd50fa67e82375c23e317d755ee52de07c6e2840 +P112/MP06.lean 3722 02d4f4c3dc89e560e8f1109b051bb912f26e6a238c8f3c25237b67b144321f7e +P112/MP07.lean 3730 39452ad57ba92c9cd54e9868a663b1b773c25143e0c24556899153cbcdae3842 +P112/MP08.lean 3730 5905bb732b9976adba77dab859b52f1a3dbd01a2368ca92e1144d98db0c0b967 +P112/MP09.lean 3730 580c7521ccf594444d673a66280d448d36f5111bdfdc5303ad95547420c49ca2 +P112/MP10.lean 3730 317283042cdb1844c55de12c5fc9afaaf8efbd97552f64d7a3172a3b51fbd4d3 +P112/MP11.lean 3730 e8898d45d1e5d0e39235b6a1eaf1880cdb9928442b4238d3a909a0b725ca394e +P112/MP12.lean 3730 9244768a96a7351430167c9865051fcac394f591cd37bb21b8a93c59a0d9295a +P112/MP13.lean 3730 b84a8d8657b85161f98fb8971b574526a6d53fce9e50847f59bf816a91351a38 +P112/MP14.lean 3730 03915213d9aec2110071dcfd205de00e929220d092ea8238ed9036f96ac1fc4f +P112/MP15.lean 3730 c1342bca97cb22f3773f16453fa88ec4a4ec4a5b2ad8deaa8f37317cc131fa04 +P112/MP16.lean 3730 47336a6652bdfb9efac4291b73be99f41efe2fc68014562bd86ff092a34f2368 +P112/MP17.lean 3730 7da6a378c8e262cd027a7b8391df3f9b8c445eb750a5e2e11a2fa988314368a5 +P112/QP00.lean 4100 b5015a85de7edf9df93f1b00fd6433113ef25ef177b75a840cdaa29068e5edff +P112/QP01.lean 4130 e00cc8dd0c6798387436fa2625ef7bc59d61bfdf0b67efc4d5b132d1b9679f43 +P112/QP02.lean 725 4fa1e2783b8082d03b434d7acc6549de4027d3e72685c9913158283c76957ea7 +P112/Residual00.lean 2890 f0018130a836f72d6a830da8247d4cd37df7df7c9418f5c528785227e364b577 +P112/Residual01.lean 2914 c31b6b2d62e7b4dc0ff2d7d93c9510160c4015da8cf03729345fa4afec6e7db2 +P112/Residual02.lean 2922 fd3d9e3ec624ef77309b78f21214f9e1d44ad97b96c1268bf3f10924a50ca1f2 +P112/Residual03.lean 2922 fee2b63b5a52a3f0cd88973c0b1e9ec75a3966ff152e42cf540cb20cc737cc05 +P112/Residual04.lean 2922 45bf845eb22460635f81d85757ed29e33622a5b123dc858b5f0673f3ad968c42 +P112/Residual05.lean 2922 1fce648ce627b596a758be98790829f4df7f414a90d29cec34bdcefe749c08dd +P112/Residual06.lean 2922 fc26879525f376ee93a7d4c037ca42e49c597372a30b82d4f1107c9f0c36d1bb +P112/Residual07.lean 2922 828f358afed3c9ea4839a3e15400294b77e313b31dcfd58b278f309e5f4854fd +P112/Residual08.lean 2922 665f03ae5197ee1b90c585613e717da85b682cae471d8b00da97846b28732497 +P112/Residual09.lean 2922 ada3f0b6e1e66fd4a16f56bbcfb62e02f248d3d085889697ff818f95ade3b95d +P112/Residual10.lean 2922 3dfeb23cd21058c8b98b58cc97d0fc2812d49efad5b1752dcb52cd2b47ff317f +P112/Residual11.lean 2922 6d7604d36d7879801758de815fbfbdf38b2975ae6cd5ce722c20709bd00c50bc +P112/Residual12.lean 2938 6a727a2c56358da83565fc27474cef83c02fb0fa5af53dae4e18af6d55675810 +P112.json 13183 a1b43a5a7a8dcce0b84858244c512e53e6c344877cc35e87937fedd2601f29d5 +P112Certificate.lean 49456 3cc91d09e6f743a3e2e0ed02b8d73246b306965c2f12e82f49deac8d16899ff0 +P112Consequences.lean 4848 bf2d28f786f2aeee4ea0e0d733ad3f6973c133fe9cde452c21fc36ca709444bc +P112Damaged.lean 3230 e915b6ca54379292462315ca613ccfe46e5d77acd2b31e07e83dbcd7f0f3fd32 +P112Data.lean 96317 c5619fb4e1b10663f48deb39272d191ba444f7052b0170a65186422e8177d967 +P112Sparse.lean 3312 1f9cae94b0767d117cd0c30c5852df385a1e98f6d255f130303130d9b7b4d071 +PR1497Bridge.lean 48758 a27494b0d40bbf7874fd9a875e468c67d11545b266e17bc98f2ca75c77f6ee40 +PRODUCER_CHECKS.json 5985 7255a96dad702adae230a08a231f708e1191821c13d63d51e535f6fa4f6fa341 +PROVENANCE.json 3115 76063decdff483be76ca871619ad7360ce9b40ee43e6c5d1188e7d570a0ac3eb +README.md 6783 b551eb494b04f314f1e844f32d69fd7e43e8830133bd54557dbcca33f2b98fac +REPLAY_PLAN.json 1311 cd587bce837cf4204b2a78194c45e53109a11f0b6c545505d99207dde1da8d3c +SCOPE.md 15164 754dbc101e4a1e52e6c4e809cccd6c4e40c2d1ed9b07414532b71006911e7103 +audit_sources.py 8220 c55d731d66c52a424c6aaee75ae854b8da1a822901ee473a425892ae822c526d +check_axioms.py 3063 23e86145231da2080a362aa69a01faa4bba9c2408d642155c83d57a29ab43a54 +check_numeric.py 5636 0abe2ff45db7e064d6ca01d7c9eee32b4ced2fd026e2e8c62e60e8105a5096d3 +fixtures/RejectDamagedW.lean 596 7796f968b92e57759776b10c9a37847ffde62bbc6d8a7fda321f09b3cba2dda5 +generate.py 16960 ebd2d4eeb44064c04ff6097d8b7e50e14370f893d56bd5b11536f225a10aa319 +producer/integer-check.stderr 0 e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 +producer/integer-check.stdout 824 808f025e73edf581cb4d0f232f375ed1447be3a7bdd1d38e5621ffc68805cfb4 +producer/regeneration.stderr 0 e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 +producer/regeneration.stdout 422 c30455250b56b4ad8d3184e7e9e3ec87bf30762e3144e14584c35eb29982d096 +producer/source-audit.stderr 0 e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 +producer/source-audit.stdout 703 4bee7de0aa02385c1afd581b1ea9726c603e3c2ecd18c68a19c4a5a8af674181 +producer/tooling-tests.stderr 1711 2a9466d31616e93b0d5a055b32791ce466a2e14f55d89320d4686df1596fbba0 +producer/tooling-tests.stdout 0 e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 +replay.py 9961 cf32f674bfdc1b62903b8fa7d647d1c918f319f21d6e882bb59c38186e8f55c6 +test_tooling.py 5591 d34f2b4212dced3c922f77ccf5c702c108baef8b374c41aff7188036fb13d559 diff --git a/research/p112-integral-retraction-instance/source/P112.json b/research/p112-integral-retraction-instance/source/P112.json new file mode 100644 index 0000000000..c32cd88cdb --- /dev/null +++ b/research/p112-integral-retraction-instance/source/P112.json @@ -0,0 +1 @@ +{"M":[[[0,1],[1,-1],[4,-1],[5,1]],[[0,1],[1,-1],[8,-1],[9,1]],[[0,1],[1,-1],[12,-1],[13,1]],[[0,1],[1,-1],[16,-1],[17,1]],[[0,1],[2,-1],[20,-1],[21,1]],[[0,1],[2,-1],[24,-1],[25,1]],[[0,1],[2,-1],[28,-1],[29,1]],[[0,1],[2,-1],[32,-1],[33,1]],[[0,1],[3,-1],[36,-1],[37,1]],[[0,1],[3,-1],[40,-1],[41,1]],[[0,1],[3,-1],[44,-1],[45,1]],[[0,1],[3,-1],[48,-1],[49,1]],[[1,1],[2,-1],[52,-1],[53,1]],[[1,1],[2,-1],[56,-1],[57,1]],[[1,1],[2,-1],[60,-1],[61,1]],[[1,1],[2,-1],[64,-1],[65,1]],[[1,1],[3,-1],[68,-1],[69,1]],[[1,1],[3,-1],[72,-1],[73,1]],[[1,1],[3,-1],[76,-1],[77,1]],[[1,1],[3,-1],[80,-1],[81,1]],[[2,1],[3,-1],[84,-1],[85,1]],[[2,1],[3,-1],[88,-1],[89,1]],[[2,1],[3,-1],[92,-1],[93,1]],[[2,1],[3,-1],[96,-1],[97,1]],[[4,1],[5,-1],[12,-1],[13,1]],[[4,1],[5,-1],[16,-1],[17,1]],[[4,1],[6,-1],[20,-1],[22,1]],[[4,1],[6,-1],[24,-1],[26,1]],[[4,1],[7,-1],[28,-1],[30,1]],[[4,1],[7,-1],[32,-1],[34,1]],[[4,1],[6,-1],[36,-1],[38,1]],[[4,1],[6,-1],[40,-1],[42,1]],[[4,1],[7,-1],[44,-1],[46,1]],[[4,1],[7,-1],[48,-1],[50,1]],[[5,1],[6,-1],[52,-1],[54,1]],[[5,1],[6,-1],[56,-1],[58,1]],[[5,1],[7,-1],[60,-1],[62,1]],[[5,1],[7,-1],[64,-1],[66,1]],[[5,1],[6,-1],[68,-1],[70,1]],[[5,1],[6,-1],[72,-1],[74,1]],[[5,1],[7,-1],[76,-1],[78,1]],[[5,1],[7,-1],[80,-1],[82,1]],[[6,1],[7,-1],[86,-1],[87,1]],[[6,1],[7,-1],[90,-1],[91,1]],[[6,1],[7,-1],[100,-1],[101,1]],[[8,1],[9,-1],[12,-1],[13,1]],[[8,1],[9,-1],[16,-1],[17,1]],[[8,1],[10,-1],[20,-1],[22,1]],[[8,1],[10,-1],[24,-1],[26,1]],[[8,1],[11,-1],[28,-1],[30,1]],[[8,1],[11,-1],[32,-1],[34,1]],[[8,1],[10,-1],[36,-1],[38,1]],[[8,1],[10,-1],[40,-1],[42,1]],[[8,1],[11,-1],[44,-1],[46,1]],[[8,1],[11,-1],[48,-1],[50,1]],[[9,1],[10,-1],[52,-1],[54,1]],[[9,1],[10,-1],[56,-1],[58,1]],[[9,1],[11,-1],[60,-1],[62,1]],[[9,1],[11,-1],[64,-1],[66,1]],[[9,1],[10,-1],[68,-1],[70,1]],[[9,1],[10,-1],[72,-1],[74,1]],[[9,1],[11,-1],[76,-1],[78,1]],[[9,1],[11,-1],[80,-1],[82,1]],[[10,1],[11,-1],[86,-1],[87,1]],[[10,1],[11,-1],[90,-1],[91,1]],[[10,1],[11,-1],[100,-1],[101,1]],[[12,1],[14,-1],[20,-1],[23,1]],[[12,1],[14,-1],[24,-1],[27,1]],[[12,1],[15,-1],[28,-1],[31,1]],[[12,1],[15,-1],[32,-1],[35,1]],[[12,1],[15,-1],[36,-1],[39,1]],[[12,1],[15,-1],[40,-1],[43,1]],[[12,1],[14,-1],[44,-1],[47,1]],[[12,1],[14,-1],[48,-1],[51,1]],[[13,1],[15,-1],[52,-1],[55,1]],[[13,1],[15,-1],[56,-1],[59,1]],[[13,1],[14,-1],[60,-1],[63,1]],[[13,1],[14,-1],[64,-1],[67,1]],[[13,1],[14,-1],[68,-1],[71,1]],[[13,1],[14,-1],[72,-1],[75,1]],[[13,1],[15,-1],[76,-1],[79,1]],[[13,1],[15,-1],[80,-1],[83,1]],[[14,1],[15,-1],[94,-1],[95,1]],[[14,1],[15,-1],[98,-1],[99,1]],[[14,1],[15,-1],[102,-1],[103,1]],[[16,1],[18,-1],[20,-1],[23,1]],[[16,1],[18,-1],[24,-1],[27,1]],[[16,1],[19,-1],[28,-1],[31,1]],[[16,1],[19,-1],[32,-1],[35,1]],[[16,1],[19,-1],[36,-1],[39,1]],[[16,1],[19,-1],[40,-1],[43,1]],[[16,1],[18,-1],[44,-1],[47,1]],[[16,1],[18,-1],[48,-1],[51,1]],[[17,1],[19,-1],[52,-1],[55,1]],[[17,1],[19,-1],[56,-1],[59,1]],[[17,1],[18,-1],[60,-1],[63,1]],[[17,1],[18,-1],[64,-1],[67,1]],[[17,1],[18,-1],[68,-1],[71,1]],[[17,1],[18,-1],[72,-1],[75,1]],[[17,1],[19,-1],[76,-1],[79,1]],[[17,1],[19,-1],[80,-1],[83,1]],[[18,1],[19,-1],[94,-1],[95,1]],[[18,1],[19,-1],[98,-1],[99,1]],[[18,1],[19,-1],[102,-1],[103,1]],[[20,1],[21,-1],[28,-1],[29,1]],[[20,1],[21,-1],[32,-1],[33,1]],[[20,1],[22,-1],[36,-1],[38,1]],[[20,1],[22,-1],[40,-1],[42,1]],[[20,1],[23,-1],[44,-1],[47,1]],[[20,1],[23,-1],[48,-1],[51,1]],[[21,1],[22,-1],[53,-1],[54,1]],[[21,1],[22,-1],[57,-1],[58,1]],[[21,1],[23,-1],[61,-1],[63,1]],[[21,1],[23,-1],[65,-1],[67,1]],[[22,1],[23,-1],[70,-1],[71,1]],[[22,1],[23,-1],[74,-1],[75,1]],[[21,1],[22,-1],[84,-1],[86,1]],[[21,1],[22,-1],[88,-1],[90,1]],[[21,1],[23,-1],[92,-1],[94,1]],[[21,1],[23,-1],[96,-1],[98,1]],[[22,1],[23,-1],[100,-1],[102,1]],[[24,1],[25,-1],[28,-1],[29,1]],[[24,1],[25,-1],[32,-1],[33,1]],[[24,1],[26,-1],[36,-1],[38,1]],[[24,1],[26,-1],[40,-1],[42,1]],[[24,1],[27,-1],[44,-1],[47,1]],[[24,1],[27,-1],[48,-1],[51,1]],[[25,1],[26,-1],[53,-1],[54,1]],[[25,1],[26,-1],[57,-1],[58,1]],[[25,1],[27,-1],[61,-1],[63,1]],[[25,1],[27,-1],[65,-1],[67,1]],[[26,1],[27,-1],[70,-1],[71,1]],[[26,1],[27,-1],[74,-1],[75,1]],[[25,1],[26,-1],[84,-1],[86,1]],[[25,1],[26,-1],[88,-1],[90,1]],[[25,1],[27,-1],[92,-1],[94,1]],[[25,1],[27,-1],[96,-1],[98,1]],[[26,1],[27,-1],[100,-1],[102,1]],[[28,1],[31,-1],[36,-1],[39,1]],[[28,1],[31,-1],[40,-1],[43,1]],[[28,1],[30,-1],[44,-1],[46,1]],[[28,1],[30,-1],[48,-1],[50,1]],[[29,1],[31,-1],[53,-1],[55,1]],[[29,1],[31,-1],[57,-1],[59,1]],[[29,1],[30,-1],[61,-1],[62,1]],[[29,1],[30,-1],[65,-1],[66,1]],[[30,1],[31,-1],[78,-1],[79,1]],[[30,1],[31,-1],[82,-1],[83,1]],[[29,1],[30,-1],[84,-1],[87,1]],[[29,1],[30,-1],[88,-1],[91,1]],[[29,1],[31,-1],[92,-1],[95,1]],[[29,1],[31,-1],[96,-1],[99,1]],[[30,1],[31,-1],[101,-1],[103,1]],[[32,1],[35,-1],[36,-1],[39,1]],[[32,1],[35,-1],[40,-1],[43,1]],[[32,1],[34,-1],[44,-1],[46,1]],[[32,1],[34,-1],[48,-1],[50,1]],[[33,1],[35,-1],[53,-1],[55,1]],[[33,1],[35,-1],[57,-1],[59,1]],[[33,1],[34,-1],[61,-1],[62,1]],[[33,1],[34,-1],[65,-1],[66,1]],[[34,1],[35,-1],[78,-1],[79,1]],[[34,1],[35,-1],[82,-1],[83,1]],[[33,1],[34,-1],[84,-1],[87,1]],[[33,1],[34,-1],[88,-1],[91,1]],[[33,1],[35,-1],[92,-1],[95,1]],[[33,1],[35,-1],[96,-1],[99,1]],[[34,1],[35,-1],[101,-1],[103,1]],[[36,1],[37,-1],[44,-1],[45,1]],[[36,1],[37,-1],[48,-1],[49,1]],[[38,1],[39,-1],[54,-1],[55,1]],[[38,1],[39,-1],[58,-1],[59,1]],[[37,1],[38,-1],[69,-1],[70,1]],[[37,1],[38,-1],[73,-1],[74,1]],[[37,1],[39,-1],[77,-1],[79,1]],[[37,1],[39,-1],[81,-1],[83,1]],[[37,1],[38,-1],[85,-1],[86,1]],[[37,1],[38,-1],[89,-1],[90,1]],[[37,1],[39,-1],[93,-1],[95,1]],[[37,1],[39,-1],[97,-1],[99,1]],[[38,1],[39,-1],[100,-1],[103,1]],[[40,1],[41,-1],[44,-1],[45,1]],[[40,1],[41,-1],[48,-1],[49,1]],[[42,1],[43,-1],[54,-1],[55,1]],[[42,1],[43,-1],[58,-1],[59,1]],[[41,1],[42,-1],[69,-1],[70,1]],[[41,1],[42,-1],[73,-1],[74,1]],[[41,1],[43,-1],[77,-1],[79,1]],[[41,1],[43,-1],[81,-1],[83,1]],[[41,1],[42,-1],[85,-1],[86,1]],[[41,1],[42,-1],[89,-1],[90,1]],[[41,1],[43,-1],[93,-1],[95,1]],[[41,1],[43,-1],[97,-1],[99,1]],[[42,1],[43,-1],[100,-1],[103,1]],[[46,1],[47,-1],[62,-1],[63,1]],[[46,1],[47,-1],[66,-1],[67,1]],[[45,1],[47,-1],[69,-1],[71,1]],[[45,1],[47,-1],[73,-1],[75,1]],[[45,1],[46,-1],[77,-1],[78,1]],[[45,1],[46,-1],[81,-1],[82,1]],[[45,1],[46,-1],[85,-1],[87,1]],[[45,1],[46,-1],[89,-1],[91,1]],[[45,1],[47,-1],[93,-1],[94,1]],[[45,1],[47,-1],[97,-1],[98,1]],[[46,1],[47,-1],[101,-1],[102,1]],[[50,1],[51,-1],[62,-1],[63,1]],[[50,1],[51,-1],[66,-1],[67,1]],[[49,1],[51,-1],[69,-1],[71,1]],[[49,1],[51,-1],[73,-1],[75,1]],[[49,1],[50,-1],[77,-1],[78,1]],[[49,1],[50,-1],[81,-1],[82,1]],[[49,1],[50,-1],[85,-1],[87,1]],[[49,1],[50,-1],[89,-1],[91,1]],[[49,1],[51,-1],[93,-1],[94,1]],[[49,1],[51,-1],[97,-1],[98,1]],[[50,1],[51,-1],[101,-1],[102,1]],[[52,1],[53,-1],[60,-1],[61,1]],[[52,1],[53,-1],[64,-1],[65,1]],[[52,1],[54,-1],[68,-1],[70,1]],[[52,1],[54,-1],[72,-1],[74,1]],[[52,1],[55,-1],[76,-1],[79,1]],[[52,1],[55,-1],[80,-1],[83,1]],[[53,1],[54,-1],[84,-1],[86,1]],[[53,1],[54,-1],[88,-1],[90,1]],[[53,1],[55,-1],[92,-1],[95,1]],[[53,1],[55,-1],[96,-1],[99,1]],[[54,1],[55,-1],[100,-1],[103,1]],[[56,1],[57,-1],[60,-1],[61,1]],[[56,1],[57,-1],[64,-1],[65,1]],[[56,1],[58,-1],[68,-1],[70,1]],[[56,1],[58,-1],[72,-1],[74,1]],[[56,1],[59,-1],[76,-1],[79,1]],[[56,1],[59,-1],[80,-1],[83,1]],[[57,1],[58,-1],[84,-1],[86,1]],[[57,1],[58,-1],[88,-1],[90,1]],[[57,1],[59,-1],[92,-1],[95,1]],[[57,1],[59,-1],[96,-1],[99,1]],[[58,1],[59,-1],[100,-1],[103,1]],[[60,1],[63,-1],[68,-1],[71,1]],[[60,1],[63,-1],[72,-1],[75,1]],[[60,1],[62,-1],[76,-1],[78,1]],[[60,1],[62,-1],[80,-1],[82,1]],[[61,1],[62,-1],[84,-1],[87,1]],[[61,1],[62,-1],[88,-1],[91,1]],[[61,1],[63,-1],[92,-1],[94,1]],[[61,1],[63,-1],[96,-1],[98,1]],[[62,1],[63,-1],[101,-1],[102,1]],[[64,1],[67,-1],[68,-1],[71,1]],[[64,1],[67,-1],[72,-1],[75,1]],[[64,1],[66,-1],[76,-1],[78,1]],[[64,1],[66,-1],[80,-1],[82,1]],[[65,1],[66,-1],[84,-1],[87,1]],[[65,1],[66,-1],[88,-1],[91,1]],[[65,1],[67,-1],[92,-1],[94,1]],[[65,1],[67,-1],[96,-1],[98,1]],[[66,1],[67,-1],[101,-1],[102,1]],[[68,1],[69,-1],[76,-1],[77,1]],[[68,1],[69,-1],[80,-1],[81,1]],[[69,1],[70,-1],[85,-1],[86,1]],[[69,1],[70,-1],[89,-1],[90,1]],[[69,1],[71,-1],[93,-1],[94,1]],[[69,1],[71,-1],[97,-1],[98,1]],[[70,1],[71,-1],[100,-1],[102,1]],[[72,1],[73,-1],[76,-1],[77,1]],[[72,1],[73,-1],[80,-1],[81,1]],[[73,1],[74,-1],[85,-1],[86,1]],[[73,1],[74,-1],[89,-1],[90,1]],[[73,1],[75,-1],[93,-1],[94,1]],[[73,1],[75,-1],[97,-1],[98,1]],[[74,1],[75,-1],[100,-1],[102,1]],[[77,1],[78,-1],[85,-1],[87,1]],[[77,1],[78,-1],[89,-1],[91,1]],[[77,1],[79,-1],[93,-1],[95,1]],[[77,1],[79,-1],[97,-1],[99,1]],[[78,1],[79,-1],[101,-1],[103,1]],[[81,1],[82,-1],[85,-1],[87,1]],[[81,1],[82,-1],[89,-1],[91,1]],[[81,1],[83,-1],[93,-1],[95,1]],[[81,1],[83,-1],[97,-1],[99,1]],[[82,1],[83,-1],[101,-1],[103,1]],[[84,1],[85,-1],[92,-1],[93,1]],[[84,1],[85,-1],[96,-1],[97,1]],[[86,1],[87,-1],[100,-1],[101,1]],[[88,1],[89,-1],[92,-1],[93,1]],[[88,1],[89,-1],[96,-1],[97,1]],[[90,1],[91,-1],[100,-1],[101,1]],[[94,1],[95,-1],[102,-1],[103,1]],[[98,1],[99,-1],[102,-1],[103,1]]],"P":[[[0,1]],[[0,1],[26,1]],[[0,1],[27,1]],[[0,1],[28,1]],[[1,1]],[[1,1],[26,1]],[[1,1],[29,1]],[[1,1],[30,1]],[[2,1]],[[2,1],[26,1]],[[2,1],[29,1]],[[2,1],[30,1]],[[3,1]],[[3,1],[26,1]],[[3,1],[31,1]],[[3,1],[32,1]],[[4,1]],[[4,1],[26,1]],[[4,1],[31,1]],[[4,1],[32,1]],[[5,1]],[[5,1],[27,1]],[[5,1],[29,1]],[[5,1],[31,1]],[[6,1]],[[6,1],[27,1]],[[6,1],[29,1]],[[6,1],[31,1]],[[7,1]],[[7,1],[27,1]],[[7,1],[30,1]],[[7,1],[32,1]],[[8,1]],[[8,1],[27,1]],[[8,1],[30,1]],[[8,1],[32,1]],[[9,1]],[[9,1],[28,1]],[[9,1],[29,1]],[[9,1],[32,1]],[[10,1]],[[10,1],[28,1]],[[10,1],[29,1]],[[10,1],[32,1]],[[11,1]],[[11,1],[28,1]],[[11,1],[30,1]],[[11,1],[31,1]],[[12,1]],[[12,1],[28,1]],[[12,1],[30,1]],[[12,1],[31,1]],[[13,1],[26,1]],[[13,1],[27,1]],[[13,1],[29,1]],[[13,1],[32,1]],[[14,1],[26,1]],[[14,1],[27,1]],[[14,1],[29,1]],[[14,1],[32,1]],[[15,1],[26,1]],[[15,1],[27,1]],[[15,1],[30,1]],[[15,1],[31,1]],[[16,1],[26,1]],[[16,1],[27,1]],[[16,1],[30,1]],[[16,1],[31,1]],[[17,1],[26,1]],[[17,1],[28,1]],[[17,1],[29,1]],[[17,1],[31,1]],[[18,1],[26,1]],[[18,1],[28,1]],[[18,1],[29,1]],[[18,1],[31,1]],[[19,1],[26,1]],[[19,1],[28,1]],[[19,1],[30,1]],[[19,1],[32,1]],[[20,1],[26,1]],[[20,1],[28,1]],[[20,1],[30,1]],[[20,1],[32,1]],[[21,1],[27,1]],[[21,1],[28,1]],[[21,1],[29,1]],[[21,1],[30,1]],[[22,1],[27,1]],[[22,1],[28,1]],[[22,1],[29,1]],[[22,1],[30,1]],[[23,1],[27,1]],[[23,1],[28,1]],[[23,1],[31,1]],[[23,1],[32,1]],[[24,1],[27,1]],[[24,1],[28,1]],[[24,1],[31,1]],[[24,1],[32,1]],[[25,1],[29,1]],[[25,1],[30,1]],[[25,1],[31,1]],[[25,1],[32,1]]],"Q":[[[0,1]],[[4,1]],[[8,1]],[[12,1]],[[16,1]],[[20,1]],[[24,1]],[[28,1]],[[32,1]],[[36,1]],[[40,1]],[[44,1]],[[48,1]],[[0,1],[1,-1],[52,1]],[[0,1],[1,-1],[56,1]],[[0,1],[1,-1],[60,1]],[[0,1],[1,-1],[64,1]],[[0,1],[1,-1],[68,1]],[[0,1],[1,-1],[72,1]],[[0,1],[1,-1],[76,1]],[[0,1],[1,-1],[80,1]],[[0,1],[2,-1],[84,1]],[[0,1],[2,-1],[88,1]],[[0,1],[2,-1],[92,1]],[[0,1],[2,-1],[96,1]],[[4,1],[6,-1],[100,1]],[[0,-1],[1,1]],[[0,-1],[2,1]],[[0,-1],[3,1]],[[4,-1],[6,1]],[[4,-1],[7,1]],[[12,-1],[14,1]],[[12,-1],[15,1]]],"W":[[],[],[],[],[],[[0,1]],[],[],[],[[1,1]],[[26,1],[47,-1]],[[28,1],[49,-1]],[],[[2,1]],[],[],[],[[3,1]],[[66,1],[85,-1]],[[68,1],[87,-1]],[],[[4,1]],[[26,1]],[[66,1]],[],[[5,1]],[[27,1]],[[67,1]],[],[[6,1]],[[28,1]],[[68,1]],[],[[7,1]],[[29,1]],[[69,1]],[],[[8,1]],[[30,1]],[[70,1]],[],[[9,1]],[[31,1]],[[71,1]],[],[[10,1]],[[32,1]],[[72,1]],[],[[11,1]],[[33,1]],[[73,1]],[],[[12,1]],[[0,-1],[34,1]],[[2,-1],[74,1]],[],[[13,1]],[[0,-1],[35,1]],[[2,-1],[75,1]],[],[[14,1]],[[0,-1],[36,1]],[[2,-1],[76,1]],[],[[15,1]],[[0,-1],[37,1]],[[2,-1],[77,1]],[],[[16,1]],[[0,-1],[38,1]],[[2,-1],[78,1]],[],[[17,1]],[[0,-1],[39,1]],[[2,-1],[79,1]],[],[[18,1]],[[0,-1],[40,1]],[[2,-1],[80,1]],[],[[19,1]],[[0,-1],[41,1]],[[2,-1],[81,1]],[],[[20,1]],[[4,-1],[26,1],[116,1]],[[6,-1],[28,1],[148,1]],[],[[21,1]],[[4,-1],[26,1],[117,1]],[[6,-1],[28,1],[149,1]],[],[[22,1]],[[4,-1],[66,1],[118,1]],[[6,-1],[68,1],[150,1]],[],[[23,1]],[[4,-1],[66,1],[119,1]],[[6,-1],[68,1],[151,1]],[],[[44,1]],[[26,-1],[66,1],[120,1]],[[30,-1],[70,1],[180,1]]],"anchors":[0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,2,2,2,2,4],"base_pair_representatives":{"1":0,"2":0,"3":0,"4":1,"5":1,"6":3,"7":3},"coordinates":[[0,0],[0,1],[0,2],[0,3],[1,0],[1,1],[1,4],[1,5],[2,0],[2,1],[2,4],[2,5],[3,0],[3,1],[3,6],[3,7],[4,0],[4,1],[4,6],[4,7],[5,0],[5,2],[5,4],[5,6],[6,0],[6,2],[6,4],[6,6],[7,0],[7,2],[7,5],[7,7],[8,0],[8,2],[8,5],[8,7],[9,0],[9,3],[9,4],[9,7],[10,0],[10,3],[10,4],[10,7],[11,0],[11,3],[11,5],[11,6],[12,0],[12,3],[12,5],[12,6],[13,1],[13,2],[13,4],[13,7],[14,1],[14,2],[14,4],[14,7],[15,1],[15,2],[15,5],[15,6],[16,1],[16,2],[16,5],[16,6],[17,1],[17,3],[17,4],[17,6],[18,1],[18,3],[18,4],[18,6],[19,1],[19,3],[19,5],[19,7],[20,1],[20,3],[20,5],[20,7],[21,2],[21,3],[21,4],[21,5],[22,2],[22,3],[22,4],[22,5],[23,2],[23,3],[23,6],[23,7],[24,2],[24,3],[24,6],[24,7],[25,4],[25,5],[25,6],[25,7]],"free_parameters":33,"parameter_order":{"class_parameters":26,"g_points":[1,2,3,4,5,6,7]},"rank":71} diff --git a/research/p112-integral-retraction-instance/source/P112/MP00.lean b/research/p112-integral-retraction-instance/source/P112/MP00.lean new file mode 100644 index 0000000000..d8f8a664d9 --- /dev/null +++ b/research/p112-integral-retraction-instance/source/P112/MP00.lean @@ -0,0 +1,116 @@ +/- +Copyright (c) 2026 Andrey Mas and contributors. +SPDX-License-Identifier: Apache-2.0 +P112 numerical instance of the unchanged PR1497/PR1610 bridge. +SOURCE ONLY / NOT YET KERNEL CHECKED. Generated deterministically by generate.py. +Proof/source assistance: GPT-6 Pro through ChatGPT (operator-selected label). +-/ +import P112Data + +set_option autoImplicit false +set_option maxRecDepth 4096 +set_option maxHeartbeats 1000000 + +namespace P112Cert +open PR1497 + +/-- Complete mp row 0, not a sampled set of columns. -/ +theorem mp_row_000 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨0, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 1, not a sampled set of columns. -/ +theorem mp_row_001 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨1, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 2, not a sampled set of columns. -/ +theorem mp_row_002 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨2, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 3, not a sampled set of columns. -/ +theorem mp_row_003 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨3, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 4, not a sampled set of columns. -/ +theorem mp_row_004 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨4, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 5, not a sampled set of columns. -/ +theorem mp_row_005 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨5, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 6, not a sampled set of columns. -/ +theorem mp_row_006 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨6, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 7, not a sampled set of columns. -/ +theorem mp_row_007 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨7, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 8, not a sampled set of columns. -/ +theorem mp_row_008 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨8, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 9, not a sampled set of columns. -/ +theorem mp_row_009 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨9, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 10, not a sampled set of columns. -/ +theorem mp_row_010 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨10, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 11, not a sampled set of columns. -/ +theorem mp_row_011 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨11, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 12, not a sampled set of columns. -/ +theorem mp_row_012 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨12, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 13, not a sampled set of columns. -/ +theorem mp_row_013 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨13, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 14, not a sampled set of columns. -/ +theorem mp_row_014 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨14, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 15, not a sampled set of columns. -/ +theorem mp_row_015 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨15, by decide⟩) P j = 0 := by + decide + + +end P112Cert + +set_option pp.fullNames true +#print axioms P112Cert.mp_row_000 +#print axioms P112Cert.mp_row_001 +#print axioms P112Cert.mp_row_002 +#print axioms P112Cert.mp_row_003 +#print axioms P112Cert.mp_row_004 +#print axioms P112Cert.mp_row_005 +#print axioms P112Cert.mp_row_006 +#print axioms P112Cert.mp_row_007 +#print axioms P112Cert.mp_row_008 +#print axioms P112Cert.mp_row_009 +#print axioms P112Cert.mp_row_010 +#print axioms P112Cert.mp_row_011 +#print axioms P112Cert.mp_row_012 +#print axioms P112Cert.mp_row_013 +#print axioms P112Cert.mp_row_014 +#print axioms P112Cert.mp_row_015 diff --git a/research/p112-integral-retraction-instance/source/P112/MP01.lean b/research/p112-integral-retraction-instance/source/P112/MP01.lean new file mode 100644 index 0000000000..c31d9727f0 --- /dev/null +++ b/research/p112-integral-retraction-instance/source/P112/MP01.lean @@ -0,0 +1,116 @@ +/- +Copyright (c) 2026 Andrey Mas and contributors. +SPDX-License-Identifier: Apache-2.0 +P112 numerical instance of the unchanged PR1497/PR1610 bridge. +SOURCE ONLY / NOT YET KERNEL CHECKED. Generated deterministically by generate.py. +Proof/source assistance: GPT-6 Pro through ChatGPT (operator-selected label). +-/ +import P112Data + +set_option autoImplicit false +set_option maxRecDepth 4096 +set_option maxHeartbeats 1000000 + +namespace P112Cert +open PR1497 + +/-- Complete mp row 16, not a sampled set of columns. -/ +theorem mp_row_016 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨16, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 17, not a sampled set of columns. -/ +theorem mp_row_017 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨17, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 18, not a sampled set of columns. -/ +theorem mp_row_018 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨18, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 19, not a sampled set of columns. -/ +theorem mp_row_019 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨19, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 20, not a sampled set of columns. -/ +theorem mp_row_020 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨20, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 21, not a sampled set of columns. -/ +theorem mp_row_021 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨21, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 22, not a sampled set of columns. -/ +theorem mp_row_022 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨22, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 23, not a sampled set of columns. -/ +theorem mp_row_023 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨23, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 24, not a sampled set of columns. -/ +theorem mp_row_024 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨24, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 25, not a sampled set of columns. -/ +theorem mp_row_025 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨25, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 26, not a sampled set of columns. -/ +theorem mp_row_026 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨26, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 27, not a sampled set of columns. -/ +theorem mp_row_027 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨27, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 28, not a sampled set of columns. -/ +theorem mp_row_028 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨28, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 29, not a sampled set of columns. -/ +theorem mp_row_029 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨29, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 30, not a sampled set of columns. -/ +theorem mp_row_030 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨30, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 31, not a sampled set of columns. -/ +theorem mp_row_031 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨31, by decide⟩) P j = 0 := by + decide + + +end P112Cert + +set_option pp.fullNames true +#print axioms P112Cert.mp_row_016 +#print axioms P112Cert.mp_row_017 +#print axioms P112Cert.mp_row_018 +#print axioms P112Cert.mp_row_019 +#print axioms P112Cert.mp_row_020 +#print axioms P112Cert.mp_row_021 +#print axioms P112Cert.mp_row_022 +#print axioms P112Cert.mp_row_023 +#print axioms P112Cert.mp_row_024 +#print axioms P112Cert.mp_row_025 +#print axioms P112Cert.mp_row_026 +#print axioms P112Cert.mp_row_027 +#print axioms P112Cert.mp_row_028 +#print axioms P112Cert.mp_row_029 +#print axioms P112Cert.mp_row_030 +#print axioms P112Cert.mp_row_031 diff --git a/research/p112-integral-retraction-instance/source/P112/MP02.lean b/research/p112-integral-retraction-instance/source/P112/MP02.lean new file mode 100644 index 0000000000..cf102ca34d --- /dev/null +++ b/research/p112-integral-retraction-instance/source/P112/MP02.lean @@ -0,0 +1,116 @@ +/- +Copyright (c) 2026 Andrey Mas and contributors. +SPDX-License-Identifier: Apache-2.0 +P112 numerical instance of the unchanged PR1497/PR1610 bridge. +SOURCE ONLY / NOT YET KERNEL CHECKED. Generated deterministically by generate.py. +Proof/source assistance: GPT-6 Pro through ChatGPT (operator-selected label). +-/ +import P112Data + +set_option autoImplicit false +set_option maxRecDepth 4096 +set_option maxHeartbeats 1000000 + +namespace P112Cert +open PR1497 + +/-- Complete mp row 32, not a sampled set of columns. -/ +theorem mp_row_032 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨32, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 33, not a sampled set of columns. -/ +theorem mp_row_033 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨33, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 34, not a sampled set of columns. -/ +theorem mp_row_034 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨34, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 35, not a sampled set of columns. -/ +theorem mp_row_035 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨35, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 36, not a sampled set of columns. -/ +theorem mp_row_036 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨36, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 37, not a sampled set of columns. -/ +theorem mp_row_037 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨37, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 38, not a sampled set of columns. -/ +theorem mp_row_038 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨38, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 39, not a sampled set of columns. -/ +theorem mp_row_039 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨39, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 40, not a sampled set of columns. -/ +theorem mp_row_040 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨40, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 41, not a sampled set of columns. -/ +theorem mp_row_041 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨41, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 42, not a sampled set of columns. -/ +theorem mp_row_042 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨42, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 43, not a sampled set of columns. -/ +theorem mp_row_043 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨43, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 44, not a sampled set of columns. -/ +theorem mp_row_044 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨44, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 45, not a sampled set of columns. -/ +theorem mp_row_045 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨45, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 46, not a sampled set of columns. -/ +theorem mp_row_046 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨46, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 47, not a sampled set of columns. -/ +theorem mp_row_047 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨47, by decide⟩) P j = 0 := by + decide + + +end P112Cert + +set_option pp.fullNames true +#print axioms P112Cert.mp_row_032 +#print axioms P112Cert.mp_row_033 +#print axioms P112Cert.mp_row_034 +#print axioms P112Cert.mp_row_035 +#print axioms P112Cert.mp_row_036 +#print axioms P112Cert.mp_row_037 +#print axioms P112Cert.mp_row_038 +#print axioms P112Cert.mp_row_039 +#print axioms P112Cert.mp_row_040 +#print axioms P112Cert.mp_row_041 +#print axioms P112Cert.mp_row_042 +#print axioms P112Cert.mp_row_043 +#print axioms P112Cert.mp_row_044 +#print axioms P112Cert.mp_row_045 +#print axioms P112Cert.mp_row_046 +#print axioms P112Cert.mp_row_047 diff --git a/research/p112-integral-retraction-instance/source/P112/MP03.lean b/research/p112-integral-retraction-instance/source/P112/MP03.lean new file mode 100644 index 0000000000..c1b5cfc7ff --- /dev/null +++ b/research/p112-integral-retraction-instance/source/P112/MP03.lean @@ -0,0 +1,116 @@ +/- +Copyright (c) 2026 Andrey Mas and contributors. +SPDX-License-Identifier: Apache-2.0 +P112 numerical instance of the unchanged PR1497/PR1610 bridge. +SOURCE ONLY / NOT YET KERNEL CHECKED. Generated deterministically by generate.py. +Proof/source assistance: GPT-6 Pro through ChatGPT (operator-selected label). +-/ +import P112Data + +set_option autoImplicit false +set_option maxRecDepth 4096 +set_option maxHeartbeats 1000000 + +namespace P112Cert +open PR1497 + +/-- Complete mp row 48, not a sampled set of columns. -/ +theorem mp_row_048 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨48, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 49, not a sampled set of columns. -/ +theorem mp_row_049 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨49, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 50, not a sampled set of columns. -/ +theorem mp_row_050 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨50, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 51, not a sampled set of columns. -/ +theorem mp_row_051 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨51, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 52, not a sampled set of columns. -/ +theorem mp_row_052 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨52, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 53, not a sampled set of columns. -/ +theorem mp_row_053 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨53, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 54, not a sampled set of columns. -/ +theorem mp_row_054 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨54, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 55, not a sampled set of columns. -/ +theorem mp_row_055 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨55, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 56, not a sampled set of columns. -/ +theorem mp_row_056 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨56, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 57, not a sampled set of columns. -/ +theorem mp_row_057 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨57, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 58, not a sampled set of columns. -/ +theorem mp_row_058 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨58, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 59, not a sampled set of columns. -/ +theorem mp_row_059 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨59, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 60, not a sampled set of columns. -/ +theorem mp_row_060 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨60, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 61, not a sampled set of columns. -/ +theorem mp_row_061 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨61, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 62, not a sampled set of columns. -/ +theorem mp_row_062 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨62, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 63, not a sampled set of columns. -/ +theorem mp_row_063 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨63, by decide⟩) P j = 0 := by + decide + + +end P112Cert + +set_option pp.fullNames true +#print axioms P112Cert.mp_row_048 +#print axioms P112Cert.mp_row_049 +#print axioms P112Cert.mp_row_050 +#print axioms P112Cert.mp_row_051 +#print axioms P112Cert.mp_row_052 +#print axioms P112Cert.mp_row_053 +#print axioms P112Cert.mp_row_054 +#print axioms P112Cert.mp_row_055 +#print axioms P112Cert.mp_row_056 +#print axioms P112Cert.mp_row_057 +#print axioms P112Cert.mp_row_058 +#print axioms P112Cert.mp_row_059 +#print axioms P112Cert.mp_row_060 +#print axioms P112Cert.mp_row_061 +#print axioms P112Cert.mp_row_062 +#print axioms P112Cert.mp_row_063 diff --git a/research/p112-integral-retraction-instance/source/P112/MP04.lean b/research/p112-integral-retraction-instance/source/P112/MP04.lean new file mode 100644 index 0000000000..37287fe5d8 --- /dev/null +++ b/research/p112-integral-retraction-instance/source/P112/MP04.lean @@ -0,0 +1,116 @@ +/- +Copyright (c) 2026 Andrey Mas and contributors. +SPDX-License-Identifier: Apache-2.0 +P112 numerical instance of the unchanged PR1497/PR1610 bridge. +SOURCE ONLY / NOT YET KERNEL CHECKED. Generated deterministically by generate.py. +Proof/source assistance: GPT-6 Pro through ChatGPT (operator-selected label). +-/ +import P112Data + +set_option autoImplicit false +set_option maxRecDepth 4096 +set_option maxHeartbeats 1000000 + +namespace P112Cert +open PR1497 + +/-- Complete mp row 64, not a sampled set of columns. -/ +theorem mp_row_064 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨64, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 65, not a sampled set of columns. -/ +theorem mp_row_065 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨65, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 66, not a sampled set of columns. -/ +theorem mp_row_066 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨66, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 67, not a sampled set of columns. -/ +theorem mp_row_067 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨67, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 68, not a sampled set of columns. -/ +theorem mp_row_068 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨68, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 69, not a sampled set of columns. -/ +theorem mp_row_069 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨69, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 70, not a sampled set of columns. -/ +theorem mp_row_070 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨70, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 71, not a sampled set of columns. -/ +theorem mp_row_071 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨71, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 72, not a sampled set of columns. -/ +theorem mp_row_072 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨72, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 73, not a sampled set of columns. -/ +theorem mp_row_073 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨73, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 74, not a sampled set of columns. -/ +theorem mp_row_074 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨74, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 75, not a sampled set of columns. -/ +theorem mp_row_075 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨75, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 76, not a sampled set of columns. -/ +theorem mp_row_076 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨76, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 77, not a sampled set of columns. -/ +theorem mp_row_077 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨77, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 78, not a sampled set of columns. -/ +theorem mp_row_078 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨78, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 79, not a sampled set of columns. -/ +theorem mp_row_079 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨79, by decide⟩) P j = 0 := by + decide + + +end P112Cert + +set_option pp.fullNames true +#print axioms P112Cert.mp_row_064 +#print axioms P112Cert.mp_row_065 +#print axioms P112Cert.mp_row_066 +#print axioms P112Cert.mp_row_067 +#print axioms P112Cert.mp_row_068 +#print axioms P112Cert.mp_row_069 +#print axioms P112Cert.mp_row_070 +#print axioms P112Cert.mp_row_071 +#print axioms P112Cert.mp_row_072 +#print axioms P112Cert.mp_row_073 +#print axioms P112Cert.mp_row_074 +#print axioms P112Cert.mp_row_075 +#print axioms P112Cert.mp_row_076 +#print axioms P112Cert.mp_row_077 +#print axioms P112Cert.mp_row_078 +#print axioms P112Cert.mp_row_079 diff --git a/research/p112-integral-retraction-instance/source/P112/MP05.lean b/research/p112-integral-retraction-instance/source/P112/MP05.lean new file mode 100644 index 0000000000..a02344aaed --- /dev/null +++ b/research/p112-integral-retraction-instance/source/P112/MP05.lean @@ -0,0 +1,116 @@ +/- +Copyright (c) 2026 Andrey Mas and contributors. +SPDX-License-Identifier: Apache-2.0 +P112 numerical instance of the unchanged PR1497/PR1610 bridge. +SOURCE ONLY / NOT YET KERNEL CHECKED. Generated deterministically by generate.py. +Proof/source assistance: GPT-6 Pro through ChatGPT (operator-selected label). +-/ +import P112Data + +set_option autoImplicit false +set_option maxRecDepth 4096 +set_option maxHeartbeats 1000000 + +namespace P112Cert +open PR1497 + +/-- Complete mp row 80, not a sampled set of columns. -/ +theorem mp_row_080 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨80, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 81, not a sampled set of columns. -/ +theorem mp_row_081 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨81, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 82, not a sampled set of columns. -/ +theorem mp_row_082 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨82, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 83, not a sampled set of columns. -/ +theorem mp_row_083 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨83, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 84, not a sampled set of columns. -/ +theorem mp_row_084 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨84, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 85, not a sampled set of columns. -/ +theorem mp_row_085 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨85, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 86, not a sampled set of columns. -/ +theorem mp_row_086 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨86, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 87, not a sampled set of columns. -/ +theorem mp_row_087 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨87, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 88, not a sampled set of columns. -/ +theorem mp_row_088 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨88, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 89, not a sampled set of columns. -/ +theorem mp_row_089 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨89, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 90, not a sampled set of columns. -/ +theorem mp_row_090 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨90, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 91, not a sampled set of columns. -/ +theorem mp_row_091 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨91, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 92, not a sampled set of columns. -/ +theorem mp_row_092 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨92, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 93, not a sampled set of columns. -/ +theorem mp_row_093 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨93, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 94, not a sampled set of columns. -/ +theorem mp_row_094 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨94, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 95, not a sampled set of columns. -/ +theorem mp_row_095 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨95, by decide⟩) P j = 0 := by + decide + + +end P112Cert + +set_option pp.fullNames true +#print axioms P112Cert.mp_row_080 +#print axioms P112Cert.mp_row_081 +#print axioms P112Cert.mp_row_082 +#print axioms P112Cert.mp_row_083 +#print axioms P112Cert.mp_row_084 +#print axioms P112Cert.mp_row_085 +#print axioms P112Cert.mp_row_086 +#print axioms P112Cert.mp_row_087 +#print axioms P112Cert.mp_row_088 +#print axioms P112Cert.mp_row_089 +#print axioms P112Cert.mp_row_090 +#print axioms P112Cert.mp_row_091 +#print axioms P112Cert.mp_row_092 +#print axioms P112Cert.mp_row_093 +#print axioms P112Cert.mp_row_094 +#print axioms P112Cert.mp_row_095 diff --git a/research/p112-integral-retraction-instance/source/P112/MP06.lean b/research/p112-integral-retraction-instance/source/P112/MP06.lean new file mode 100644 index 0000000000..374e8484d5 --- /dev/null +++ b/research/p112-integral-retraction-instance/source/P112/MP06.lean @@ -0,0 +1,116 @@ +/- +Copyright (c) 2026 Andrey Mas and contributors. +SPDX-License-Identifier: Apache-2.0 +P112 numerical instance of the unchanged PR1497/PR1610 bridge. +SOURCE ONLY / NOT YET KERNEL CHECKED. Generated deterministically by generate.py. +Proof/source assistance: GPT-6 Pro through ChatGPT (operator-selected label). +-/ +import P112Data + +set_option autoImplicit false +set_option maxRecDepth 4096 +set_option maxHeartbeats 1000000 + +namespace P112Cert +open PR1497 + +/-- Complete mp row 96, not a sampled set of columns. -/ +theorem mp_row_096 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨96, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 97, not a sampled set of columns. -/ +theorem mp_row_097 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨97, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 98, not a sampled set of columns. -/ +theorem mp_row_098 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨98, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 99, not a sampled set of columns. -/ +theorem mp_row_099 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨99, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 100, not a sampled set of columns. -/ +theorem mp_row_100 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨100, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 101, not a sampled set of columns. -/ +theorem mp_row_101 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨101, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 102, not a sampled set of columns. -/ +theorem mp_row_102 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨102, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 103, not a sampled set of columns. -/ +theorem mp_row_103 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨103, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 104, not a sampled set of columns. -/ +theorem mp_row_104 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨104, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 105, not a sampled set of columns. -/ +theorem mp_row_105 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨105, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 106, not a sampled set of columns. -/ +theorem mp_row_106 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨106, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 107, not a sampled set of columns. -/ +theorem mp_row_107 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨107, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 108, not a sampled set of columns. -/ +theorem mp_row_108 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨108, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 109, not a sampled set of columns. -/ +theorem mp_row_109 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨109, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 110, not a sampled set of columns. -/ +theorem mp_row_110 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨110, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 111, not a sampled set of columns. -/ +theorem mp_row_111 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨111, by decide⟩) P j = 0 := by + decide + + +end P112Cert + +set_option pp.fullNames true +#print axioms P112Cert.mp_row_096 +#print axioms P112Cert.mp_row_097 +#print axioms P112Cert.mp_row_098 +#print axioms P112Cert.mp_row_099 +#print axioms P112Cert.mp_row_100 +#print axioms P112Cert.mp_row_101 +#print axioms P112Cert.mp_row_102 +#print axioms P112Cert.mp_row_103 +#print axioms P112Cert.mp_row_104 +#print axioms P112Cert.mp_row_105 +#print axioms P112Cert.mp_row_106 +#print axioms P112Cert.mp_row_107 +#print axioms P112Cert.mp_row_108 +#print axioms P112Cert.mp_row_109 +#print axioms P112Cert.mp_row_110 +#print axioms P112Cert.mp_row_111 diff --git a/research/p112-integral-retraction-instance/source/P112/MP07.lean b/research/p112-integral-retraction-instance/source/P112/MP07.lean new file mode 100644 index 0000000000..71f3b64fbb --- /dev/null +++ b/research/p112-integral-retraction-instance/source/P112/MP07.lean @@ -0,0 +1,116 @@ +/- +Copyright (c) 2026 Andrey Mas and contributors. +SPDX-License-Identifier: Apache-2.0 +P112 numerical instance of the unchanged PR1497/PR1610 bridge. +SOURCE ONLY / NOT YET KERNEL CHECKED. Generated deterministically by generate.py. +Proof/source assistance: GPT-6 Pro through ChatGPT (operator-selected label). +-/ +import P112Data + +set_option autoImplicit false +set_option maxRecDepth 4096 +set_option maxHeartbeats 1000000 + +namespace P112Cert +open PR1497 + +/-- Complete mp row 112, not a sampled set of columns. -/ +theorem mp_row_112 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨112, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 113, not a sampled set of columns. -/ +theorem mp_row_113 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨113, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 114, not a sampled set of columns. -/ +theorem mp_row_114 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨114, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 115, not a sampled set of columns. -/ +theorem mp_row_115 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨115, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 116, not a sampled set of columns. -/ +theorem mp_row_116 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨116, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 117, not a sampled set of columns. -/ +theorem mp_row_117 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨117, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 118, not a sampled set of columns. -/ +theorem mp_row_118 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨118, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 119, not a sampled set of columns. -/ +theorem mp_row_119 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨119, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 120, not a sampled set of columns. -/ +theorem mp_row_120 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨120, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 121, not a sampled set of columns. -/ +theorem mp_row_121 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨121, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 122, not a sampled set of columns. -/ +theorem mp_row_122 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨122, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 123, not a sampled set of columns. -/ +theorem mp_row_123 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨123, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 124, not a sampled set of columns. -/ +theorem mp_row_124 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨124, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 125, not a sampled set of columns. -/ +theorem mp_row_125 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨125, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 126, not a sampled set of columns. -/ +theorem mp_row_126 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨126, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 127, not a sampled set of columns. -/ +theorem mp_row_127 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨127, by decide⟩) P j = 0 := by + decide + + +end P112Cert + +set_option pp.fullNames true +#print axioms P112Cert.mp_row_112 +#print axioms P112Cert.mp_row_113 +#print axioms P112Cert.mp_row_114 +#print axioms P112Cert.mp_row_115 +#print axioms P112Cert.mp_row_116 +#print axioms P112Cert.mp_row_117 +#print axioms P112Cert.mp_row_118 +#print axioms P112Cert.mp_row_119 +#print axioms P112Cert.mp_row_120 +#print axioms P112Cert.mp_row_121 +#print axioms P112Cert.mp_row_122 +#print axioms P112Cert.mp_row_123 +#print axioms P112Cert.mp_row_124 +#print axioms P112Cert.mp_row_125 +#print axioms P112Cert.mp_row_126 +#print axioms P112Cert.mp_row_127 diff --git a/research/p112-integral-retraction-instance/source/P112/MP08.lean b/research/p112-integral-retraction-instance/source/P112/MP08.lean new file mode 100644 index 0000000000..212d403702 --- /dev/null +++ b/research/p112-integral-retraction-instance/source/P112/MP08.lean @@ -0,0 +1,116 @@ +/- +Copyright (c) 2026 Andrey Mas and contributors. +SPDX-License-Identifier: Apache-2.0 +P112 numerical instance of the unchanged PR1497/PR1610 bridge. +SOURCE ONLY / NOT YET KERNEL CHECKED. Generated deterministically by generate.py. +Proof/source assistance: GPT-6 Pro through ChatGPT (operator-selected label). +-/ +import P112Data + +set_option autoImplicit false +set_option maxRecDepth 4096 +set_option maxHeartbeats 1000000 + +namespace P112Cert +open PR1497 + +/-- Complete mp row 128, not a sampled set of columns. -/ +theorem mp_row_128 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨128, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 129, not a sampled set of columns. -/ +theorem mp_row_129 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨129, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 130, not a sampled set of columns. -/ +theorem mp_row_130 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨130, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 131, not a sampled set of columns. -/ +theorem mp_row_131 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨131, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 132, not a sampled set of columns. -/ +theorem mp_row_132 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨132, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 133, not a sampled set of columns. -/ +theorem mp_row_133 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨133, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 134, not a sampled set of columns. -/ +theorem mp_row_134 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨134, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 135, not a sampled set of columns. -/ +theorem mp_row_135 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨135, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 136, not a sampled set of columns. -/ +theorem mp_row_136 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨136, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 137, not a sampled set of columns. -/ +theorem mp_row_137 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨137, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 138, not a sampled set of columns. -/ +theorem mp_row_138 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨138, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 139, not a sampled set of columns. -/ +theorem mp_row_139 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨139, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 140, not a sampled set of columns. -/ +theorem mp_row_140 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨140, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 141, not a sampled set of columns. -/ +theorem mp_row_141 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨141, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 142, not a sampled set of columns. -/ +theorem mp_row_142 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨142, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 143, not a sampled set of columns. -/ +theorem mp_row_143 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨143, by decide⟩) P j = 0 := by + decide + + +end P112Cert + +set_option pp.fullNames true +#print axioms P112Cert.mp_row_128 +#print axioms P112Cert.mp_row_129 +#print axioms P112Cert.mp_row_130 +#print axioms P112Cert.mp_row_131 +#print axioms P112Cert.mp_row_132 +#print axioms P112Cert.mp_row_133 +#print axioms P112Cert.mp_row_134 +#print axioms P112Cert.mp_row_135 +#print axioms P112Cert.mp_row_136 +#print axioms P112Cert.mp_row_137 +#print axioms P112Cert.mp_row_138 +#print axioms P112Cert.mp_row_139 +#print axioms P112Cert.mp_row_140 +#print axioms P112Cert.mp_row_141 +#print axioms P112Cert.mp_row_142 +#print axioms P112Cert.mp_row_143 diff --git a/research/p112-integral-retraction-instance/source/P112/MP09.lean b/research/p112-integral-retraction-instance/source/P112/MP09.lean new file mode 100644 index 0000000000..a414c4e535 --- /dev/null +++ b/research/p112-integral-retraction-instance/source/P112/MP09.lean @@ -0,0 +1,116 @@ +/- +Copyright (c) 2026 Andrey Mas and contributors. +SPDX-License-Identifier: Apache-2.0 +P112 numerical instance of the unchanged PR1497/PR1610 bridge. +SOURCE ONLY / NOT YET KERNEL CHECKED. Generated deterministically by generate.py. +Proof/source assistance: GPT-6 Pro through ChatGPT (operator-selected label). +-/ +import P112Data + +set_option autoImplicit false +set_option maxRecDepth 4096 +set_option maxHeartbeats 1000000 + +namespace P112Cert +open PR1497 + +/-- Complete mp row 144, not a sampled set of columns. -/ +theorem mp_row_144 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨144, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 145, not a sampled set of columns. -/ +theorem mp_row_145 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨145, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 146, not a sampled set of columns. -/ +theorem mp_row_146 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨146, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 147, not a sampled set of columns. -/ +theorem mp_row_147 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨147, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 148, not a sampled set of columns. -/ +theorem mp_row_148 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨148, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 149, not a sampled set of columns. -/ +theorem mp_row_149 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨149, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 150, not a sampled set of columns. -/ +theorem mp_row_150 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨150, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 151, not a sampled set of columns. -/ +theorem mp_row_151 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨151, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 152, not a sampled set of columns. -/ +theorem mp_row_152 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨152, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 153, not a sampled set of columns. -/ +theorem mp_row_153 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨153, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 154, not a sampled set of columns. -/ +theorem mp_row_154 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨154, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 155, not a sampled set of columns. -/ +theorem mp_row_155 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨155, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 156, not a sampled set of columns. -/ +theorem mp_row_156 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨156, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 157, not a sampled set of columns. -/ +theorem mp_row_157 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨157, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 158, not a sampled set of columns. -/ +theorem mp_row_158 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨158, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 159, not a sampled set of columns. -/ +theorem mp_row_159 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨159, by decide⟩) P j = 0 := by + decide + + +end P112Cert + +set_option pp.fullNames true +#print axioms P112Cert.mp_row_144 +#print axioms P112Cert.mp_row_145 +#print axioms P112Cert.mp_row_146 +#print axioms P112Cert.mp_row_147 +#print axioms P112Cert.mp_row_148 +#print axioms P112Cert.mp_row_149 +#print axioms P112Cert.mp_row_150 +#print axioms P112Cert.mp_row_151 +#print axioms P112Cert.mp_row_152 +#print axioms P112Cert.mp_row_153 +#print axioms P112Cert.mp_row_154 +#print axioms P112Cert.mp_row_155 +#print axioms P112Cert.mp_row_156 +#print axioms P112Cert.mp_row_157 +#print axioms P112Cert.mp_row_158 +#print axioms P112Cert.mp_row_159 diff --git a/research/p112-integral-retraction-instance/source/P112/MP10.lean b/research/p112-integral-retraction-instance/source/P112/MP10.lean new file mode 100644 index 0000000000..6977a486f9 --- /dev/null +++ b/research/p112-integral-retraction-instance/source/P112/MP10.lean @@ -0,0 +1,116 @@ +/- +Copyright (c) 2026 Andrey Mas and contributors. +SPDX-License-Identifier: Apache-2.0 +P112 numerical instance of the unchanged PR1497/PR1610 bridge. +SOURCE ONLY / NOT YET KERNEL CHECKED. Generated deterministically by generate.py. +Proof/source assistance: GPT-6 Pro through ChatGPT (operator-selected label). +-/ +import P112Data + +set_option autoImplicit false +set_option maxRecDepth 4096 +set_option maxHeartbeats 1000000 + +namespace P112Cert +open PR1497 + +/-- Complete mp row 160, not a sampled set of columns. -/ +theorem mp_row_160 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨160, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 161, not a sampled set of columns. -/ +theorem mp_row_161 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨161, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 162, not a sampled set of columns. -/ +theorem mp_row_162 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨162, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 163, not a sampled set of columns. -/ +theorem mp_row_163 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨163, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 164, not a sampled set of columns. -/ +theorem mp_row_164 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨164, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 165, not a sampled set of columns. -/ +theorem mp_row_165 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨165, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 166, not a sampled set of columns. -/ +theorem mp_row_166 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨166, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 167, not a sampled set of columns. -/ +theorem mp_row_167 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨167, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 168, not a sampled set of columns. -/ +theorem mp_row_168 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨168, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 169, not a sampled set of columns. -/ +theorem mp_row_169 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨169, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 170, not a sampled set of columns. -/ +theorem mp_row_170 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨170, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 171, not a sampled set of columns. -/ +theorem mp_row_171 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨171, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 172, not a sampled set of columns. -/ +theorem mp_row_172 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨172, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 173, not a sampled set of columns. -/ +theorem mp_row_173 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨173, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 174, not a sampled set of columns. -/ +theorem mp_row_174 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨174, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 175, not a sampled set of columns. -/ +theorem mp_row_175 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨175, by decide⟩) P j = 0 := by + decide + + +end P112Cert + +set_option pp.fullNames true +#print axioms P112Cert.mp_row_160 +#print axioms P112Cert.mp_row_161 +#print axioms P112Cert.mp_row_162 +#print axioms P112Cert.mp_row_163 +#print axioms P112Cert.mp_row_164 +#print axioms P112Cert.mp_row_165 +#print axioms P112Cert.mp_row_166 +#print axioms P112Cert.mp_row_167 +#print axioms P112Cert.mp_row_168 +#print axioms P112Cert.mp_row_169 +#print axioms P112Cert.mp_row_170 +#print axioms P112Cert.mp_row_171 +#print axioms P112Cert.mp_row_172 +#print axioms P112Cert.mp_row_173 +#print axioms P112Cert.mp_row_174 +#print axioms P112Cert.mp_row_175 diff --git a/research/p112-integral-retraction-instance/source/P112/MP11.lean b/research/p112-integral-retraction-instance/source/P112/MP11.lean new file mode 100644 index 0000000000..88ad2c971f --- /dev/null +++ b/research/p112-integral-retraction-instance/source/P112/MP11.lean @@ -0,0 +1,116 @@ +/- +Copyright (c) 2026 Andrey Mas and contributors. +SPDX-License-Identifier: Apache-2.0 +P112 numerical instance of the unchanged PR1497/PR1610 bridge. +SOURCE ONLY / NOT YET KERNEL CHECKED. Generated deterministically by generate.py. +Proof/source assistance: GPT-6 Pro through ChatGPT (operator-selected label). +-/ +import P112Data + +set_option autoImplicit false +set_option maxRecDepth 4096 +set_option maxHeartbeats 1000000 + +namespace P112Cert +open PR1497 + +/-- Complete mp row 176, not a sampled set of columns. -/ +theorem mp_row_176 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨176, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 177, not a sampled set of columns. -/ +theorem mp_row_177 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨177, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 178, not a sampled set of columns. -/ +theorem mp_row_178 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨178, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 179, not a sampled set of columns. -/ +theorem mp_row_179 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨179, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 180, not a sampled set of columns. -/ +theorem mp_row_180 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨180, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 181, not a sampled set of columns. -/ +theorem mp_row_181 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨181, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 182, not a sampled set of columns. -/ +theorem mp_row_182 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨182, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 183, not a sampled set of columns. -/ +theorem mp_row_183 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨183, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 184, not a sampled set of columns. -/ +theorem mp_row_184 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨184, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 185, not a sampled set of columns. -/ +theorem mp_row_185 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨185, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 186, not a sampled set of columns. -/ +theorem mp_row_186 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨186, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 187, not a sampled set of columns. -/ +theorem mp_row_187 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨187, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 188, not a sampled set of columns. -/ +theorem mp_row_188 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨188, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 189, not a sampled set of columns. -/ +theorem mp_row_189 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨189, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 190, not a sampled set of columns. -/ +theorem mp_row_190 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨190, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 191, not a sampled set of columns. -/ +theorem mp_row_191 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨191, by decide⟩) P j = 0 := by + decide + + +end P112Cert + +set_option pp.fullNames true +#print axioms P112Cert.mp_row_176 +#print axioms P112Cert.mp_row_177 +#print axioms P112Cert.mp_row_178 +#print axioms P112Cert.mp_row_179 +#print axioms P112Cert.mp_row_180 +#print axioms P112Cert.mp_row_181 +#print axioms P112Cert.mp_row_182 +#print axioms P112Cert.mp_row_183 +#print axioms P112Cert.mp_row_184 +#print axioms P112Cert.mp_row_185 +#print axioms P112Cert.mp_row_186 +#print axioms P112Cert.mp_row_187 +#print axioms P112Cert.mp_row_188 +#print axioms P112Cert.mp_row_189 +#print axioms P112Cert.mp_row_190 +#print axioms P112Cert.mp_row_191 diff --git a/research/p112-integral-retraction-instance/source/P112/MP12.lean b/research/p112-integral-retraction-instance/source/P112/MP12.lean new file mode 100644 index 0000000000..141a084592 --- /dev/null +++ b/research/p112-integral-retraction-instance/source/P112/MP12.lean @@ -0,0 +1,116 @@ +/- +Copyright (c) 2026 Andrey Mas and contributors. +SPDX-License-Identifier: Apache-2.0 +P112 numerical instance of the unchanged PR1497/PR1610 bridge. +SOURCE ONLY / NOT YET KERNEL CHECKED. Generated deterministically by generate.py. +Proof/source assistance: GPT-6 Pro through ChatGPT (operator-selected label). +-/ +import P112Data + +set_option autoImplicit false +set_option maxRecDepth 4096 +set_option maxHeartbeats 1000000 + +namespace P112Cert +open PR1497 + +/-- Complete mp row 192, not a sampled set of columns. -/ +theorem mp_row_192 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨192, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 193, not a sampled set of columns. -/ +theorem mp_row_193 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨193, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 194, not a sampled set of columns. -/ +theorem mp_row_194 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨194, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 195, not a sampled set of columns. -/ +theorem mp_row_195 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨195, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 196, not a sampled set of columns. -/ +theorem mp_row_196 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨196, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 197, not a sampled set of columns. -/ +theorem mp_row_197 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨197, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 198, not a sampled set of columns. -/ +theorem mp_row_198 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨198, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 199, not a sampled set of columns. -/ +theorem mp_row_199 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨199, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 200, not a sampled set of columns. -/ +theorem mp_row_200 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨200, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 201, not a sampled set of columns. -/ +theorem mp_row_201 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨201, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 202, not a sampled set of columns. -/ +theorem mp_row_202 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨202, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 203, not a sampled set of columns. -/ +theorem mp_row_203 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨203, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 204, not a sampled set of columns. -/ +theorem mp_row_204 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨204, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 205, not a sampled set of columns. -/ +theorem mp_row_205 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨205, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 206, not a sampled set of columns. -/ +theorem mp_row_206 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨206, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 207, not a sampled set of columns. -/ +theorem mp_row_207 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨207, by decide⟩) P j = 0 := by + decide + + +end P112Cert + +set_option pp.fullNames true +#print axioms P112Cert.mp_row_192 +#print axioms P112Cert.mp_row_193 +#print axioms P112Cert.mp_row_194 +#print axioms P112Cert.mp_row_195 +#print axioms P112Cert.mp_row_196 +#print axioms P112Cert.mp_row_197 +#print axioms P112Cert.mp_row_198 +#print axioms P112Cert.mp_row_199 +#print axioms P112Cert.mp_row_200 +#print axioms P112Cert.mp_row_201 +#print axioms P112Cert.mp_row_202 +#print axioms P112Cert.mp_row_203 +#print axioms P112Cert.mp_row_204 +#print axioms P112Cert.mp_row_205 +#print axioms P112Cert.mp_row_206 +#print axioms P112Cert.mp_row_207 diff --git a/research/p112-integral-retraction-instance/source/P112/MP13.lean b/research/p112-integral-retraction-instance/source/P112/MP13.lean new file mode 100644 index 0000000000..95a2190883 --- /dev/null +++ b/research/p112-integral-retraction-instance/source/P112/MP13.lean @@ -0,0 +1,116 @@ +/- +Copyright (c) 2026 Andrey Mas and contributors. +SPDX-License-Identifier: Apache-2.0 +P112 numerical instance of the unchanged PR1497/PR1610 bridge. +SOURCE ONLY / NOT YET KERNEL CHECKED. Generated deterministically by generate.py. +Proof/source assistance: GPT-6 Pro through ChatGPT (operator-selected label). +-/ +import P112Data + +set_option autoImplicit false +set_option maxRecDepth 4096 +set_option maxHeartbeats 1000000 + +namespace P112Cert +open PR1497 + +/-- Complete mp row 208, not a sampled set of columns. -/ +theorem mp_row_208 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨208, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 209, not a sampled set of columns. -/ +theorem mp_row_209 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨209, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 210, not a sampled set of columns. -/ +theorem mp_row_210 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨210, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 211, not a sampled set of columns. -/ +theorem mp_row_211 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨211, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 212, not a sampled set of columns. -/ +theorem mp_row_212 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨212, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 213, not a sampled set of columns. -/ +theorem mp_row_213 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨213, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 214, not a sampled set of columns. -/ +theorem mp_row_214 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨214, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 215, not a sampled set of columns. -/ +theorem mp_row_215 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨215, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 216, not a sampled set of columns. -/ +theorem mp_row_216 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨216, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 217, not a sampled set of columns. -/ +theorem mp_row_217 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨217, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 218, not a sampled set of columns. -/ +theorem mp_row_218 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨218, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 219, not a sampled set of columns. -/ +theorem mp_row_219 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨219, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 220, not a sampled set of columns. -/ +theorem mp_row_220 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨220, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 221, not a sampled set of columns. -/ +theorem mp_row_221 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨221, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 222, not a sampled set of columns. -/ +theorem mp_row_222 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨222, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 223, not a sampled set of columns. -/ +theorem mp_row_223 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨223, by decide⟩) P j = 0 := by + decide + + +end P112Cert + +set_option pp.fullNames true +#print axioms P112Cert.mp_row_208 +#print axioms P112Cert.mp_row_209 +#print axioms P112Cert.mp_row_210 +#print axioms P112Cert.mp_row_211 +#print axioms P112Cert.mp_row_212 +#print axioms P112Cert.mp_row_213 +#print axioms P112Cert.mp_row_214 +#print axioms P112Cert.mp_row_215 +#print axioms P112Cert.mp_row_216 +#print axioms P112Cert.mp_row_217 +#print axioms P112Cert.mp_row_218 +#print axioms P112Cert.mp_row_219 +#print axioms P112Cert.mp_row_220 +#print axioms P112Cert.mp_row_221 +#print axioms P112Cert.mp_row_222 +#print axioms P112Cert.mp_row_223 diff --git a/research/p112-integral-retraction-instance/source/P112/MP14.lean b/research/p112-integral-retraction-instance/source/P112/MP14.lean new file mode 100644 index 0000000000..af203b287c --- /dev/null +++ b/research/p112-integral-retraction-instance/source/P112/MP14.lean @@ -0,0 +1,116 @@ +/- +Copyright (c) 2026 Andrey Mas and contributors. +SPDX-License-Identifier: Apache-2.0 +P112 numerical instance of the unchanged PR1497/PR1610 bridge. +SOURCE ONLY / NOT YET KERNEL CHECKED. Generated deterministically by generate.py. +Proof/source assistance: GPT-6 Pro through ChatGPT (operator-selected label). +-/ +import P112Data + +set_option autoImplicit false +set_option maxRecDepth 4096 +set_option maxHeartbeats 1000000 + +namespace P112Cert +open PR1497 + +/-- Complete mp row 224, not a sampled set of columns. -/ +theorem mp_row_224 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨224, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 225, not a sampled set of columns. -/ +theorem mp_row_225 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨225, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 226, not a sampled set of columns. -/ +theorem mp_row_226 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨226, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 227, not a sampled set of columns. -/ +theorem mp_row_227 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨227, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 228, not a sampled set of columns. -/ +theorem mp_row_228 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨228, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 229, not a sampled set of columns. -/ +theorem mp_row_229 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨229, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 230, not a sampled set of columns. -/ +theorem mp_row_230 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨230, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 231, not a sampled set of columns. -/ +theorem mp_row_231 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨231, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 232, not a sampled set of columns. -/ +theorem mp_row_232 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨232, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 233, not a sampled set of columns. -/ +theorem mp_row_233 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨233, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 234, not a sampled set of columns. -/ +theorem mp_row_234 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨234, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 235, not a sampled set of columns. -/ +theorem mp_row_235 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨235, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 236, not a sampled set of columns. -/ +theorem mp_row_236 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨236, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 237, not a sampled set of columns. -/ +theorem mp_row_237 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨237, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 238, not a sampled set of columns. -/ +theorem mp_row_238 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨238, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 239, not a sampled set of columns. -/ +theorem mp_row_239 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨239, by decide⟩) P j = 0 := by + decide + + +end P112Cert + +set_option pp.fullNames true +#print axioms P112Cert.mp_row_224 +#print axioms P112Cert.mp_row_225 +#print axioms P112Cert.mp_row_226 +#print axioms P112Cert.mp_row_227 +#print axioms P112Cert.mp_row_228 +#print axioms P112Cert.mp_row_229 +#print axioms P112Cert.mp_row_230 +#print axioms P112Cert.mp_row_231 +#print axioms P112Cert.mp_row_232 +#print axioms P112Cert.mp_row_233 +#print axioms P112Cert.mp_row_234 +#print axioms P112Cert.mp_row_235 +#print axioms P112Cert.mp_row_236 +#print axioms P112Cert.mp_row_237 +#print axioms P112Cert.mp_row_238 +#print axioms P112Cert.mp_row_239 diff --git a/research/p112-integral-retraction-instance/source/P112/MP15.lean b/research/p112-integral-retraction-instance/source/P112/MP15.lean new file mode 100644 index 0000000000..a7ef94fe67 --- /dev/null +++ b/research/p112-integral-retraction-instance/source/P112/MP15.lean @@ -0,0 +1,116 @@ +/- +Copyright (c) 2026 Andrey Mas and contributors. +SPDX-License-Identifier: Apache-2.0 +P112 numerical instance of the unchanged PR1497/PR1610 bridge. +SOURCE ONLY / NOT YET KERNEL CHECKED. Generated deterministically by generate.py. +Proof/source assistance: GPT-6 Pro through ChatGPT (operator-selected label). +-/ +import P112Data + +set_option autoImplicit false +set_option maxRecDepth 4096 +set_option maxHeartbeats 1000000 + +namespace P112Cert +open PR1497 + +/-- Complete mp row 240, not a sampled set of columns. -/ +theorem mp_row_240 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨240, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 241, not a sampled set of columns. -/ +theorem mp_row_241 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨241, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 242, not a sampled set of columns. -/ +theorem mp_row_242 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨242, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 243, not a sampled set of columns. -/ +theorem mp_row_243 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨243, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 244, not a sampled set of columns. -/ +theorem mp_row_244 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨244, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 245, not a sampled set of columns. -/ +theorem mp_row_245 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨245, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 246, not a sampled set of columns. -/ +theorem mp_row_246 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨246, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 247, not a sampled set of columns. -/ +theorem mp_row_247 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨247, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 248, not a sampled set of columns. -/ +theorem mp_row_248 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨248, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 249, not a sampled set of columns. -/ +theorem mp_row_249 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨249, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 250, not a sampled set of columns. -/ +theorem mp_row_250 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨250, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 251, not a sampled set of columns. -/ +theorem mp_row_251 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨251, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 252, not a sampled set of columns. -/ +theorem mp_row_252 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨252, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 253, not a sampled set of columns. -/ +theorem mp_row_253 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨253, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 254, not a sampled set of columns. -/ +theorem mp_row_254 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨254, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 255, not a sampled set of columns. -/ +theorem mp_row_255 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨255, by decide⟩) P j = 0 := by + decide + + +end P112Cert + +set_option pp.fullNames true +#print axioms P112Cert.mp_row_240 +#print axioms P112Cert.mp_row_241 +#print axioms P112Cert.mp_row_242 +#print axioms P112Cert.mp_row_243 +#print axioms P112Cert.mp_row_244 +#print axioms P112Cert.mp_row_245 +#print axioms P112Cert.mp_row_246 +#print axioms P112Cert.mp_row_247 +#print axioms P112Cert.mp_row_248 +#print axioms P112Cert.mp_row_249 +#print axioms P112Cert.mp_row_250 +#print axioms P112Cert.mp_row_251 +#print axioms P112Cert.mp_row_252 +#print axioms P112Cert.mp_row_253 +#print axioms P112Cert.mp_row_254 +#print axioms P112Cert.mp_row_255 diff --git a/research/p112-integral-retraction-instance/source/P112/MP16.lean b/research/p112-integral-retraction-instance/source/P112/MP16.lean new file mode 100644 index 0000000000..b1482c4f13 --- /dev/null +++ b/research/p112-integral-retraction-instance/source/P112/MP16.lean @@ -0,0 +1,116 @@ +/- +Copyright (c) 2026 Andrey Mas and contributors. +SPDX-License-Identifier: Apache-2.0 +P112 numerical instance of the unchanged PR1497/PR1610 bridge. +SOURCE ONLY / NOT YET KERNEL CHECKED. Generated deterministically by generate.py. +Proof/source assistance: GPT-6 Pro through ChatGPT (operator-selected label). +-/ +import P112Data + +set_option autoImplicit false +set_option maxRecDepth 4096 +set_option maxHeartbeats 1000000 + +namespace P112Cert +open PR1497 + +/-- Complete mp row 256, not a sampled set of columns. -/ +theorem mp_row_256 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨256, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 257, not a sampled set of columns. -/ +theorem mp_row_257 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨257, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 258, not a sampled set of columns. -/ +theorem mp_row_258 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨258, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 259, not a sampled set of columns. -/ +theorem mp_row_259 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨259, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 260, not a sampled set of columns. -/ +theorem mp_row_260 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨260, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 261, not a sampled set of columns. -/ +theorem mp_row_261 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨261, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 262, not a sampled set of columns. -/ +theorem mp_row_262 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨262, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 263, not a sampled set of columns. -/ +theorem mp_row_263 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨263, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 264, not a sampled set of columns. -/ +theorem mp_row_264 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨264, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 265, not a sampled set of columns. -/ +theorem mp_row_265 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨265, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 266, not a sampled set of columns. -/ +theorem mp_row_266 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨266, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 267, not a sampled set of columns. -/ +theorem mp_row_267 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨267, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 268, not a sampled set of columns. -/ +theorem mp_row_268 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨268, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 269, not a sampled set of columns. -/ +theorem mp_row_269 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨269, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 270, not a sampled set of columns. -/ +theorem mp_row_270 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨270, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 271, not a sampled set of columns. -/ +theorem mp_row_271 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨271, by decide⟩) P j = 0 := by + decide + + +end P112Cert + +set_option pp.fullNames true +#print axioms P112Cert.mp_row_256 +#print axioms P112Cert.mp_row_257 +#print axioms P112Cert.mp_row_258 +#print axioms P112Cert.mp_row_259 +#print axioms P112Cert.mp_row_260 +#print axioms P112Cert.mp_row_261 +#print axioms P112Cert.mp_row_262 +#print axioms P112Cert.mp_row_263 +#print axioms P112Cert.mp_row_264 +#print axioms P112Cert.mp_row_265 +#print axioms P112Cert.mp_row_266 +#print axioms P112Cert.mp_row_267 +#print axioms P112Cert.mp_row_268 +#print axioms P112Cert.mp_row_269 +#print axioms P112Cert.mp_row_270 +#print axioms P112Cert.mp_row_271 diff --git a/research/p112-integral-retraction-instance/source/P112/MP17.lean b/research/p112-integral-retraction-instance/source/P112/MP17.lean new file mode 100644 index 0000000000..1d8faf464b --- /dev/null +++ b/research/p112-integral-retraction-instance/source/P112/MP17.lean @@ -0,0 +1,116 @@ +/- +Copyright (c) 2026 Andrey Mas and contributors. +SPDX-License-Identifier: Apache-2.0 +P112 numerical instance of the unchanged PR1497/PR1610 bridge. +SOURCE ONLY / NOT YET KERNEL CHECKED. Generated deterministically by generate.py. +Proof/source assistance: GPT-6 Pro through ChatGPT (operator-selected label). +-/ +import P112Data + +set_option autoImplicit false +set_option maxRecDepth 4096 +set_option maxHeartbeats 1000000 + +namespace P112Cert +open PR1497 + +/-- Complete mp row 272, not a sampled set of columns. -/ +theorem mp_row_272 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨272, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 273, not a sampled set of columns. -/ +theorem mp_row_273 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨273, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 274, not a sampled set of columns. -/ +theorem mp_row_274 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨274, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 275, not a sampled set of columns. -/ +theorem mp_row_275 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨275, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 276, not a sampled set of columns. -/ +theorem mp_row_276 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨276, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 277, not a sampled set of columns. -/ +theorem mp_row_277 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨277, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 278, not a sampled set of columns. -/ +theorem mp_row_278 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨278, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 279, not a sampled set of columns. -/ +theorem mp_row_279 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨279, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 280, not a sampled set of columns. -/ +theorem mp_row_280 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨280, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 281, not a sampled set of columns. -/ +theorem mp_row_281 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨281, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 282, not a sampled set of columns. -/ +theorem mp_row_282 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨282, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 283, not a sampled set of columns. -/ +theorem mp_row_283 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨283, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 284, not a sampled set of columns. -/ +theorem mp_row_284 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨284, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 285, not a sampled set of columns. -/ +theorem mp_row_285 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨285, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 286, not a sampled set of columns. -/ +theorem mp_row_286 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨286, by decide⟩) P j = 0 := by + decide + +/-- Complete mp row 287, not a sampled set of columns. -/ +theorem mp_row_287 : + ∀ j : Fin 33, Sparse.eval (M_entries ⟨287, by decide⟩) P j = 0 := by + decide + + +end P112Cert + +set_option pp.fullNames true +#print axioms P112Cert.mp_row_272 +#print axioms P112Cert.mp_row_273 +#print axioms P112Cert.mp_row_274 +#print axioms P112Cert.mp_row_275 +#print axioms P112Cert.mp_row_276 +#print axioms P112Cert.mp_row_277 +#print axioms P112Cert.mp_row_278 +#print axioms P112Cert.mp_row_279 +#print axioms P112Cert.mp_row_280 +#print axioms P112Cert.mp_row_281 +#print axioms P112Cert.mp_row_282 +#print axioms P112Cert.mp_row_283 +#print axioms P112Cert.mp_row_284 +#print axioms P112Cert.mp_row_285 +#print axioms P112Cert.mp_row_286 +#print axioms P112Cert.mp_row_287 diff --git a/research/p112-integral-retraction-instance/source/P112/QP00.lean b/research/p112-integral-retraction-instance/source/P112/QP00.lean new file mode 100644 index 0000000000..274379f899 --- /dev/null +++ b/research/p112-integral-retraction-instance/source/P112/QP00.lean @@ -0,0 +1,116 @@ +/- +Copyright (c) 2026 Andrey Mas and contributors. +SPDX-License-Identifier: Apache-2.0 +P112 numerical instance of the unchanged PR1497/PR1610 bridge. +SOURCE ONLY / NOT YET KERNEL CHECKED. Generated deterministically by generate.py. +Proof/source assistance: GPT-6 Pro through ChatGPT (operator-selected label). +-/ +import P112Data + +set_option autoImplicit false +set_option maxRecDepth 4096 +set_option maxHeartbeats 1000000 + +namespace P112Cert +open PR1497 + +/-- Complete qp row 0, not a sampled set of columns. -/ +theorem qp_row_000 : + ∀ j : Fin 33, Sparse.eval (Q_entries ⟨0, by decide⟩) P j = eye 33 ⟨0, by decide⟩ j := by + decide + +/-- Complete qp row 1, not a sampled set of columns. -/ +theorem qp_row_001 : + ∀ j : Fin 33, Sparse.eval (Q_entries ⟨1, by decide⟩) P j = eye 33 ⟨1, by decide⟩ j := by + decide + +/-- Complete qp row 2, not a sampled set of columns. -/ +theorem qp_row_002 : + ∀ j : Fin 33, Sparse.eval (Q_entries ⟨2, by decide⟩) P j = eye 33 ⟨2, by decide⟩ j := by + decide + +/-- Complete qp row 3, not a sampled set of columns. -/ +theorem qp_row_003 : + ∀ j : Fin 33, Sparse.eval (Q_entries ⟨3, by decide⟩) P j = eye 33 ⟨3, by decide⟩ j := by + decide + +/-- Complete qp row 4, not a sampled set of columns. -/ +theorem qp_row_004 : + ∀ j : Fin 33, Sparse.eval (Q_entries ⟨4, by decide⟩) P j = eye 33 ⟨4, by decide⟩ j := by + decide + +/-- Complete qp row 5, not a sampled set of columns. -/ +theorem qp_row_005 : + ∀ j : Fin 33, Sparse.eval (Q_entries ⟨5, by decide⟩) P j = eye 33 ⟨5, by decide⟩ j := by + decide + +/-- Complete qp row 6, not a sampled set of columns. -/ +theorem qp_row_006 : + ∀ j : Fin 33, Sparse.eval (Q_entries ⟨6, by decide⟩) P j = eye 33 ⟨6, by decide⟩ j := by + decide + +/-- Complete qp row 7, not a sampled set of columns. -/ +theorem qp_row_007 : + ∀ j : Fin 33, Sparse.eval (Q_entries ⟨7, by decide⟩) P j = eye 33 ⟨7, by decide⟩ j := by + decide + +/-- Complete qp row 8, not a sampled set of columns. -/ +theorem qp_row_008 : + ∀ j : Fin 33, Sparse.eval (Q_entries ⟨8, by decide⟩) P j = eye 33 ⟨8, by decide⟩ j := by + decide + +/-- Complete qp row 9, not a sampled set of columns. -/ +theorem qp_row_009 : + ∀ j : Fin 33, Sparse.eval (Q_entries ⟨9, by decide⟩) P j = eye 33 ⟨9, by decide⟩ j := by + decide + +/-- Complete qp row 10, not a sampled set of columns. -/ +theorem qp_row_010 : + ∀ j : Fin 33, Sparse.eval (Q_entries ⟨10, by decide⟩) P j = eye 33 ⟨10, by decide⟩ j := by + decide + +/-- Complete qp row 11, not a sampled set of columns. -/ +theorem qp_row_011 : + ∀ j : Fin 33, Sparse.eval (Q_entries ⟨11, by decide⟩) P j = eye 33 ⟨11, by decide⟩ j := by + decide + +/-- Complete qp row 12, not a sampled set of columns. -/ +theorem qp_row_012 : + ∀ j : Fin 33, Sparse.eval (Q_entries ⟨12, by decide⟩) P j = eye 33 ⟨12, by decide⟩ j := by + decide + +/-- Complete qp row 13, not a sampled set of columns. -/ +theorem qp_row_013 : + ∀ j : Fin 33, Sparse.eval (Q_entries ⟨13, by decide⟩) P j = eye 33 ⟨13, by decide⟩ j := by + decide + +/-- Complete qp row 14, not a sampled set of columns. -/ +theorem qp_row_014 : + ∀ j : Fin 33, Sparse.eval (Q_entries ⟨14, by decide⟩) P j = eye 33 ⟨14, by decide⟩ j := by + decide + +/-- Complete qp row 15, not a sampled set of columns. -/ +theorem qp_row_015 : + ∀ j : Fin 33, Sparse.eval (Q_entries ⟨15, by decide⟩) P j = eye 33 ⟨15, by decide⟩ j := by + decide + + +end P112Cert + +set_option pp.fullNames true +#print axioms P112Cert.qp_row_000 +#print axioms P112Cert.qp_row_001 +#print axioms P112Cert.qp_row_002 +#print axioms P112Cert.qp_row_003 +#print axioms P112Cert.qp_row_004 +#print axioms P112Cert.qp_row_005 +#print axioms P112Cert.qp_row_006 +#print axioms P112Cert.qp_row_007 +#print axioms P112Cert.qp_row_008 +#print axioms P112Cert.qp_row_009 +#print axioms P112Cert.qp_row_010 +#print axioms P112Cert.qp_row_011 +#print axioms P112Cert.qp_row_012 +#print axioms P112Cert.qp_row_013 +#print axioms P112Cert.qp_row_014 +#print axioms P112Cert.qp_row_015 diff --git a/research/p112-integral-retraction-instance/source/P112/QP01.lean b/research/p112-integral-retraction-instance/source/P112/QP01.lean new file mode 100644 index 0000000000..4bc649f95d --- /dev/null +++ b/research/p112-integral-retraction-instance/source/P112/QP01.lean @@ -0,0 +1,116 @@ +/- +Copyright (c) 2026 Andrey Mas and contributors. +SPDX-License-Identifier: Apache-2.0 +P112 numerical instance of the unchanged PR1497/PR1610 bridge. +SOURCE ONLY / NOT YET KERNEL CHECKED. Generated deterministically by generate.py. +Proof/source assistance: GPT-6 Pro through ChatGPT (operator-selected label). +-/ +import P112Data + +set_option autoImplicit false +set_option maxRecDepth 4096 +set_option maxHeartbeats 1000000 + +namespace P112Cert +open PR1497 + +/-- Complete qp row 16, not a sampled set of columns. -/ +theorem qp_row_016 : + ∀ j : Fin 33, Sparse.eval (Q_entries ⟨16, by decide⟩) P j = eye 33 ⟨16, by decide⟩ j := by + decide + +/-- Complete qp row 17, not a sampled set of columns. -/ +theorem qp_row_017 : + ∀ j : Fin 33, Sparse.eval (Q_entries ⟨17, by decide⟩) P j = eye 33 ⟨17, by decide⟩ j := by + decide + +/-- Complete qp row 18, not a sampled set of columns. -/ +theorem qp_row_018 : + ∀ j : Fin 33, Sparse.eval (Q_entries ⟨18, by decide⟩) P j = eye 33 ⟨18, by decide⟩ j := by + decide + +/-- Complete qp row 19, not a sampled set of columns. -/ +theorem qp_row_019 : + ∀ j : Fin 33, Sparse.eval (Q_entries ⟨19, by decide⟩) P j = eye 33 ⟨19, by decide⟩ j := by + decide + +/-- Complete qp row 20, not a sampled set of columns. -/ +theorem qp_row_020 : + ∀ j : Fin 33, Sparse.eval (Q_entries ⟨20, by decide⟩) P j = eye 33 ⟨20, by decide⟩ j := by + decide + +/-- Complete qp row 21, not a sampled set of columns. -/ +theorem qp_row_021 : + ∀ j : Fin 33, Sparse.eval (Q_entries ⟨21, by decide⟩) P j = eye 33 ⟨21, by decide⟩ j := by + decide + +/-- Complete qp row 22, not a sampled set of columns. -/ +theorem qp_row_022 : + ∀ j : Fin 33, Sparse.eval (Q_entries ⟨22, by decide⟩) P j = eye 33 ⟨22, by decide⟩ j := by + decide + +/-- Complete qp row 23, not a sampled set of columns. -/ +theorem qp_row_023 : + ∀ j : Fin 33, Sparse.eval (Q_entries ⟨23, by decide⟩) P j = eye 33 ⟨23, by decide⟩ j := by + decide + +/-- Complete qp row 24, not a sampled set of columns. -/ +theorem qp_row_024 : + ∀ j : Fin 33, Sparse.eval (Q_entries ⟨24, by decide⟩) P j = eye 33 ⟨24, by decide⟩ j := by + decide + +/-- Complete qp row 25, not a sampled set of columns. -/ +theorem qp_row_025 : + ∀ j : Fin 33, Sparse.eval (Q_entries ⟨25, by decide⟩) P j = eye 33 ⟨25, by decide⟩ j := by + decide + +/-- Complete qp row 26, not a sampled set of columns. -/ +theorem qp_row_026 : + ∀ j : Fin 33, Sparse.eval (Q_entries ⟨26, by decide⟩) P j = eye 33 ⟨26, by decide⟩ j := by + decide + +/-- Complete qp row 27, not a sampled set of columns. -/ +theorem qp_row_027 : + ∀ j : Fin 33, Sparse.eval (Q_entries ⟨27, by decide⟩) P j = eye 33 ⟨27, by decide⟩ j := by + decide + +/-- Complete qp row 28, not a sampled set of columns. -/ +theorem qp_row_028 : + ∀ j : Fin 33, Sparse.eval (Q_entries ⟨28, by decide⟩) P j = eye 33 ⟨28, by decide⟩ j := by + decide + +/-- Complete qp row 29, not a sampled set of columns. -/ +theorem qp_row_029 : + ∀ j : Fin 33, Sparse.eval (Q_entries ⟨29, by decide⟩) P j = eye 33 ⟨29, by decide⟩ j := by + decide + +/-- Complete qp row 30, not a sampled set of columns. -/ +theorem qp_row_030 : + ∀ j : Fin 33, Sparse.eval (Q_entries ⟨30, by decide⟩) P j = eye 33 ⟨30, by decide⟩ j := by + decide + +/-- Complete qp row 31, not a sampled set of columns. -/ +theorem qp_row_031 : + ∀ j : Fin 33, Sparse.eval (Q_entries ⟨31, by decide⟩) P j = eye 33 ⟨31, by decide⟩ j := by + decide + + +end P112Cert + +set_option pp.fullNames true +#print axioms P112Cert.qp_row_016 +#print axioms P112Cert.qp_row_017 +#print axioms P112Cert.qp_row_018 +#print axioms P112Cert.qp_row_019 +#print axioms P112Cert.qp_row_020 +#print axioms P112Cert.qp_row_021 +#print axioms P112Cert.qp_row_022 +#print axioms P112Cert.qp_row_023 +#print axioms P112Cert.qp_row_024 +#print axioms P112Cert.qp_row_025 +#print axioms P112Cert.qp_row_026 +#print axioms P112Cert.qp_row_027 +#print axioms P112Cert.qp_row_028 +#print axioms P112Cert.qp_row_029 +#print axioms P112Cert.qp_row_030 +#print axioms P112Cert.qp_row_031 diff --git a/research/p112-integral-retraction-instance/source/P112/QP02.lean b/research/p112-integral-retraction-instance/source/P112/QP02.lean new file mode 100644 index 0000000000..27caae19b3 --- /dev/null +++ b/research/p112-integral-retraction-instance/source/P112/QP02.lean @@ -0,0 +1,26 @@ +/- +Copyright (c) 2026 Andrey Mas and contributors. +SPDX-License-Identifier: Apache-2.0 +P112 numerical instance of the unchanged PR1497/PR1610 bridge. +SOURCE ONLY / NOT YET KERNEL CHECKED. Generated deterministically by generate.py. +Proof/source assistance: GPT-6 Pro through ChatGPT (operator-selected label). +-/ +import P112Data + +set_option autoImplicit false +set_option maxRecDepth 4096 +set_option maxHeartbeats 1000000 + +namespace P112Cert +open PR1497 + +/-- Complete qp row 32, not a sampled set of columns. -/ +theorem qp_row_032 : + ∀ j : Fin 33, Sparse.eval (Q_entries ⟨32, by decide⟩) P j = eye 33 ⟨32, by decide⟩ j := by + decide + + +end P112Cert + +set_option pp.fullNames true +#print axioms P112Cert.qp_row_032 diff --git a/research/p112-integral-retraction-instance/source/P112/Residual00.lean b/research/p112-integral-retraction-instance/source/P112/Residual00.lean new file mode 100644 index 0000000000..52e5d35913 --- /dev/null +++ b/research/p112-integral-retraction-instance/source/P112/Residual00.lean @@ -0,0 +1,76 @@ +/- +Copyright (c) 2026 Andrey Mas and contributors. +SPDX-License-Identifier: Apache-2.0 +P112 numerical instance of the unchanged PR1497/PR1610 bridge. +SOURCE ONLY / NOT YET KERNEL CHECKED. Generated deterministically by generate.py. +Proof/source assistance: GPT-6 Pro through ChatGPT (operator-selected label). +-/ +import P112Data + +set_option autoImplicit false +set_option maxRecDepth 4096 +set_option maxHeartbeats 1000000 + +namespace P112Cert +open PR1497 + +/-- Complete residual row 0, not a sampled set of columns. -/ +theorem residual_row_000 : + ∀ j : Fin 104, eye 104 ⟨0, by decide⟩ j - Sparse.eval (P_entries ⟨0, by decide⟩) Q j = + Sparse.eval (W_entries ⟨0, by decide⟩) M j := by + decide + +/-- Complete residual row 1, not a sampled set of columns. -/ +theorem residual_row_001 : + ∀ j : Fin 104, eye 104 ⟨1, by decide⟩ j - Sparse.eval (P_entries ⟨1, by decide⟩) Q j = + Sparse.eval (W_entries ⟨1, by decide⟩) M j := by + decide + +/-- Complete residual row 2, not a sampled set of columns. -/ +theorem residual_row_002 : + ∀ j : Fin 104, eye 104 ⟨2, by decide⟩ j - Sparse.eval (P_entries ⟨2, by decide⟩) Q j = + Sparse.eval (W_entries ⟨2, by decide⟩) M j := by + decide + +/-- Complete residual row 3, not a sampled set of columns. -/ +theorem residual_row_003 : + ∀ j : Fin 104, eye 104 ⟨3, by decide⟩ j - Sparse.eval (P_entries ⟨3, by decide⟩) Q j = + Sparse.eval (W_entries ⟨3, by decide⟩) M j := by + decide + +/-- Complete residual row 4, not a sampled set of columns. -/ +theorem residual_row_004 : + ∀ j : Fin 104, eye 104 ⟨4, by decide⟩ j - Sparse.eval (P_entries ⟨4, by decide⟩) Q j = + Sparse.eval (W_entries ⟨4, by decide⟩) M j := by + decide + +/-- Complete residual row 5, not a sampled set of columns. -/ +theorem residual_row_005 : + ∀ j : Fin 104, eye 104 ⟨5, by decide⟩ j - Sparse.eval (P_entries ⟨5, by decide⟩) Q j = + Sparse.eval (W_entries ⟨5, by decide⟩) M j := by + decide + +/-- Complete residual row 6, not a sampled set of columns. -/ +theorem residual_row_006 : + ∀ j : Fin 104, eye 104 ⟨6, by decide⟩ j - Sparse.eval (P_entries ⟨6, by decide⟩) Q j = + Sparse.eval (W_entries ⟨6, by decide⟩) M j := by + decide + +/-- Complete residual row 7, not a sampled set of columns. -/ +theorem residual_row_007 : + ∀ j : Fin 104, eye 104 ⟨7, by decide⟩ j - Sparse.eval (P_entries ⟨7, by decide⟩) Q j = + Sparse.eval (W_entries ⟨7, by decide⟩) M j := by + decide + + +end P112Cert + +set_option pp.fullNames true +#print axioms P112Cert.residual_row_000 +#print axioms P112Cert.residual_row_001 +#print axioms P112Cert.residual_row_002 +#print axioms P112Cert.residual_row_003 +#print axioms P112Cert.residual_row_004 +#print axioms P112Cert.residual_row_005 +#print axioms P112Cert.residual_row_006 +#print axioms P112Cert.residual_row_007 diff --git a/research/p112-integral-retraction-instance/source/P112/Residual01.lean b/research/p112-integral-retraction-instance/source/P112/Residual01.lean new file mode 100644 index 0000000000..47aaf19664 --- /dev/null +++ b/research/p112-integral-retraction-instance/source/P112/Residual01.lean @@ -0,0 +1,76 @@ +/- +Copyright (c) 2026 Andrey Mas and contributors. +SPDX-License-Identifier: Apache-2.0 +P112 numerical instance of the unchanged PR1497/PR1610 bridge. +SOURCE ONLY / NOT YET KERNEL CHECKED. Generated deterministically by generate.py. +Proof/source assistance: GPT-6 Pro through ChatGPT (operator-selected label). +-/ +import P112Data + +set_option autoImplicit false +set_option maxRecDepth 4096 +set_option maxHeartbeats 1000000 + +namespace P112Cert +open PR1497 + +/-- Complete residual row 8, not a sampled set of columns. -/ +theorem residual_row_008 : + ∀ j : Fin 104, eye 104 ⟨8, by decide⟩ j - Sparse.eval (P_entries ⟨8, by decide⟩) Q j = + Sparse.eval (W_entries ⟨8, by decide⟩) M j := by + decide + +/-- Complete residual row 9, not a sampled set of columns. -/ +theorem residual_row_009 : + ∀ j : Fin 104, eye 104 ⟨9, by decide⟩ j - Sparse.eval (P_entries ⟨9, by decide⟩) Q j = + Sparse.eval (W_entries ⟨9, by decide⟩) M j := by + decide + +/-- Complete residual row 10, not a sampled set of columns. -/ +theorem residual_row_010 : + ∀ j : Fin 104, eye 104 ⟨10, by decide⟩ j - Sparse.eval (P_entries ⟨10, by decide⟩) Q j = + Sparse.eval (W_entries ⟨10, by decide⟩) M j := by + decide + +/-- Complete residual row 11, not a sampled set of columns. -/ +theorem residual_row_011 : + ∀ j : Fin 104, eye 104 ⟨11, by decide⟩ j - Sparse.eval (P_entries ⟨11, by decide⟩) Q j = + Sparse.eval (W_entries ⟨11, by decide⟩) M j := by + decide + +/-- Complete residual row 12, not a sampled set of columns. -/ +theorem residual_row_012 : + ∀ j : Fin 104, eye 104 ⟨12, by decide⟩ j - Sparse.eval (P_entries ⟨12, by decide⟩) Q j = + Sparse.eval (W_entries ⟨12, by decide⟩) M j := by + decide + +/-- Complete residual row 13, not a sampled set of columns. -/ +theorem residual_row_013 : + ∀ j : Fin 104, eye 104 ⟨13, by decide⟩ j - Sparse.eval (P_entries ⟨13, by decide⟩) Q j = + Sparse.eval (W_entries ⟨13, by decide⟩) M j := by + decide + +/-- Complete residual row 14, not a sampled set of columns. -/ +theorem residual_row_014 : + ∀ j : Fin 104, eye 104 ⟨14, by decide⟩ j - Sparse.eval (P_entries ⟨14, by decide⟩) Q j = + Sparse.eval (W_entries ⟨14, by decide⟩) M j := by + decide + +/-- Complete residual row 15, not a sampled set of columns. -/ +theorem residual_row_015 : + ∀ j : Fin 104, eye 104 ⟨15, by decide⟩ j - Sparse.eval (P_entries ⟨15, by decide⟩) Q j = + Sparse.eval (W_entries ⟨15, by decide⟩) M j := by + decide + + +end P112Cert + +set_option pp.fullNames true +#print axioms P112Cert.residual_row_008 +#print axioms P112Cert.residual_row_009 +#print axioms P112Cert.residual_row_010 +#print axioms P112Cert.residual_row_011 +#print axioms P112Cert.residual_row_012 +#print axioms P112Cert.residual_row_013 +#print axioms P112Cert.residual_row_014 +#print axioms P112Cert.residual_row_015 diff --git a/research/p112-integral-retraction-instance/source/P112/Residual02.lean b/research/p112-integral-retraction-instance/source/P112/Residual02.lean new file mode 100644 index 0000000000..546d0d825e --- /dev/null +++ b/research/p112-integral-retraction-instance/source/P112/Residual02.lean @@ -0,0 +1,76 @@ +/- +Copyright (c) 2026 Andrey Mas and contributors. +SPDX-License-Identifier: Apache-2.0 +P112 numerical instance of the unchanged PR1497/PR1610 bridge. +SOURCE ONLY / NOT YET KERNEL CHECKED. Generated deterministically by generate.py. +Proof/source assistance: GPT-6 Pro through ChatGPT (operator-selected label). +-/ +import P112Data + +set_option autoImplicit false +set_option maxRecDepth 4096 +set_option maxHeartbeats 1000000 + +namespace P112Cert +open PR1497 + +/-- Complete residual row 16, not a sampled set of columns. -/ +theorem residual_row_016 : + ∀ j : Fin 104, eye 104 ⟨16, by decide⟩ j - Sparse.eval (P_entries ⟨16, by decide⟩) Q j = + Sparse.eval (W_entries ⟨16, by decide⟩) M j := by + decide + +/-- Complete residual row 17, not a sampled set of columns. -/ +theorem residual_row_017 : + ∀ j : Fin 104, eye 104 ⟨17, by decide⟩ j - Sparse.eval (P_entries ⟨17, by decide⟩) Q j = + Sparse.eval (W_entries ⟨17, by decide⟩) M j := by + decide + +/-- Complete residual row 18, not a sampled set of columns. -/ +theorem residual_row_018 : + ∀ j : Fin 104, eye 104 ⟨18, by decide⟩ j - Sparse.eval (P_entries ⟨18, by decide⟩) Q j = + Sparse.eval (W_entries ⟨18, by decide⟩) M j := by + decide + +/-- Complete residual row 19, not a sampled set of columns. -/ +theorem residual_row_019 : + ∀ j : Fin 104, eye 104 ⟨19, by decide⟩ j - Sparse.eval (P_entries ⟨19, by decide⟩) Q j = + Sparse.eval (W_entries ⟨19, by decide⟩) M j := by + decide + +/-- Complete residual row 20, not a sampled set of columns. -/ +theorem residual_row_020 : + ∀ j : Fin 104, eye 104 ⟨20, by decide⟩ j - Sparse.eval (P_entries ⟨20, by decide⟩) Q j = + Sparse.eval (W_entries ⟨20, by decide⟩) M j := by + decide + +/-- Complete residual row 21, not a sampled set of columns. -/ +theorem residual_row_021 : + ∀ j : Fin 104, eye 104 ⟨21, by decide⟩ j - Sparse.eval (P_entries ⟨21, by decide⟩) Q j = + Sparse.eval (W_entries ⟨21, by decide⟩) M j := by + decide + +/-- Complete residual row 22, not a sampled set of columns. -/ +theorem residual_row_022 : + ∀ j : Fin 104, eye 104 ⟨22, by decide⟩ j - Sparse.eval (P_entries ⟨22, by decide⟩) Q j = + Sparse.eval (W_entries ⟨22, by decide⟩) M j := by + decide + +/-- Complete residual row 23, not a sampled set of columns. -/ +theorem residual_row_023 : + ∀ j : Fin 104, eye 104 ⟨23, by decide⟩ j - Sparse.eval (P_entries ⟨23, by decide⟩) Q j = + Sparse.eval (W_entries ⟨23, by decide⟩) M j := by + decide + + +end P112Cert + +set_option pp.fullNames true +#print axioms P112Cert.residual_row_016 +#print axioms P112Cert.residual_row_017 +#print axioms P112Cert.residual_row_018 +#print axioms P112Cert.residual_row_019 +#print axioms P112Cert.residual_row_020 +#print axioms P112Cert.residual_row_021 +#print axioms P112Cert.residual_row_022 +#print axioms P112Cert.residual_row_023 diff --git a/research/p112-integral-retraction-instance/source/P112/Residual03.lean b/research/p112-integral-retraction-instance/source/P112/Residual03.lean new file mode 100644 index 0000000000..9ac4275acd --- /dev/null +++ b/research/p112-integral-retraction-instance/source/P112/Residual03.lean @@ -0,0 +1,76 @@ +/- +Copyright (c) 2026 Andrey Mas and contributors. +SPDX-License-Identifier: Apache-2.0 +P112 numerical instance of the unchanged PR1497/PR1610 bridge. +SOURCE ONLY / NOT YET KERNEL CHECKED. Generated deterministically by generate.py. +Proof/source assistance: GPT-6 Pro through ChatGPT (operator-selected label). +-/ +import P112Data + +set_option autoImplicit false +set_option maxRecDepth 4096 +set_option maxHeartbeats 1000000 + +namespace P112Cert +open PR1497 + +/-- Complete residual row 24, not a sampled set of columns. -/ +theorem residual_row_024 : + ∀ j : Fin 104, eye 104 ⟨24, by decide⟩ j - Sparse.eval (P_entries ⟨24, by decide⟩) Q j = + Sparse.eval (W_entries ⟨24, by decide⟩) M j := by + decide + +/-- Complete residual row 25, not a sampled set of columns. -/ +theorem residual_row_025 : + ∀ j : Fin 104, eye 104 ⟨25, by decide⟩ j - Sparse.eval (P_entries ⟨25, by decide⟩) Q j = + Sparse.eval (W_entries ⟨25, by decide⟩) M j := by + decide + +/-- Complete residual row 26, not a sampled set of columns. -/ +theorem residual_row_026 : + ∀ j : Fin 104, eye 104 ⟨26, by decide⟩ j - Sparse.eval (P_entries ⟨26, by decide⟩) Q j = + Sparse.eval (W_entries ⟨26, by decide⟩) M j := by + decide + +/-- Complete residual row 27, not a sampled set of columns. -/ +theorem residual_row_027 : + ∀ j : Fin 104, eye 104 ⟨27, by decide⟩ j - Sparse.eval (P_entries ⟨27, by decide⟩) Q j = + Sparse.eval (W_entries ⟨27, by decide⟩) M j := by + decide + +/-- Complete residual row 28, not a sampled set of columns. -/ +theorem residual_row_028 : + ∀ j : Fin 104, eye 104 ⟨28, by decide⟩ j - Sparse.eval (P_entries ⟨28, by decide⟩) Q j = + Sparse.eval (W_entries ⟨28, by decide⟩) M j := by + decide + +/-- Complete residual row 29, not a sampled set of columns. -/ +theorem residual_row_029 : + ∀ j : Fin 104, eye 104 ⟨29, by decide⟩ j - Sparse.eval (P_entries ⟨29, by decide⟩) Q j = + Sparse.eval (W_entries ⟨29, by decide⟩) M j := by + decide + +/-- Complete residual row 30, not a sampled set of columns. -/ +theorem residual_row_030 : + ∀ j : Fin 104, eye 104 ⟨30, by decide⟩ j - Sparse.eval (P_entries ⟨30, by decide⟩) Q j = + Sparse.eval (W_entries ⟨30, by decide⟩) M j := by + decide + +/-- Complete residual row 31, not a sampled set of columns. -/ +theorem residual_row_031 : + ∀ j : Fin 104, eye 104 ⟨31, by decide⟩ j - Sparse.eval (P_entries ⟨31, by decide⟩) Q j = + Sparse.eval (W_entries ⟨31, by decide⟩) M j := by + decide + + +end P112Cert + +set_option pp.fullNames true +#print axioms P112Cert.residual_row_024 +#print axioms P112Cert.residual_row_025 +#print axioms P112Cert.residual_row_026 +#print axioms P112Cert.residual_row_027 +#print axioms P112Cert.residual_row_028 +#print axioms P112Cert.residual_row_029 +#print axioms P112Cert.residual_row_030 +#print axioms P112Cert.residual_row_031 diff --git a/research/p112-integral-retraction-instance/source/P112/Residual04.lean b/research/p112-integral-retraction-instance/source/P112/Residual04.lean new file mode 100644 index 0000000000..d49ab697db --- /dev/null +++ b/research/p112-integral-retraction-instance/source/P112/Residual04.lean @@ -0,0 +1,76 @@ +/- +Copyright (c) 2026 Andrey Mas and contributors. +SPDX-License-Identifier: Apache-2.0 +P112 numerical instance of the unchanged PR1497/PR1610 bridge. +SOURCE ONLY / NOT YET KERNEL CHECKED. Generated deterministically by generate.py. +Proof/source assistance: GPT-6 Pro through ChatGPT (operator-selected label). +-/ +import P112Data + +set_option autoImplicit false +set_option maxRecDepth 4096 +set_option maxHeartbeats 1000000 + +namespace P112Cert +open PR1497 + +/-- Complete residual row 32, not a sampled set of columns. -/ +theorem residual_row_032 : + ∀ j : Fin 104, eye 104 ⟨32, by decide⟩ j - Sparse.eval (P_entries ⟨32, by decide⟩) Q j = + Sparse.eval (W_entries ⟨32, by decide⟩) M j := by + decide + +/-- Complete residual row 33, not a sampled set of columns. -/ +theorem residual_row_033 : + ∀ j : Fin 104, eye 104 ⟨33, by decide⟩ j - Sparse.eval (P_entries ⟨33, by decide⟩) Q j = + Sparse.eval (W_entries ⟨33, by decide⟩) M j := by + decide + +/-- Complete residual row 34, not a sampled set of columns. -/ +theorem residual_row_034 : + ∀ j : Fin 104, eye 104 ⟨34, by decide⟩ j - Sparse.eval (P_entries ⟨34, by decide⟩) Q j = + Sparse.eval (W_entries ⟨34, by decide⟩) M j := by + decide + +/-- Complete residual row 35, not a sampled set of columns. -/ +theorem residual_row_035 : + ∀ j : Fin 104, eye 104 ⟨35, by decide⟩ j - Sparse.eval (P_entries ⟨35, by decide⟩) Q j = + Sparse.eval (W_entries ⟨35, by decide⟩) M j := by + decide + +/-- Complete residual row 36, not a sampled set of columns. -/ +theorem residual_row_036 : + ∀ j : Fin 104, eye 104 ⟨36, by decide⟩ j - Sparse.eval (P_entries ⟨36, by decide⟩) Q j = + Sparse.eval (W_entries ⟨36, by decide⟩) M j := by + decide + +/-- Complete residual row 37, not a sampled set of columns. -/ +theorem residual_row_037 : + ∀ j : Fin 104, eye 104 ⟨37, by decide⟩ j - Sparse.eval (P_entries ⟨37, by decide⟩) Q j = + Sparse.eval (W_entries ⟨37, by decide⟩) M j := by + decide + +/-- Complete residual row 38, not a sampled set of columns. -/ +theorem residual_row_038 : + ∀ j : Fin 104, eye 104 ⟨38, by decide⟩ j - Sparse.eval (P_entries ⟨38, by decide⟩) Q j = + Sparse.eval (W_entries ⟨38, by decide⟩) M j := by + decide + +/-- Complete residual row 39, not a sampled set of columns. -/ +theorem residual_row_039 : + ∀ j : Fin 104, eye 104 ⟨39, by decide⟩ j - Sparse.eval (P_entries ⟨39, by decide⟩) Q j = + Sparse.eval (W_entries ⟨39, by decide⟩) M j := by + decide + + +end P112Cert + +set_option pp.fullNames true +#print axioms P112Cert.residual_row_032 +#print axioms P112Cert.residual_row_033 +#print axioms P112Cert.residual_row_034 +#print axioms P112Cert.residual_row_035 +#print axioms P112Cert.residual_row_036 +#print axioms P112Cert.residual_row_037 +#print axioms P112Cert.residual_row_038 +#print axioms P112Cert.residual_row_039 diff --git a/research/p112-integral-retraction-instance/source/P112/Residual05.lean b/research/p112-integral-retraction-instance/source/P112/Residual05.lean new file mode 100644 index 0000000000..b2464b7a01 --- /dev/null +++ b/research/p112-integral-retraction-instance/source/P112/Residual05.lean @@ -0,0 +1,76 @@ +/- +Copyright (c) 2026 Andrey Mas and contributors. +SPDX-License-Identifier: Apache-2.0 +P112 numerical instance of the unchanged PR1497/PR1610 bridge. +SOURCE ONLY / NOT YET KERNEL CHECKED. Generated deterministically by generate.py. +Proof/source assistance: GPT-6 Pro through ChatGPT (operator-selected label). +-/ +import P112Data + +set_option autoImplicit false +set_option maxRecDepth 4096 +set_option maxHeartbeats 1000000 + +namespace P112Cert +open PR1497 + +/-- Complete residual row 40, not a sampled set of columns. -/ +theorem residual_row_040 : + ∀ j : Fin 104, eye 104 ⟨40, by decide⟩ j - Sparse.eval (P_entries ⟨40, by decide⟩) Q j = + Sparse.eval (W_entries ⟨40, by decide⟩) M j := by + decide + +/-- Complete residual row 41, not a sampled set of columns. -/ +theorem residual_row_041 : + ∀ j : Fin 104, eye 104 ⟨41, by decide⟩ j - Sparse.eval (P_entries ⟨41, by decide⟩) Q j = + Sparse.eval (W_entries ⟨41, by decide⟩) M j := by + decide + +/-- Complete residual row 42, not a sampled set of columns. -/ +theorem residual_row_042 : + ∀ j : Fin 104, eye 104 ⟨42, by decide⟩ j - Sparse.eval (P_entries ⟨42, by decide⟩) Q j = + Sparse.eval (W_entries ⟨42, by decide⟩) M j := by + decide + +/-- Complete residual row 43, not a sampled set of columns. -/ +theorem residual_row_043 : + ∀ j : Fin 104, eye 104 ⟨43, by decide⟩ j - Sparse.eval (P_entries ⟨43, by decide⟩) Q j = + Sparse.eval (W_entries ⟨43, by decide⟩) M j := by + decide + +/-- Complete residual row 44, not a sampled set of columns. -/ +theorem residual_row_044 : + ∀ j : Fin 104, eye 104 ⟨44, by decide⟩ j - Sparse.eval (P_entries ⟨44, by decide⟩) Q j = + Sparse.eval (W_entries ⟨44, by decide⟩) M j := by + decide + +/-- Complete residual row 45, not a sampled set of columns. -/ +theorem residual_row_045 : + ∀ j : Fin 104, eye 104 ⟨45, by decide⟩ j - Sparse.eval (P_entries ⟨45, by decide⟩) Q j = + Sparse.eval (W_entries ⟨45, by decide⟩) M j := by + decide + +/-- Complete residual row 46, not a sampled set of columns. -/ +theorem residual_row_046 : + ∀ j : Fin 104, eye 104 ⟨46, by decide⟩ j - Sparse.eval (P_entries ⟨46, by decide⟩) Q j = + Sparse.eval (W_entries ⟨46, by decide⟩) M j := by + decide + +/-- Complete residual row 47, not a sampled set of columns. -/ +theorem residual_row_047 : + ∀ j : Fin 104, eye 104 ⟨47, by decide⟩ j - Sparse.eval (P_entries ⟨47, by decide⟩) Q j = + Sparse.eval (W_entries ⟨47, by decide⟩) M j := by + decide + + +end P112Cert + +set_option pp.fullNames true +#print axioms P112Cert.residual_row_040 +#print axioms P112Cert.residual_row_041 +#print axioms P112Cert.residual_row_042 +#print axioms P112Cert.residual_row_043 +#print axioms P112Cert.residual_row_044 +#print axioms P112Cert.residual_row_045 +#print axioms P112Cert.residual_row_046 +#print axioms P112Cert.residual_row_047 diff --git a/research/p112-integral-retraction-instance/source/P112/Residual06.lean b/research/p112-integral-retraction-instance/source/P112/Residual06.lean new file mode 100644 index 0000000000..01d6a24c5f --- /dev/null +++ b/research/p112-integral-retraction-instance/source/P112/Residual06.lean @@ -0,0 +1,76 @@ +/- +Copyright (c) 2026 Andrey Mas and contributors. +SPDX-License-Identifier: Apache-2.0 +P112 numerical instance of the unchanged PR1497/PR1610 bridge. +SOURCE ONLY / NOT YET KERNEL CHECKED. Generated deterministically by generate.py. +Proof/source assistance: GPT-6 Pro through ChatGPT (operator-selected label). +-/ +import P112Data + +set_option autoImplicit false +set_option maxRecDepth 4096 +set_option maxHeartbeats 1000000 + +namespace P112Cert +open PR1497 + +/-- Complete residual row 48, not a sampled set of columns. -/ +theorem residual_row_048 : + ∀ j : Fin 104, eye 104 ⟨48, by decide⟩ j - Sparse.eval (P_entries ⟨48, by decide⟩) Q j = + Sparse.eval (W_entries ⟨48, by decide⟩) M j := by + decide + +/-- Complete residual row 49, not a sampled set of columns. -/ +theorem residual_row_049 : + ∀ j : Fin 104, eye 104 ⟨49, by decide⟩ j - Sparse.eval (P_entries ⟨49, by decide⟩) Q j = + Sparse.eval (W_entries ⟨49, by decide⟩) M j := by + decide + +/-- Complete residual row 50, not a sampled set of columns. -/ +theorem residual_row_050 : + ∀ j : Fin 104, eye 104 ⟨50, by decide⟩ j - Sparse.eval (P_entries ⟨50, by decide⟩) Q j = + Sparse.eval (W_entries ⟨50, by decide⟩) M j := by + decide + +/-- Complete residual row 51, not a sampled set of columns. -/ +theorem residual_row_051 : + ∀ j : Fin 104, eye 104 ⟨51, by decide⟩ j - Sparse.eval (P_entries ⟨51, by decide⟩) Q j = + Sparse.eval (W_entries ⟨51, by decide⟩) M j := by + decide + +/-- Complete residual row 52, not a sampled set of columns. -/ +theorem residual_row_052 : + ∀ j : Fin 104, eye 104 ⟨52, by decide⟩ j - Sparse.eval (P_entries ⟨52, by decide⟩) Q j = + Sparse.eval (W_entries ⟨52, by decide⟩) M j := by + decide + +/-- Complete residual row 53, not a sampled set of columns. -/ +theorem residual_row_053 : + ∀ j : Fin 104, eye 104 ⟨53, by decide⟩ j - Sparse.eval (P_entries ⟨53, by decide⟩) Q j = + Sparse.eval (W_entries ⟨53, by decide⟩) M j := by + decide + +/-- Complete residual row 54, not a sampled set of columns. -/ +theorem residual_row_054 : + ∀ j : Fin 104, eye 104 ⟨54, by decide⟩ j - Sparse.eval (P_entries ⟨54, by decide⟩) Q j = + Sparse.eval (W_entries ⟨54, by decide⟩) M j := by + decide + +/-- Complete residual row 55, not a sampled set of columns. -/ +theorem residual_row_055 : + ∀ j : Fin 104, eye 104 ⟨55, by decide⟩ j - Sparse.eval (P_entries ⟨55, by decide⟩) Q j = + Sparse.eval (W_entries ⟨55, by decide⟩) M j := by + decide + + +end P112Cert + +set_option pp.fullNames true +#print axioms P112Cert.residual_row_048 +#print axioms P112Cert.residual_row_049 +#print axioms P112Cert.residual_row_050 +#print axioms P112Cert.residual_row_051 +#print axioms P112Cert.residual_row_052 +#print axioms P112Cert.residual_row_053 +#print axioms P112Cert.residual_row_054 +#print axioms P112Cert.residual_row_055 diff --git a/research/p112-integral-retraction-instance/source/P112/Residual07.lean b/research/p112-integral-retraction-instance/source/P112/Residual07.lean new file mode 100644 index 0000000000..f30667a236 --- /dev/null +++ b/research/p112-integral-retraction-instance/source/P112/Residual07.lean @@ -0,0 +1,76 @@ +/- +Copyright (c) 2026 Andrey Mas and contributors. +SPDX-License-Identifier: Apache-2.0 +P112 numerical instance of the unchanged PR1497/PR1610 bridge. +SOURCE ONLY / NOT YET KERNEL CHECKED. Generated deterministically by generate.py. +Proof/source assistance: GPT-6 Pro through ChatGPT (operator-selected label). +-/ +import P112Data + +set_option autoImplicit false +set_option maxRecDepth 4096 +set_option maxHeartbeats 1000000 + +namespace P112Cert +open PR1497 + +/-- Complete residual row 56, not a sampled set of columns. -/ +theorem residual_row_056 : + ∀ j : Fin 104, eye 104 ⟨56, by decide⟩ j - Sparse.eval (P_entries ⟨56, by decide⟩) Q j = + Sparse.eval (W_entries ⟨56, by decide⟩) M j := by + decide + +/-- Complete residual row 57, not a sampled set of columns. -/ +theorem residual_row_057 : + ∀ j : Fin 104, eye 104 ⟨57, by decide⟩ j - Sparse.eval (P_entries ⟨57, by decide⟩) Q j = + Sparse.eval (W_entries ⟨57, by decide⟩) M j := by + decide + +/-- Complete residual row 58, not a sampled set of columns. -/ +theorem residual_row_058 : + ∀ j : Fin 104, eye 104 ⟨58, by decide⟩ j - Sparse.eval (P_entries ⟨58, by decide⟩) Q j = + Sparse.eval (W_entries ⟨58, by decide⟩) M j := by + decide + +/-- Complete residual row 59, not a sampled set of columns. -/ +theorem residual_row_059 : + ∀ j : Fin 104, eye 104 ⟨59, by decide⟩ j - Sparse.eval (P_entries ⟨59, by decide⟩) Q j = + Sparse.eval (W_entries ⟨59, by decide⟩) M j := by + decide + +/-- Complete residual row 60, not a sampled set of columns. -/ +theorem residual_row_060 : + ∀ j : Fin 104, eye 104 ⟨60, by decide⟩ j - Sparse.eval (P_entries ⟨60, by decide⟩) Q j = + Sparse.eval (W_entries ⟨60, by decide⟩) M j := by + decide + +/-- Complete residual row 61, not a sampled set of columns. -/ +theorem residual_row_061 : + ∀ j : Fin 104, eye 104 ⟨61, by decide⟩ j - Sparse.eval (P_entries ⟨61, by decide⟩) Q j = + Sparse.eval (W_entries ⟨61, by decide⟩) M j := by + decide + +/-- Complete residual row 62, not a sampled set of columns. -/ +theorem residual_row_062 : + ∀ j : Fin 104, eye 104 ⟨62, by decide⟩ j - Sparse.eval (P_entries ⟨62, by decide⟩) Q j = + Sparse.eval (W_entries ⟨62, by decide⟩) M j := by + decide + +/-- Complete residual row 63, not a sampled set of columns. -/ +theorem residual_row_063 : + ∀ j : Fin 104, eye 104 ⟨63, by decide⟩ j - Sparse.eval (P_entries ⟨63, by decide⟩) Q j = + Sparse.eval (W_entries ⟨63, by decide⟩) M j := by + decide + + +end P112Cert + +set_option pp.fullNames true +#print axioms P112Cert.residual_row_056 +#print axioms P112Cert.residual_row_057 +#print axioms P112Cert.residual_row_058 +#print axioms P112Cert.residual_row_059 +#print axioms P112Cert.residual_row_060 +#print axioms P112Cert.residual_row_061 +#print axioms P112Cert.residual_row_062 +#print axioms P112Cert.residual_row_063 diff --git a/research/p112-integral-retraction-instance/source/P112/Residual08.lean b/research/p112-integral-retraction-instance/source/P112/Residual08.lean new file mode 100644 index 0000000000..6a7626a80f --- /dev/null +++ b/research/p112-integral-retraction-instance/source/P112/Residual08.lean @@ -0,0 +1,76 @@ +/- +Copyright (c) 2026 Andrey Mas and contributors. +SPDX-License-Identifier: Apache-2.0 +P112 numerical instance of the unchanged PR1497/PR1610 bridge. +SOURCE ONLY / NOT YET KERNEL CHECKED. Generated deterministically by generate.py. +Proof/source assistance: GPT-6 Pro through ChatGPT (operator-selected label). +-/ +import P112Data + +set_option autoImplicit false +set_option maxRecDepth 4096 +set_option maxHeartbeats 1000000 + +namespace P112Cert +open PR1497 + +/-- Complete residual row 64, not a sampled set of columns. -/ +theorem residual_row_064 : + ∀ j : Fin 104, eye 104 ⟨64, by decide⟩ j - Sparse.eval (P_entries ⟨64, by decide⟩) Q j = + Sparse.eval (W_entries ⟨64, by decide⟩) M j := by + decide + +/-- Complete residual row 65, not a sampled set of columns. -/ +theorem residual_row_065 : + ∀ j : Fin 104, eye 104 ⟨65, by decide⟩ j - Sparse.eval (P_entries ⟨65, by decide⟩) Q j = + Sparse.eval (W_entries ⟨65, by decide⟩) M j := by + decide + +/-- Complete residual row 66, not a sampled set of columns. -/ +theorem residual_row_066 : + ∀ j : Fin 104, eye 104 ⟨66, by decide⟩ j - Sparse.eval (P_entries ⟨66, by decide⟩) Q j = + Sparse.eval (W_entries ⟨66, by decide⟩) M j := by + decide + +/-- Complete residual row 67, not a sampled set of columns. -/ +theorem residual_row_067 : + ∀ j : Fin 104, eye 104 ⟨67, by decide⟩ j - Sparse.eval (P_entries ⟨67, by decide⟩) Q j = + Sparse.eval (W_entries ⟨67, by decide⟩) M j := by + decide + +/-- Complete residual row 68, not a sampled set of columns. -/ +theorem residual_row_068 : + ∀ j : Fin 104, eye 104 ⟨68, by decide⟩ j - Sparse.eval (P_entries ⟨68, by decide⟩) Q j = + Sparse.eval (W_entries ⟨68, by decide⟩) M j := by + decide + +/-- Complete residual row 69, not a sampled set of columns. -/ +theorem residual_row_069 : + ∀ j : Fin 104, eye 104 ⟨69, by decide⟩ j - Sparse.eval (P_entries ⟨69, by decide⟩) Q j = + Sparse.eval (W_entries ⟨69, by decide⟩) M j := by + decide + +/-- Complete residual row 70, not a sampled set of columns. -/ +theorem residual_row_070 : + ∀ j : Fin 104, eye 104 ⟨70, by decide⟩ j - Sparse.eval (P_entries ⟨70, by decide⟩) Q j = + Sparse.eval (W_entries ⟨70, by decide⟩) M j := by + decide + +/-- Complete residual row 71, not a sampled set of columns. -/ +theorem residual_row_071 : + ∀ j : Fin 104, eye 104 ⟨71, by decide⟩ j - Sparse.eval (P_entries ⟨71, by decide⟩) Q j = + Sparse.eval (W_entries ⟨71, by decide⟩) M j := by + decide + + +end P112Cert + +set_option pp.fullNames true +#print axioms P112Cert.residual_row_064 +#print axioms P112Cert.residual_row_065 +#print axioms P112Cert.residual_row_066 +#print axioms P112Cert.residual_row_067 +#print axioms P112Cert.residual_row_068 +#print axioms P112Cert.residual_row_069 +#print axioms P112Cert.residual_row_070 +#print axioms P112Cert.residual_row_071 diff --git a/research/p112-integral-retraction-instance/source/P112/Residual09.lean b/research/p112-integral-retraction-instance/source/P112/Residual09.lean new file mode 100644 index 0000000000..0a695ba59f --- /dev/null +++ b/research/p112-integral-retraction-instance/source/P112/Residual09.lean @@ -0,0 +1,76 @@ +/- +Copyright (c) 2026 Andrey Mas and contributors. +SPDX-License-Identifier: Apache-2.0 +P112 numerical instance of the unchanged PR1497/PR1610 bridge. +SOURCE ONLY / NOT YET KERNEL CHECKED. Generated deterministically by generate.py. +Proof/source assistance: GPT-6 Pro through ChatGPT (operator-selected label). +-/ +import P112Data + +set_option autoImplicit false +set_option maxRecDepth 4096 +set_option maxHeartbeats 1000000 + +namespace P112Cert +open PR1497 + +/-- Complete residual row 72, not a sampled set of columns. -/ +theorem residual_row_072 : + ∀ j : Fin 104, eye 104 ⟨72, by decide⟩ j - Sparse.eval (P_entries ⟨72, by decide⟩) Q j = + Sparse.eval (W_entries ⟨72, by decide⟩) M j := by + decide + +/-- Complete residual row 73, not a sampled set of columns. -/ +theorem residual_row_073 : + ∀ j : Fin 104, eye 104 ⟨73, by decide⟩ j - Sparse.eval (P_entries ⟨73, by decide⟩) Q j = + Sparse.eval (W_entries ⟨73, by decide⟩) M j := by + decide + +/-- Complete residual row 74, not a sampled set of columns. -/ +theorem residual_row_074 : + ∀ j : Fin 104, eye 104 ⟨74, by decide⟩ j - Sparse.eval (P_entries ⟨74, by decide⟩) Q j = + Sparse.eval (W_entries ⟨74, by decide⟩) M j := by + decide + +/-- Complete residual row 75, not a sampled set of columns. -/ +theorem residual_row_075 : + ∀ j : Fin 104, eye 104 ⟨75, by decide⟩ j - Sparse.eval (P_entries ⟨75, by decide⟩) Q j = + Sparse.eval (W_entries ⟨75, by decide⟩) M j := by + decide + +/-- Complete residual row 76, not a sampled set of columns. -/ +theorem residual_row_076 : + ∀ j : Fin 104, eye 104 ⟨76, by decide⟩ j - Sparse.eval (P_entries ⟨76, by decide⟩) Q j = + Sparse.eval (W_entries ⟨76, by decide⟩) M j := by + decide + +/-- Complete residual row 77, not a sampled set of columns. -/ +theorem residual_row_077 : + ∀ j : Fin 104, eye 104 ⟨77, by decide⟩ j - Sparse.eval (P_entries ⟨77, by decide⟩) Q j = + Sparse.eval (W_entries ⟨77, by decide⟩) M j := by + decide + +/-- Complete residual row 78, not a sampled set of columns. -/ +theorem residual_row_078 : + ∀ j : Fin 104, eye 104 ⟨78, by decide⟩ j - Sparse.eval (P_entries ⟨78, by decide⟩) Q j = + Sparse.eval (W_entries ⟨78, by decide⟩) M j := by + decide + +/-- Complete residual row 79, not a sampled set of columns. -/ +theorem residual_row_079 : + ∀ j : Fin 104, eye 104 ⟨79, by decide⟩ j - Sparse.eval (P_entries ⟨79, by decide⟩) Q j = + Sparse.eval (W_entries ⟨79, by decide⟩) M j := by + decide + + +end P112Cert + +set_option pp.fullNames true +#print axioms P112Cert.residual_row_072 +#print axioms P112Cert.residual_row_073 +#print axioms P112Cert.residual_row_074 +#print axioms P112Cert.residual_row_075 +#print axioms P112Cert.residual_row_076 +#print axioms P112Cert.residual_row_077 +#print axioms P112Cert.residual_row_078 +#print axioms P112Cert.residual_row_079 diff --git a/research/p112-integral-retraction-instance/source/P112/Residual10.lean b/research/p112-integral-retraction-instance/source/P112/Residual10.lean new file mode 100644 index 0000000000..3329acc8da --- /dev/null +++ b/research/p112-integral-retraction-instance/source/P112/Residual10.lean @@ -0,0 +1,76 @@ +/- +Copyright (c) 2026 Andrey Mas and contributors. +SPDX-License-Identifier: Apache-2.0 +P112 numerical instance of the unchanged PR1497/PR1610 bridge. +SOURCE ONLY / NOT YET KERNEL CHECKED. Generated deterministically by generate.py. +Proof/source assistance: GPT-6 Pro through ChatGPT (operator-selected label). +-/ +import P112Data + +set_option autoImplicit false +set_option maxRecDepth 4096 +set_option maxHeartbeats 1000000 + +namespace P112Cert +open PR1497 + +/-- Complete residual row 80, not a sampled set of columns. -/ +theorem residual_row_080 : + ∀ j : Fin 104, eye 104 ⟨80, by decide⟩ j - Sparse.eval (P_entries ⟨80, by decide⟩) Q j = + Sparse.eval (W_entries ⟨80, by decide⟩) M j := by + decide + +/-- Complete residual row 81, not a sampled set of columns. -/ +theorem residual_row_081 : + ∀ j : Fin 104, eye 104 ⟨81, by decide⟩ j - Sparse.eval (P_entries ⟨81, by decide⟩) Q j = + Sparse.eval (W_entries ⟨81, by decide⟩) M j := by + decide + +/-- Complete residual row 82, not a sampled set of columns. -/ +theorem residual_row_082 : + ∀ j : Fin 104, eye 104 ⟨82, by decide⟩ j - Sparse.eval (P_entries ⟨82, by decide⟩) Q j = + Sparse.eval (W_entries ⟨82, by decide⟩) M j := by + decide + +/-- Complete residual row 83, not a sampled set of columns. -/ +theorem residual_row_083 : + ∀ j : Fin 104, eye 104 ⟨83, by decide⟩ j - Sparse.eval (P_entries ⟨83, by decide⟩) Q j = + Sparse.eval (W_entries ⟨83, by decide⟩) M j := by + decide + +/-- Complete residual row 84, not a sampled set of columns. -/ +theorem residual_row_084 : + ∀ j : Fin 104, eye 104 ⟨84, by decide⟩ j - Sparse.eval (P_entries ⟨84, by decide⟩) Q j = + Sparse.eval (W_entries ⟨84, by decide⟩) M j := by + decide + +/-- Complete residual row 85, not a sampled set of columns. -/ +theorem residual_row_085 : + ∀ j : Fin 104, eye 104 ⟨85, by decide⟩ j - Sparse.eval (P_entries ⟨85, by decide⟩) Q j = + Sparse.eval (W_entries ⟨85, by decide⟩) M j := by + decide + +/-- Complete residual row 86, not a sampled set of columns. -/ +theorem residual_row_086 : + ∀ j : Fin 104, eye 104 ⟨86, by decide⟩ j - Sparse.eval (P_entries ⟨86, by decide⟩) Q j = + Sparse.eval (W_entries ⟨86, by decide⟩) M j := by + decide + +/-- Complete residual row 87, not a sampled set of columns. -/ +theorem residual_row_087 : + ∀ j : Fin 104, eye 104 ⟨87, by decide⟩ j - Sparse.eval (P_entries ⟨87, by decide⟩) Q j = + Sparse.eval (W_entries ⟨87, by decide⟩) M j := by + decide + + +end P112Cert + +set_option pp.fullNames true +#print axioms P112Cert.residual_row_080 +#print axioms P112Cert.residual_row_081 +#print axioms P112Cert.residual_row_082 +#print axioms P112Cert.residual_row_083 +#print axioms P112Cert.residual_row_084 +#print axioms P112Cert.residual_row_085 +#print axioms P112Cert.residual_row_086 +#print axioms P112Cert.residual_row_087 diff --git a/research/p112-integral-retraction-instance/source/P112/Residual11.lean b/research/p112-integral-retraction-instance/source/P112/Residual11.lean new file mode 100644 index 0000000000..fc08265af6 --- /dev/null +++ b/research/p112-integral-retraction-instance/source/P112/Residual11.lean @@ -0,0 +1,76 @@ +/- +Copyright (c) 2026 Andrey Mas and contributors. +SPDX-License-Identifier: Apache-2.0 +P112 numerical instance of the unchanged PR1497/PR1610 bridge. +SOURCE ONLY / NOT YET KERNEL CHECKED. Generated deterministically by generate.py. +Proof/source assistance: GPT-6 Pro through ChatGPT (operator-selected label). +-/ +import P112Data + +set_option autoImplicit false +set_option maxRecDepth 4096 +set_option maxHeartbeats 1000000 + +namespace P112Cert +open PR1497 + +/-- Complete residual row 88, not a sampled set of columns. -/ +theorem residual_row_088 : + ∀ j : Fin 104, eye 104 ⟨88, by decide⟩ j - Sparse.eval (P_entries ⟨88, by decide⟩) Q j = + Sparse.eval (W_entries ⟨88, by decide⟩) M j := by + decide + +/-- Complete residual row 89, not a sampled set of columns. -/ +theorem residual_row_089 : + ∀ j : Fin 104, eye 104 ⟨89, by decide⟩ j - Sparse.eval (P_entries ⟨89, by decide⟩) Q j = + Sparse.eval (W_entries ⟨89, by decide⟩) M j := by + decide + +/-- Complete residual row 90, not a sampled set of columns. -/ +theorem residual_row_090 : + ∀ j : Fin 104, eye 104 ⟨90, by decide⟩ j - Sparse.eval (P_entries ⟨90, by decide⟩) Q j = + Sparse.eval (W_entries ⟨90, by decide⟩) M j := by + decide + +/-- Complete residual row 91, not a sampled set of columns. -/ +theorem residual_row_091 : + ∀ j : Fin 104, eye 104 ⟨91, by decide⟩ j - Sparse.eval (P_entries ⟨91, by decide⟩) Q j = + Sparse.eval (W_entries ⟨91, by decide⟩) M j := by + decide + +/-- Complete residual row 92, not a sampled set of columns. -/ +theorem residual_row_092 : + ∀ j : Fin 104, eye 104 ⟨92, by decide⟩ j - Sparse.eval (P_entries ⟨92, by decide⟩) Q j = + Sparse.eval (W_entries ⟨92, by decide⟩) M j := by + decide + +/-- Complete residual row 93, not a sampled set of columns. -/ +theorem residual_row_093 : + ∀ j : Fin 104, eye 104 ⟨93, by decide⟩ j - Sparse.eval (P_entries ⟨93, by decide⟩) Q j = + Sparse.eval (W_entries ⟨93, by decide⟩) M j := by + decide + +/-- Complete residual row 94, not a sampled set of columns. -/ +theorem residual_row_094 : + ∀ j : Fin 104, eye 104 ⟨94, by decide⟩ j - Sparse.eval (P_entries ⟨94, by decide⟩) Q j = + Sparse.eval (W_entries ⟨94, by decide⟩) M j := by + decide + +/-- Complete residual row 95, not a sampled set of columns. -/ +theorem residual_row_095 : + ∀ j : Fin 104, eye 104 ⟨95, by decide⟩ j - Sparse.eval (P_entries ⟨95, by decide⟩) Q j = + Sparse.eval (W_entries ⟨95, by decide⟩) M j := by + decide + + +end P112Cert + +set_option pp.fullNames true +#print axioms P112Cert.residual_row_088 +#print axioms P112Cert.residual_row_089 +#print axioms P112Cert.residual_row_090 +#print axioms P112Cert.residual_row_091 +#print axioms P112Cert.residual_row_092 +#print axioms P112Cert.residual_row_093 +#print axioms P112Cert.residual_row_094 +#print axioms P112Cert.residual_row_095 diff --git a/research/p112-integral-retraction-instance/source/P112/Residual12.lean b/research/p112-integral-retraction-instance/source/P112/Residual12.lean new file mode 100644 index 0000000000..1291d87301 --- /dev/null +++ b/research/p112-integral-retraction-instance/source/P112/Residual12.lean @@ -0,0 +1,76 @@ +/- +Copyright (c) 2026 Andrey Mas and contributors. +SPDX-License-Identifier: Apache-2.0 +P112 numerical instance of the unchanged PR1497/PR1610 bridge. +SOURCE ONLY / NOT YET KERNEL CHECKED. Generated deterministically by generate.py. +Proof/source assistance: GPT-6 Pro through ChatGPT (operator-selected label). +-/ +import P112Data + +set_option autoImplicit false +set_option maxRecDepth 4096 +set_option maxHeartbeats 1000000 + +namespace P112Cert +open PR1497 + +/-- Complete residual row 96, not a sampled set of columns. -/ +theorem residual_row_096 : + ∀ j : Fin 104, eye 104 ⟨96, by decide⟩ j - Sparse.eval (P_entries ⟨96, by decide⟩) Q j = + Sparse.eval (W_entries ⟨96, by decide⟩) M j := by + decide + +/-- Complete residual row 97, not a sampled set of columns. -/ +theorem residual_row_097 : + ∀ j : Fin 104, eye 104 ⟨97, by decide⟩ j - Sparse.eval (P_entries ⟨97, by decide⟩) Q j = + Sparse.eval (W_entries ⟨97, by decide⟩) M j := by + decide + +/-- Complete residual row 98, not a sampled set of columns. -/ +theorem residual_row_098 : + ∀ j : Fin 104, eye 104 ⟨98, by decide⟩ j - Sparse.eval (P_entries ⟨98, by decide⟩) Q j = + Sparse.eval (W_entries ⟨98, by decide⟩) M j := by + decide + +/-- Complete residual row 99, not a sampled set of columns. -/ +theorem residual_row_099 : + ∀ j : Fin 104, eye 104 ⟨99, by decide⟩ j - Sparse.eval (P_entries ⟨99, by decide⟩) Q j = + Sparse.eval (W_entries ⟨99, by decide⟩) M j := by + decide + +/-- Complete residual row 100, not a sampled set of columns. -/ +theorem residual_row_100 : + ∀ j : Fin 104, eye 104 ⟨100, by decide⟩ j - Sparse.eval (P_entries ⟨100, by decide⟩) Q j = + Sparse.eval (W_entries ⟨100, by decide⟩) M j := by + decide + +/-- Complete residual row 101, not a sampled set of columns. -/ +theorem residual_row_101 : + ∀ j : Fin 104, eye 104 ⟨101, by decide⟩ j - Sparse.eval (P_entries ⟨101, by decide⟩) Q j = + Sparse.eval (W_entries ⟨101, by decide⟩) M j := by + decide + +/-- Complete residual row 102, not a sampled set of columns. -/ +theorem residual_row_102 : + ∀ j : Fin 104, eye 104 ⟨102, by decide⟩ j - Sparse.eval (P_entries ⟨102, by decide⟩) Q j = + Sparse.eval (W_entries ⟨102, by decide⟩) M j := by + decide + +/-- Complete residual row 103, not a sampled set of columns. -/ +theorem residual_row_103 : + ∀ j : Fin 104, eye 104 ⟨103, by decide⟩ j - Sparse.eval (P_entries ⟨103, by decide⟩) Q j = + Sparse.eval (W_entries ⟨103, by decide⟩) M j := by + decide + + +end P112Cert + +set_option pp.fullNames true +#print axioms P112Cert.residual_row_096 +#print axioms P112Cert.residual_row_097 +#print axioms P112Cert.residual_row_098 +#print axioms P112Cert.residual_row_099 +#print axioms P112Cert.residual_row_100 +#print axioms P112Cert.residual_row_101 +#print axioms P112Cert.residual_row_102 +#print axioms P112Cert.residual_row_103 diff --git a/research/p112-integral-retraction-instance/source/P112Certificate.lean b/research/p112-integral-retraction-instance/source/P112Certificate.lean new file mode 100644 index 0000000000..c2e76726ff --- /dev/null +++ b/research/p112-integral-retraction-instance/source/P112Certificate.lean @@ -0,0 +1,953 @@ +/- +Copyright (c) 2026 Andrey Mas and contributors. +SPDX-License-Identifier: Apache-2.0 +P112 numerical instance of the unchanged PR1497/PR1610 bridge. +SOURCE ONLY / NOT YET KERNEL CHECKED. Generated deterministically by generate.py. +Proof/source assistance: GPT-6 Pro through ChatGPT (operator-selected label). +-/ +import P112.MP00 +import P112.MP01 +import P112.MP02 +import P112.MP03 +import P112.MP04 +import P112.MP05 +import P112.MP06 +import P112.MP07 +import P112.MP08 +import P112.MP09 +import P112.MP10 +import P112.MP11 +import P112.MP12 +import P112.MP13 +import P112.MP14 +import P112.MP15 +import P112.MP16 +import P112.MP17 +import P112.QP00 +import P112.QP01 +import P112.QP02 +import P112.Residual00 +import P112.Residual01 +import P112.Residual02 +import P112.Residual03 +import P112.Residual04 +import P112.Residual05 +import P112.Residual06 +import P112.Residual07 +import P112.Residual08 +import P112.Residual09 +import P112.Residual10 +import P112.Residual11 +import P112.Residual12 + +set_option autoImplicit false +set_option maxRecDepth 4096 +set_option maxHeartbeats 1000000 + +namespace P112Cert +open PR1497 + +theorem mp_sparse_all : ∀ i : Fin 288, + ∀ j : Fin 33, Sparse.eval (M_entries i) P j = 0 := by + exact + (Sparse.allFinAdd (a := 144) (b := 144) + (Sparse.allFinAdd (a := 72) (b := 72) + (Sparse.allFinAdd (a := 36) (b := 36) + (Sparse.allFinAdd (a := 18) (b := 18) + (Sparse.allFinAdd (a := 9) (b := 9) + (Sparse.allFinAdd (a := 4) (b := 5) + (Sparse.allFinAdd (a := 2) (b := 2) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_000) + (Fin.forall_fin_one.mpr mp_row_001)) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_002) + (Fin.forall_fin_one.mpr mp_row_003))) + (Sparse.allFinAdd (a := 2) (b := 3) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_004) + (Fin.forall_fin_one.mpr mp_row_005)) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr mp_row_006) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_007) + (Fin.forall_fin_one.mpr mp_row_008))))) + (Sparse.allFinAdd (a := 4) (b := 5) + (Sparse.allFinAdd (a := 2) (b := 2) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_009) + (Fin.forall_fin_one.mpr mp_row_010)) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_011) + (Fin.forall_fin_one.mpr mp_row_012))) + (Sparse.allFinAdd (a := 2) (b := 3) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_013) + (Fin.forall_fin_one.mpr mp_row_014)) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr mp_row_015) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_016) + (Fin.forall_fin_one.mpr mp_row_017)))))) + (Sparse.allFinAdd (a := 9) (b := 9) + (Sparse.allFinAdd (a := 4) (b := 5) + (Sparse.allFinAdd (a := 2) (b := 2) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_018) + (Fin.forall_fin_one.mpr mp_row_019)) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_020) + (Fin.forall_fin_one.mpr mp_row_021))) + (Sparse.allFinAdd (a := 2) (b := 3) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_022) + (Fin.forall_fin_one.mpr mp_row_023)) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr mp_row_024) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_025) + (Fin.forall_fin_one.mpr mp_row_026))))) + (Sparse.allFinAdd (a := 4) (b := 5) + (Sparse.allFinAdd (a := 2) (b := 2) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_027) + (Fin.forall_fin_one.mpr mp_row_028)) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_029) + (Fin.forall_fin_one.mpr mp_row_030))) + (Sparse.allFinAdd (a := 2) (b := 3) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_031) + (Fin.forall_fin_one.mpr mp_row_032)) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr mp_row_033) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_034) + (Fin.forall_fin_one.mpr mp_row_035))))))) + (Sparse.allFinAdd (a := 18) (b := 18) + (Sparse.allFinAdd (a := 9) (b := 9) + (Sparse.allFinAdd (a := 4) (b := 5) + (Sparse.allFinAdd (a := 2) (b := 2) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_036) + (Fin.forall_fin_one.mpr mp_row_037)) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_038) + (Fin.forall_fin_one.mpr mp_row_039))) + (Sparse.allFinAdd (a := 2) (b := 3) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_040) + (Fin.forall_fin_one.mpr mp_row_041)) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr mp_row_042) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_043) + (Fin.forall_fin_one.mpr mp_row_044))))) + (Sparse.allFinAdd (a := 4) (b := 5) + (Sparse.allFinAdd (a := 2) (b := 2) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_045) + (Fin.forall_fin_one.mpr mp_row_046)) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_047) + (Fin.forall_fin_one.mpr mp_row_048))) + (Sparse.allFinAdd (a := 2) (b := 3) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_049) + (Fin.forall_fin_one.mpr mp_row_050)) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr mp_row_051) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_052) + (Fin.forall_fin_one.mpr mp_row_053)))))) + (Sparse.allFinAdd (a := 9) (b := 9) + (Sparse.allFinAdd (a := 4) (b := 5) + (Sparse.allFinAdd (a := 2) (b := 2) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_054) + (Fin.forall_fin_one.mpr mp_row_055)) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_056) + (Fin.forall_fin_one.mpr mp_row_057))) + (Sparse.allFinAdd (a := 2) (b := 3) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_058) + (Fin.forall_fin_one.mpr mp_row_059)) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr mp_row_060) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_061) + (Fin.forall_fin_one.mpr mp_row_062))))) + (Sparse.allFinAdd (a := 4) (b := 5) + (Sparse.allFinAdd (a := 2) (b := 2) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_063) + (Fin.forall_fin_one.mpr mp_row_064)) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_065) + (Fin.forall_fin_one.mpr mp_row_066))) + (Sparse.allFinAdd (a := 2) (b := 3) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_067) + (Fin.forall_fin_one.mpr mp_row_068)) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr mp_row_069) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_070) + (Fin.forall_fin_one.mpr mp_row_071)))))))) + (Sparse.allFinAdd (a := 36) (b := 36) + (Sparse.allFinAdd (a := 18) (b := 18) + (Sparse.allFinAdd (a := 9) (b := 9) + (Sparse.allFinAdd (a := 4) (b := 5) + (Sparse.allFinAdd (a := 2) (b := 2) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_072) + (Fin.forall_fin_one.mpr mp_row_073)) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_074) + (Fin.forall_fin_one.mpr mp_row_075))) + (Sparse.allFinAdd (a := 2) (b := 3) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_076) + (Fin.forall_fin_one.mpr mp_row_077)) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr mp_row_078) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_079) + (Fin.forall_fin_one.mpr mp_row_080))))) + (Sparse.allFinAdd (a := 4) (b := 5) + (Sparse.allFinAdd (a := 2) (b := 2) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_081) + (Fin.forall_fin_one.mpr mp_row_082)) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_083) + (Fin.forall_fin_one.mpr mp_row_084))) + (Sparse.allFinAdd (a := 2) (b := 3) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_085) + (Fin.forall_fin_one.mpr mp_row_086)) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr mp_row_087) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_088) + (Fin.forall_fin_one.mpr mp_row_089)))))) + (Sparse.allFinAdd (a := 9) (b := 9) + (Sparse.allFinAdd (a := 4) (b := 5) + (Sparse.allFinAdd (a := 2) (b := 2) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_090) + (Fin.forall_fin_one.mpr mp_row_091)) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_092) + (Fin.forall_fin_one.mpr mp_row_093))) + (Sparse.allFinAdd (a := 2) (b := 3) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_094) + (Fin.forall_fin_one.mpr mp_row_095)) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr mp_row_096) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_097) + (Fin.forall_fin_one.mpr mp_row_098))))) + (Sparse.allFinAdd (a := 4) (b := 5) + (Sparse.allFinAdd (a := 2) (b := 2) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_099) + (Fin.forall_fin_one.mpr mp_row_100)) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_101) + (Fin.forall_fin_one.mpr mp_row_102))) + (Sparse.allFinAdd (a := 2) (b := 3) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_103) + (Fin.forall_fin_one.mpr mp_row_104)) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr mp_row_105) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_106) + (Fin.forall_fin_one.mpr mp_row_107))))))) + (Sparse.allFinAdd (a := 18) (b := 18) + (Sparse.allFinAdd (a := 9) (b := 9) + (Sparse.allFinAdd (a := 4) (b := 5) + (Sparse.allFinAdd (a := 2) (b := 2) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_108) + (Fin.forall_fin_one.mpr mp_row_109)) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_110) + (Fin.forall_fin_one.mpr mp_row_111))) + (Sparse.allFinAdd (a := 2) (b := 3) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_112) + (Fin.forall_fin_one.mpr mp_row_113)) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr mp_row_114) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_115) + (Fin.forall_fin_one.mpr mp_row_116))))) + (Sparse.allFinAdd (a := 4) (b := 5) + (Sparse.allFinAdd (a := 2) (b := 2) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_117) + (Fin.forall_fin_one.mpr mp_row_118)) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_119) + (Fin.forall_fin_one.mpr mp_row_120))) + (Sparse.allFinAdd (a := 2) (b := 3) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_121) + (Fin.forall_fin_one.mpr mp_row_122)) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr mp_row_123) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_124) + (Fin.forall_fin_one.mpr mp_row_125)))))) + (Sparse.allFinAdd (a := 9) (b := 9) + (Sparse.allFinAdd (a := 4) (b := 5) + (Sparse.allFinAdd (a := 2) (b := 2) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_126) + (Fin.forall_fin_one.mpr mp_row_127)) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_128) + (Fin.forall_fin_one.mpr mp_row_129))) + (Sparse.allFinAdd (a := 2) (b := 3) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_130) + (Fin.forall_fin_one.mpr mp_row_131)) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr mp_row_132) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_133) + (Fin.forall_fin_one.mpr mp_row_134))))) + (Sparse.allFinAdd (a := 4) (b := 5) + (Sparse.allFinAdd (a := 2) (b := 2) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_135) + (Fin.forall_fin_one.mpr mp_row_136)) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_137) + (Fin.forall_fin_one.mpr mp_row_138))) + (Sparse.allFinAdd (a := 2) (b := 3) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_139) + (Fin.forall_fin_one.mpr mp_row_140)) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr mp_row_141) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_142) + (Fin.forall_fin_one.mpr mp_row_143))))))))) + (Sparse.allFinAdd (a := 72) (b := 72) + (Sparse.allFinAdd (a := 36) (b := 36) + (Sparse.allFinAdd (a := 18) (b := 18) + (Sparse.allFinAdd (a := 9) (b := 9) + (Sparse.allFinAdd (a := 4) (b := 5) + (Sparse.allFinAdd (a := 2) (b := 2) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_144) + (Fin.forall_fin_one.mpr mp_row_145)) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_146) + (Fin.forall_fin_one.mpr mp_row_147))) + (Sparse.allFinAdd (a := 2) (b := 3) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_148) + (Fin.forall_fin_one.mpr mp_row_149)) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr mp_row_150) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_151) + (Fin.forall_fin_one.mpr mp_row_152))))) + (Sparse.allFinAdd (a := 4) (b := 5) + (Sparse.allFinAdd (a := 2) (b := 2) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_153) + (Fin.forall_fin_one.mpr mp_row_154)) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_155) + (Fin.forall_fin_one.mpr mp_row_156))) + (Sparse.allFinAdd (a := 2) (b := 3) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_157) + (Fin.forall_fin_one.mpr mp_row_158)) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr mp_row_159) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_160) + (Fin.forall_fin_one.mpr mp_row_161)))))) + (Sparse.allFinAdd (a := 9) (b := 9) + (Sparse.allFinAdd (a := 4) (b := 5) + (Sparse.allFinAdd (a := 2) (b := 2) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_162) + (Fin.forall_fin_one.mpr mp_row_163)) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_164) + (Fin.forall_fin_one.mpr mp_row_165))) + (Sparse.allFinAdd (a := 2) (b := 3) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_166) + (Fin.forall_fin_one.mpr mp_row_167)) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr mp_row_168) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_169) + (Fin.forall_fin_one.mpr mp_row_170))))) + (Sparse.allFinAdd (a := 4) (b := 5) + (Sparse.allFinAdd (a := 2) (b := 2) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_171) + (Fin.forall_fin_one.mpr mp_row_172)) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_173) + (Fin.forall_fin_one.mpr mp_row_174))) + (Sparse.allFinAdd (a := 2) (b := 3) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_175) + (Fin.forall_fin_one.mpr mp_row_176)) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr mp_row_177) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_178) + (Fin.forall_fin_one.mpr mp_row_179))))))) + (Sparse.allFinAdd (a := 18) (b := 18) + (Sparse.allFinAdd (a := 9) (b := 9) + (Sparse.allFinAdd (a := 4) (b := 5) + (Sparse.allFinAdd (a := 2) (b := 2) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_180) + (Fin.forall_fin_one.mpr mp_row_181)) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_182) + (Fin.forall_fin_one.mpr mp_row_183))) + (Sparse.allFinAdd (a := 2) (b := 3) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_184) + (Fin.forall_fin_one.mpr mp_row_185)) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr mp_row_186) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_187) + (Fin.forall_fin_one.mpr mp_row_188))))) + (Sparse.allFinAdd (a := 4) (b := 5) + (Sparse.allFinAdd (a := 2) (b := 2) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_189) + (Fin.forall_fin_one.mpr mp_row_190)) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_191) + (Fin.forall_fin_one.mpr mp_row_192))) + (Sparse.allFinAdd (a := 2) (b := 3) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_193) + (Fin.forall_fin_one.mpr mp_row_194)) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr mp_row_195) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_196) + (Fin.forall_fin_one.mpr mp_row_197)))))) + (Sparse.allFinAdd (a := 9) (b := 9) + (Sparse.allFinAdd (a := 4) (b := 5) + (Sparse.allFinAdd (a := 2) (b := 2) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_198) + (Fin.forall_fin_one.mpr mp_row_199)) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_200) + (Fin.forall_fin_one.mpr mp_row_201))) + (Sparse.allFinAdd (a := 2) (b := 3) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_202) + (Fin.forall_fin_one.mpr mp_row_203)) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr mp_row_204) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_205) + (Fin.forall_fin_one.mpr mp_row_206))))) + (Sparse.allFinAdd (a := 4) (b := 5) + (Sparse.allFinAdd (a := 2) (b := 2) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_207) + (Fin.forall_fin_one.mpr mp_row_208)) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_209) + (Fin.forall_fin_one.mpr mp_row_210))) + (Sparse.allFinAdd (a := 2) (b := 3) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_211) + (Fin.forall_fin_one.mpr mp_row_212)) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr mp_row_213) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_214) + (Fin.forall_fin_one.mpr mp_row_215)))))))) + (Sparse.allFinAdd (a := 36) (b := 36) + (Sparse.allFinAdd (a := 18) (b := 18) + (Sparse.allFinAdd (a := 9) (b := 9) + (Sparse.allFinAdd (a := 4) (b := 5) + (Sparse.allFinAdd (a := 2) (b := 2) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_216) + (Fin.forall_fin_one.mpr mp_row_217)) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_218) + (Fin.forall_fin_one.mpr mp_row_219))) + (Sparse.allFinAdd (a := 2) (b := 3) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_220) + (Fin.forall_fin_one.mpr mp_row_221)) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr mp_row_222) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_223) + (Fin.forall_fin_one.mpr mp_row_224))))) + (Sparse.allFinAdd (a := 4) (b := 5) + (Sparse.allFinAdd (a := 2) (b := 2) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_225) + (Fin.forall_fin_one.mpr mp_row_226)) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_227) + (Fin.forall_fin_one.mpr mp_row_228))) + (Sparse.allFinAdd (a := 2) (b := 3) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_229) + (Fin.forall_fin_one.mpr mp_row_230)) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr mp_row_231) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_232) + (Fin.forall_fin_one.mpr mp_row_233)))))) + (Sparse.allFinAdd (a := 9) (b := 9) + (Sparse.allFinAdd (a := 4) (b := 5) + (Sparse.allFinAdd (a := 2) (b := 2) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_234) + (Fin.forall_fin_one.mpr mp_row_235)) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_236) + (Fin.forall_fin_one.mpr mp_row_237))) + (Sparse.allFinAdd (a := 2) (b := 3) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_238) + (Fin.forall_fin_one.mpr mp_row_239)) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr mp_row_240) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_241) + (Fin.forall_fin_one.mpr mp_row_242))))) + (Sparse.allFinAdd (a := 4) (b := 5) + (Sparse.allFinAdd (a := 2) (b := 2) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_243) + (Fin.forall_fin_one.mpr mp_row_244)) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_245) + (Fin.forall_fin_one.mpr mp_row_246))) + (Sparse.allFinAdd (a := 2) (b := 3) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_247) + (Fin.forall_fin_one.mpr mp_row_248)) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr mp_row_249) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_250) + (Fin.forall_fin_one.mpr mp_row_251))))))) + (Sparse.allFinAdd (a := 18) (b := 18) + (Sparse.allFinAdd (a := 9) (b := 9) + (Sparse.allFinAdd (a := 4) (b := 5) + (Sparse.allFinAdd (a := 2) (b := 2) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_252) + (Fin.forall_fin_one.mpr mp_row_253)) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_254) + (Fin.forall_fin_one.mpr mp_row_255))) + (Sparse.allFinAdd (a := 2) (b := 3) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_256) + (Fin.forall_fin_one.mpr mp_row_257)) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr mp_row_258) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_259) + (Fin.forall_fin_one.mpr mp_row_260))))) + (Sparse.allFinAdd (a := 4) (b := 5) + (Sparse.allFinAdd (a := 2) (b := 2) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_261) + (Fin.forall_fin_one.mpr mp_row_262)) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_263) + (Fin.forall_fin_one.mpr mp_row_264))) + (Sparse.allFinAdd (a := 2) (b := 3) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_265) + (Fin.forall_fin_one.mpr mp_row_266)) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr mp_row_267) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_268) + (Fin.forall_fin_one.mpr mp_row_269)))))) + (Sparse.allFinAdd (a := 9) (b := 9) + (Sparse.allFinAdd (a := 4) (b := 5) + (Sparse.allFinAdd (a := 2) (b := 2) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_270) + (Fin.forall_fin_one.mpr mp_row_271)) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_272) + (Fin.forall_fin_one.mpr mp_row_273))) + (Sparse.allFinAdd (a := 2) (b := 3) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_274) + (Fin.forall_fin_one.mpr mp_row_275)) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr mp_row_276) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_277) + (Fin.forall_fin_one.mpr mp_row_278))))) + (Sparse.allFinAdd (a := 4) (b := 5) + (Sparse.allFinAdd (a := 2) (b := 2) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_279) + (Fin.forall_fin_one.mpr mp_row_280)) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_281) + (Fin.forall_fin_one.mpr mp_row_282))) + (Sparse.allFinAdd (a := 2) (b := 3) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_283) + (Fin.forall_fin_one.mpr mp_row_284)) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr mp_row_285) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr mp_row_286) + (Fin.forall_fin_one.mpr mp_row_287)))))))))) + +theorem qp_sparse_all : ∀ i : Fin 33, + ∀ j : Fin 33, Sparse.eval (Q_entries i) P j = eye 33 i j := by + exact + (Sparse.allFinAdd (a := 16) (b := 17) + (Sparse.allFinAdd (a := 8) (b := 8) + (Sparse.allFinAdd (a := 4) (b := 4) + (Sparse.allFinAdd (a := 2) (b := 2) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr qp_row_000) + (Fin.forall_fin_one.mpr qp_row_001)) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr qp_row_002) + (Fin.forall_fin_one.mpr qp_row_003))) + (Sparse.allFinAdd (a := 2) (b := 2) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr qp_row_004) + (Fin.forall_fin_one.mpr qp_row_005)) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr qp_row_006) + (Fin.forall_fin_one.mpr qp_row_007)))) + (Sparse.allFinAdd (a := 4) (b := 4) + (Sparse.allFinAdd (a := 2) (b := 2) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr qp_row_008) + (Fin.forall_fin_one.mpr qp_row_009)) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr qp_row_010) + (Fin.forall_fin_one.mpr qp_row_011))) + (Sparse.allFinAdd (a := 2) (b := 2) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr qp_row_012) + (Fin.forall_fin_one.mpr qp_row_013)) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr qp_row_014) + (Fin.forall_fin_one.mpr qp_row_015))))) + (Sparse.allFinAdd (a := 8) (b := 9) + (Sparse.allFinAdd (a := 4) (b := 4) + (Sparse.allFinAdd (a := 2) (b := 2) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr qp_row_016) + (Fin.forall_fin_one.mpr qp_row_017)) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr qp_row_018) + (Fin.forall_fin_one.mpr qp_row_019))) + (Sparse.allFinAdd (a := 2) (b := 2) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr qp_row_020) + (Fin.forall_fin_one.mpr qp_row_021)) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr qp_row_022) + (Fin.forall_fin_one.mpr qp_row_023)))) + (Sparse.allFinAdd (a := 4) (b := 5) + (Sparse.allFinAdd (a := 2) (b := 2) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr qp_row_024) + (Fin.forall_fin_one.mpr qp_row_025)) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr qp_row_026) + (Fin.forall_fin_one.mpr qp_row_027))) + (Sparse.allFinAdd (a := 2) (b := 3) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr qp_row_028) + (Fin.forall_fin_one.mpr qp_row_029)) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr qp_row_030) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr qp_row_031) + (Fin.forall_fin_one.mpr qp_row_032))))))) + +theorem residual_sparse_all : ∀ i : Fin 104, + ∀ j : Fin 104, eye 104 i j - Sparse.eval (P_entries i) Q j = + Sparse.eval (W_entries i) M j := by + exact + (Sparse.allFinAdd (a := 52) (b := 52) + (Sparse.allFinAdd (a := 26) (b := 26) + (Sparse.allFinAdd (a := 13) (b := 13) + (Sparse.allFinAdd (a := 6) (b := 7) + (Sparse.allFinAdd (a := 3) (b := 3) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr residual_row_000) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr residual_row_001) + (Fin.forall_fin_one.mpr residual_row_002))) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr residual_row_003) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr residual_row_004) + (Fin.forall_fin_one.mpr residual_row_005)))) + (Sparse.allFinAdd (a := 3) (b := 4) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr residual_row_006) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr residual_row_007) + (Fin.forall_fin_one.mpr residual_row_008))) + (Sparse.allFinAdd (a := 2) (b := 2) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr residual_row_009) + (Fin.forall_fin_one.mpr residual_row_010)) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr residual_row_011) + (Fin.forall_fin_one.mpr residual_row_012))))) + (Sparse.allFinAdd (a := 6) (b := 7) + (Sparse.allFinAdd (a := 3) (b := 3) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr residual_row_013) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr residual_row_014) + (Fin.forall_fin_one.mpr residual_row_015))) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr residual_row_016) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr residual_row_017) + (Fin.forall_fin_one.mpr residual_row_018)))) + (Sparse.allFinAdd (a := 3) (b := 4) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr residual_row_019) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr residual_row_020) + (Fin.forall_fin_one.mpr residual_row_021))) + (Sparse.allFinAdd (a := 2) (b := 2) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr residual_row_022) + (Fin.forall_fin_one.mpr residual_row_023)) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr residual_row_024) + (Fin.forall_fin_one.mpr residual_row_025)))))) + (Sparse.allFinAdd (a := 13) (b := 13) + (Sparse.allFinAdd (a := 6) (b := 7) + (Sparse.allFinAdd (a := 3) (b := 3) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr residual_row_026) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr residual_row_027) + (Fin.forall_fin_one.mpr residual_row_028))) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr residual_row_029) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr residual_row_030) + (Fin.forall_fin_one.mpr residual_row_031)))) + (Sparse.allFinAdd (a := 3) (b := 4) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr residual_row_032) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr residual_row_033) + (Fin.forall_fin_one.mpr residual_row_034))) + (Sparse.allFinAdd (a := 2) (b := 2) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr residual_row_035) + (Fin.forall_fin_one.mpr residual_row_036)) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr residual_row_037) + (Fin.forall_fin_one.mpr residual_row_038))))) + (Sparse.allFinAdd (a := 6) (b := 7) + (Sparse.allFinAdd (a := 3) (b := 3) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr residual_row_039) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr residual_row_040) + (Fin.forall_fin_one.mpr residual_row_041))) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr residual_row_042) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr residual_row_043) + (Fin.forall_fin_one.mpr residual_row_044)))) + (Sparse.allFinAdd (a := 3) (b := 4) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr residual_row_045) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr residual_row_046) + (Fin.forall_fin_one.mpr residual_row_047))) + (Sparse.allFinAdd (a := 2) (b := 2) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr residual_row_048) + (Fin.forall_fin_one.mpr residual_row_049)) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr residual_row_050) + (Fin.forall_fin_one.mpr residual_row_051))))))) + (Sparse.allFinAdd (a := 26) (b := 26) + (Sparse.allFinAdd (a := 13) (b := 13) + (Sparse.allFinAdd (a := 6) (b := 7) + (Sparse.allFinAdd (a := 3) (b := 3) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr residual_row_052) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr residual_row_053) + (Fin.forall_fin_one.mpr residual_row_054))) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr residual_row_055) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr residual_row_056) + (Fin.forall_fin_one.mpr residual_row_057)))) + (Sparse.allFinAdd (a := 3) (b := 4) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr residual_row_058) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr residual_row_059) + (Fin.forall_fin_one.mpr residual_row_060))) + (Sparse.allFinAdd (a := 2) (b := 2) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr residual_row_061) + (Fin.forall_fin_one.mpr residual_row_062)) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr residual_row_063) + (Fin.forall_fin_one.mpr residual_row_064))))) + (Sparse.allFinAdd (a := 6) (b := 7) + (Sparse.allFinAdd (a := 3) (b := 3) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr residual_row_065) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr residual_row_066) + (Fin.forall_fin_one.mpr residual_row_067))) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr residual_row_068) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr residual_row_069) + (Fin.forall_fin_one.mpr residual_row_070)))) + (Sparse.allFinAdd (a := 3) (b := 4) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr residual_row_071) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr residual_row_072) + (Fin.forall_fin_one.mpr residual_row_073))) + (Sparse.allFinAdd (a := 2) (b := 2) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr residual_row_074) + (Fin.forall_fin_one.mpr residual_row_075)) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr residual_row_076) + (Fin.forall_fin_one.mpr residual_row_077)))))) + (Sparse.allFinAdd (a := 13) (b := 13) + (Sparse.allFinAdd (a := 6) (b := 7) + (Sparse.allFinAdd (a := 3) (b := 3) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr residual_row_078) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr residual_row_079) + (Fin.forall_fin_one.mpr residual_row_080))) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr residual_row_081) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr residual_row_082) + (Fin.forall_fin_one.mpr residual_row_083)))) + (Sparse.allFinAdd (a := 3) (b := 4) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr residual_row_084) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr residual_row_085) + (Fin.forall_fin_one.mpr residual_row_086))) + (Sparse.allFinAdd (a := 2) (b := 2) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr residual_row_087) + (Fin.forall_fin_one.mpr residual_row_088)) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr residual_row_089) + (Fin.forall_fin_one.mpr residual_row_090))))) + (Sparse.allFinAdd (a := 6) (b := 7) + (Sparse.allFinAdd (a := 3) (b := 3) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr residual_row_091) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr residual_row_092) + (Fin.forall_fin_one.mpr residual_row_093))) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr residual_row_094) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr residual_row_095) + (Fin.forall_fin_one.mpr residual_row_096)))) + (Sparse.allFinAdd (a := 3) (b := 4) + (Sparse.allFinAdd (a := 1) (b := 2) + (Fin.forall_fin_one.mpr residual_row_097) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr residual_row_098) + (Fin.forall_fin_one.mpr residual_row_099))) + (Sparse.allFinAdd (a := 2) (b := 2) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr residual_row_100) + (Fin.forall_fin_one.mpr residual_row_101)) + (Sparse.allFinAdd (a := 1) (b := 1) + (Fin.forall_fin_one.mpr residual_row_102) + (Fin.forall_fin_one.mpr residual_row_103)))))))) + +/-- Equality for the imported bridge's ordinary Int matrix product. -/ +theorem mp : matMul M P = zeroMat 288 33 := by + funext i j + change rowMul (Sparse.row (M_entries i)) P j = (0 : Int) + exact (congrArg (fun v : Row 33 => v j) + (Sparse.rowMul_row (M_entries i) P)).trans (mp_sparse_all i j) + +/-- Equality for the imported bridge's ordinary Int matrix product. -/ +theorem qp : matMul Q P = eye 33 := by + funext i j + change rowMul (Sparse.row (Q_entries i)) P j = eye 33 i j + exact (congrArg (fun v : Row 33 => v j) + (Sparse.rowMul_row (Q_entries i) P)).trans (qp_sparse_all i j) + +/-- The full 104-by-104 residual, with the original row orientation and W signs. -/ +theorem residual : matSub (eye 104) (matMul P Q) = matMul W M := by + funext i j + change eye 104 i j - rowMul (Sparse.row (P_entries i)) Q j = + rowMul (Sparse.row (W_entries i)) M j + have hp := congrArg (fun v : Row 104 => v j) + (Sparse.rowMul_row (P_entries i) Q) + change rowMul (Sparse.row (P_entries i)) Q j = + Sparse.eval (P_entries i) Q j at hp + have hw := congrArg (fun v : Row 104 => v j) + (Sparse.rowMul_row (W_entries i) M) + change rowMul (Sparse.row (W_entries i)) M j = + Sparse.eval (W_entries i) M j at hw + rw [hp, hw] + exact residual_sparse_all i j + +/-- No certificate hypothesis: the three fields are the proved numerical equalities. -/ +theorem certificate : MatrixIdentities M P Q W := + { mp := mp, qp := qp, residual := residual } + +end P112Cert + +set_option pp.fullNames true +#print axioms P112Cert.mp_sparse_all +#print axioms P112Cert.qp_sparse_all +#print axioms P112Cert.residual_sparse_all +#print axioms P112Cert.mp +#print axioms P112Cert.qp +#print axioms P112Cert.residual +#print axioms P112Cert.certificate diff --git a/research/p112-integral-retraction-instance/source/P112Consequences.lean b/research/p112-integral-retraction-instance/source/P112Consequences.lean new file mode 100644 index 0000000000..adeec06c15 --- /dev/null +++ b/research/p112-integral-retraction-instance/source/P112Consequences.lean @@ -0,0 +1,110 @@ +/- +Copyright (c) 2026 Andrey Mas and contributors. +SPDX-License-Identifier: Apache-2.0 +P112 finite binding of existing PR1497/PR1610 conclusions. No new general theorem. +SOURCE ONLY / NOT YET KERNEL CHECKED for this successor. +Proof/source assistance: GPT-6 Pro through ChatGPT (operator-selected label). +-/ +import P112Certificate + +set_option autoImplicit false +set_option maxRecDepth 4096 +set_option maxHeartbeats 1000000 + +namespace P112Cert +open PR1497 +universe u + +/-- No numerical identity remains as a hypothesis of this finite application. -/ +theorem lattice_eq_kernel (v : Row 104) : + MatrixBridge.Lattice (M := M) v ↔ rowMul v P = (rowGroup 33).zero := + MatrixBridge.lattice_eq_kernel certificate v + +theorem phi_surjective : ∀ z : Row 33, ∃ v : Row 104, rowMul v P = z := + MatrixBridge.phi_surjective certificate + +/-- The actual image-difference quotient, not an arbitrary quotient type. -/ +def quotientIso : + AddIso (matrixRetraction certificate).quotientGroup (rowGroup 33) := + MatrixBridge.quotientIso certificate + +theorem quotient_relation (v w : Row 104) : + (matrixRetraction certificate).Rel v w ↔ + ∃ z : Row 288, rowMul z M = (fun i => v i - w i) := + MatrixBridge.quotient_relation certificate v w + +theorem quotient_forward_on_representative (v : Row 104) : + quotientIso.forward.run ((matrixRetraction certificate).qmk v) = rowMul v P := + MatrixBridge.quotient_forward_on_representative certificate v + +theorem quotient_inverse_on_parameter (z : Row 33) : + quotientIso.backward.run z = + (matrixRetraction certificate).qmk (rowMul z Q) := + MatrixBridge.quotient_inverse_on_parameter certificate z + +theorem quotient_left_inverse (x : (matrixRetraction certificate).LQuot) : + quotientIso.backward.run (quotientIso.forward.run x) = x := + MatrixBridge.quotient_left_inverse certificate x + +theorem quotient_right_inverse (z : Row 33) : + quotientIso.forward.run (quotientIso.backward.run z) = z := + MatrixBridge.quotient_right_inverse certificate z + +theorem lattice_saturated (k : Int) (hk : k ≠ 0) (v : Row 104) + (hv : MatrixBridge.Lattice (M := M) (scale k v)) : + MatrixBridge.Lattice (M := M) v := + MatrixBridge.lattice_saturated certificate k hk v hv + +/-- The ordinary commutative-group and INDIVIDUAL relation hypotheses remain explicit. + This is not a field/nonzero-elements adapter and not a geometric premise proof. -/ +theorem reconstruction {D : Type u} (G : CommGroup D) (x : Fin 104 → D) + (hx : MonomialBridge.Relations G M x) : + x = MonomialBridge.realization G P (MonomialBridge.parameters G Q x) := + MonomialBridge.reconstruction G certificate x hx + +theorem reconstruct_coordinate {D : Type u} (G : CommGroup D) (x : Fin 104 → D) + (hx : MonomialBridge.Relations G M x) (i : Fin 104) : + x i = monomial G (MonomialBridge.parameters G Q x) (P i) := + MonomialBridge.reconstruct_coordinate G certificate x hx i + +theorem converse_relations {D : Type u} (G : CommGroup D) (theta : Fin 33 → D) : + MonomialBridge.Relations G M (MonomialBridge.realization G P theta) := + MonomialBridge.converse_relations G certificate theta + +theorem parameters_recover {D : Type u} (G : CommGroup D) (theta : Fin 33 → D) : + MonomialBridge.parameters G Q (MonomialBridge.realization G P theta) = theta := + MonomialBridge.parameters_recover G certificate theta + +theorem unique_parameterization {D : Type u} (G : CommGroup D) (x : Fin 104 → D) + (hx : MonomialBridge.Relations G M x) : + (∀ i, x i = monomial G (MonomialBridge.parameters G Q x) (P i)) ∧ + (∀ theta : Fin 33 → D, + (∀ i, x i = monomial G theta (P i)) → + MonomialBridge.parameters G Q x = theta) := + MonomialBridge.unique_parameterization G certificate x hx + +/-- Literal W residual product. No assertion that these row values equal one is hidden. -/ +theorem residual_relations_formula {D : Type u} (G : CommGroup D) + (x : Fin 104 → D) (i : Fin 104) : + G.div (x i) (monomial G (MonomialBridge.parameters G Q x) (P i)) = + G.prod 288 (fun r => G.zpow (monomial G x (M r)) (W i r)) := + MonomialBridge.residual_relations_formula G certificate x i + +end P112Cert + +set_option pp.fullNames true +#print axioms P112Cert.lattice_eq_kernel +#print axioms P112Cert.phi_surjective +#print axioms P112Cert.quotientIso +#print axioms P112Cert.quotient_relation +#print axioms P112Cert.quotient_forward_on_representative +#print axioms P112Cert.quotient_inverse_on_parameter +#print axioms P112Cert.quotient_left_inverse +#print axioms P112Cert.quotient_right_inverse +#print axioms P112Cert.lattice_saturated +#print axioms P112Cert.reconstruction +#print axioms P112Cert.reconstruct_coordinate +#print axioms P112Cert.converse_relations +#print axioms P112Cert.parameters_recover +#print axioms P112Cert.unique_parameterization +#print axioms P112Cert.residual_relations_formula diff --git a/research/p112-integral-retraction-instance/source/P112Damaged.lean b/research/p112-integral-retraction-instance/source/P112Damaged.lean new file mode 100644 index 0000000000..44ff4febb1 --- /dev/null +++ b/research/p112-integral-retraction-instance/source/P112Damaged.lean @@ -0,0 +1,80 @@ +/- +Copyright (c) 2026 Andrey Mas and contributors. +SPDX-License-Identifier: Apache-2.0 +SOURCE ONLY / NOT YET KERNEL CHECKED. +Source-specific W sign corruption control, in the spirit of the inherited +PR1497 verify.py W-corruption control. This exact damaged entry proof is new. +Proof/source assistance: GPT-6 Pro through ChatGPT (operator-selected label). +-/ +import P112Certificate + +set_option autoImplicit false +set_option maxRecDepth 4096 +set_option maxHeartbeats 1000000 + +namespace P112Cert.Damaged +open PR1497 + +/-- Exactly W[5,0] is changed from +1 to -1; all other rows are retained. -/ +def W_entries_bad (i : Fin 104) : List (Fin 288 × Int) := + if i.val = 5 then [(⟨0, by decide⟩, (-1 : Int))] else W_entries i + +def W_bad : Mat 104 288 := fun i => Sparse.row (W_entries_bad i) + +theorem original_coefficient : W (5 : Fin 104) (0 : Fin 288) = 1 := by + decide + +theorem damaged_coefficient : W_bad (5 : Fin 104) (0 : Fin 288) = -1 := by + decide + +theorem unchanged_other_rows (i : Fin 104) (hi : i.val ≠ 5) : W_bad i = W i := by + change Sparse.row (if i.val = 5 then [(⟨0, by decide⟩, (-1 : Int))] + else W_entries i) = Sparse.row (W_entries i) + rw [if_neg hi] + +/-- The intended left residual at (5,0) is +1, computed through the sound adapter. -/ +theorem residual_entry : + matSub (eye 104) (matMul P Q) (5 : Fin 104) (0 : Fin 104) = 1 := by + change eye 104 (5 : Fin 104) (0 : Fin 104) - + rowMul (Sparse.row (P_entries (5 : Fin 104))) Q (0 : Fin 104) = (1 : Int) + have hp := congrArg (fun v : Row 104 => v (0 : Fin 104)) + (Sparse.rowMul_row (P_entries (5 : Fin 104)) Q) + change rowMul (Sparse.row (P_entries (5 : Fin 104))) Q (0 : Fin 104) = + Sparse.eval (P_entries (5 : Fin 104)) Q (0 : Fin 104) at hp + rw [hp] + decide + +/-- The corrupted right residual at (5,0) is -1, not +1. -/ +theorem damaged_product_entry : + matMul W_bad M (5 : Fin 104) (0 : Fin 104) = -1 := by + change rowMul (Sparse.row (W_entries_bad (5 : Fin 104))) M (0 : Fin 104) = (-1 : Int) + have hw := congrArg (fun v : Row 104 => v (0 : Fin 104)) + (Sparse.rowMul_row (W_entries_bad (5 : Fin 104)) M) + change rowMul (Sparse.row (W_entries_bad (5 : Fin 104))) M (0 : Fin 104) = + Sparse.eval (W_entries_bad (5 : Fin 104)) M (0 : Fin 104) at hw + rw [hw] + decide + +theorem not_residual : matSub (eye 104) (matMul P Q) ≠ matMul W_bad M := by + intro h + have he := congrArg (fun A : Mat 104 104 => A (5 : Fin 104) (0 : Fin 104)) h + change matSub (eye 104) (matMul P Q) (5 : Fin 104) (0 : Fin 104) = + matMul W_bad M (5 : Fin 104) (0 : Fin 104) at he + rw [residual_entry, damaged_product_entry] at he + exact (by decide : (1 : Int) ≠ -1) he + +theorem no_certificate : ¬ MatrixIdentities M P Q W_bad := + fun h => not_residual h.residual + +end P112Cert.Damaged + +set_option pp.fullNames true +#print axioms P112Cert.Damaged.W_entries_bad +#print axioms P112Cert.Damaged.W_bad +#print axioms P112Cert.Damaged.original_coefficient +#print axioms P112Cert.Damaged.damaged_coefficient +#print axioms P112Cert.Damaged.unchanged_other_rows +#print axioms P112Cert.Damaged.residual_entry +#print axioms P112Cert.Damaged.damaged_product_entry +#print axioms P112Cert.Damaged.not_residual +#print axioms P112Cert.Damaged.no_certificate diff --git a/research/p112-integral-retraction-instance/source/P112Data.lean b/research/p112-integral-retraction-instance/source/P112Data.lean new file mode 100644 index 0000000000..1f21d38b94 --- /dev/null +++ b/research/p112-integral-retraction-instance/source/P112Data.lean @@ -0,0 +1,1649 @@ +/- +Copyright (c) 2026 Andrey Mas and contributors. +SPDX-License-Identifier: Apache-2.0 +P112 numerical instance of the unchanged PR1497/PR1610 bridge. +SOURCE ONLY / NOT YET KERNEL CHECKED. Generated deterministically by generate.py. +Proof/source assistance: GPT-6 Pro through ChatGPT (operator-selected label). +-/ +import P112Sparse + +set_option autoImplicit false +set_option maxRecDepth 4096 +set_option maxHeartbeats 1000000 + +namespace P112Cert +open PR1497 + +/-- Original sparse M rows, in original row/entry order. -/ +def M_entries (i : Fin 288) : List (Fin 104 × Int) := + if i.val < 144 then + if i.val < 72 then + if i.val < 36 then + if i.val < 18 then + if i.val < 9 then + if i.val < 4 then + if i.val < 2 then + if i.val < 1 then + [(⟨0, by decide⟩, (1 : Int)), (⟨1, by decide⟩, (-1 : Int)), (⟨4, by decide⟩, (-1 : Int)), (⟨5, by decide⟩, (1 : Int))] -- /M/0 + else + [(⟨0, by decide⟩, (1 : Int)), (⟨1, by decide⟩, (-1 : Int)), (⟨8, by decide⟩, (-1 : Int)), (⟨9, by decide⟩, (1 : Int))] -- /M/1 + else + if i.val < 3 then + [(⟨0, by decide⟩, (1 : Int)), (⟨1, by decide⟩, (-1 : Int)), (⟨12, by decide⟩, (-1 : Int)), (⟨13, by decide⟩, (1 : Int))] -- /M/2 + else + [(⟨0, by decide⟩, (1 : Int)), (⟨1, by decide⟩, (-1 : Int)), (⟨16, by decide⟩, (-1 : Int)), (⟨17, by decide⟩, (1 : Int))] -- /M/3 + else + if i.val < 6 then + if i.val < 5 then + [(⟨0, by decide⟩, (1 : Int)), (⟨2, by decide⟩, (-1 : Int)), (⟨20, by decide⟩, (-1 : Int)), (⟨21, by decide⟩, (1 : Int))] -- /M/4 + else + [(⟨0, by decide⟩, (1 : Int)), (⟨2, by decide⟩, (-1 : Int)), (⟨24, by decide⟩, (-1 : Int)), (⟨25, by decide⟩, (1 : Int))] -- /M/5 + else + if i.val < 7 then + [(⟨0, by decide⟩, (1 : Int)), (⟨2, by decide⟩, (-1 : Int)), (⟨28, by decide⟩, (-1 : Int)), (⟨29, by decide⟩, (1 : Int))] -- /M/6 + else + if i.val < 8 then + [(⟨0, by decide⟩, (1 : Int)), (⟨2, by decide⟩, (-1 : Int)), (⟨32, by decide⟩, (-1 : Int)), (⟨33, by decide⟩, (1 : Int))] -- /M/7 + else + [(⟨0, by decide⟩, (1 : Int)), (⟨3, by decide⟩, (-1 : Int)), (⟨36, by decide⟩, (-1 : Int)), (⟨37, by decide⟩, (1 : Int))] -- /M/8 + else + if i.val < 13 then + if i.val < 11 then + if i.val < 10 then + [(⟨0, by decide⟩, (1 : Int)), (⟨3, by decide⟩, (-1 : Int)), (⟨40, by decide⟩, (-1 : Int)), (⟨41, by decide⟩, (1 : Int))] -- /M/9 + else + [(⟨0, by decide⟩, (1 : Int)), (⟨3, by decide⟩, (-1 : Int)), (⟨44, by decide⟩, (-1 : Int)), (⟨45, by decide⟩, (1 : Int))] -- /M/10 + else + if i.val < 12 then + [(⟨0, by decide⟩, (1 : Int)), (⟨3, by decide⟩, (-1 : Int)), (⟨48, by decide⟩, (-1 : Int)), (⟨49, by decide⟩, (1 : Int))] -- /M/11 + else + [(⟨1, by decide⟩, (1 : Int)), (⟨2, by decide⟩, (-1 : Int)), (⟨52, by decide⟩, (-1 : Int)), (⟨53, by decide⟩, (1 : Int))] -- /M/12 + else + if i.val < 15 then + if i.val < 14 then + [(⟨1, by decide⟩, (1 : Int)), (⟨2, by decide⟩, (-1 : Int)), (⟨56, by decide⟩, (-1 : Int)), (⟨57, by decide⟩, (1 : Int))] -- /M/13 + else + [(⟨1, by decide⟩, (1 : Int)), (⟨2, by decide⟩, (-1 : Int)), (⟨60, by decide⟩, (-1 : Int)), (⟨61, by decide⟩, (1 : Int))] -- /M/14 + else + if i.val < 16 then + [(⟨1, by decide⟩, (1 : Int)), (⟨2, by decide⟩, (-1 : Int)), (⟨64, by decide⟩, (-1 : Int)), (⟨65, by decide⟩, (1 : Int))] -- /M/15 + else + if i.val < 17 then + [(⟨1, by decide⟩, (1 : Int)), (⟨3, by decide⟩, (-1 : Int)), (⟨68, by decide⟩, (-1 : Int)), (⟨69, by decide⟩, (1 : Int))] -- /M/16 + else + [(⟨1, by decide⟩, (1 : Int)), (⟨3, by decide⟩, (-1 : Int)), (⟨72, by decide⟩, (-1 : Int)), (⟨73, by decide⟩, (1 : Int))] -- /M/17 + else + if i.val < 27 then + if i.val < 22 then + if i.val < 20 then + if i.val < 19 then + [(⟨1, by decide⟩, (1 : Int)), (⟨3, by decide⟩, (-1 : Int)), (⟨76, by decide⟩, (-1 : Int)), (⟨77, by decide⟩, (1 : Int))] -- /M/18 + else + [(⟨1, by decide⟩, (1 : Int)), (⟨3, by decide⟩, (-1 : Int)), (⟨80, by decide⟩, (-1 : Int)), (⟨81, by decide⟩, (1 : Int))] -- /M/19 + else + if i.val < 21 then + [(⟨2, by decide⟩, (1 : Int)), (⟨3, by decide⟩, (-1 : Int)), (⟨84, by decide⟩, (-1 : Int)), (⟨85, by decide⟩, (1 : Int))] -- /M/20 + else + [(⟨2, by decide⟩, (1 : Int)), (⟨3, by decide⟩, (-1 : Int)), (⟨88, by decide⟩, (-1 : Int)), (⟨89, by decide⟩, (1 : Int))] -- /M/21 + else + if i.val < 24 then + if i.val < 23 then + [(⟨2, by decide⟩, (1 : Int)), (⟨3, by decide⟩, (-1 : Int)), (⟨92, by decide⟩, (-1 : Int)), (⟨93, by decide⟩, (1 : Int))] -- /M/22 + else + [(⟨2, by decide⟩, (1 : Int)), (⟨3, by decide⟩, (-1 : Int)), (⟨96, by decide⟩, (-1 : Int)), (⟨97, by decide⟩, (1 : Int))] -- /M/23 + else + if i.val < 25 then + [(⟨4, by decide⟩, (1 : Int)), (⟨5, by decide⟩, (-1 : Int)), (⟨12, by decide⟩, (-1 : Int)), (⟨13, by decide⟩, (1 : Int))] -- /M/24 + else + if i.val < 26 then + [(⟨4, by decide⟩, (1 : Int)), (⟨5, by decide⟩, (-1 : Int)), (⟨16, by decide⟩, (-1 : Int)), (⟨17, by decide⟩, (1 : Int))] -- /M/25 + else + [(⟨4, by decide⟩, (1 : Int)), (⟨6, by decide⟩, (-1 : Int)), (⟨20, by decide⟩, (-1 : Int)), (⟨22, by decide⟩, (1 : Int))] -- /M/26 + else + if i.val < 31 then + if i.val < 29 then + if i.val < 28 then + [(⟨4, by decide⟩, (1 : Int)), (⟨6, by decide⟩, (-1 : Int)), (⟨24, by decide⟩, (-1 : Int)), (⟨26, by decide⟩, (1 : Int))] -- /M/27 + else + [(⟨4, by decide⟩, (1 : Int)), (⟨7, by decide⟩, (-1 : Int)), (⟨28, by decide⟩, (-1 : Int)), (⟨30, by decide⟩, (1 : Int))] -- /M/28 + else + if i.val < 30 then + [(⟨4, by decide⟩, (1 : Int)), (⟨7, by decide⟩, (-1 : Int)), (⟨32, by decide⟩, (-1 : Int)), (⟨34, by decide⟩, (1 : Int))] -- /M/29 + else + [(⟨4, by decide⟩, (1 : Int)), (⟨6, by decide⟩, (-1 : Int)), (⟨36, by decide⟩, (-1 : Int)), (⟨38, by decide⟩, (1 : Int))] -- /M/30 + else + if i.val < 33 then + if i.val < 32 then + [(⟨4, by decide⟩, (1 : Int)), (⟨6, by decide⟩, (-1 : Int)), (⟨40, by decide⟩, (-1 : Int)), (⟨42, by decide⟩, (1 : Int))] -- /M/31 + else + [(⟨4, by decide⟩, (1 : Int)), (⟨7, by decide⟩, (-1 : Int)), (⟨44, by decide⟩, (-1 : Int)), (⟨46, by decide⟩, (1 : Int))] -- /M/32 + else + if i.val < 34 then + [(⟨4, by decide⟩, (1 : Int)), (⟨7, by decide⟩, (-1 : Int)), (⟨48, by decide⟩, (-1 : Int)), (⟨50, by decide⟩, (1 : Int))] -- /M/33 + else + if i.val < 35 then + [(⟨5, by decide⟩, (1 : Int)), (⟨6, by decide⟩, (-1 : Int)), (⟨52, by decide⟩, (-1 : Int)), (⟨54, by decide⟩, (1 : Int))] -- /M/34 + else + [(⟨5, by decide⟩, (1 : Int)), (⟨6, by decide⟩, (-1 : Int)), (⟨56, by decide⟩, (-1 : Int)), (⟨58, by decide⟩, (1 : Int))] -- /M/35 + else + if i.val < 54 then + if i.val < 45 then + if i.val < 40 then + if i.val < 38 then + if i.val < 37 then + [(⟨5, by decide⟩, (1 : Int)), (⟨7, by decide⟩, (-1 : Int)), (⟨60, by decide⟩, (-1 : Int)), (⟨62, by decide⟩, (1 : Int))] -- /M/36 + else + [(⟨5, by decide⟩, (1 : Int)), (⟨7, by decide⟩, (-1 : Int)), (⟨64, by decide⟩, (-1 : Int)), (⟨66, by decide⟩, (1 : Int))] -- /M/37 + else + if i.val < 39 then + [(⟨5, by decide⟩, (1 : Int)), (⟨6, by decide⟩, (-1 : Int)), (⟨68, by decide⟩, (-1 : Int)), (⟨70, by decide⟩, (1 : Int))] -- /M/38 + else + [(⟨5, by decide⟩, (1 : Int)), (⟨6, by decide⟩, (-1 : Int)), (⟨72, by decide⟩, (-1 : Int)), (⟨74, by decide⟩, (1 : Int))] -- /M/39 + else + if i.val < 42 then + if i.val < 41 then + [(⟨5, by decide⟩, (1 : Int)), (⟨7, by decide⟩, (-1 : Int)), (⟨76, by decide⟩, (-1 : Int)), (⟨78, by decide⟩, (1 : Int))] -- /M/40 + else + [(⟨5, by decide⟩, (1 : Int)), (⟨7, by decide⟩, (-1 : Int)), (⟨80, by decide⟩, (-1 : Int)), (⟨82, by decide⟩, (1 : Int))] -- /M/41 + else + if i.val < 43 then + [(⟨6, by decide⟩, (1 : Int)), (⟨7, by decide⟩, (-1 : Int)), (⟨86, by decide⟩, (-1 : Int)), (⟨87, by decide⟩, (1 : Int))] -- /M/42 + else + if i.val < 44 then + [(⟨6, by decide⟩, (1 : Int)), (⟨7, by decide⟩, (-1 : Int)), (⟨90, by decide⟩, (-1 : Int)), (⟨91, by decide⟩, (1 : Int))] -- /M/43 + else + [(⟨6, by decide⟩, (1 : Int)), (⟨7, by decide⟩, (-1 : Int)), (⟨100, by decide⟩, (-1 : Int)), (⟨101, by decide⟩, (1 : Int))] -- /M/44 + else + if i.val < 49 then + if i.val < 47 then + if i.val < 46 then + [(⟨8, by decide⟩, (1 : Int)), (⟨9, by decide⟩, (-1 : Int)), (⟨12, by decide⟩, (-1 : Int)), (⟨13, by decide⟩, (1 : Int))] -- /M/45 + else + [(⟨8, by decide⟩, (1 : Int)), (⟨9, by decide⟩, (-1 : Int)), (⟨16, by decide⟩, (-1 : Int)), (⟨17, by decide⟩, (1 : Int))] -- /M/46 + else + if i.val < 48 then + [(⟨8, by decide⟩, (1 : Int)), (⟨10, by decide⟩, (-1 : Int)), (⟨20, by decide⟩, (-1 : Int)), (⟨22, by decide⟩, (1 : Int))] -- /M/47 + else + [(⟨8, by decide⟩, (1 : Int)), (⟨10, by decide⟩, (-1 : Int)), (⟨24, by decide⟩, (-1 : Int)), (⟨26, by decide⟩, (1 : Int))] -- /M/48 + else + if i.val < 51 then + if i.val < 50 then + [(⟨8, by decide⟩, (1 : Int)), (⟨11, by decide⟩, (-1 : Int)), (⟨28, by decide⟩, (-1 : Int)), (⟨30, by decide⟩, (1 : Int))] -- /M/49 + else + [(⟨8, by decide⟩, (1 : Int)), (⟨11, by decide⟩, (-1 : Int)), (⟨32, by decide⟩, (-1 : Int)), (⟨34, by decide⟩, (1 : Int))] -- /M/50 + else + if i.val < 52 then + [(⟨8, by decide⟩, (1 : Int)), (⟨10, by decide⟩, (-1 : Int)), (⟨36, by decide⟩, (-1 : Int)), (⟨38, by decide⟩, (1 : Int))] -- /M/51 + else + if i.val < 53 then + [(⟨8, by decide⟩, (1 : Int)), (⟨10, by decide⟩, (-1 : Int)), (⟨40, by decide⟩, (-1 : Int)), (⟨42, by decide⟩, (1 : Int))] -- /M/52 + else + [(⟨8, by decide⟩, (1 : Int)), (⟨11, by decide⟩, (-1 : Int)), (⟨44, by decide⟩, (-1 : Int)), (⟨46, by decide⟩, (1 : Int))] -- /M/53 + else + if i.val < 63 then + if i.val < 58 then + if i.val < 56 then + if i.val < 55 then + [(⟨8, by decide⟩, (1 : Int)), (⟨11, by decide⟩, (-1 : Int)), (⟨48, by decide⟩, (-1 : Int)), (⟨50, by decide⟩, (1 : Int))] -- /M/54 + else + [(⟨9, by decide⟩, (1 : Int)), (⟨10, by decide⟩, (-1 : Int)), (⟨52, by decide⟩, (-1 : Int)), (⟨54, by decide⟩, (1 : Int))] -- /M/55 + else + if i.val < 57 then + [(⟨9, by decide⟩, (1 : Int)), (⟨10, by decide⟩, (-1 : Int)), (⟨56, by decide⟩, (-1 : Int)), (⟨58, by decide⟩, (1 : Int))] -- /M/56 + else + [(⟨9, by decide⟩, (1 : Int)), (⟨11, by decide⟩, (-1 : Int)), (⟨60, by decide⟩, (-1 : Int)), (⟨62, by decide⟩, (1 : Int))] -- /M/57 + else + if i.val < 60 then + if i.val < 59 then + [(⟨9, by decide⟩, (1 : Int)), (⟨11, by decide⟩, (-1 : Int)), (⟨64, by decide⟩, (-1 : Int)), (⟨66, by decide⟩, (1 : Int))] -- /M/58 + else + [(⟨9, by decide⟩, (1 : Int)), (⟨10, by decide⟩, (-1 : Int)), (⟨68, by decide⟩, (-1 : Int)), (⟨70, by decide⟩, (1 : Int))] -- /M/59 + else + if i.val < 61 then + [(⟨9, by decide⟩, (1 : Int)), (⟨10, by decide⟩, (-1 : Int)), (⟨72, by decide⟩, (-1 : Int)), (⟨74, by decide⟩, (1 : Int))] -- /M/60 + else + if i.val < 62 then + [(⟨9, by decide⟩, (1 : Int)), (⟨11, by decide⟩, (-1 : Int)), (⟨76, by decide⟩, (-1 : Int)), (⟨78, by decide⟩, (1 : Int))] -- /M/61 + else + [(⟨9, by decide⟩, (1 : Int)), (⟨11, by decide⟩, (-1 : Int)), (⟨80, by decide⟩, (-1 : Int)), (⟨82, by decide⟩, (1 : Int))] -- /M/62 + else + if i.val < 67 then + if i.val < 65 then + if i.val < 64 then + [(⟨10, by decide⟩, (1 : Int)), (⟨11, by decide⟩, (-1 : Int)), (⟨86, by decide⟩, (-1 : Int)), (⟨87, by decide⟩, (1 : Int))] -- /M/63 + else + [(⟨10, by decide⟩, (1 : Int)), (⟨11, by decide⟩, (-1 : Int)), (⟨90, by decide⟩, (-1 : Int)), (⟨91, by decide⟩, (1 : Int))] -- /M/64 + else + if i.val < 66 then + [(⟨10, by decide⟩, (1 : Int)), (⟨11, by decide⟩, (-1 : Int)), (⟨100, by decide⟩, (-1 : Int)), (⟨101, by decide⟩, (1 : Int))] -- /M/65 + else + [(⟨12, by decide⟩, (1 : Int)), (⟨14, by decide⟩, (-1 : Int)), (⟨20, by decide⟩, (-1 : Int)), (⟨23, by decide⟩, (1 : Int))] -- /M/66 + else + if i.val < 69 then + if i.val < 68 then + [(⟨12, by decide⟩, (1 : Int)), (⟨14, by decide⟩, (-1 : Int)), (⟨24, by decide⟩, (-1 : Int)), (⟨27, by decide⟩, (1 : Int))] -- /M/67 + else + [(⟨12, by decide⟩, (1 : Int)), (⟨15, by decide⟩, (-1 : Int)), (⟨28, by decide⟩, (-1 : Int)), (⟨31, by decide⟩, (1 : Int))] -- /M/68 + else + if i.val < 70 then + [(⟨12, by decide⟩, (1 : Int)), (⟨15, by decide⟩, (-1 : Int)), (⟨32, by decide⟩, (-1 : Int)), (⟨35, by decide⟩, (1 : Int))] -- /M/69 + else + if i.val < 71 then + [(⟨12, by decide⟩, (1 : Int)), (⟨15, by decide⟩, (-1 : Int)), (⟨36, by decide⟩, (-1 : Int)), (⟨39, by decide⟩, (1 : Int))] -- /M/70 + else + [(⟨12, by decide⟩, (1 : Int)), (⟨15, by decide⟩, (-1 : Int)), (⟨40, by decide⟩, (-1 : Int)), (⟨43, by decide⟩, (1 : Int))] -- /M/71 + else + if i.val < 108 then + if i.val < 90 then + if i.val < 81 then + if i.val < 76 then + if i.val < 74 then + if i.val < 73 then + [(⟨12, by decide⟩, (1 : Int)), (⟨14, by decide⟩, (-1 : Int)), (⟨44, by decide⟩, (-1 : Int)), (⟨47, by decide⟩, (1 : Int))] -- /M/72 + else + [(⟨12, by decide⟩, (1 : Int)), (⟨14, by decide⟩, (-1 : Int)), (⟨48, by decide⟩, (-1 : Int)), (⟨51, by decide⟩, (1 : Int))] -- /M/73 + else + if i.val < 75 then + [(⟨13, by decide⟩, (1 : Int)), (⟨15, by decide⟩, (-1 : Int)), (⟨52, by decide⟩, (-1 : Int)), (⟨55, by decide⟩, (1 : Int))] -- /M/74 + else + [(⟨13, by decide⟩, (1 : Int)), (⟨15, by decide⟩, (-1 : Int)), (⟨56, by decide⟩, (-1 : Int)), (⟨59, by decide⟩, (1 : Int))] -- /M/75 + else + if i.val < 78 then + if i.val < 77 then + [(⟨13, by decide⟩, (1 : Int)), (⟨14, by decide⟩, (-1 : Int)), (⟨60, by decide⟩, (-1 : Int)), (⟨63, by decide⟩, (1 : Int))] -- /M/76 + else + [(⟨13, by decide⟩, (1 : Int)), (⟨14, by decide⟩, (-1 : Int)), (⟨64, by decide⟩, (-1 : Int)), (⟨67, by decide⟩, (1 : Int))] -- /M/77 + else + if i.val < 79 then + [(⟨13, by decide⟩, (1 : Int)), (⟨14, by decide⟩, (-1 : Int)), (⟨68, by decide⟩, (-1 : Int)), (⟨71, by decide⟩, (1 : Int))] -- /M/78 + else + if i.val < 80 then + [(⟨13, by decide⟩, (1 : Int)), (⟨14, by decide⟩, (-1 : Int)), (⟨72, by decide⟩, (-1 : Int)), (⟨75, by decide⟩, (1 : Int))] -- /M/79 + else + [(⟨13, by decide⟩, (1 : Int)), (⟨15, by decide⟩, (-1 : Int)), (⟨76, by decide⟩, (-1 : Int)), (⟨79, by decide⟩, (1 : Int))] -- /M/80 + else + if i.val < 85 then + if i.val < 83 then + if i.val < 82 then + [(⟨13, by decide⟩, (1 : Int)), (⟨15, by decide⟩, (-1 : Int)), (⟨80, by decide⟩, (-1 : Int)), (⟨83, by decide⟩, (1 : Int))] -- /M/81 + else + [(⟨14, by decide⟩, (1 : Int)), (⟨15, by decide⟩, (-1 : Int)), (⟨94, by decide⟩, (-1 : Int)), (⟨95, by decide⟩, (1 : Int))] -- /M/82 + else + if i.val < 84 then + [(⟨14, by decide⟩, (1 : Int)), (⟨15, by decide⟩, (-1 : Int)), (⟨98, by decide⟩, (-1 : Int)), (⟨99, by decide⟩, (1 : Int))] -- /M/83 + else + [(⟨14, by decide⟩, (1 : Int)), (⟨15, by decide⟩, (-1 : Int)), (⟨102, by decide⟩, (-1 : Int)), (⟨103, by decide⟩, (1 : Int))] -- /M/84 + else + if i.val < 87 then + if i.val < 86 then + [(⟨16, by decide⟩, (1 : Int)), (⟨18, by decide⟩, (-1 : Int)), (⟨20, by decide⟩, (-1 : Int)), (⟨23, by decide⟩, (1 : Int))] -- /M/85 + else + [(⟨16, by decide⟩, (1 : Int)), (⟨18, by decide⟩, (-1 : Int)), (⟨24, by decide⟩, (-1 : Int)), (⟨27, by decide⟩, (1 : Int))] -- /M/86 + else + if i.val < 88 then + [(⟨16, by decide⟩, (1 : Int)), (⟨19, by decide⟩, (-1 : Int)), (⟨28, by decide⟩, (-1 : Int)), (⟨31, by decide⟩, (1 : Int))] -- /M/87 + else + if i.val < 89 then + [(⟨16, by decide⟩, (1 : Int)), (⟨19, by decide⟩, (-1 : Int)), (⟨32, by decide⟩, (-1 : Int)), (⟨35, by decide⟩, (1 : Int))] -- /M/88 + else + [(⟨16, by decide⟩, (1 : Int)), (⟨19, by decide⟩, (-1 : Int)), (⟨36, by decide⟩, (-1 : Int)), (⟨39, by decide⟩, (1 : Int))] -- /M/89 + else + if i.val < 99 then + if i.val < 94 then + if i.val < 92 then + if i.val < 91 then + [(⟨16, by decide⟩, (1 : Int)), (⟨19, by decide⟩, (-1 : Int)), (⟨40, by decide⟩, (-1 : Int)), (⟨43, by decide⟩, (1 : Int))] -- /M/90 + else + [(⟨16, by decide⟩, (1 : Int)), (⟨18, by decide⟩, (-1 : Int)), (⟨44, by decide⟩, (-1 : Int)), (⟨47, by decide⟩, (1 : Int))] -- /M/91 + else + if i.val < 93 then + [(⟨16, by decide⟩, (1 : Int)), (⟨18, by decide⟩, (-1 : Int)), (⟨48, by decide⟩, (-1 : Int)), (⟨51, by decide⟩, (1 : Int))] -- /M/92 + else + [(⟨17, by decide⟩, (1 : Int)), (⟨19, by decide⟩, (-1 : Int)), (⟨52, by decide⟩, (-1 : Int)), (⟨55, by decide⟩, (1 : Int))] -- /M/93 + else + if i.val < 96 then + if i.val < 95 then + [(⟨17, by decide⟩, (1 : Int)), (⟨19, by decide⟩, (-1 : Int)), (⟨56, by decide⟩, (-1 : Int)), (⟨59, by decide⟩, (1 : Int))] -- /M/94 + else + [(⟨17, by decide⟩, (1 : Int)), (⟨18, by decide⟩, (-1 : Int)), (⟨60, by decide⟩, (-1 : Int)), (⟨63, by decide⟩, (1 : Int))] -- /M/95 + else + if i.val < 97 then + [(⟨17, by decide⟩, (1 : Int)), (⟨18, by decide⟩, (-1 : Int)), (⟨64, by decide⟩, (-1 : Int)), (⟨67, by decide⟩, (1 : Int))] -- /M/96 + else + if i.val < 98 then + [(⟨17, by decide⟩, (1 : Int)), (⟨18, by decide⟩, (-1 : Int)), (⟨68, by decide⟩, (-1 : Int)), (⟨71, by decide⟩, (1 : Int))] -- /M/97 + else + [(⟨17, by decide⟩, (1 : Int)), (⟨18, by decide⟩, (-1 : Int)), (⟨72, by decide⟩, (-1 : Int)), (⟨75, by decide⟩, (1 : Int))] -- /M/98 + else + if i.val < 103 then + if i.val < 101 then + if i.val < 100 then + [(⟨17, by decide⟩, (1 : Int)), (⟨19, by decide⟩, (-1 : Int)), (⟨76, by decide⟩, (-1 : Int)), (⟨79, by decide⟩, (1 : Int))] -- /M/99 + else + [(⟨17, by decide⟩, (1 : Int)), (⟨19, by decide⟩, (-1 : Int)), (⟨80, by decide⟩, (-1 : Int)), (⟨83, by decide⟩, (1 : Int))] -- /M/100 + else + if i.val < 102 then + [(⟨18, by decide⟩, (1 : Int)), (⟨19, by decide⟩, (-1 : Int)), (⟨94, by decide⟩, (-1 : Int)), (⟨95, by decide⟩, (1 : Int))] -- /M/101 + else + [(⟨18, by decide⟩, (1 : Int)), (⟨19, by decide⟩, (-1 : Int)), (⟨98, by decide⟩, (-1 : Int)), (⟨99, by decide⟩, (1 : Int))] -- /M/102 + else + if i.val < 105 then + if i.val < 104 then + [(⟨18, by decide⟩, (1 : Int)), (⟨19, by decide⟩, (-1 : Int)), (⟨102, by decide⟩, (-1 : Int)), (⟨103, by decide⟩, (1 : Int))] -- /M/103 + else + [(⟨20, by decide⟩, (1 : Int)), (⟨21, by decide⟩, (-1 : Int)), (⟨28, by decide⟩, (-1 : Int)), (⟨29, by decide⟩, (1 : Int))] -- /M/104 + else + if i.val < 106 then + [(⟨20, by decide⟩, (1 : Int)), (⟨21, by decide⟩, (-1 : Int)), (⟨32, by decide⟩, (-1 : Int)), (⟨33, by decide⟩, (1 : Int))] -- /M/105 + else + if i.val < 107 then + [(⟨20, by decide⟩, (1 : Int)), (⟨22, by decide⟩, (-1 : Int)), (⟨36, by decide⟩, (-1 : Int)), (⟨38, by decide⟩, (1 : Int))] -- /M/106 + else + [(⟨20, by decide⟩, (1 : Int)), (⟨22, by decide⟩, (-1 : Int)), (⟨40, by decide⟩, (-1 : Int)), (⟨42, by decide⟩, (1 : Int))] -- /M/107 + else + if i.val < 126 then + if i.val < 117 then + if i.val < 112 then + if i.val < 110 then + if i.val < 109 then + [(⟨20, by decide⟩, (1 : Int)), (⟨23, by decide⟩, (-1 : Int)), (⟨44, by decide⟩, (-1 : Int)), (⟨47, by decide⟩, (1 : Int))] -- /M/108 + else + [(⟨20, by decide⟩, (1 : Int)), (⟨23, by decide⟩, (-1 : Int)), (⟨48, by decide⟩, (-1 : Int)), (⟨51, by decide⟩, (1 : Int))] -- /M/109 + else + if i.val < 111 then + [(⟨21, by decide⟩, (1 : Int)), (⟨22, by decide⟩, (-1 : Int)), (⟨53, by decide⟩, (-1 : Int)), (⟨54, by decide⟩, (1 : Int))] -- /M/110 + else + [(⟨21, by decide⟩, (1 : Int)), (⟨22, by decide⟩, (-1 : Int)), (⟨57, by decide⟩, (-1 : Int)), (⟨58, by decide⟩, (1 : Int))] -- /M/111 + else + if i.val < 114 then + if i.val < 113 then + [(⟨21, by decide⟩, (1 : Int)), (⟨23, by decide⟩, (-1 : Int)), (⟨61, by decide⟩, (-1 : Int)), (⟨63, by decide⟩, (1 : Int))] -- /M/112 + else + [(⟨21, by decide⟩, (1 : Int)), (⟨23, by decide⟩, (-1 : Int)), (⟨65, by decide⟩, (-1 : Int)), (⟨67, by decide⟩, (1 : Int))] -- /M/113 + else + if i.val < 115 then + [(⟨22, by decide⟩, (1 : Int)), (⟨23, by decide⟩, (-1 : Int)), (⟨70, by decide⟩, (-1 : Int)), (⟨71, by decide⟩, (1 : Int))] -- /M/114 + else + if i.val < 116 then + [(⟨22, by decide⟩, (1 : Int)), (⟨23, by decide⟩, (-1 : Int)), (⟨74, by decide⟩, (-1 : Int)), (⟨75, by decide⟩, (1 : Int))] -- /M/115 + else + [(⟨21, by decide⟩, (1 : Int)), (⟨22, by decide⟩, (-1 : Int)), (⟨84, by decide⟩, (-1 : Int)), (⟨86, by decide⟩, (1 : Int))] -- /M/116 + else + if i.val < 121 then + if i.val < 119 then + if i.val < 118 then + [(⟨21, by decide⟩, (1 : Int)), (⟨22, by decide⟩, (-1 : Int)), (⟨88, by decide⟩, (-1 : Int)), (⟨90, by decide⟩, (1 : Int))] -- /M/117 + else + [(⟨21, by decide⟩, (1 : Int)), (⟨23, by decide⟩, (-1 : Int)), (⟨92, by decide⟩, (-1 : Int)), (⟨94, by decide⟩, (1 : Int))] -- /M/118 + else + if i.val < 120 then + [(⟨21, by decide⟩, (1 : Int)), (⟨23, by decide⟩, (-1 : Int)), (⟨96, by decide⟩, (-1 : Int)), (⟨98, by decide⟩, (1 : Int))] -- /M/119 + else + [(⟨22, by decide⟩, (1 : Int)), (⟨23, by decide⟩, (-1 : Int)), (⟨100, by decide⟩, (-1 : Int)), (⟨102, by decide⟩, (1 : Int))] -- /M/120 + else + if i.val < 123 then + if i.val < 122 then + [(⟨24, by decide⟩, (1 : Int)), (⟨25, by decide⟩, (-1 : Int)), (⟨28, by decide⟩, (-1 : Int)), (⟨29, by decide⟩, (1 : Int))] -- /M/121 + else + [(⟨24, by decide⟩, (1 : Int)), (⟨25, by decide⟩, (-1 : Int)), (⟨32, by decide⟩, (-1 : Int)), (⟨33, by decide⟩, (1 : Int))] -- /M/122 + else + if i.val < 124 then + [(⟨24, by decide⟩, (1 : Int)), (⟨26, by decide⟩, (-1 : Int)), (⟨36, by decide⟩, (-1 : Int)), (⟨38, by decide⟩, (1 : Int))] -- /M/123 + else + if i.val < 125 then + [(⟨24, by decide⟩, (1 : Int)), (⟨26, by decide⟩, (-1 : Int)), (⟨40, by decide⟩, (-1 : Int)), (⟨42, by decide⟩, (1 : Int))] -- /M/124 + else + [(⟨24, by decide⟩, (1 : Int)), (⟨27, by decide⟩, (-1 : Int)), (⟨44, by decide⟩, (-1 : Int)), (⟨47, by decide⟩, (1 : Int))] -- /M/125 + else + if i.val < 135 then + if i.val < 130 then + if i.val < 128 then + if i.val < 127 then + [(⟨24, by decide⟩, (1 : Int)), (⟨27, by decide⟩, (-1 : Int)), (⟨48, by decide⟩, (-1 : Int)), (⟨51, by decide⟩, (1 : Int))] -- /M/126 + else + [(⟨25, by decide⟩, (1 : Int)), (⟨26, by decide⟩, (-1 : Int)), (⟨53, by decide⟩, (-1 : Int)), (⟨54, by decide⟩, (1 : Int))] -- /M/127 + else + if i.val < 129 then + [(⟨25, by decide⟩, (1 : Int)), (⟨26, by decide⟩, (-1 : Int)), (⟨57, by decide⟩, (-1 : Int)), (⟨58, by decide⟩, (1 : Int))] -- /M/128 + else + [(⟨25, by decide⟩, (1 : Int)), (⟨27, by decide⟩, (-1 : Int)), (⟨61, by decide⟩, (-1 : Int)), (⟨63, by decide⟩, (1 : Int))] -- /M/129 + else + if i.val < 132 then + if i.val < 131 then + [(⟨25, by decide⟩, (1 : Int)), (⟨27, by decide⟩, (-1 : Int)), (⟨65, by decide⟩, (-1 : Int)), (⟨67, by decide⟩, (1 : Int))] -- /M/130 + else + [(⟨26, by decide⟩, (1 : Int)), (⟨27, by decide⟩, (-1 : Int)), (⟨70, by decide⟩, (-1 : Int)), (⟨71, by decide⟩, (1 : Int))] -- /M/131 + else + if i.val < 133 then + [(⟨26, by decide⟩, (1 : Int)), (⟨27, by decide⟩, (-1 : Int)), (⟨74, by decide⟩, (-1 : Int)), (⟨75, by decide⟩, (1 : Int))] -- /M/132 + else + if i.val < 134 then + [(⟨25, by decide⟩, (1 : Int)), (⟨26, by decide⟩, (-1 : Int)), (⟨84, by decide⟩, (-1 : Int)), (⟨86, by decide⟩, (1 : Int))] -- /M/133 + else + [(⟨25, by decide⟩, (1 : Int)), (⟨26, by decide⟩, (-1 : Int)), (⟨88, by decide⟩, (-1 : Int)), (⟨90, by decide⟩, (1 : Int))] -- /M/134 + else + if i.val < 139 then + if i.val < 137 then + if i.val < 136 then + [(⟨25, by decide⟩, (1 : Int)), (⟨27, by decide⟩, (-1 : Int)), (⟨92, by decide⟩, (-1 : Int)), (⟨94, by decide⟩, (1 : Int))] -- /M/135 + else + [(⟨25, by decide⟩, (1 : Int)), (⟨27, by decide⟩, (-1 : Int)), (⟨96, by decide⟩, (-1 : Int)), (⟨98, by decide⟩, (1 : Int))] -- /M/136 + else + if i.val < 138 then + [(⟨26, by decide⟩, (1 : Int)), (⟨27, by decide⟩, (-1 : Int)), (⟨100, by decide⟩, (-1 : Int)), (⟨102, by decide⟩, (1 : Int))] -- /M/137 + else + [(⟨28, by decide⟩, (1 : Int)), (⟨31, by decide⟩, (-1 : Int)), (⟨36, by decide⟩, (-1 : Int)), (⟨39, by decide⟩, (1 : Int))] -- /M/138 + else + if i.val < 141 then + if i.val < 140 then + [(⟨28, by decide⟩, (1 : Int)), (⟨31, by decide⟩, (-1 : Int)), (⟨40, by decide⟩, (-1 : Int)), (⟨43, by decide⟩, (1 : Int))] -- /M/139 + else + [(⟨28, by decide⟩, (1 : Int)), (⟨30, by decide⟩, (-1 : Int)), (⟨44, by decide⟩, (-1 : Int)), (⟨46, by decide⟩, (1 : Int))] -- /M/140 + else + if i.val < 142 then + [(⟨28, by decide⟩, (1 : Int)), (⟨30, by decide⟩, (-1 : Int)), (⟨48, by decide⟩, (-1 : Int)), (⟨50, by decide⟩, (1 : Int))] -- /M/141 + else + if i.val < 143 then + [(⟨29, by decide⟩, (1 : Int)), (⟨31, by decide⟩, (-1 : Int)), (⟨53, by decide⟩, (-1 : Int)), (⟨55, by decide⟩, (1 : Int))] -- /M/142 + else + [(⟨29, by decide⟩, (1 : Int)), (⟨31, by decide⟩, (-1 : Int)), (⟨57, by decide⟩, (-1 : Int)), (⟨59, by decide⟩, (1 : Int))] -- /M/143 + else + if i.val < 216 then + if i.val < 180 then + if i.val < 162 then + if i.val < 153 then + if i.val < 148 then + if i.val < 146 then + if i.val < 145 then + [(⟨29, by decide⟩, (1 : Int)), (⟨30, by decide⟩, (-1 : Int)), (⟨61, by decide⟩, (-1 : Int)), (⟨62, by decide⟩, (1 : Int))] -- /M/144 + else + [(⟨29, by decide⟩, (1 : Int)), (⟨30, by decide⟩, (-1 : Int)), (⟨65, by decide⟩, (-1 : Int)), (⟨66, by decide⟩, (1 : Int))] -- /M/145 + else + if i.val < 147 then + [(⟨30, by decide⟩, (1 : Int)), (⟨31, by decide⟩, (-1 : Int)), (⟨78, by decide⟩, (-1 : Int)), (⟨79, by decide⟩, (1 : Int))] -- /M/146 + else + [(⟨30, by decide⟩, (1 : Int)), (⟨31, by decide⟩, (-1 : Int)), (⟨82, by decide⟩, (-1 : Int)), (⟨83, by decide⟩, (1 : Int))] -- /M/147 + else + if i.val < 150 then + if i.val < 149 then + [(⟨29, by decide⟩, (1 : Int)), (⟨30, by decide⟩, (-1 : Int)), (⟨84, by decide⟩, (-1 : Int)), (⟨87, by decide⟩, (1 : Int))] -- /M/148 + else + [(⟨29, by decide⟩, (1 : Int)), (⟨30, by decide⟩, (-1 : Int)), (⟨88, by decide⟩, (-1 : Int)), (⟨91, by decide⟩, (1 : Int))] -- /M/149 + else + if i.val < 151 then + [(⟨29, by decide⟩, (1 : Int)), (⟨31, by decide⟩, (-1 : Int)), (⟨92, by decide⟩, (-1 : Int)), (⟨95, by decide⟩, (1 : Int))] -- /M/150 + else + if i.val < 152 then + [(⟨29, by decide⟩, (1 : Int)), (⟨31, by decide⟩, (-1 : Int)), (⟨96, by decide⟩, (-1 : Int)), (⟨99, by decide⟩, (1 : Int))] -- /M/151 + else + [(⟨30, by decide⟩, (1 : Int)), (⟨31, by decide⟩, (-1 : Int)), (⟨101, by decide⟩, (-1 : Int)), (⟨103, by decide⟩, (1 : Int))] -- /M/152 + else + if i.val < 157 then + if i.val < 155 then + if i.val < 154 then + [(⟨32, by decide⟩, (1 : Int)), (⟨35, by decide⟩, (-1 : Int)), (⟨36, by decide⟩, (-1 : Int)), (⟨39, by decide⟩, (1 : Int))] -- /M/153 + else + [(⟨32, by decide⟩, (1 : Int)), (⟨35, by decide⟩, (-1 : Int)), (⟨40, by decide⟩, (-1 : Int)), (⟨43, by decide⟩, (1 : Int))] -- /M/154 + else + if i.val < 156 then + [(⟨32, by decide⟩, (1 : Int)), (⟨34, by decide⟩, (-1 : Int)), (⟨44, by decide⟩, (-1 : Int)), (⟨46, by decide⟩, (1 : Int))] -- /M/155 + else + [(⟨32, by decide⟩, (1 : Int)), (⟨34, by decide⟩, (-1 : Int)), (⟨48, by decide⟩, (-1 : Int)), (⟨50, by decide⟩, (1 : Int))] -- /M/156 + else + if i.val < 159 then + if i.val < 158 then + [(⟨33, by decide⟩, (1 : Int)), (⟨35, by decide⟩, (-1 : Int)), (⟨53, by decide⟩, (-1 : Int)), (⟨55, by decide⟩, (1 : Int))] -- /M/157 + else + [(⟨33, by decide⟩, (1 : Int)), (⟨35, by decide⟩, (-1 : Int)), (⟨57, by decide⟩, (-1 : Int)), (⟨59, by decide⟩, (1 : Int))] -- /M/158 + else + if i.val < 160 then + [(⟨33, by decide⟩, (1 : Int)), (⟨34, by decide⟩, (-1 : Int)), (⟨61, by decide⟩, (-1 : Int)), (⟨62, by decide⟩, (1 : Int))] -- /M/159 + else + if i.val < 161 then + [(⟨33, by decide⟩, (1 : Int)), (⟨34, by decide⟩, (-1 : Int)), (⟨65, by decide⟩, (-1 : Int)), (⟨66, by decide⟩, (1 : Int))] -- /M/160 + else + [(⟨34, by decide⟩, (1 : Int)), (⟨35, by decide⟩, (-1 : Int)), (⟨78, by decide⟩, (-1 : Int)), (⟨79, by decide⟩, (1 : Int))] -- /M/161 + else + if i.val < 171 then + if i.val < 166 then + if i.val < 164 then + if i.val < 163 then + [(⟨34, by decide⟩, (1 : Int)), (⟨35, by decide⟩, (-1 : Int)), (⟨82, by decide⟩, (-1 : Int)), (⟨83, by decide⟩, (1 : Int))] -- /M/162 + else + [(⟨33, by decide⟩, (1 : Int)), (⟨34, by decide⟩, (-1 : Int)), (⟨84, by decide⟩, (-1 : Int)), (⟨87, by decide⟩, (1 : Int))] -- /M/163 + else + if i.val < 165 then + [(⟨33, by decide⟩, (1 : Int)), (⟨34, by decide⟩, (-1 : Int)), (⟨88, by decide⟩, (-1 : Int)), (⟨91, by decide⟩, (1 : Int))] -- /M/164 + else + [(⟨33, by decide⟩, (1 : Int)), (⟨35, by decide⟩, (-1 : Int)), (⟨92, by decide⟩, (-1 : Int)), (⟨95, by decide⟩, (1 : Int))] -- /M/165 + else + if i.val < 168 then + if i.val < 167 then + [(⟨33, by decide⟩, (1 : Int)), (⟨35, by decide⟩, (-1 : Int)), (⟨96, by decide⟩, (-1 : Int)), (⟨99, by decide⟩, (1 : Int))] -- /M/166 + else + [(⟨34, by decide⟩, (1 : Int)), (⟨35, by decide⟩, (-1 : Int)), (⟨101, by decide⟩, (-1 : Int)), (⟨103, by decide⟩, (1 : Int))] -- /M/167 + else + if i.val < 169 then + [(⟨36, by decide⟩, (1 : Int)), (⟨37, by decide⟩, (-1 : Int)), (⟨44, by decide⟩, (-1 : Int)), (⟨45, by decide⟩, (1 : Int))] -- /M/168 + else + if i.val < 170 then + [(⟨36, by decide⟩, (1 : Int)), (⟨37, by decide⟩, (-1 : Int)), (⟨48, by decide⟩, (-1 : Int)), (⟨49, by decide⟩, (1 : Int))] -- /M/169 + else + [(⟨38, by decide⟩, (1 : Int)), (⟨39, by decide⟩, (-1 : Int)), (⟨54, by decide⟩, (-1 : Int)), (⟨55, by decide⟩, (1 : Int))] -- /M/170 + else + if i.val < 175 then + if i.val < 173 then + if i.val < 172 then + [(⟨38, by decide⟩, (1 : Int)), (⟨39, by decide⟩, (-1 : Int)), (⟨58, by decide⟩, (-1 : Int)), (⟨59, by decide⟩, (1 : Int))] -- /M/171 + else + [(⟨37, by decide⟩, (1 : Int)), (⟨38, by decide⟩, (-1 : Int)), (⟨69, by decide⟩, (-1 : Int)), (⟨70, by decide⟩, (1 : Int))] -- /M/172 + else + if i.val < 174 then + [(⟨37, by decide⟩, (1 : Int)), (⟨38, by decide⟩, (-1 : Int)), (⟨73, by decide⟩, (-1 : Int)), (⟨74, by decide⟩, (1 : Int))] -- /M/173 + else + [(⟨37, by decide⟩, (1 : Int)), (⟨39, by decide⟩, (-1 : Int)), (⟨77, by decide⟩, (-1 : Int)), (⟨79, by decide⟩, (1 : Int))] -- /M/174 + else + if i.val < 177 then + if i.val < 176 then + [(⟨37, by decide⟩, (1 : Int)), (⟨39, by decide⟩, (-1 : Int)), (⟨81, by decide⟩, (-1 : Int)), (⟨83, by decide⟩, (1 : Int))] -- /M/175 + else + [(⟨37, by decide⟩, (1 : Int)), (⟨38, by decide⟩, (-1 : Int)), (⟨85, by decide⟩, (-1 : Int)), (⟨86, by decide⟩, (1 : Int))] -- /M/176 + else + if i.val < 178 then + [(⟨37, by decide⟩, (1 : Int)), (⟨38, by decide⟩, (-1 : Int)), (⟨89, by decide⟩, (-1 : Int)), (⟨90, by decide⟩, (1 : Int))] -- /M/177 + else + if i.val < 179 then + [(⟨37, by decide⟩, (1 : Int)), (⟨39, by decide⟩, (-1 : Int)), (⟨93, by decide⟩, (-1 : Int)), (⟨95, by decide⟩, (1 : Int))] -- /M/178 + else + [(⟨37, by decide⟩, (1 : Int)), (⟨39, by decide⟩, (-1 : Int)), (⟨97, by decide⟩, (-1 : Int)), (⟨99, by decide⟩, (1 : Int))] -- /M/179 + else + if i.val < 198 then + if i.val < 189 then + if i.val < 184 then + if i.val < 182 then + if i.val < 181 then + [(⟨38, by decide⟩, (1 : Int)), (⟨39, by decide⟩, (-1 : Int)), (⟨100, by decide⟩, (-1 : Int)), (⟨103, by decide⟩, (1 : Int))] -- /M/180 + else + [(⟨40, by decide⟩, (1 : Int)), (⟨41, by decide⟩, (-1 : Int)), (⟨44, by decide⟩, (-1 : Int)), (⟨45, by decide⟩, (1 : Int))] -- /M/181 + else + if i.val < 183 then + [(⟨40, by decide⟩, (1 : Int)), (⟨41, by decide⟩, (-1 : Int)), (⟨48, by decide⟩, (-1 : Int)), (⟨49, by decide⟩, (1 : Int))] -- /M/182 + else + [(⟨42, by decide⟩, (1 : Int)), (⟨43, by decide⟩, (-1 : Int)), (⟨54, by decide⟩, (-1 : Int)), (⟨55, by decide⟩, (1 : Int))] -- /M/183 + else + if i.val < 186 then + if i.val < 185 then + [(⟨42, by decide⟩, (1 : Int)), (⟨43, by decide⟩, (-1 : Int)), (⟨58, by decide⟩, (-1 : Int)), (⟨59, by decide⟩, (1 : Int))] -- /M/184 + else + [(⟨41, by decide⟩, (1 : Int)), (⟨42, by decide⟩, (-1 : Int)), (⟨69, by decide⟩, (-1 : Int)), (⟨70, by decide⟩, (1 : Int))] -- /M/185 + else + if i.val < 187 then + [(⟨41, by decide⟩, (1 : Int)), (⟨42, by decide⟩, (-1 : Int)), (⟨73, by decide⟩, (-1 : Int)), (⟨74, by decide⟩, (1 : Int))] -- /M/186 + else + if i.val < 188 then + [(⟨41, by decide⟩, (1 : Int)), (⟨43, by decide⟩, (-1 : Int)), (⟨77, by decide⟩, (-1 : Int)), (⟨79, by decide⟩, (1 : Int))] -- /M/187 + else + [(⟨41, by decide⟩, (1 : Int)), (⟨43, by decide⟩, (-1 : Int)), (⟨81, by decide⟩, (-1 : Int)), (⟨83, by decide⟩, (1 : Int))] -- /M/188 + else + if i.val < 193 then + if i.val < 191 then + if i.val < 190 then + [(⟨41, by decide⟩, (1 : Int)), (⟨42, by decide⟩, (-1 : Int)), (⟨85, by decide⟩, (-1 : Int)), (⟨86, by decide⟩, (1 : Int))] -- /M/189 + else + [(⟨41, by decide⟩, (1 : Int)), (⟨42, by decide⟩, (-1 : Int)), (⟨89, by decide⟩, (-1 : Int)), (⟨90, by decide⟩, (1 : Int))] -- /M/190 + else + if i.val < 192 then + [(⟨41, by decide⟩, (1 : Int)), (⟨43, by decide⟩, (-1 : Int)), (⟨93, by decide⟩, (-1 : Int)), (⟨95, by decide⟩, (1 : Int))] -- /M/191 + else + [(⟨41, by decide⟩, (1 : Int)), (⟨43, by decide⟩, (-1 : Int)), (⟨97, by decide⟩, (-1 : Int)), (⟨99, by decide⟩, (1 : Int))] -- /M/192 + else + if i.val < 195 then + if i.val < 194 then + [(⟨42, by decide⟩, (1 : Int)), (⟨43, by decide⟩, (-1 : Int)), (⟨100, by decide⟩, (-1 : Int)), (⟨103, by decide⟩, (1 : Int))] -- /M/193 + else + [(⟨46, by decide⟩, (1 : Int)), (⟨47, by decide⟩, (-1 : Int)), (⟨62, by decide⟩, (-1 : Int)), (⟨63, by decide⟩, (1 : Int))] -- /M/194 + else + if i.val < 196 then + [(⟨46, by decide⟩, (1 : Int)), (⟨47, by decide⟩, (-1 : Int)), (⟨66, by decide⟩, (-1 : Int)), (⟨67, by decide⟩, (1 : Int))] -- /M/195 + else + if i.val < 197 then + [(⟨45, by decide⟩, (1 : Int)), (⟨47, by decide⟩, (-1 : Int)), (⟨69, by decide⟩, (-1 : Int)), (⟨71, by decide⟩, (1 : Int))] -- /M/196 + else + [(⟨45, by decide⟩, (1 : Int)), (⟨47, by decide⟩, (-1 : Int)), (⟨73, by decide⟩, (-1 : Int)), (⟨75, by decide⟩, (1 : Int))] -- /M/197 + else + if i.val < 207 then + if i.val < 202 then + if i.val < 200 then + if i.val < 199 then + [(⟨45, by decide⟩, (1 : Int)), (⟨46, by decide⟩, (-1 : Int)), (⟨77, by decide⟩, (-1 : Int)), (⟨78, by decide⟩, (1 : Int))] -- /M/198 + else + [(⟨45, by decide⟩, (1 : Int)), (⟨46, by decide⟩, (-1 : Int)), (⟨81, by decide⟩, (-1 : Int)), (⟨82, by decide⟩, (1 : Int))] -- /M/199 + else + if i.val < 201 then + [(⟨45, by decide⟩, (1 : Int)), (⟨46, by decide⟩, (-1 : Int)), (⟨85, by decide⟩, (-1 : Int)), (⟨87, by decide⟩, (1 : Int))] -- /M/200 + else + [(⟨45, by decide⟩, (1 : Int)), (⟨46, by decide⟩, (-1 : Int)), (⟨89, by decide⟩, (-1 : Int)), (⟨91, by decide⟩, (1 : Int))] -- /M/201 + else + if i.val < 204 then + if i.val < 203 then + [(⟨45, by decide⟩, (1 : Int)), (⟨47, by decide⟩, (-1 : Int)), (⟨93, by decide⟩, (-1 : Int)), (⟨94, by decide⟩, (1 : Int))] -- /M/202 + else + [(⟨45, by decide⟩, (1 : Int)), (⟨47, by decide⟩, (-1 : Int)), (⟨97, by decide⟩, (-1 : Int)), (⟨98, by decide⟩, (1 : Int))] -- /M/203 + else + if i.val < 205 then + [(⟨46, by decide⟩, (1 : Int)), (⟨47, by decide⟩, (-1 : Int)), (⟨101, by decide⟩, (-1 : Int)), (⟨102, by decide⟩, (1 : Int))] -- /M/204 + else + if i.val < 206 then + [(⟨50, by decide⟩, (1 : Int)), (⟨51, by decide⟩, (-1 : Int)), (⟨62, by decide⟩, (-1 : Int)), (⟨63, by decide⟩, (1 : Int))] -- /M/205 + else + [(⟨50, by decide⟩, (1 : Int)), (⟨51, by decide⟩, (-1 : Int)), (⟨66, by decide⟩, (-1 : Int)), (⟨67, by decide⟩, (1 : Int))] -- /M/206 + else + if i.val < 211 then + if i.val < 209 then + if i.val < 208 then + [(⟨49, by decide⟩, (1 : Int)), (⟨51, by decide⟩, (-1 : Int)), (⟨69, by decide⟩, (-1 : Int)), (⟨71, by decide⟩, (1 : Int))] -- /M/207 + else + [(⟨49, by decide⟩, (1 : Int)), (⟨51, by decide⟩, (-1 : Int)), (⟨73, by decide⟩, (-1 : Int)), (⟨75, by decide⟩, (1 : Int))] -- /M/208 + else + if i.val < 210 then + [(⟨49, by decide⟩, (1 : Int)), (⟨50, by decide⟩, (-1 : Int)), (⟨77, by decide⟩, (-1 : Int)), (⟨78, by decide⟩, (1 : Int))] -- /M/209 + else + [(⟨49, by decide⟩, (1 : Int)), (⟨50, by decide⟩, (-1 : Int)), (⟨81, by decide⟩, (-1 : Int)), (⟨82, by decide⟩, (1 : Int))] -- /M/210 + else + if i.val < 213 then + if i.val < 212 then + [(⟨49, by decide⟩, (1 : Int)), (⟨50, by decide⟩, (-1 : Int)), (⟨85, by decide⟩, (-1 : Int)), (⟨87, by decide⟩, (1 : Int))] -- /M/211 + else + [(⟨49, by decide⟩, (1 : Int)), (⟨50, by decide⟩, (-1 : Int)), (⟨89, by decide⟩, (-1 : Int)), (⟨91, by decide⟩, (1 : Int))] -- /M/212 + else + if i.val < 214 then + [(⟨49, by decide⟩, (1 : Int)), (⟨51, by decide⟩, (-1 : Int)), (⟨93, by decide⟩, (-1 : Int)), (⟨94, by decide⟩, (1 : Int))] -- /M/213 + else + if i.val < 215 then + [(⟨49, by decide⟩, (1 : Int)), (⟨51, by decide⟩, (-1 : Int)), (⟨97, by decide⟩, (-1 : Int)), (⟨98, by decide⟩, (1 : Int))] -- /M/214 + else + [(⟨50, by decide⟩, (1 : Int)), (⟨51, by decide⟩, (-1 : Int)), (⟨101, by decide⟩, (-1 : Int)), (⟨102, by decide⟩, (1 : Int))] -- /M/215 + else + if i.val < 252 then + if i.val < 234 then + if i.val < 225 then + if i.val < 220 then + if i.val < 218 then + if i.val < 217 then + [(⟨52, by decide⟩, (1 : Int)), (⟨53, by decide⟩, (-1 : Int)), (⟨60, by decide⟩, (-1 : Int)), (⟨61, by decide⟩, (1 : Int))] -- /M/216 + else + [(⟨52, by decide⟩, (1 : Int)), (⟨53, by decide⟩, (-1 : Int)), (⟨64, by decide⟩, (-1 : Int)), (⟨65, by decide⟩, (1 : Int))] -- /M/217 + else + if i.val < 219 then + [(⟨52, by decide⟩, (1 : Int)), (⟨54, by decide⟩, (-1 : Int)), (⟨68, by decide⟩, (-1 : Int)), (⟨70, by decide⟩, (1 : Int))] -- /M/218 + else + [(⟨52, by decide⟩, (1 : Int)), (⟨54, by decide⟩, (-1 : Int)), (⟨72, by decide⟩, (-1 : Int)), (⟨74, by decide⟩, (1 : Int))] -- /M/219 + else + if i.val < 222 then + if i.val < 221 then + [(⟨52, by decide⟩, (1 : Int)), (⟨55, by decide⟩, (-1 : Int)), (⟨76, by decide⟩, (-1 : Int)), (⟨79, by decide⟩, (1 : Int))] -- /M/220 + else + [(⟨52, by decide⟩, (1 : Int)), (⟨55, by decide⟩, (-1 : Int)), (⟨80, by decide⟩, (-1 : Int)), (⟨83, by decide⟩, (1 : Int))] -- /M/221 + else + if i.val < 223 then + [(⟨53, by decide⟩, (1 : Int)), (⟨54, by decide⟩, (-1 : Int)), (⟨84, by decide⟩, (-1 : Int)), (⟨86, by decide⟩, (1 : Int))] -- /M/222 + else + if i.val < 224 then + [(⟨53, by decide⟩, (1 : Int)), (⟨54, by decide⟩, (-1 : Int)), (⟨88, by decide⟩, (-1 : Int)), (⟨90, by decide⟩, (1 : Int))] -- /M/223 + else + [(⟨53, by decide⟩, (1 : Int)), (⟨55, by decide⟩, (-1 : Int)), (⟨92, by decide⟩, (-1 : Int)), (⟨95, by decide⟩, (1 : Int))] -- /M/224 + else + if i.val < 229 then + if i.val < 227 then + if i.val < 226 then + [(⟨53, by decide⟩, (1 : Int)), (⟨55, by decide⟩, (-1 : Int)), (⟨96, by decide⟩, (-1 : Int)), (⟨99, by decide⟩, (1 : Int))] -- /M/225 + else + [(⟨54, by decide⟩, (1 : Int)), (⟨55, by decide⟩, (-1 : Int)), (⟨100, by decide⟩, (-1 : Int)), (⟨103, by decide⟩, (1 : Int))] -- /M/226 + else + if i.val < 228 then + [(⟨56, by decide⟩, (1 : Int)), (⟨57, by decide⟩, (-1 : Int)), (⟨60, by decide⟩, (-1 : Int)), (⟨61, by decide⟩, (1 : Int))] -- /M/227 + else + [(⟨56, by decide⟩, (1 : Int)), (⟨57, by decide⟩, (-1 : Int)), (⟨64, by decide⟩, (-1 : Int)), (⟨65, by decide⟩, (1 : Int))] -- /M/228 + else + if i.val < 231 then + if i.val < 230 then + [(⟨56, by decide⟩, (1 : Int)), (⟨58, by decide⟩, (-1 : Int)), (⟨68, by decide⟩, (-1 : Int)), (⟨70, by decide⟩, (1 : Int))] -- /M/229 + else + [(⟨56, by decide⟩, (1 : Int)), (⟨58, by decide⟩, (-1 : Int)), (⟨72, by decide⟩, (-1 : Int)), (⟨74, by decide⟩, (1 : Int))] -- /M/230 + else + if i.val < 232 then + [(⟨56, by decide⟩, (1 : Int)), (⟨59, by decide⟩, (-1 : Int)), (⟨76, by decide⟩, (-1 : Int)), (⟨79, by decide⟩, (1 : Int))] -- /M/231 + else + if i.val < 233 then + [(⟨56, by decide⟩, (1 : Int)), (⟨59, by decide⟩, (-1 : Int)), (⟨80, by decide⟩, (-1 : Int)), (⟨83, by decide⟩, (1 : Int))] -- /M/232 + else + [(⟨57, by decide⟩, (1 : Int)), (⟨58, by decide⟩, (-1 : Int)), (⟨84, by decide⟩, (-1 : Int)), (⟨86, by decide⟩, (1 : Int))] -- /M/233 + else + if i.val < 243 then + if i.val < 238 then + if i.val < 236 then + if i.val < 235 then + [(⟨57, by decide⟩, (1 : Int)), (⟨58, by decide⟩, (-1 : Int)), (⟨88, by decide⟩, (-1 : Int)), (⟨90, by decide⟩, (1 : Int))] -- /M/234 + else + [(⟨57, by decide⟩, (1 : Int)), (⟨59, by decide⟩, (-1 : Int)), (⟨92, by decide⟩, (-1 : Int)), (⟨95, by decide⟩, (1 : Int))] -- /M/235 + else + if i.val < 237 then + [(⟨57, by decide⟩, (1 : Int)), (⟨59, by decide⟩, (-1 : Int)), (⟨96, by decide⟩, (-1 : Int)), (⟨99, by decide⟩, (1 : Int))] -- /M/236 + else + [(⟨58, by decide⟩, (1 : Int)), (⟨59, by decide⟩, (-1 : Int)), (⟨100, by decide⟩, (-1 : Int)), (⟨103, by decide⟩, (1 : Int))] -- /M/237 + else + if i.val < 240 then + if i.val < 239 then + [(⟨60, by decide⟩, (1 : Int)), (⟨63, by decide⟩, (-1 : Int)), (⟨68, by decide⟩, (-1 : Int)), (⟨71, by decide⟩, (1 : Int))] -- /M/238 + else + [(⟨60, by decide⟩, (1 : Int)), (⟨63, by decide⟩, (-1 : Int)), (⟨72, by decide⟩, (-1 : Int)), (⟨75, by decide⟩, (1 : Int))] -- /M/239 + else + if i.val < 241 then + [(⟨60, by decide⟩, (1 : Int)), (⟨62, by decide⟩, (-1 : Int)), (⟨76, by decide⟩, (-1 : Int)), (⟨78, by decide⟩, (1 : Int))] -- /M/240 + else + if i.val < 242 then + [(⟨60, by decide⟩, (1 : Int)), (⟨62, by decide⟩, (-1 : Int)), (⟨80, by decide⟩, (-1 : Int)), (⟨82, by decide⟩, (1 : Int))] -- /M/241 + else + [(⟨61, by decide⟩, (1 : Int)), (⟨62, by decide⟩, (-1 : Int)), (⟨84, by decide⟩, (-1 : Int)), (⟨87, by decide⟩, (1 : Int))] -- /M/242 + else + if i.val < 247 then + if i.val < 245 then + if i.val < 244 then + [(⟨61, by decide⟩, (1 : Int)), (⟨62, by decide⟩, (-1 : Int)), (⟨88, by decide⟩, (-1 : Int)), (⟨91, by decide⟩, (1 : Int))] -- /M/243 + else + [(⟨61, by decide⟩, (1 : Int)), (⟨63, by decide⟩, (-1 : Int)), (⟨92, by decide⟩, (-1 : Int)), (⟨94, by decide⟩, (1 : Int))] -- /M/244 + else + if i.val < 246 then + [(⟨61, by decide⟩, (1 : Int)), (⟨63, by decide⟩, (-1 : Int)), (⟨96, by decide⟩, (-1 : Int)), (⟨98, by decide⟩, (1 : Int))] -- /M/245 + else + [(⟨62, by decide⟩, (1 : Int)), (⟨63, by decide⟩, (-1 : Int)), (⟨101, by decide⟩, (-1 : Int)), (⟨102, by decide⟩, (1 : Int))] -- /M/246 + else + if i.val < 249 then + if i.val < 248 then + [(⟨64, by decide⟩, (1 : Int)), (⟨67, by decide⟩, (-1 : Int)), (⟨68, by decide⟩, (-1 : Int)), (⟨71, by decide⟩, (1 : Int))] -- /M/247 + else + [(⟨64, by decide⟩, (1 : Int)), (⟨67, by decide⟩, (-1 : Int)), (⟨72, by decide⟩, (-1 : Int)), (⟨75, by decide⟩, (1 : Int))] -- /M/248 + else + if i.val < 250 then + [(⟨64, by decide⟩, (1 : Int)), (⟨66, by decide⟩, (-1 : Int)), (⟨76, by decide⟩, (-1 : Int)), (⟨78, by decide⟩, (1 : Int))] -- /M/249 + else + if i.val < 251 then + [(⟨64, by decide⟩, (1 : Int)), (⟨66, by decide⟩, (-1 : Int)), (⟨80, by decide⟩, (-1 : Int)), (⟨82, by decide⟩, (1 : Int))] -- /M/250 + else + [(⟨65, by decide⟩, (1 : Int)), (⟨66, by decide⟩, (-1 : Int)), (⟨84, by decide⟩, (-1 : Int)), (⟨87, by decide⟩, (1 : Int))] -- /M/251 + else + if i.val < 270 then + if i.val < 261 then + if i.val < 256 then + if i.val < 254 then + if i.val < 253 then + [(⟨65, by decide⟩, (1 : Int)), (⟨66, by decide⟩, (-1 : Int)), (⟨88, by decide⟩, (-1 : Int)), (⟨91, by decide⟩, (1 : Int))] -- /M/252 + else + [(⟨65, by decide⟩, (1 : Int)), (⟨67, by decide⟩, (-1 : Int)), (⟨92, by decide⟩, (-1 : Int)), (⟨94, by decide⟩, (1 : Int))] -- /M/253 + else + if i.val < 255 then + [(⟨65, by decide⟩, (1 : Int)), (⟨67, by decide⟩, (-1 : Int)), (⟨96, by decide⟩, (-1 : Int)), (⟨98, by decide⟩, (1 : Int))] -- /M/254 + else + [(⟨66, by decide⟩, (1 : Int)), (⟨67, by decide⟩, (-1 : Int)), (⟨101, by decide⟩, (-1 : Int)), (⟨102, by decide⟩, (1 : Int))] -- /M/255 + else + if i.val < 258 then + if i.val < 257 then + [(⟨68, by decide⟩, (1 : Int)), (⟨69, by decide⟩, (-1 : Int)), (⟨76, by decide⟩, (-1 : Int)), (⟨77, by decide⟩, (1 : Int))] -- /M/256 + else + [(⟨68, by decide⟩, (1 : Int)), (⟨69, by decide⟩, (-1 : Int)), (⟨80, by decide⟩, (-1 : Int)), (⟨81, by decide⟩, (1 : Int))] -- /M/257 + else + if i.val < 259 then + [(⟨69, by decide⟩, (1 : Int)), (⟨70, by decide⟩, (-1 : Int)), (⟨85, by decide⟩, (-1 : Int)), (⟨86, by decide⟩, (1 : Int))] -- /M/258 + else + if i.val < 260 then + [(⟨69, by decide⟩, (1 : Int)), (⟨70, by decide⟩, (-1 : Int)), (⟨89, by decide⟩, (-1 : Int)), (⟨90, by decide⟩, (1 : Int))] -- /M/259 + else + [(⟨69, by decide⟩, (1 : Int)), (⟨71, by decide⟩, (-1 : Int)), (⟨93, by decide⟩, (-1 : Int)), (⟨94, by decide⟩, (1 : Int))] -- /M/260 + else + if i.val < 265 then + if i.val < 263 then + if i.val < 262 then + [(⟨69, by decide⟩, (1 : Int)), (⟨71, by decide⟩, (-1 : Int)), (⟨97, by decide⟩, (-1 : Int)), (⟨98, by decide⟩, (1 : Int))] -- /M/261 + else + [(⟨70, by decide⟩, (1 : Int)), (⟨71, by decide⟩, (-1 : Int)), (⟨100, by decide⟩, (-1 : Int)), (⟨102, by decide⟩, (1 : Int))] -- /M/262 + else + if i.val < 264 then + [(⟨72, by decide⟩, (1 : Int)), (⟨73, by decide⟩, (-1 : Int)), (⟨76, by decide⟩, (-1 : Int)), (⟨77, by decide⟩, (1 : Int))] -- /M/263 + else + [(⟨72, by decide⟩, (1 : Int)), (⟨73, by decide⟩, (-1 : Int)), (⟨80, by decide⟩, (-1 : Int)), (⟨81, by decide⟩, (1 : Int))] -- /M/264 + else + if i.val < 267 then + if i.val < 266 then + [(⟨73, by decide⟩, (1 : Int)), (⟨74, by decide⟩, (-1 : Int)), (⟨85, by decide⟩, (-1 : Int)), (⟨86, by decide⟩, (1 : Int))] -- /M/265 + else + [(⟨73, by decide⟩, (1 : Int)), (⟨74, by decide⟩, (-1 : Int)), (⟨89, by decide⟩, (-1 : Int)), (⟨90, by decide⟩, (1 : Int))] -- /M/266 + else + if i.val < 268 then + [(⟨73, by decide⟩, (1 : Int)), (⟨75, by decide⟩, (-1 : Int)), (⟨93, by decide⟩, (-1 : Int)), (⟨94, by decide⟩, (1 : Int))] -- /M/267 + else + if i.val < 269 then + [(⟨73, by decide⟩, (1 : Int)), (⟨75, by decide⟩, (-1 : Int)), (⟨97, by decide⟩, (-1 : Int)), (⟨98, by decide⟩, (1 : Int))] -- /M/268 + else + [(⟨74, by decide⟩, (1 : Int)), (⟨75, by decide⟩, (-1 : Int)), (⟨100, by decide⟩, (-1 : Int)), (⟨102, by decide⟩, (1 : Int))] -- /M/269 + else + if i.val < 279 then + if i.val < 274 then + if i.val < 272 then + if i.val < 271 then + [(⟨77, by decide⟩, (1 : Int)), (⟨78, by decide⟩, (-1 : Int)), (⟨85, by decide⟩, (-1 : Int)), (⟨87, by decide⟩, (1 : Int))] -- /M/270 + else + [(⟨77, by decide⟩, (1 : Int)), (⟨78, by decide⟩, (-1 : Int)), (⟨89, by decide⟩, (-1 : Int)), (⟨91, by decide⟩, (1 : Int))] -- /M/271 + else + if i.val < 273 then + [(⟨77, by decide⟩, (1 : Int)), (⟨79, by decide⟩, (-1 : Int)), (⟨93, by decide⟩, (-1 : Int)), (⟨95, by decide⟩, (1 : Int))] -- /M/272 + else + [(⟨77, by decide⟩, (1 : Int)), (⟨79, by decide⟩, (-1 : Int)), (⟨97, by decide⟩, (-1 : Int)), (⟨99, by decide⟩, (1 : Int))] -- /M/273 + else + if i.val < 276 then + if i.val < 275 then + [(⟨78, by decide⟩, (1 : Int)), (⟨79, by decide⟩, (-1 : Int)), (⟨101, by decide⟩, (-1 : Int)), (⟨103, by decide⟩, (1 : Int))] -- /M/274 + else + [(⟨81, by decide⟩, (1 : Int)), (⟨82, by decide⟩, (-1 : Int)), (⟨85, by decide⟩, (-1 : Int)), (⟨87, by decide⟩, (1 : Int))] -- /M/275 + else + if i.val < 277 then + [(⟨81, by decide⟩, (1 : Int)), (⟨82, by decide⟩, (-1 : Int)), (⟨89, by decide⟩, (-1 : Int)), (⟨91, by decide⟩, (1 : Int))] -- /M/276 + else + if i.val < 278 then + [(⟨81, by decide⟩, (1 : Int)), (⟨83, by decide⟩, (-1 : Int)), (⟨93, by decide⟩, (-1 : Int)), (⟨95, by decide⟩, (1 : Int))] -- /M/277 + else + [(⟨81, by decide⟩, (1 : Int)), (⟨83, by decide⟩, (-1 : Int)), (⟨97, by decide⟩, (-1 : Int)), (⟨99, by decide⟩, (1 : Int))] -- /M/278 + else + if i.val < 283 then + if i.val < 281 then + if i.val < 280 then + [(⟨82, by decide⟩, (1 : Int)), (⟨83, by decide⟩, (-1 : Int)), (⟨101, by decide⟩, (-1 : Int)), (⟨103, by decide⟩, (1 : Int))] -- /M/279 + else + [(⟨84, by decide⟩, (1 : Int)), (⟨85, by decide⟩, (-1 : Int)), (⟨92, by decide⟩, (-1 : Int)), (⟨93, by decide⟩, (1 : Int))] -- /M/280 + else + if i.val < 282 then + [(⟨84, by decide⟩, (1 : Int)), (⟨85, by decide⟩, (-1 : Int)), (⟨96, by decide⟩, (-1 : Int)), (⟨97, by decide⟩, (1 : Int))] -- /M/281 + else + [(⟨86, by decide⟩, (1 : Int)), (⟨87, by decide⟩, (-1 : Int)), (⟨100, by decide⟩, (-1 : Int)), (⟨101, by decide⟩, (1 : Int))] -- /M/282 + else + if i.val < 285 then + if i.val < 284 then + [(⟨88, by decide⟩, (1 : Int)), (⟨89, by decide⟩, (-1 : Int)), (⟨92, by decide⟩, (-1 : Int)), (⟨93, by decide⟩, (1 : Int))] -- /M/283 + else + [(⟨88, by decide⟩, (1 : Int)), (⟨89, by decide⟩, (-1 : Int)), (⟨96, by decide⟩, (-1 : Int)), (⟨97, by decide⟩, (1 : Int))] -- /M/284 + else + if i.val < 286 then + [(⟨90, by decide⟩, (1 : Int)), (⟨91, by decide⟩, (-1 : Int)), (⟨100, by decide⟩, (-1 : Int)), (⟨101, by decide⟩, (1 : Int))] -- /M/285 + else + if i.val < 287 then + [(⟨94, by decide⟩, (1 : Int)), (⟨95, by decide⟩, (-1 : Int)), (⟨102, by decide⟩, (-1 : Int)), (⟨103, by decide⟩, (1 : Int))] -- /M/286 + else + [(⟨98, by decide⟩, (1 : Int)), (⟨99, by decide⟩, (-1 : Int)), (⟨102, by decide⟩, (-1 : Int)), (⟨103, by decide⟩, (1 : Int))] -- /M/287 + +def M : Mat 288 104 := fun i => Sparse.row (M_entries i) + +/-- Original sparse P rows, in original row/entry order. -/ +def P_entries (i : Fin 104) : List (Fin 33 × Int) := + if i.val < 52 then + if i.val < 26 then + if i.val < 13 then + if i.val < 6 then + if i.val < 3 then + if i.val < 1 then + [(⟨0, by decide⟩, (1 : Int))] -- /P/0 + else + if i.val < 2 then + [(⟨0, by decide⟩, (1 : Int)), (⟨26, by decide⟩, (1 : Int))] -- /P/1 + else + [(⟨0, by decide⟩, (1 : Int)), (⟨27, by decide⟩, (1 : Int))] -- /P/2 + else + if i.val < 4 then + [(⟨0, by decide⟩, (1 : Int)), (⟨28, by decide⟩, (1 : Int))] -- /P/3 + else + if i.val < 5 then + [(⟨1, by decide⟩, (1 : Int))] -- /P/4 + else + [(⟨1, by decide⟩, (1 : Int)), (⟨26, by decide⟩, (1 : Int))] -- /P/5 + else + if i.val < 9 then + if i.val < 7 then + [(⟨1, by decide⟩, (1 : Int)), (⟨29, by decide⟩, (1 : Int))] -- /P/6 + else + if i.val < 8 then + [(⟨1, by decide⟩, (1 : Int)), (⟨30, by decide⟩, (1 : Int))] -- /P/7 + else + [(⟨2, by decide⟩, (1 : Int))] -- /P/8 + else + if i.val < 11 then + if i.val < 10 then + [(⟨2, by decide⟩, (1 : Int)), (⟨26, by decide⟩, (1 : Int))] -- /P/9 + else + [(⟨2, by decide⟩, (1 : Int)), (⟨29, by decide⟩, (1 : Int))] -- /P/10 + else + if i.val < 12 then + [(⟨2, by decide⟩, (1 : Int)), (⟨30, by decide⟩, (1 : Int))] -- /P/11 + else + [(⟨3, by decide⟩, (1 : Int))] -- /P/12 + else + if i.val < 19 then + if i.val < 16 then + if i.val < 14 then + [(⟨3, by decide⟩, (1 : Int)), (⟨26, by decide⟩, (1 : Int))] -- /P/13 + else + if i.val < 15 then + [(⟨3, by decide⟩, (1 : Int)), (⟨31, by decide⟩, (1 : Int))] -- /P/14 + else + [(⟨3, by decide⟩, (1 : Int)), (⟨32, by decide⟩, (1 : Int))] -- /P/15 + else + if i.val < 17 then + [(⟨4, by decide⟩, (1 : Int))] -- /P/16 + else + if i.val < 18 then + [(⟨4, by decide⟩, (1 : Int)), (⟨26, by decide⟩, (1 : Int))] -- /P/17 + else + [(⟨4, by decide⟩, (1 : Int)), (⟨31, by decide⟩, (1 : Int))] -- /P/18 + else + if i.val < 22 then + if i.val < 20 then + [(⟨4, by decide⟩, (1 : Int)), (⟨32, by decide⟩, (1 : Int))] -- /P/19 + else + if i.val < 21 then + [(⟨5, by decide⟩, (1 : Int))] -- /P/20 + else + [(⟨5, by decide⟩, (1 : Int)), (⟨27, by decide⟩, (1 : Int))] -- /P/21 + else + if i.val < 24 then + if i.val < 23 then + [(⟨5, by decide⟩, (1 : Int)), (⟨29, by decide⟩, (1 : Int))] -- /P/22 + else + [(⟨5, by decide⟩, (1 : Int)), (⟨31, by decide⟩, (1 : Int))] -- /P/23 + else + if i.val < 25 then + [(⟨6, by decide⟩, (1 : Int))] -- /P/24 + else + [(⟨6, by decide⟩, (1 : Int)), (⟨27, by decide⟩, (1 : Int))] -- /P/25 + else + if i.val < 39 then + if i.val < 32 then + if i.val < 29 then + if i.val < 27 then + [(⟨6, by decide⟩, (1 : Int)), (⟨29, by decide⟩, (1 : Int))] -- /P/26 + else + if i.val < 28 then + [(⟨6, by decide⟩, (1 : Int)), (⟨31, by decide⟩, (1 : Int))] -- /P/27 + else + [(⟨7, by decide⟩, (1 : Int))] -- /P/28 + else + if i.val < 30 then + [(⟨7, by decide⟩, (1 : Int)), (⟨27, by decide⟩, (1 : Int))] -- /P/29 + else + if i.val < 31 then + [(⟨7, by decide⟩, (1 : Int)), (⟨30, by decide⟩, (1 : Int))] -- /P/30 + else + [(⟨7, by decide⟩, (1 : Int)), (⟨32, by decide⟩, (1 : Int))] -- /P/31 + else + if i.val < 35 then + if i.val < 33 then + [(⟨8, by decide⟩, (1 : Int))] -- /P/32 + else + if i.val < 34 then + [(⟨8, by decide⟩, (1 : Int)), (⟨27, by decide⟩, (1 : Int))] -- /P/33 + else + [(⟨8, by decide⟩, (1 : Int)), (⟨30, by decide⟩, (1 : Int))] -- /P/34 + else + if i.val < 37 then + if i.val < 36 then + [(⟨8, by decide⟩, (1 : Int)), (⟨32, by decide⟩, (1 : Int))] -- /P/35 + else + [(⟨9, by decide⟩, (1 : Int))] -- /P/36 + else + if i.val < 38 then + [(⟨9, by decide⟩, (1 : Int)), (⟨28, by decide⟩, (1 : Int))] -- /P/37 + else + [(⟨9, by decide⟩, (1 : Int)), (⟨29, by decide⟩, (1 : Int))] -- /P/38 + else + if i.val < 45 then + if i.val < 42 then + if i.val < 40 then + [(⟨9, by decide⟩, (1 : Int)), (⟨32, by decide⟩, (1 : Int))] -- /P/39 + else + if i.val < 41 then + [(⟨10, by decide⟩, (1 : Int))] -- /P/40 + else + [(⟨10, by decide⟩, (1 : Int)), (⟨28, by decide⟩, (1 : Int))] -- /P/41 + else + if i.val < 43 then + [(⟨10, by decide⟩, (1 : Int)), (⟨29, by decide⟩, (1 : Int))] -- /P/42 + else + if i.val < 44 then + [(⟨10, by decide⟩, (1 : Int)), (⟨32, by decide⟩, (1 : Int))] -- /P/43 + else + [(⟨11, by decide⟩, (1 : Int))] -- /P/44 + else + if i.val < 48 then + if i.val < 46 then + [(⟨11, by decide⟩, (1 : Int)), (⟨28, by decide⟩, (1 : Int))] -- /P/45 + else + if i.val < 47 then + [(⟨11, by decide⟩, (1 : Int)), (⟨30, by decide⟩, (1 : Int))] -- /P/46 + else + [(⟨11, by decide⟩, (1 : Int)), (⟨31, by decide⟩, (1 : Int))] -- /P/47 + else + if i.val < 50 then + if i.val < 49 then + [(⟨12, by decide⟩, (1 : Int))] -- /P/48 + else + [(⟨12, by decide⟩, (1 : Int)), (⟨28, by decide⟩, (1 : Int))] -- /P/49 + else + if i.val < 51 then + [(⟨12, by decide⟩, (1 : Int)), (⟨30, by decide⟩, (1 : Int))] -- /P/50 + else + [(⟨12, by decide⟩, (1 : Int)), (⟨31, by decide⟩, (1 : Int))] -- /P/51 + else + if i.val < 78 then + if i.val < 65 then + if i.val < 58 then + if i.val < 55 then + if i.val < 53 then + [(⟨13, by decide⟩, (1 : Int)), (⟨26, by decide⟩, (1 : Int))] -- /P/52 + else + if i.val < 54 then + [(⟨13, by decide⟩, (1 : Int)), (⟨27, by decide⟩, (1 : Int))] -- /P/53 + else + [(⟨13, by decide⟩, (1 : Int)), (⟨29, by decide⟩, (1 : Int))] -- /P/54 + else + if i.val < 56 then + [(⟨13, by decide⟩, (1 : Int)), (⟨32, by decide⟩, (1 : Int))] -- /P/55 + else + if i.val < 57 then + [(⟨14, by decide⟩, (1 : Int)), (⟨26, by decide⟩, (1 : Int))] -- /P/56 + else + [(⟨14, by decide⟩, (1 : Int)), (⟨27, by decide⟩, (1 : Int))] -- /P/57 + else + if i.val < 61 then + if i.val < 59 then + [(⟨14, by decide⟩, (1 : Int)), (⟨29, by decide⟩, (1 : Int))] -- /P/58 + else + if i.val < 60 then + [(⟨14, by decide⟩, (1 : Int)), (⟨32, by decide⟩, (1 : Int))] -- /P/59 + else + [(⟨15, by decide⟩, (1 : Int)), (⟨26, by decide⟩, (1 : Int))] -- /P/60 + else + if i.val < 63 then + if i.val < 62 then + [(⟨15, by decide⟩, (1 : Int)), (⟨27, by decide⟩, (1 : Int))] -- /P/61 + else + [(⟨15, by decide⟩, (1 : Int)), (⟨30, by decide⟩, (1 : Int))] -- /P/62 + else + if i.val < 64 then + [(⟨15, by decide⟩, (1 : Int)), (⟨31, by decide⟩, (1 : Int))] -- /P/63 + else + [(⟨16, by decide⟩, (1 : Int)), (⟨26, by decide⟩, (1 : Int))] -- /P/64 + else + if i.val < 71 then + if i.val < 68 then + if i.val < 66 then + [(⟨16, by decide⟩, (1 : Int)), (⟨27, by decide⟩, (1 : Int))] -- /P/65 + else + if i.val < 67 then + [(⟨16, by decide⟩, (1 : Int)), (⟨30, by decide⟩, (1 : Int))] -- /P/66 + else + [(⟨16, by decide⟩, (1 : Int)), (⟨31, by decide⟩, (1 : Int))] -- /P/67 + else + if i.val < 69 then + [(⟨17, by decide⟩, (1 : Int)), (⟨26, by decide⟩, (1 : Int))] -- /P/68 + else + if i.val < 70 then + [(⟨17, by decide⟩, (1 : Int)), (⟨28, by decide⟩, (1 : Int))] -- /P/69 + else + [(⟨17, by decide⟩, (1 : Int)), (⟨29, by decide⟩, (1 : Int))] -- /P/70 + else + if i.val < 74 then + if i.val < 72 then + [(⟨17, by decide⟩, (1 : Int)), (⟨31, by decide⟩, (1 : Int))] -- /P/71 + else + if i.val < 73 then + [(⟨18, by decide⟩, (1 : Int)), (⟨26, by decide⟩, (1 : Int))] -- /P/72 + else + [(⟨18, by decide⟩, (1 : Int)), (⟨28, by decide⟩, (1 : Int))] -- /P/73 + else + if i.val < 76 then + if i.val < 75 then + [(⟨18, by decide⟩, (1 : Int)), (⟨29, by decide⟩, (1 : Int))] -- /P/74 + else + [(⟨18, by decide⟩, (1 : Int)), (⟨31, by decide⟩, (1 : Int))] -- /P/75 + else + if i.val < 77 then + [(⟨19, by decide⟩, (1 : Int)), (⟨26, by decide⟩, (1 : Int))] -- /P/76 + else + [(⟨19, by decide⟩, (1 : Int)), (⟨28, by decide⟩, (1 : Int))] -- /P/77 + else + if i.val < 91 then + if i.val < 84 then + if i.val < 81 then + if i.val < 79 then + [(⟨19, by decide⟩, (1 : Int)), (⟨30, by decide⟩, (1 : Int))] -- /P/78 + else + if i.val < 80 then + [(⟨19, by decide⟩, (1 : Int)), (⟨32, by decide⟩, (1 : Int))] -- /P/79 + else + [(⟨20, by decide⟩, (1 : Int)), (⟨26, by decide⟩, (1 : Int))] -- /P/80 + else + if i.val < 82 then + [(⟨20, by decide⟩, (1 : Int)), (⟨28, by decide⟩, (1 : Int))] -- /P/81 + else + if i.val < 83 then + [(⟨20, by decide⟩, (1 : Int)), (⟨30, by decide⟩, (1 : Int))] -- /P/82 + else + [(⟨20, by decide⟩, (1 : Int)), (⟨32, by decide⟩, (1 : Int))] -- /P/83 + else + if i.val < 87 then + if i.val < 85 then + [(⟨21, by decide⟩, (1 : Int)), (⟨27, by decide⟩, (1 : Int))] -- /P/84 + else + if i.val < 86 then + [(⟨21, by decide⟩, (1 : Int)), (⟨28, by decide⟩, (1 : Int))] -- /P/85 + else + [(⟨21, by decide⟩, (1 : Int)), (⟨29, by decide⟩, (1 : Int))] -- /P/86 + else + if i.val < 89 then + if i.val < 88 then + [(⟨21, by decide⟩, (1 : Int)), (⟨30, by decide⟩, (1 : Int))] -- /P/87 + else + [(⟨22, by decide⟩, (1 : Int)), (⟨27, by decide⟩, (1 : Int))] -- /P/88 + else + if i.val < 90 then + [(⟨22, by decide⟩, (1 : Int)), (⟨28, by decide⟩, (1 : Int))] -- /P/89 + else + [(⟨22, by decide⟩, (1 : Int)), (⟨29, by decide⟩, (1 : Int))] -- /P/90 + else + if i.val < 97 then + if i.val < 94 then + if i.val < 92 then + [(⟨22, by decide⟩, (1 : Int)), (⟨30, by decide⟩, (1 : Int))] -- /P/91 + else + if i.val < 93 then + [(⟨23, by decide⟩, (1 : Int)), (⟨27, by decide⟩, (1 : Int))] -- /P/92 + else + [(⟨23, by decide⟩, (1 : Int)), (⟨28, by decide⟩, (1 : Int))] -- /P/93 + else + if i.val < 95 then + [(⟨23, by decide⟩, (1 : Int)), (⟨31, by decide⟩, (1 : Int))] -- /P/94 + else + if i.val < 96 then + [(⟨23, by decide⟩, (1 : Int)), (⟨32, by decide⟩, (1 : Int))] -- /P/95 + else + [(⟨24, by decide⟩, (1 : Int)), (⟨27, by decide⟩, (1 : Int))] -- /P/96 + else + if i.val < 100 then + if i.val < 98 then + [(⟨24, by decide⟩, (1 : Int)), (⟨28, by decide⟩, (1 : Int))] -- /P/97 + else + if i.val < 99 then + [(⟨24, by decide⟩, (1 : Int)), (⟨31, by decide⟩, (1 : Int))] -- /P/98 + else + [(⟨24, by decide⟩, (1 : Int)), (⟨32, by decide⟩, (1 : Int))] -- /P/99 + else + if i.val < 102 then + if i.val < 101 then + [(⟨25, by decide⟩, (1 : Int)), (⟨29, by decide⟩, (1 : Int))] -- /P/100 + else + [(⟨25, by decide⟩, (1 : Int)), (⟨30, by decide⟩, (1 : Int))] -- /P/101 + else + if i.val < 103 then + [(⟨25, by decide⟩, (1 : Int)), (⟨31, by decide⟩, (1 : Int))] -- /P/102 + else + [(⟨25, by decide⟩, (1 : Int)), (⟨32, by decide⟩, (1 : Int))] -- /P/103 + +def P : Mat 104 33 := fun i => Sparse.row (P_entries i) + +/-- Original sparse Q rows, in original row/entry order. -/ +def Q_entries (i : Fin 33) : List (Fin 104 × Int) := + if i.val < 16 then + if i.val < 8 then + if i.val < 4 then + if i.val < 2 then + if i.val < 1 then + [(⟨0, by decide⟩, (1 : Int))] -- /Q/0 + else + [(⟨4, by decide⟩, (1 : Int))] -- /Q/1 + else + if i.val < 3 then + [(⟨8, by decide⟩, (1 : Int))] -- /Q/2 + else + [(⟨12, by decide⟩, (1 : Int))] -- /Q/3 + else + if i.val < 6 then + if i.val < 5 then + [(⟨16, by decide⟩, (1 : Int))] -- /Q/4 + else + [(⟨20, by decide⟩, (1 : Int))] -- /Q/5 + else + if i.val < 7 then + [(⟨24, by decide⟩, (1 : Int))] -- /Q/6 + else + [(⟨28, by decide⟩, (1 : Int))] -- /Q/7 + else + if i.val < 12 then + if i.val < 10 then + if i.val < 9 then + [(⟨32, by decide⟩, (1 : Int))] -- /Q/8 + else + [(⟨36, by decide⟩, (1 : Int))] -- /Q/9 + else + if i.val < 11 then + [(⟨40, by decide⟩, (1 : Int))] -- /Q/10 + else + [(⟨44, by decide⟩, (1 : Int))] -- /Q/11 + else + if i.val < 14 then + if i.val < 13 then + [(⟨48, by decide⟩, (1 : Int))] -- /Q/12 + else + [(⟨0, by decide⟩, (1 : Int)), (⟨1, by decide⟩, (-1 : Int)), (⟨52, by decide⟩, (1 : Int))] -- /Q/13 + else + if i.val < 15 then + [(⟨0, by decide⟩, (1 : Int)), (⟨1, by decide⟩, (-1 : Int)), (⟨56, by decide⟩, (1 : Int))] -- /Q/14 + else + [(⟨0, by decide⟩, (1 : Int)), (⟨1, by decide⟩, (-1 : Int)), (⟨60, by decide⟩, (1 : Int))] -- /Q/15 + else + if i.val < 24 then + if i.val < 20 then + if i.val < 18 then + if i.val < 17 then + [(⟨0, by decide⟩, (1 : Int)), (⟨1, by decide⟩, (-1 : Int)), (⟨64, by decide⟩, (1 : Int))] -- /Q/16 + else + [(⟨0, by decide⟩, (1 : Int)), (⟨1, by decide⟩, (-1 : Int)), (⟨68, by decide⟩, (1 : Int))] -- /Q/17 + else + if i.val < 19 then + [(⟨0, by decide⟩, (1 : Int)), (⟨1, by decide⟩, (-1 : Int)), (⟨72, by decide⟩, (1 : Int))] -- /Q/18 + else + [(⟨0, by decide⟩, (1 : Int)), (⟨1, by decide⟩, (-1 : Int)), (⟨76, by decide⟩, (1 : Int))] -- /Q/19 + else + if i.val < 22 then + if i.val < 21 then + [(⟨0, by decide⟩, (1 : Int)), (⟨1, by decide⟩, (-1 : Int)), (⟨80, by decide⟩, (1 : Int))] -- /Q/20 + else + [(⟨0, by decide⟩, (1 : Int)), (⟨2, by decide⟩, (-1 : Int)), (⟨84, by decide⟩, (1 : Int))] -- /Q/21 + else + if i.val < 23 then + [(⟨0, by decide⟩, (1 : Int)), (⟨2, by decide⟩, (-1 : Int)), (⟨88, by decide⟩, (1 : Int))] -- /Q/22 + else + [(⟨0, by decide⟩, (1 : Int)), (⟨2, by decide⟩, (-1 : Int)), (⟨92, by decide⟩, (1 : Int))] -- /Q/23 + else + if i.val < 28 then + if i.val < 26 then + if i.val < 25 then + [(⟨0, by decide⟩, (1 : Int)), (⟨2, by decide⟩, (-1 : Int)), (⟨96, by decide⟩, (1 : Int))] -- /Q/24 + else + [(⟨4, by decide⟩, (1 : Int)), (⟨6, by decide⟩, (-1 : Int)), (⟨100, by decide⟩, (1 : Int))] -- /Q/25 + else + if i.val < 27 then + [(⟨0, by decide⟩, (-1 : Int)), (⟨1, by decide⟩, (1 : Int))] -- /Q/26 + else + [(⟨0, by decide⟩, (-1 : Int)), (⟨2, by decide⟩, (1 : Int))] -- /Q/27 + else + if i.val < 30 then + if i.val < 29 then + [(⟨0, by decide⟩, (-1 : Int)), (⟨3, by decide⟩, (1 : Int))] -- /Q/28 + else + [(⟨4, by decide⟩, (-1 : Int)), (⟨6, by decide⟩, (1 : Int))] -- /Q/29 + else + if i.val < 31 then + [(⟨4, by decide⟩, (-1 : Int)), (⟨7, by decide⟩, (1 : Int))] -- /Q/30 + else + if i.val < 32 then + [(⟨12, by decide⟩, (-1 : Int)), (⟨14, by decide⟩, (1 : Int))] -- /Q/31 + else + [(⟨12, by decide⟩, (-1 : Int)), (⟨15, by decide⟩, (1 : Int))] -- /Q/32 + +def Q : Mat 33 104 := fun i => Sparse.row (Q_entries i) + +/-- Original sparse W rows, in original row/entry order. -/ +def W_entries (i : Fin 104) : List (Fin 288 × Int) := + if i.val < 52 then + if i.val < 26 then + if i.val < 13 then + if i.val < 6 then + if i.val < 3 then + if i.val < 1 then + [] -- /W/0 + else + if i.val < 2 then + [] -- /W/1 + else + [] -- /W/2 + else + if i.val < 4 then + [] -- /W/3 + else + if i.val < 5 then + [] -- /W/4 + else + [(⟨0, by decide⟩, (1 : Int))] -- /W/5 + else + if i.val < 9 then + if i.val < 7 then + [] -- /W/6 + else + if i.val < 8 then + [] -- /W/7 + else + [] -- /W/8 + else + if i.val < 11 then + if i.val < 10 then + [(⟨1, by decide⟩, (1 : Int))] -- /W/9 + else + [(⟨26, by decide⟩, (1 : Int)), (⟨47, by decide⟩, (-1 : Int))] -- /W/10 + else + if i.val < 12 then + [(⟨28, by decide⟩, (1 : Int)), (⟨49, by decide⟩, (-1 : Int))] -- /W/11 + else + [] -- /W/12 + else + if i.val < 19 then + if i.val < 16 then + if i.val < 14 then + [(⟨2, by decide⟩, (1 : Int))] -- /W/13 + else + if i.val < 15 then + [] -- /W/14 + else + [] -- /W/15 + else + if i.val < 17 then + [] -- /W/16 + else + if i.val < 18 then + [(⟨3, by decide⟩, (1 : Int))] -- /W/17 + else + [(⟨66, by decide⟩, (1 : Int)), (⟨85, by decide⟩, (-1 : Int))] -- /W/18 + else + if i.val < 22 then + if i.val < 20 then + [(⟨68, by decide⟩, (1 : Int)), (⟨87, by decide⟩, (-1 : Int))] -- /W/19 + else + if i.val < 21 then + [] -- /W/20 + else + [(⟨4, by decide⟩, (1 : Int))] -- /W/21 + else + if i.val < 24 then + if i.val < 23 then + [(⟨26, by decide⟩, (1 : Int))] -- /W/22 + else + [(⟨66, by decide⟩, (1 : Int))] -- /W/23 + else + if i.val < 25 then + [] -- /W/24 + else + [(⟨5, by decide⟩, (1 : Int))] -- /W/25 + else + if i.val < 39 then + if i.val < 32 then + if i.val < 29 then + if i.val < 27 then + [(⟨27, by decide⟩, (1 : Int))] -- /W/26 + else + if i.val < 28 then + [(⟨67, by decide⟩, (1 : Int))] -- /W/27 + else + [] -- /W/28 + else + if i.val < 30 then + [(⟨6, by decide⟩, (1 : Int))] -- /W/29 + else + if i.val < 31 then + [(⟨28, by decide⟩, (1 : Int))] -- /W/30 + else + [(⟨68, by decide⟩, (1 : Int))] -- /W/31 + else + if i.val < 35 then + if i.val < 33 then + [] -- /W/32 + else + if i.val < 34 then + [(⟨7, by decide⟩, (1 : Int))] -- /W/33 + else + [(⟨29, by decide⟩, (1 : Int))] -- /W/34 + else + if i.val < 37 then + if i.val < 36 then + [(⟨69, by decide⟩, (1 : Int))] -- /W/35 + else + [] -- /W/36 + else + if i.val < 38 then + [(⟨8, by decide⟩, (1 : Int))] -- /W/37 + else + [(⟨30, by decide⟩, (1 : Int))] -- /W/38 + else + if i.val < 45 then + if i.val < 42 then + if i.val < 40 then + [(⟨70, by decide⟩, (1 : Int))] -- /W/39 + else + if i.val < 41 then + [] -- /W/40 + else + [(⟨9, by decide⟩, (1 : Int))] -- /W/41 + else + if i.val < 43 then + [(⟨31, by decide⟩, (1 : Int))] -- /W/42 + else + if i.val < 44 then + [(⟨71, by decide⟩, (1 : Int))] -- /W/43 + else + [] -- /W/44 + else + if i.val < 48 then + if i.val < 46 then + [(⟨10, by decide⟩, (1 : Int))] -- /W/45 + else + if i.val < 47 then + [(⟨32, by decide⟩, (1 : Int))] -- /W/46 + else + [(⟨72, by decide⟩, (1 : Int))] -- /W/47 + else + if i.val < 50 then + if i.val < 49 then + [] -- /W/48 + else + [(⟨11, by decide⟩, (1 : Int))] -- /W/49 + else + if i.val < 51 then + [(⟨33, by decide⟩, (1 : Int))] -- /W/50 + else + [(⟨73, by decide⟩, (1 : Int))] -- /W/51 + else + if i.val < 78 then + if i.val < 65 then + if i.val < 58 then + if i.val < 55 then + if i.val < 53 then + [] -- /W/52 + else + if i.val < 54 then + [(⟨12, by decide⟩, (1 : Int))] -- /W/53 + else + [(⟨0, by decide⟩, (-1 : Int)), (⟨34, by decide⟩, (1 : Int))] -- /W/54 + else + if i.val < 56 then + [(⟨2, by decide⟩, (-1 : Int)), (⟨74, by decide⟩, (1 : Int))] -- /W/55 + else + if i.val < 57 then + [] -- /W/56 + else + [(⟨13, by decide⟩, (1 : Int))] -- /W/57 + else + if i.val < 61 then + if i.val < 59 then + [(⟨0, by decide⟩, (-1 : Int)), (⟨35, by decide⟩, (1 : Int))] -- /W/58 + else + if i.val < 60 then + [(⟨2, by decide⟩, (-1 : Int)), (⟨75, by decide⟩, (1 : Int))] -- /W/59 + else + [] -- /W/60 + else + if i.val < 63 then + if i.val < 62 then + [(⟨14, by decide⟩, (1 : Int))] -- /W/61 + else + [(⟨0, by decide⟩, (-1 : Int)), (⟨36, by decide⟩, (1 : Int))] -- /W/62 + else + if i.val < 64 then + [(⟨2, by decide⟩, (-1 : Int)), (⟨76, by decide⟩, (1 : Int))] -- /W/63 + else + [] -- /W/64 + else + if i.val < 71 then + if i.val < 68 then + if i.val < 66 then + [(⟨15, by decide⟩, (1 : Int))] -- /W/65 + else + if i.val < 67 then + [(⟨0, by decide⟩, (-1 : Int)), (⟨37, by decide⟩, (1 : Int))] -- /W/66 + else + [(⟨2, by decide⟩, (-1 : Int)), (⟨77, by decide⟩, (1 : Int))] -- /W/67 + else + if i.val < 69 then + [] -- /W/68 + else + if i.val < 70 then + [(⟨16, by decide⟩, (1 : Int))] -- /W/69 + else + [(⟨0, by decide⟩, (-1 : Int)), (⟨38, by decide⟩, (1 : Int))] -- /W/70 + else + if i.val < 74 then + if i.val < 72 then + [(⟨2, by decide⟩, (-1 : Int)), (⟨78, by decide⟩, (1 : Int))] -- /W/71 + else + if i.val < 73 then + [] -- /W/72 + else + [(⟨17, by decide⟩, (1 : Int))] -- /W/73 + else + if i.val < 76 then + if i.val < 75 then + [(⟨0, by decide⟩, (-1 : Int)), (⟨39, by decide⟩, (1 : Int))] -- /W/74 + else + [(⟨2, by decide⟩, (-1 : Int)), (⟨79, by decide⟩, (1 : Int))] -- /W/75 + else + if i.val < 77 then + [] -- /W/76 + else + [(⟨18, by decide⟩, (1 : Int))] -- /W/77 + else + if i.val < 91 then + if i.val < 84 then + if i.val < 81 then + if i.val < 79 then + [(⟨0, by decide⟩, (-1 : Int)), (⟨40, by decide⟩, (1 : Int))] -- /W/78 + else + if i.val < 80 then + [(⟨2, by decide⟩, (-1 : Int)), (⟨80, by decide⟩, (1 : Int))] -- /W/79 + else + [] -- /W/80 + else + if i.val < 82 then + [(⟨19, by decide⟩, (1 : Int))] -- /W/81 + else + if i.val < 83 then + [(⟨0, by decide⟩, (-1 : Int)), (⟨41, by decide⟩, (1 : Int))] -- /W/82 + else + [(⟨2, by decide⟩, (-1 : Int)), (⟨81, by decide⟩, (1 : Int))] -- /W/83 + else + if i.val < 87 then + if i.val < 85 then + [] -- /W/84 + else + if i.val < 86 then + [(⟨20, by decide⟩, (1 : Int))] -- /W/85 + else + [(⟨4, by decide⟩, (-1 : Int)), (⟨26, by decide⟩, (1 : Int)), (⟨116, by decide⟩, (1 : Int))] -- /W/86 + else + if i.val < 89 then + if i.val < 88 then + [(⟨6, by decide⟩, (-1 : Int)), (⟨28, by decide⟩, (1 : Int)), (⟨148, by decide⟩, (1 : Int))] -- /W/87 + else + [] -- /W/88 + else + if i.val < 90 then + [(⟨21, by decide⟩, (1 : Int))] -- /W/89 + else + [(⟨4, by decide⟩, (-1 : Int)), (⟨26, by decide⟩, (1 : Int)), (⟨117, by decide⟩, (1 : Int))] -- /W/90 + else + if i.val < 97 then + if i.val < 94 then + if i.val < 92 then + [(⟨6, by decide⟩, (-1 : Int)), (⟨28, by decide⟩, (1 : Int)), (⟨149, by decide⟩, (1 : Int))] -- /W/91 + else + if i.val < 93 then + [] -- /W/92 + else + [(⟨22, by decide⟩, (1 : Int))] -- /W/93 + else + if i.val < 95 then + [(⟨4, by decide⟩, (-1 : Int)), (⟨66, by decide⟩, (1 : Int)), (⟨118, by decide⟩, (1 : Int))] -- /W/94 + else + if i.val < 96 then + [(⟨6, by decide⟩, (-1 : Int)), (⟨68, by decide⟩, (1 : Int)), (⟨150, by decide⟩, (1 : Int))] -- /W/95 + else + [] -- /W/96 + else + if i.val < 100 then + if i.val < 98 then + [(⟨23, by decide⟩, (1 : Int))] -- /W/97 + else + if i.val < 99 then + [(⟨4, by decide⟩, (-1 : Int)), (⟨66, by decide⟩, (1 : Int)), (⟨119, by decide⟩, (1 : Int))] -- /W/98 + else + [(⟨6, by decide⟩, (-1 : Int)), (⟨68, by decide⟩, (1 : Int)), (⟨151, by decide⟩, (1 : Int))] -- /W/99 + else + if i.val < 102 then + if i.val < 101 then + [] -- /W/100 + else + [(⟨44, by decide⟩, (1 : Int))] -- /W/101 + else + if i.val < 103 then + [(⟨26, by decide⟩, (-1 : Int)), (⟨66, by decide⟩, (1 : Int)), (⟨120, by decide⟩, (1 : Int))] -- /W/102 + else + [(⟨30, by decide⟩, (-1 : Int)), (⟨70, by decide⟩, (1 : Int)), (⟨180, by decide⟩, (1 : Int))] -- /W/103 + +def W : Mat 104 288 := fun i => Sparse.row (W_entries i) + +/-- Provenance metadata only; no class-completeness theorem is asserted. -/ +def anchors : List Nat := [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 4] + +def basePairRepresentatives : List (String × Nat) := [("1", 0), ("2", 0), ("3", 0), ("4", 1), ("5", 1), ("6", 3), ("7", 3)] + +def coordinateLabels : List (Nat × Nat) := [(0, 0), (0, 1), (0, 2), (0, 3), (1, 0), (1, 1), (1, 4), (1, 5), (2, 0), (2, 1), (2, 4), (2, 5), (3, 0), (3, 1), (3, 6), (3, 7), (4, 0), (4, 1), (4, 6), (4, 7), (5, 0), (5, 2), (5, 4), (5, 6), (6, 0), (6, 2), (6, 4), (6, 6), (7, 0), (7, 2), (7, 5), (7, 7), (8, 0), (8, 2), (8, 5), (8, 7), (9, 0), (9, 3), (9, 4), (9, 7), (10, 0), (10, 3), (10, 4), (10, 7), (11, 0), (11, 3), (11, 5), (11, 6), (12, 0), (12, 3), (12, 5), (12, 6), (13, 1), (13, 2), (13, 4), (13, 7), (14, 1), (14, 2), (14, 4), (14, 7), (15, 1), (15, 2), (15, 5), (15, 6), (16, 1), (16, 2), (16, 5), (16, 6), (17, 1), (17, 3), (17, 4), (17, 6), (18, 1), (18, 3), (18, 4), (18, 6), (19, 1), (19, 3), (19, 5), (19, 7), (20, 1), (20, 3), (20, 5), (20, 7), (21, 2), (21, 3), (21, 4), (21, 5), (22, 2), (22, 3), (22, 4), (22, 5), (23, 2), (23, 3), (23, 6), (23, 7), (24, 2), (24, 3), (24, 6), (24, 7), (25, 4), (25, 5), (25, 6), (25, 7)] + +def freeParameters : Nat := 33 + +def parameterClassCount : Nat := 26 + +def gPoints : List Nat := [1, 2, 3, 4, 5, 6, 7] + +/-- Inherited JSON metadata, NOT a formal matrix-rank statement. -/ +def rankMetadata : Nat := 71 + +end P112Cert + +set_option pp.fullNames true +#print axioms P112Cert.M_entries +#print axioms P112Cert.M +#print axioms P112Cert.P_entries +#print axioms P112Cert.P +#print axioms P112Cert.Q_entries +#print axioms P112Cert.Q +#print axioms P112Cert.W_entries +#print axioms P112Cert.W +#print axioms P112Cert.anchors +#print axioms P112Cert.basePairRepresentatives +#print axioms P112Cert.coordinateLabels +#print axioms P112Cert.freeParameters +#print axioms P112Cert.parameterClassCount +#print axioms P112Cert.gPoints +#print axioms P112Cert.rankMetadata diff --git a/research/p112-integral-retraction-instance/source/P112Sparse.lean b/research/p112-integral-retraction-instance/source/P112Sparse.lean new file mode 100644 index 0000000000..2f606f0f86 --- /dev/null +++ b/research/p112-integral-retraction-instance/source/P112Sparse.lean @@ -0,0 +1,83 @@ +/- +Copyright (c) 2026 Andrey Mas and contributors. +SPDX-License-Identifier: Apache-2.0 + +P112 finite successor to PR1497/PR1610. SOURCE ONLY: NOT YET KERNEL CHECKED. +Formalization assistance: GPT-6 Pro through ChatGPT (operator-selected label). +Only the left sparse-row evaluation needed by this fixed certificate is added. +The imported bridge is preserved byte-for-byte at its supplied published pin. +-/ +import PR1497Bridge + +set_option autoImplicit false +set_option maxRecDepth 4096 +set_option maxHeartbeats 1000000 + +namespace P112Cert.Sparse +open PR1497 + +/-- A literal integer linear combination of ordinary coordinate basis rows. -/ +def row {n : Nat} : List (Fin n × Int) → Row n + | [] => (rowGroup n).zero + | (i, c) :: xs => (rowGroup n).add (scale c (basis n i)) (row xs) + +/-- Evaluate only the listed left coefficients against the rows of B. -/ +def eval {n d : Nat} : List (Fin n × Int) → Mat n d → Row d + | [], _ => (rowGroup d).zero + | (i, c) :: xs, B => (rowGroup d).add (scale c (B i)) (eval xs B) + +/-- The sparse convention is the ordinary sum of coefficients at a column. + The pinned source has no duplicate column entries; no deduplication is used. -/ +theorem row_apply {n : Nat} (xs : List (Fin n × Int)) (j : Fin n) : + row xs j = xs.foldr (fun e s => (if j = e.1 then e.2 else 0) + s) 0 := by + induction xs with + | nil => rfl + | cons e xs ih => + cases e with + | mk i c => + change c * (if j = i then 1 else 0) + row xs j = + (if j = i then c else 0) + + xs.foldr (fun e s => (if j = e.1 then e.2 else 0) + s) 0 + rw [ih] + by_cases h : j = i + · simp only [if_pos h, Int.mul_one] + · simp only [if_neg h, Int.mul_zero] + +/-- Scalar linearity is derived from the inherited, proved row homomorphism. -/ +theorem rowMul_scale {n d : Nat} (c : Int) (v : Row n) (B : Mat n d) : + rowMul (scale c v) B = scale c (rowMul v B) := by + have h := (Rows.rowHom B).map_zsmul c v + change rowMul ((rowGroup n).zsmul c v) B = + (rowGroup d).zsmul c (rowMul v B) at h + simpa only [Rows.row_zsmul] using h + +/-- Sound connection to PR1497.rowMul and its actual recursive finite sum. + No Boolean checker, matrix identity, or annihilation law is assumed. -/ +theorem rowMul_row {n d : Nat} (xs : List (Fin n × Int)) (B : Mat n d) : + rowMul (row xs) B = eval xs B := by + induction xs with + | nil => exact Rows.rowMul_zero_left B + | cons e xs ih => + cases e with + | mk i c => + change rowMul ((rowGroup n).add (scale c (basis n i)) (row xs)) B = + (rowGroup d).add (scale c (B i)) (eval xs B) + rw [Rows.rowMul_add, rowMul_scale, Rows.rowMul_basis, ih] + +/-- Bounded-depth assembly of complete finite index families. This is only + a wrapper around core Fin.addCases; both subranges are supplied as proofs. -/ +theorem allFinAdd {a b : Nat} {R : Fin (a + b) → Prop} + (hl : ∀ i : Fin a, R (Fin.castAdd b i)) + (hr : ∀ i : Fin b, R (Fin.natAdd a i)) : + ∀ i : Fin (a + b), R i := + fun i => Fin.addCases (motive := R) hl hr i + +end P112Cert.Sparse + +set_option pp.fullNames true +#print axioms P112Cert.Sparse.row +#print axioms P112Cert.Sparse.eval +#print axioms P112Cert.Sparse.row_apply +#print axioms P112Cert.Sparse.rowMul_scale +#print axioms P112Cert.Sparse.rowMul_row +#print axioms P112Cert.Sparse.allFinAdd diff --git a/research/p112-integral-retraction-instance/source/PR1497Bridge.lean b/research/p112-integral-retraction-instance/source/PR1497Bridge.lean new file mode 100644 index 0000000000..950829a287 --- /dev/null +++ b/research/p112-integral-retraction-instance/source/PR1497Bridge.lean @@ -0,0 +1,1405 @@ +/- +Copyright (c) 2026 Andrey Mas and contributors. +SPDX-License-Identifier: Apache-2.0 + +PR1497 universal integral-retraction and monomial bridge. +TARGET: official Lean 4.30.0, commit + d024af099ca4bf2c86f649261ebf59565dc8c622 +Only import: Std. No package manager is needed. + +STATUS: Locally kernel checked with the exact compiler identified above. +The producer delivered source and diagnostic repairs without running Lean. +Subsequent local replay accepted the universal source, repaired fixtures, +and queried axiom census. See README.md and REPLAY.json for that evidence. + +Project credits: Andrey Mas / GPT6Pro for the PR1497 audit; +Brett Halligan (burntout76) and Ninefold for inherited PR1212; +DreamingOfClouds (PR717); themilkman216 (PR968). +Substantial AI mathematical/formalization assistance is disclosed in README.md. +Formalization assistance used GPT-6 Pro, as observed in the ChatGPT browser UI. + +All custom algebra structures below contain operations and ordinary algebra +laws only. Kernel/image equality, saturation, and reconstruction are theorems, +not fields. Independent test data is kept in fixtures/Positive.lean. +-/ +import Std + +set_option autoImplicit false +set_option maxRecDepth 4096 +set_option maxHeartbeats 2000000 + +namespace PR1497 + +universe u v w t + +/-! ## 1. Small, explicit abelian-group and homomorphism interfaces -/ + +structure AbGroup (A : Type u) where + zero : A + add : A → A → A + neg : A → A + add_assoc : ∀ a b c, add (add a b) c = add a (add b c) + zero_add : ∀ a, add zero a = a + add_zero : ∀ a, add a zero = a + add_comm : ∀ a b, add a b = add b a + neg_add : ∀ a, add (neg a) a = zero + add_neg : ∀ a, add a (neg a) = zero + +namespace AbGroup + +variable {A : Type u} (G : AbGroup A) + +def sub (a b : A) : A := G.add a (G.neg b) + +theorem add_left_cancel {a b c : A} + (h : G.add a b = G.add a c) : b = c := by + have h' := congrArg (fun x => G.add (G.neg a) x) h + simpa only [← G.add_assoc, G.neg_add, G.zero_add] using h' + +theorem add_right_cancel {a b c : A} + (h : G.add b a = G.add c a) : b = c := by + apply G.add_left_cancel (a := a) + calc + G.add a b = G.add b a := G.add_comm _ _ + _ = G.add c a := h + _ = G.add a c := G.add_comm _ _ + +theorem add_left_comm (a b c : A) : + G.add a (G.add b c) = G.add b (G.add a c) := by + rw [← G.add_assoc, G.add_comm a b, G.add_assoc] + +theorem add_four (a b c d : A) : + G.add (G.add a b) (G.add c d) = + G.add (G.add a c) (G.add b d) := by + rw [G.add_assoc a b (G.add c d), G.add_left_comm b c d, + ← G.add_assoc a c (G.add b d)] + +theorem neg_zero : G.neg G.zero = G.zero := by + calc + G.neg G.zero = G.add (G.neg G.zero) G.zero := (G.add_zero _).symm + _ = G.zero := G.neg_add _ + +theorem neg_neg (a : A) : G.neg (G.neg a) = a := by + apply G.add_right_cancel (a := G.neg a) + rw [G.neg_add, G.add_neg] + +theorem neg_add_distrib (a b : A) : + G.neg (G.add a b) = G.add (G.neg a) (G.neg b) := by + apply G.add_left_cancel (a := G.add a b) + rw [G.add_neg, G.add_four, G.add_neg, G.add_neg, G.zero_add] + +theorem sub_zero (a : A) : G.sub a G.zero = a := by + rw [sub, G.neg_zero, G.add_zero] + +theorem sub_self (a : A) : G.sub a a = G.zero := G.add_neg a + +theorem sub_add_cancel (a b : A) : G.add (G.sub a b) b = a := by + rw [sub, G.add_assoc, G.neg_add, G.add_zero] + +theorem add_sub_cancel (a b : A) : G.sub (G.add a b) b = a := by + rw [sub, G.add_assoc, G.add_neg, G.add_zero] + +theorem sub_eq_zero_iff (a b : A) : G.sub a b = G.zero ↔ a = b := by + constructor + · intro h + have h' := congrArg (fun x => G.add x b) h + simpa only [G.sub_add_cancel, G.zero_add] using h' + · intro h + subst b + exact G.sub_self a + +theorem eq_of_sub_eq (a b c : A) (h : G.sub a b = c) : + a = G.add b c := by + calc + a = G.add (G.sub a b) b := (G.sub_add_cancel a b).symm + _ = G.add c b := congrArg (fun x => G.add x b) h + _ = G.add b c := G.add_comm c b + +/-- Repeated addition, with the empty sum equal to zero. -/ +def nsmul (G : AbGroup A) : Nat → A → A + | 0, _ => G.zero + | n + 1, a => G.add (nsmul G n a) a + +/-- Ordinary integral multiple: negative coefficients use the group inverse. -/ +def zsmul : Int → A → A + | .ofNat n, a => G.nsmul n a + | .negSucc n, a => G.neg (G.nsmul (n + 1) a) + +theorem nsmul_zero (n : Nat) : G.nsmul n G.zero = G.zero := by + induction n with + | zero => rfl + | succ n ih => simp only [nsmul, ih, G.add_zero] + +theorem zsmul_zero (a : A) : G.zsmul 0 a = G.zero := rfl + +theorem zsmul_zero_right (k : Int) : G.zsmul k G.zero = G.zero := by + cases k with + | ofNat n => exact G.nsmul_zero n + | negSucc n => simp only [zsmul, G.nsmul_zero, G.neg_zero] + +theorem zsmul_one (a : A) : G.zsmul 1 a = a := by + change G.add G.zero a = a + exact G.zero_add a + +/-- A two-sided integer induction principle, proved from the constructors. -/ +theorem int_induction (C : Int → Prop) (h0 : C 0) + (up : ∀ k, C k → C (k + 1)) + (down : ∀ k, C k → C (k - 1)) (k : Int) : C k := by + cases k with + | ofNat n => + induction n with + | zero => exact h0 + | succ n ih => exact up (Int.ofNat n) ih + | negSucc n => + induction n with + | zero => exact down 0 h0 + | succ n ih => exact down (Int.negSucc n) ih + +theorem zsmul_succ (k : Int) (a : A) : + G.zsmul (k + 1) a = G.add (G.zsmul k a) a := by + cases k with + | ofNat n => rfl + | negSucc n => + cases n with + | zero => + change G.zero = G.add (G.neg (G.add G.zero a)) a + rw [G.zero_add, G.neg_add] + | succ n => + have hk : Int.negSucc (n + 1) + 1 = Int.negSucc n := by omega + rw [hk] + change G.neg (G.nsmul (n + 1) a) = + G.add (G.neg (G.add (G.nsmul (n + 1) a) a)) a + rw [G.neg_add_distrib (G.nsmul (n + 1) a) a, + G.add_assoc, G.neg_add a, G.add_zero] + +theorem zsmul_pred (k : Int) (a : A) : + G.zsmul (k - 1) a = G.add (G.zsmul k a) (G.neg a) := by + have hs := G.zsmul_succ (k - 1) a + have hk : (k - 1) + 1 = k := by omega + rw [hk] at hs + apply G.add_right_cancel (a := a) + calc + G.add (G.zsmul (k - 1) a) a = G.zsmul k a := hs.symm + _ = G.add (G.add (G.zsmul k a) (G.neg a)) a := by + rw [G.add_assoc, G.neg_add, G.add_zero] + +/-- The exponent-addition law is derived, not assumed. -/ +theorem zsmul_add (k l : Int) (a : A) : + G.zsmul (k + l) a = G.add (G.zsmul k a) (G.zsmul l a) := by + apply int_induction (fun j => + G.zsmul (k + j) a = G.add (G.zsmul k a) (G.zsmul j a)) + · rw [Int.add_zero, G.zsmul_zero, G.add_zero] + · intro j ih + have hk : k + (j + 1) = (k + j) + 1 := by omega + rw [hk, G.zsmul_succ (k + j) a, G.zsmul_succ j a, ih, G.add_assoc] + · intro j ih + have hk : k + (j - 1) = (k + j) - 1 := by omega + rw [hk, G.zsmul_pred (k + j) a, G.zsmul_pred j a, ih, G.add_assoc] + +end AbGroup + +structure Hom {A : Type u} {B : Type v} + (GA : AbGroup A) (GB : AbGroup B) where + run : A → B + map_zero : run GA.zero = GB.zero + map_add : ∀ a b, run (GA.add a b) = GB.add (run a) (run b) + +namespace Hom + +variable {A : Type u} {B : Type v} {C : Type w} +variable {GA : AbGroup A} {GB : AbGroup B} {GC : AbGroup C} + +def id (G : AbGroup A) : Hom G G where + run := fun a => a + map_zero := rfl + map_add := fun _ _ => rfl + +def comp (g : Hom GB GC) (f : Hom GA GB) : Hom GA GC where + run := fun a => g.run (f.run a) + map_zero := by rw [f.map_zero, g.map_zero] + map_add := by intro a b; rw [f.map_add, g.map_add] + +theorem ext (f g : Hom GA GB) (h : ∀ a, f.run a = g.run a) : f = g := by + cases f with + | mk ff f0 fa => + cases g with + | mk gg g0 ga => + have hf : ff = gg := funext h + cases hf + rfl + +theorem map_neg (f : Hom GA GB) (a : A) : + f.run (GA.neg a) = GB.neg (f.run a) := by + apply GB.add_right_cancel (a := f.run a) + rw [← f.map_add, GA.neg_add, f.map_zero, GB.neg_add] + +theorem map_sub (f : Hom GA GB) (a b : A) : + f.run (GA.sub a b) = GB.sub (f.run a) (f.run b) := by + rw [AbGroup.sub, f.map_add, f.map_neg, AbGroup.sub] + +theorem map_nsmul (f : Hom GA GB) (n : Nat) (a : A) : + f.run (GA.nsmul n a) = GB.nsmul n (f.run a) := by + induction n with + | zero => exact f.map_zero + | succ n ih => + simp only [AbGroup.nsmul, f.map_add, ih] + +theorem map_zsmul (f : Hom GA GB) (k : Int) (a : A) : + f.run (GA.zsmul k a) = GB.zsmul k (f.run a) := by + cases k with + | ofNat n => exact f.map_nsmul n a + | negSucc n => + simp only [AbGroup.zsmul, f.map_neg, f.map_nsmul] + +end Hom + +/-! ## 2. Finite sums, honest integer rows, and ordinary matrix products -/ + +/-- Sum over all of Fin n, in increasing coordinate order. -/ +def fsum {A : Type u} (G : AbGroup A) : + (n : Nat) → (Fin n → A) → A + | 0, _ => G.zero + | n + 1, f => G.add (f 0) (fsum G n (fun i => f i.succ)) + +namespace Finite + +variable {A : Type u} {B : Type v} (G : AbGroup A) + +theorem sum_congr {n : Nat} (f g : Fin n → A) + (h : ∀ i, f i = g i) : fsum G n f = fsum G n g := + congrArg (fsum G n) (funext h) + +theorem sum_zero (n : Nat) : fsum G n (fun _ => G.zero) = G.zero := by + induction n with + | zero => rfl + | succ n ih => simp only [fsum, ih, G.add_zero] + +theorem sum_add (n : Nat) (f g : Fin n → A) : + fsum G n (fun i => G.add (f i) (g i)) = + G.add (fsum G n f) (fsum G n g) := by + revert f g + induction n with + | zero => + intro f g + exact (G.add_zero G.zero).symm + | succ n ih => + intro f g + change G.add (G.add (f 0) (g 0)) + (fsum G n (fun i => G.add (f i.succ) (g i.succ))) = + G.add (G.add (f 0) (fsum G n (fun i => f i.succ))) + (G.add (g 0) (fsum G n (fun i => g i.succ))) + rw [ih] + exact G.add_four _ _ _ _ + +theorem sum_neg (n : Nat) (f : Fin n → A) : + fsum G n (fun i => G.neg (f i)) = G.neg (fsum G n f) := by + revert f + induction n with + | zero => + intro f + exact G.neg_zero.symm + | succ n ih => + intro f + change G.add (G.neg (f 0)) (fsum G n (fun i => G.neg (f i.succ))) = + G.neg (G.add (f 0) (fsum G n (fun i => f i.succ))) + rw [ih, G.neg_add_distrib] + +theorem sum_sub (n : Nat) (f g : Fin n → A) : + fsum G n (fun i => G.sub (f i) (g i)) = + G.sub (fsum G n f) (fsum G n g) := by + simp only [AbGroup.sub, sum_add, sum_neg] + +theorem sum_swap (n m : Nat) (f : Fin n → Fin m → A) : + fsum G n (fun i => fsum G m (fun j => f i j)) = + fsum G m (fun j => fsum G n (fun i => f i j)) := by + revert f + induction n with + | zero => + intro f + simp only [fsum, sum_zero] + | succ n ih => + intro f + change G.add (fsum G m (fun j => f 0 j)) + (fsum G n (fun i => fsum G m (fun j => f i.succ j))) = + fsum G m (fun j => G.add (f 0 j) + (fsum G n (fun i => f i.succ j))) + rw [sum_add, ih] + +theorem sum_single (n : Nat) (j : Fin n) (a : A) : + fsum G n (fun i => if i = j then a else G.zero) = a := by + revert j + induction n with + | zero => + intro j + exact (Nat.not_lt_zero j.val j.isLt).elim + | succ n ih => + intro j + refine Fin.cases ?_ (fun k => ?_) j + · simp only [fsum, eq_self, ite_true, Fin.succ_ne_zero, if_false, + sum_zero, G.add_zero] + · have h0 : (0 : Fin (n + 1)) ≠ k.succ := Ne.symm (Fin.succ_ne_zero k) + simp only [fsum, if_neg h0, Fin.succ_inj, ih, G.zero_add] + +theorem map_sum {GA : AbGroup A} {GB : AbGroup B} + (h : Hom GA GB) (n : Nat) (f : Fin n → A) : + h.run (fsum GA n f) = fsum GB n (fun i => h.run (f i)) := by + revert f + induction n with + | zero => + intro f + exact h.map_zero + | succ n ih => + intro f + change h.run (GA.add (f 0) (fsum GA n (fun i => f i.succ))) = + GB.add (h.run (f 0)) (fsum GB n (fun i => h.run (f i.succ))) + rw [h.map_add, ih] + +end Finite + +/-- This is the usual additive group of Lean's built-in integers. -/ +def intGroup : AbGroup Int where + zero := 0 + add := (· + ·) + neg := Neg.neg + add_assoc := Int.add_assoc + zero_add := Int.zero_add + add_zero := Int.add_zero + add_comm := Int.add_comm + neg_add := Int.add_left_neg + add_neg := Int.add_right_neg + +/-- Pointwise abelian group; in particular the group on Fin n → Int. -/ +def functionGroup {I : Type u} {A : Type v} (G : AbGroup A) : + AbGroup (I → A) where + zero := fun _ => G.zero + add := fun a b i => G.add (a i) (b i) + neg := fun a i => G.neg (a i) + add_assoc := by intro a b c; funext i; exact G.add_assoc _ _ _ + zero_add := by intro a; funext i; exact G.zero_add _ + add_zero := by intro a; funext i; exact G.add_zero _ + add_comm := by intro a b; funext i; exact G.add_comm _ _ + neg_add := by intro a; funext i; exact G.neg_add _ + add_neg := by intro a; funext i; exact G.add_neg _ + +abbrev Row (n : Nat) := Fin n → Int +abbrev Mat (m n : Nat) := Fin m → Fin n → Int + +def rowGroup (n : Nat) : AbGroup (Row n) := functionGroup intGroup + +def scale {n : Nat} (k : Int) (v : Row n) : Row n := fun i => k * v i + +def basis (n : Nat) (i : Fin n) : Row n := fun j => if j = i then 1 else 0 + +def eye (n : Nat) : Mat n n := fun i => basis n i + +def zeroMat (m n : Nat) : Mat m n := fun _ _ => 0 + +def matSub {m n : Nat} (A B : Mat m n) : Mat m n := fun i j => A i j - B i j + +/-- Ordinary row-vector multiplication: (v A)_j = sum_i v_i A_ij. -/ +def rowMul {m n : Nat} (v : Row m) (A : Mat m n) : Row n := + fun j => fsum intGroup m (fun i => v i * A i j) + +/-- Ordinary matrix multiplication, with the left index the row index. -/ +def matMul {m n d : Nat} (A : Mat m n) (B : Mat n d) : Mat m d := + fun i => rowMul (A i) B + +namespace Rows + +theorem sum_apply {I : Type u} {A : Type v} (G : AbGroup A) + (n : Nat) (f : Fin n → I → A) (j : I) : + (fsum (functionGroup G) n f) j = fsum G n (fun i => f i j) := by + revert f + induction n with + | zero => + intro f + rfl + | succ n ih => + intro f + change G.add (f 0 j) ((fsum (functionGroup G) n + (fun i => f i.succ)) j) = + G.add (f 0 j) (fsum G n (fun i => f i.succ j)) + rw [ih] + +theorem nsmul_apply {I : Type u} {A : Type v} (G : AbGroup A) + (n : Nat) (f : I → A) (j : I) : + ((functionGroup G).nsmul n f) j = G.nsmul n (f j) := by + induction n with + | zero => rfl + | succ n ih => + change G.add (((functionGroup G).nsmul n f) j) (f j) = + G.add (G.nsmul n (f j)) (f j) + rw [ih] + +theorem zsmul_apply {I : Type u} {A : Type v} (G : AbGroup A) + (k : Int) (f : I → A) (j : I) : + ((functionGroup G).zsmul k f) j = G.zsmul k (f j) := by + cases k with + | ofNat n => exact nsmul_apply G n f j + | negSucc n => + change G.neg (((functionGroup G).nsmul (n + 1) f) j) = + G.neg (G.nsmul (n + 1) (f j)) + rw [nsmul_apply] + +theorem int_nsmul (n : Nat) (a : Int) : + intGroup.nsmul n a = (n : Int) * a := by + induction n with + | zero => exact (Int.zero_mul a).symm + | succ n ih => + change intGroup.nsmul n a + a = ((n + 1 : Nat) : Int) * a + rw [ih, Int.natCast_succ, Int.add_mul, Int.one_mul] + +theorem int_zsmul (k a : Int) : intGroup.zsmul k a = k * a := by + cases k with + | ofNat n => exact int_nsmul n a + | negSucc n => + change -(intGroup.nsmul (n + 1) a) = Int.negSucc n * a + rw [int_nsmul] + change -(((n + 1 : Nat) : Int) * a) = -((n + 1 : Nat) : Int) * a + rw [Int.neg_mul] + +theorem row_zsmul {n : Nat} (k : Int) (v : Row n) : + (rowGroup n).zsmul k v = scale k v := by + funext i + exact (zsmul_apply intGroup k v i).trans (int_zsmul k (v i)) + +theorem sum_mul_right (n : Nat) (f : Fin n → Int) (a : Int) : + (fsum intGroup n f) * a = fsum intGroup n (fun i => f i * a) := by + revert f + induction n with + | zero => + intro f + exact Int.zero_mul a + | succ n ih => + intro f + change (f 0 + fsum intGroup n (fun i => f i.succ)) * a = + f 0 * a + fsum intGroup n (fun i => f i.succ * a) + rw [Int.add_mul, ih] + +theorem sum_mul_left (n : Nat) (a : Int) (f : Fin n → Int) : + a * fsum intGroup n f = fsum intGroup n (fun i => a * f i) := by + rw [Int.mul_comm a, sum_mul_right] + apply Finite.sum_congr + intro i + exact Int.mul_comm _ _ + +theorem rowMul_zero_left {m n : Nat} (A : Mat m n) : + rowMul (rowGroup m).zero A = (rowGroup n).zero := by + funext j + change fsum intGroup m (fun i => 0 * A i j) = 0 + simp only [Int.zero_mul] + exact Finite.sum_zero intGroup m + +theorem rowMul_zero_right {m n : Nat} (v : Row m) : + rowMul v (zeroMat m n) = (rowGroup n).zero := by + funext j + change fsum intGroup m (fun i => v i * 0) = 0 + simp only [Int.mul_zero] + exact Finite.sum_zero intGroup m + +theorem rowMul_add {m n : Nat} (v w : Row m) (A : Mat m n) : + rowMul ((rowGroup m).add v w) A = + (rowGroup n).add (rowMul v A) (rowMul w A) := by + funext j + change fsum intGroup m (fun i => (v i + w i) * A i j) = + fsum intGroup m (fun i => v i * A i j) + + fsum intGroup m (fun i => w i * A i j) + simp only [Int.add_mul] + exact Finite.sum_add intGroup m _ _ + +theorem rowMul_matSub {m n : Nat} (v : Row m) (A B : Mat m n) : + rowMul v (matSub A B) = + (rowGroup n).sub (rowMul v A) (rowMul v B) := by + funext j + change fsum intGroup m (fun i => v i * (A i j - B i j)) = + fsum intGroup m (fun i => v i * A i j) - + fsum intGroup m (fun i => v i * B i j) + simp only [Int.mul_sub] + exact Finite.sum_sub intGroup m _ _ + +/-- This is the row-orientation bridge, including interchange of finite sums. -/ +theorem rowMul_assoc {m n d : Nat} (v : Row m) + (A : Mat m n) (B : Mat n d) : + rowMul (rowMul v A) B = rowMul v (matMul A B) := by + funext j + change fsum intGroup n (fun k => + (fsum intGroup m (fun i => v i * A i k)) * B k j) = + fsum intGroup m (fun i => + v i * fsum intGroup n (fun k => A i k * B k j)) + calc + _ = fsum intGroup n (fun k => + fsum intGroup m (fun i => (v i * A i k) * B k j)) := by + apply Finite.sum_congr + intro k + exact sum_mul_right m _ _ + _ = fsum intGroup m (fun i => + fsum intGroup n (fun k => (v i * A i k) * B k j)) := + Finite.sum_swap intGroup n m _ + _ = fsum intGroup m (fun i => + fsum intGroup n (fun k => v i * (A i k * B k j))) := by + apply Finite.sum_congr + intro i + apply Finite.sum_congr + intro k + exact Int.mul_assoc _ _ _ + _ = _ := by + apply Finite.sum_congr + intro i + exact (sum_mul_left n (v i) _).symm + +theorem rowMul_basis {m n : Nat} (i : Fin m) (A : Mat m n) : + rowMul (basis m i) A = A i := by + funext j + change fsum intGroup m + (fun k => (if k = i then 1 else 0) * A k j) = A i j + calc + _ = fsum intGroup m (fun k => if k = i then A i j else 0) := by + apply Finite.sum_congr + intro k + by_cases h : k = i + · subst k; simp only [eq_self, ite_true, Int.one_mul] + · simp only [if_neg h, Int.zero_mul] + _ = _ := Finite.sum_single intGroup m i (A i j) + +theorem rowMul_eye {n : Nat} (v : Row n) : rowMul v (eye n) = v := by + funext j + change fsum intGroup n + (fun i => v i * (if j = i then 1 else 0)) = v j + calc + _ = fsum intGroup n (fun i => if i = j then v j else 0) := by + apply Finite.sum_congr + intro i + by_cases h : i = j + · subst i; simp only [eq_self, ite_true, Int.mul_one] + · simp only [if_neg h, if_neg (Ne.symm h), Int.mul_zero] + _ = _ := Finite.sum_single intGroup n j (v j) + +/-- Image of rowMul is exactly an integer combination of the individual rows. -/ +theorem rowMul_linear_combination {m n : Nat} (v : Row m) (A : Mat m n) : + rowMul v A = fsum (rowGroup n) m + (fun i => (rowGroup n).zsmul (v i) (A i)) := by + funext j + change fsum intGroup m (fun i => v i * A i j) = + (fsum (functionGroup intGroup) m + (fun i => (rowGroup n).zsmul (v i) (A i))) j + rw [sum_apply intGroup] + apply Finite.sum_congr + intro i + exact ((zsmul_apply intGroup (v i) (A i) j).trans + (int_zsmul (v i) (A i j))).symm + +/-- Actual matrix multiplication defines a homomorphism; no law is assumed. -/ +def rowHom {m n : Nat} (A : Mat m n) : Hom (rowGroup m) (rowGroup n) where + run := fun v => rowMul v A + map_zero := rowMul_zero_left A + map_add := fun v w => rowMul_add v w A + +end Rows + +/-! ## 3. Universal split-map theorem, with an image-difference quotient -/ + +/-- Exactly the three identities, in row-map order. -/ +structure Retraction {C : Type u} {A : Type v} {B : Type w} + (GC : AbGroup C) (GA : AbGroup A) (GB : AbGroup B) where + m : Hom GC GA + p : Hom GA GB + q : Hom GB GA + w : Hom GA GC + mp : ∀ c, p.run (m.run c) = GB.zero + qp : ∀ b, p.run (q.run b) = b + residual : ∀ a, GA.sub a (q.run (p.run a)) = m.run (w.run a) + +/-- A proved pair of inverse additive homomorphisms, not a hypothesis. -/ +structure AddIso {A : Type u} {B : Type v} + (GA : AbGroup A) (GB : AbGroup B) where + forward : Hom GA GB + backward : Hom GB GA + left_inverse : ∀ a, backward.run (forward.run a) = a + right_inverse : ∀ b, forward.run (backward.run b) = b + +/-- No nonzero integer annihilates a nonzero element. -/ +def TorsionFree {A : Type u} (G : AbGroup A) : Prop := + ∀ (k : Int), k ≠ 0 → ∀ a, G.zsmul k a = G.zero → a = G.zero + +namespace Retraction + +variable {C : Type u} {A : Type v} {B : Type w} +variable {GC : AbGroup C} {GA : AbGroup A} {GB : AbGroup B} +variable (s : Retraction GC GA GB) + +/-- The image of m, not the kernel of p by definition. -/ +def L (a : A) : Prop := ∃ c, s.m.run c = a + +theorem mem_image_iff (a : A) : s.L a ↔ s.p.run a = GB.zero := by + constructor + · intro h + cases h with + | intro c hc => + rw [← hc] + exact s.mp c + · intro h + have hr := s.residual a + rw [h, s.q.map_zero, GA.sub_zero] at hr + exact ⟨s.w.run a, hr.symm⟩ + +theorem image_eq_kernel : s.L = (fun a => s.p.run a = GB.zero) := by + funext a + exact propext (s.mem_image_iff a) + +theorem surjective : ∀ b, ∃ a, s.p.run a = b := by + intro b + exact ⟨s.q.run b, s.qp b⟩ + +theorem decomposition (a : A) : + a = GA.add (s.q.run (s.p.run a)) (s.m.run (s.w.run a)) := + GA.eq_of_sub_eq _ _ _ (s.residual a) + +/-- The literal lattice-coset relation: a - b lies in image(m). -/ +def Rel (a b : A) : Prop := s.L (GA.sub a b) + +theorem rel_iff (a b : A) : s.Rel a b ↔ s.p.run a = s.p.run b := by + unfold Rel + rw [s.mem_image_iff, s.p.map_sub] + exact GB.sub_eq_zero_iff _ _ + +def latticeSetoid : Setoid A where + r := s.Rel + iseqv := { + refl := by intro a; exact (s.rel_iff a a).mpr rfl + symm := by + intro a b hab + exact (s.rel_iff b a).mpr ((s.rel_iff a b).mp hab).symm + trans := by + intro a b c hab hbc + exact (s.rel_iff a c).mpr + (((s.rel_iff a b).mp hab).trans ((s.rel_iff b c).mp hbc)) + } + +abbrev LQuot := Quotient s.latticeSetoid + +def qmk (a : A) : s.LQuot := Quotient.mk s.latticeSetoid a + +/-- Well-definedness is the proved rel_iff, not an extra field. -/ +def qmap : s.LQuot → B := + Quotient.lift s.p.run (fun a b h => (s.rel_iff a b).mp h) + +def qinv (b : B) : s.LQuot := s.qmk (s.q.run b) + +theorem qmap_mk (a : A) : s.qmap (s.qmk a) = s.p.run a := rfl + +theorem qmap_qinv (b : B) : s.qmap (s.qinv b) = b := s.qp b + +theorem qinv_qmap (x : s.LQuot) : s.qinv (s.qmap x) = x := by + refine Quotient.inductionOn + (motive := fun q : s.LQuot => s.qinv (s.qmap q) = q) x ?_ + intro a + apply Quotient.sound + exact (s.rel_iff _ _).mpr (s.qp (s.p.run a)) + +theorem qmap_injective {x y : s.LQuot} (h : s.qmap x = s.qmap y) : x = y := by + calc + x = s.qinv (s.qmap x) := (s.qinv_qmap x).symm + _ = s.qinv (s.qmap y) := congrArg s.qinv h + _ = y := s.qinv_qmap y + +/-- Addition induced from representatives; both representative choices are checked. -/ +def qadd (x y : s.LQuot) : s.LQuot := + Quotient.liftOn₂ x y (fun a b => s.qmk (GA.add a b)) (by + intro a b c d hac hbd + apply Quotient.sound + apply (s.rel_iff _ _).mpr + rw [s.p.map_add, s.p.map_add, + (s.rel_iff a c).mp hac, (s.rel_iff b d).mp hbd]) + +def qneg (x : s.LQuot) : s.LQuot := + Quotient.liftOn x (fun a => s.qmk (GA.neg a)) (by + intro a b hab + apply Quotient.sound + apply (s.rel_iff _ _).mpr + rw [s.p.map_neg, s.p.map_neg, (s.rel_iff a b).mp hab]) + +theorem qmap_zero : s.qmap (s.qmk GA.zero) = GB.zero := s.p.map_zero + +theorem qmap_add (x y : s.LQuot) : + s.qmap (s.qadd x y) = GB.add (s.qmap x) (s.qmap y) := by + refine Quotient.inductionOn₂ + (motive := fun q r : s.LQuot => + s.qmap (s.qadd q r) = GB.add (s.qmap q) (s.qmap r)) x y ?_ + intro a b + exact s.p.map_add a b + +theorem qmap_neg (x : s.LQuot) : + s.qmap (s.qneg x) = GB.neg (s.qmap x) := by + refine Quotient.inductionOn + (motive := fun q : s.LQuot => + s.qmap (s.qneg q) = GB.neg (s.qmap q)) x ?_ + intro a + exact s.p.map_neg a + +/-- Every quotient-group axiom follows from the induced operations. -/ +def quotientGroup : AbGroup s.LQuot where + zero := s.qmk GA.zero + add := s.qadd + neg := s.qneg + add_assoc := by + intro x y z + apply s.qmap_injective + simp only [s.qmap_add] + exact GB.add_assoc _ _ _ + zero_add := by + intro x + apply s.qmap_injective + rw [s.qmap_add, s.qmap_zero, GB.zero_add] + add_zero := by + intro x + apply s.qmap_injective + rw [s.qmap_add, s.qmap_zero, GB.add_zero] + add_comm := by + intro x y + apply s.qmap_injective + rw [s.qmap_add, s.qmap_add, GB.add_comm] + neg_add := by + intro x + apply s.qmap_injective + rw [s.qmap_add, s.qmap_neg, s.qmap_zero, GB.neg_add] + add_neg := by + intro x + apply s.qmap_injective + rw [s.qmap_add, s.qmap_neg, s.qmap_zero, GB.add_neg] + +def quotientMap : Hom s.quotientGroup GB where + run := s.qmap + map_zero := s.qmap_zero + map_add := s.qmap_add + +def quotientInv : Hom GB s.quotientGroup where + run := s.qinv + map_zero := by + change s.qinv GB.zero = s.qmk GA.zero + apply s.qmap_injective + rw [s.qmap_qinv, s.qmap_zero] + map_add := by + intro x y + change s.qinv (GB.add x y) = s.qadd (s.qinv x) (s.qinv y) + apply s.qmap_injective + simp only [s.qmap_add, s.qmap_qinv] + +def quotientIso : AddIso s.quotientGroup GB where + forward := s.quotientMap + backward := s.quotientInv + left_inverse := s.qinv_qmap + right_inverse := s.qmap_qinv + +theorem saturated (hTF : TorsionFree GB) (k : Int) (hk : k ≠ 0) + (a : A) (ha : s.L (GA.zsmul k a)) : s.L a := by + apply (s.mem_image_iff a).mpr + apply hTF k hk (s.p.run a) + calc + GB.zsmul k (s.p.run a) = s.p.run (GA.zsmul k a) := + (s.p.map_zsmul k a).symm + _ = GB.zero := (s.mem_image_iff _).mp ha + +/-- Abstract character factorization; the finite-row theorem below proves + this annihilation hypothesis from the individual relation rows. -/ +theorem character_factor {D : Type t} {GD : AbGroup D} + (chi : Hom GA GD) (h : ∀ c, chi.run (s.m.run c) = GD.zero) + (a : A) : chi.run a = chi.run (s.q.run (s.p.run a)) := by + have hc := congrArg chi.run (s.residual a) + rw [chi.map_sub, h (s.w.run a)] at hc + exact (GD.sub_eq_zero_iff _ _).mp hc + +theorem character_unique {D : Type t} {GD : AbGroup D} + (chi : Hom GA GD) (psi : Hom GB GD) + (h : ∀ a, chi.run a = psi.run (s.p.run a)) (b : B) : + psi.run b = chi.run (s.q.run b) := by + have hb := h (s.q.run b) + rw [s.qp] at hb + exact hb.symm + +end Retraction + +/-! ## 4. The concrete integral-matrix instantiation -/ + +/-- The only certificate hypotheses. No geometry or hidden image assertions. -/ +structure MatrixIdentities {m N d : Nat} + (M : Mat m N) (P : Mat N d) (Q : Mat d N) (W : Mat N m) : Prop where + mp : matMul M P = zeroMat m d + qp : matMul Q P = eye d + residual : matSub (eye N) (matMul P Q) = matMul W M + +/-- Derives all three split-map identities from ordinary matrix equalities. -/ +def matrixRetraction {m N d : Nat} + {M : Mat m N} {P : Mat N d} {Q : Mat d N} {W : Mat N m} + (h : MatrixIdentities M P Q W) : + Retraction (rowGroup m) (rowGroup N) (rowGroup d) where + m := Rows.rowHom M + p := Rows.rowHom P + q := Rows.rowHom Q + w := Rows.rowHom W + mp := by + intro z + change rowMul (rowMul z M) P = (rowGroup d).zero + rw [Rows.rowMul_assoc, h.mp, Rows.rowMul_zero_right] + qp := by + intro z + change rowMul (rowMul z Q) P = z + rw [Rows.rowMul_assoc, h.qp, Rows.rowMul_eye] + residual := by + intro z + change (rowGroup N).sub z (rowMul (rowMul z P) Q) = + rowMul (rowMul z W) M + rw [Rows.rowMul_assoc z P Q, Rows.rowMul_assoc z W M] + calc + (rowGroup N).sub z (rowMul z (matMul P Q)) = + rowMul z (matSub (eye N) (matMul P Q)) := by + rw [Rows.rowMul_matSub, Rows.rowMul_eye] + _ = rowMul z (matMul W M) := congrArg (rowMul z) h.residual + +namespace MatrixBridge + +variable {m N d : Nat} +variable {M : Mat m N} {P : Mat N d} {Q : Mat d N} {W : Mat N m} + +/-- Image definition, with literal integer coefficients. -/ +def Lattice (v : Row N) : Prop := ∃ z : Row m, rowMul z M = v + +theorem lattice_iff_integer_span (v : Row N) : + Lattice (M := M) v ↔ ∃ z : Row m, + fsum (rowGroup N) m (fun r => (rowGroup N).zsmul (z r) (M r)) = v := by + constructor + · intro hv + cases hv with + | intro z hz => + exact ⟨z, (Rows.rowMul_linear_combination z M).symm.trans hz⟩ + · intro hv + cases hv with + | intro z hz => + exact ⟨z, (Rows.rowMul_linear_combination z M).trans hz⟩ + +theorem lattice_eq_kernel (h : MatrixIdentities M P Q W) + (v : Row N) : + Lattice (M := M) v ↔ rowMul v P = (rowGroup d).zero := + (matrixRetraction h).mem_image_iff v + +theorem lattice_eq_kernel_as_predicate (h : MatrixIdentities M P Q W) : + Lattice (M := M) = (fun v => rowMul v P = (rowGroup d).zero) := by + funext v + exact propext (lattice_eq_kernel h v) + +theorem quotient_relation (h : MatrixIdentities M P Q W) + (v w : Row N) : + (matrixRetraction h).Rel v w ↔ + ∃ z : Row m, rowMul z M = (fun i => v i - w i) := Iff.rfl + +theorem quotient_equal_iff (h : MatrixIdentities M P Q W) + (v w : Row N) : + (matrixRetraction h).qmk v = (matrixRetraction h).qmk w ↔ + Lattice (M := M) ((rowGroup N).sub v w) := by + constructor + · intro heq + exact Quotient.exact heq + · intro hrel + exact Quotient.sound hrel + +theorem phi_surjective (h : MatrixIdentities M P Q W) : ∀ z : Row d, ∃ v : Row N, rowMul v P = z := + (matrixRetraction h).surjective + +/-- The inverse representative is z Q; this is not an arbitrary chosen section. -/ +def quotientIso (h : MatrixIdentities M P Q W) : + AddIso (matrixRetraction h).quotientGroup (rowGroup d) := + (matrixRetraction h).quotientIso + +theorem quotient_forward_on_representative (h : MatrixIdentities M P Q W) + (v : Row N) : + (quotientIso h).forward.run ((matrixRetraction h).qmk v) = rowMul v P := rfl + +theorem quotient_inverse_on_parameter (h : MatrixIdentities M P Q W) + (z : Row d) : + (quotientIso h).backward.run z = + (matrixRetraction h).qmk (rowMul z Q) := rfl + +theorem quotient_left_inverse (h : MatrixIdentities M P Q W) + (x : (matrixRetraction h).LQuot) : + (quotientIso h).backward.run ((quotientIso h).forward.run x) = x := + (quotientIso h).left_inverse x + +theorem quotient_right_inverse (h : MatrixIdentities M P Q W) + (z : Row d) : + (quotientIso h).forward.run ((quotientIso h).backward.run z) = z := + (quotientIso h).right_inverse z + +/-- Concrete torsion-freeness, from integer multiplication having no zero divisors. -/ +theorem row_torsion_free (n : Nat) : TorsionFree (rowGroup n) := by + intro k hk v hv + rw [Rows.row_zsmul] at hv + funext i + have hi := congrArg (fun a : Row n => a i) hv + change k * v i = 0 at hi + exact (Int.mul_eq_zero.mp hi).resolve_left hk + +theorem lattice_saturated (h : MatrixIdentities M P Q W) + (k : Int) (hk : k ≠ 0) (v : Row N) + (hv : Lattice (M := M) (scale k v)) : Lattice (M := M) v := by + apply (matrixRetraction h).saturated (row_torsion_free d) k hk v + change Lattice (M := M) ((rowGroup N).zsmul k v) + rw [Rows.row_zsmul] + exact hv + +end MatrixBridge + +/-! ## 5. Lawful commutative groups, actual products, and signed powers -/ + +/-- No field, divisibility, roots, or characteristic hypotheses. -/ +structure CommGroup (D : Type u) where + one : D + mul : D → D → D + inv : D → D + mul_assoc : ∀ a b c, mul (mul a b) c = mul a (mul b c) + one_mul : ∀ a, mul one a = a + mul_one : ∀ a, mul a one = a + mul_comm : ∀ a b, mul a b = mul b a + inv_mul : ∀ a, mul (inv a) a = one + mul_inv : ∀ a, mul a (inv a) = one + +namespace CommGroup + +variable {D : Type u} (G : CommGroup D) + +/-- Only a change of notation: addition is multiplication, negation is inverse. -/ +def asAdd : AbGroup D where + zero := G.one + add := G.mul + neg := G.inv + add_assoc := G.mul_assoc + zero_add := G.one_mul + add_zero := G.mul_one + add_comm := G.mul_comm + neg_add := G.inv_mul + add_neg := G.mul_inv + +def npow (a : D) (n : Nat) : D := G.asAdd.nsmul n a + +def zpow (a : D) (k : Int) : D := G.asAdd.zsmul k a + +def prod (n : Nat) (f : Fin n → D) : D := fsum G.asAdd n f + +def div (a b : D) : D := G.mul a (G.inv b) + +theorem npow_zero (a : D) : G.npow a 0 = G.one := rfl + +theorem npow_succ (a : D) (n : Nat) : + G.npow a (n + 1) = G.mul (G.npow a n) a := rfl + +theorem zpow_nat (a : D) (n : Nat) : + G.zpow a (Int.ofNat n) = G.npow a n := rfl + +theorem zpow_negative (a : D) (n : Nat) : + G.zpow a (-((n + 1 : Nat) : Int)) = G.inv (G.npow a (n + 1)) := rfl + +theorem zpow_zero (a : D) : G.zpow a 0 = G.one := rfl + +theorem zpow_one (a : D) : G.zpow a 1 = a := G.asAdd.zsmul_one a + +theorem one_zpow (k : Int) : G.zpow G.one k = G.one := + G.asAdd.zsmul_zero_right k + +theorem zpow_add (a : D) (k l : Int) : + G.zpow a (k + l) = G.mul (G.zpow a k) (G.zpow a l) := + G.asAdd.zsmul_add k l a + +theorem prod_zero (f : Fin 0 → D) : G.prod 0 f = G.one := rfl + +theorem prod_succ (n : Nat) (f : Fin (n + 1) → D) : + G.prod (n + 1) f = G.mul (f 0) (G.prod n (fun i => f i.succ)) := rfl + +theorem prod_mul (n : Nat) (f g : Fin n → D) : + G.prod n (fun i => G.mul (f i) (g i)) = + G.mul (G.prod n f) (G.prod n g) := + Finite.sum_add G.asAdd n f g + +end CommGroup + +/-- Literal finite product of ordinary signed integral powers. -/ +def monomial {D : Type u} (G : CommGroup D) {n : Nat} + (x : Fin n → D) (v : Row n) : D := + G.prod n (fun i => G.zpow (x i) (v i)) + +/-- The monomial is proved to be a character, not supplied as one. -/ +def monomialHom {D : Type u} (G : CommGroup D) {n : Nat} + (x : Fin n → D) : Hom (rowGroup n) G.asAdd where + run := monomial G x + map_zero := by + change fsum G.asAdd n (fun i => G.asAdd.zsmul 0 (x i)) = G.one + simp only [AbGroup.zsmul_zero] + exact Finite.sum_zero G.asAdd n + map_add := by + intro v w + change fsum G.asAdd n (fun i => G.asAdd.zsmul (v i + w i) (x i)) = + G.asAdd.add (fsum G.asAdd n (fun i => G.asAdd.zsmul (v i) (x i))) + (fsum G.asAdd n (fun i => G.asAdd.zsmul (w i) (x i))) + simp only [AbGroup.zsmul_add] + exact Finite.sum_add G.asAdd n _ _ + +namespace Character + +variable {D : Type u} {m n : Nat} + +/-- A finite row image is evaluated as the indicated integer powers of row values. -/ +theorem row_image (G : AbGroup D) (chi : Hom (rowGroup n) G) + (v : Row m) (A : Mat m n) : + chi.run (rowMul v A) = + fsum G m (fun r => G.zsmul (v r) (chi.run (A r))) := by + rw [Rows.rowMul_linear_combination, Finite.map_sum] + apply Finite.sum_congr + intro r + exact chi.map_zsmul (v r) (A r) + +/-- The bridge from INDIVIDUAL rows to their entire INTEGER span. -/ +theorem rows_annihilate_span (G : AbGroup D) (chi : Hom (rowGroup n) G) + (A : Mat m n) (h : ∀ r, chi.run (A r) = G.zero) (v : Row m) : + chi.run (rowMul v A) = G.zero := by + rw [row_image G chi v A] + calc + _ = fsum G m (fun _ => G.zero) := by + apply Finite.sum_congr + intro r + rw [h r, G.zsmul_zero_right] + _ = G.zero := Finite.sum_zero G m + +end Character + +namespace Monomial + +variable {D : Type u} (G : CommGroup D) + +theorem zero {n : Nat} (x : Fin n → D) : + monomial G x (rowGroup n).zero = G.one := (monomialHom G x).map_zero + +theorem add {n : Nat} (x : Fin n → D) (v w : Row n) : + monomial G x ((rowGroup n).add v w) = + G.mul (monomial G x v) (monomial G x w) := + (monomialHom G x).map_add v w + +theorem sub {n : Nat} (x : Fin n → D) (v w : Row n) : + monomial G x ((rowGroup n).sub v w) = + G.div (monomial G x v) (monomial G x w) := + (monomialHom G x).map_sub v w + +theorem scale {n : Nat} (x : Fin n → D) (k : Int) (v : Row n) : + monomial G x (PR1497.scale k v) = G.zpow (monomial G x v) k := by + rw [← Rows.row_zsmul] + exact (monomialHom G x).map_zsmul k v + +theorem on_basis {n : Nat} (x : Fin n → D) (i : Fin n) : + monomial G x (basis n i) = x i := by + change fsum G.asAdd n + (fun j => G.asAdd.zsmul (if j = i then 1 else 0) (x j)) = x i + calc + _ = fsum G.asAdd n (fun j => if j = i then x i else G.asAdd.zero) := by + apply Finite.sum_congr + intro j + by_cases h : j = i + · subst j + simp only [eq_self, ite_true, AbGroup.zsmul_one] + · simp only [if_neg h, AbGroup.zsmul_zero] + _ = x i := Finite.sum_single G.asAdd n i (x i) + +/-- Actual monomial substitution, including negative exponents. -/ +theorem substitution {m n : Nat} (x : Fin n → D) + (v : Row m) (A : Mat m n) : + monomial G x (rowMul v A) = + monomial G (fun r => monomial G x (A r)) v := + Character.row_image G.asAdd (monomialHom G x) v A + +theorem individual_rows_to_span {m n : Nat} (x : Fin n → D) + (A : Mat m n) (h : ∀ r, monomial G x (A r) = G.one) (v : Row m) : + monomial G x (rowMul v A) = G.one := + Character.rows_annihilate_span G.asAdd (monomialHom G x) A h v + +end Monomial + +/-! ## 6. Matrix-to-monomial reconstruction and converse, without root extraction -/ + +namespace MonomialBridge + +variable {D : Type u} (G : CommGroup D) + +def parameters {d N : Nat} (Q : Mat d N) (x : Fin N → D) : Fin d → D := + fun j => monomial G x (Q j) + +def realization {N d : Nat} (P : Mat N d) (theta : Fin d → D) : Fin N → D := + fun i => monomial G theta (P i) + +def Relations {m N : Nat} (M : Mat m N) (x : Fin N → D) : Prop := + ∀ r, monomial G x (M r) = G.one + +variable {m N d : Nat} +variable {M : Mat m N} {P : Mat N d} {Q : Mat d N} {W : Mat N m} + +/-- Stronger than coordinate reconstruction: every exponent vector factors through P. -/ +theorem reconstruction_all_exponents (h : MatrixIdentities M P Q W) + (x : Fin N → D) + (hx : Relations G M x) (v : Row N) : + monomial G x v = monomial G (parameters G Q x) (rowMul v P) := by + have hann : ∀ c, (monomialHom G x).run ((matrixRetraction h).m.run c) = + G.asAdd.zero := by + intro c + exact Monomial.individual_rows_to_span G x M hx c + calc + monomial G x v = monomial G x (rowMul (rowMul v P) Q) := + (matrixRetraction h).character_factor (monomialHom G x) hann v + _ = monomial G (parameters G Q x) (rowMul v P) := + Monomial.substitution G x (rowMul v P) Q + +theorem reconstruct_coordinate (h : MatrixIdentities M P Q W) + (x : Fin N → D) + (hx : Relations G M x) (i : Fin N) : + x i = monomial G (parameters G Q x) (P i) := by + have hi := reconstruction_all_exponents G h x hx (basis N i) + rw [Monomial.on_basis, Rows.rowMul_basis] at hi + exact hi + +theorem reconstruction (h : MatrixIdentities M P Q W) + (x : Fin N → D) (hx : Relations G M x) : + x = realization G P (parameters G Q x) := by + funext i + exact reconstruct_coordinate G h x hx i + +/-- Every arbitrary parameter tuple gives a solution of the individual relations. -/ +theorem converse_relations (h : MatrixIdentities M P Q W) + (theta : Fin d → D) : + Relations G M (realization G P theta) := by + intro r + have hr : rowMul (M r) P = (rowGroup d).zero := + congrArg (fun A : Mat m d => A r) h.mp + calc + monomial G (realization G P theta) (M r) = + monomial G theta (rowMul (M r) P) := + (Monomial.substitution G theta (M r) P).symm + _ = G.one := by rw [hr]; exact Monomial.zero G theta + +/-- QP = I recovers arbitrary parameters exactly, not merely up to powers. -/ +theorem parameters_recover (h : MatrixIdentities M P Q W) + (theta : Fin d → D) : + parameters G Q (realization G P theta) = theta := by + funext j + have hj : rowMul (Q j) P = basis d j := + congrArg (fun A : Mat d d => A j) h.qp + change monomial G (realization G P theta) (Q j) = theta j + calc + _ = monomial G theta (rowMul (Q j) P) := + (Monomial.substitution G theta (Q j) P).symm + _ = theta j := by rw [hj]; exact Monomial.on_basis G theta j + +/-- Any tuple realizing x is the tuple defined by the Q monomials. -/ +theorem parameters_unique (h : MatrixIdentities M P Q W) + (x : Fin N → D) (theta : Fin d → D) + (hreal : ∀ i, x i = monomial G theta (P i)) : + parameters G Q x = theta := by + have hx : x = realization G P theta := funext hreal + rw [hx] + exact parameters_recover G h theta + +/-- First equality in the requested residual calculation. -/ +theorem residual_exponent_formula (x : Fin N → D) (i : Fin N) : + G.div (x i) (monomial G (parameters G Q x) (P i)) = + monomial G x ((rowGroup N).sub (basis N i) ((matMul P Q) i)) := by + change G.div (x i) + (monomial G (fun j => monomial G x (Q j)) (P i)) = + monomial G x ((rowGroup N).sub (basis N i) (rowMul (P i) Q)) + rw [Monomial.sub, Monomial.on_basis, Monomial.substitution] + +/-- Second equality, with a literal finite product and the literal W coefficients. + This equation does not need the row relations to equal one. -/ +theorem residual_relations_formula (h : MatrixIdentities M P Q W) + (x : Fin N → D) (i : Fin N) : + G.div (x i) (monomial G (parameters G Q x) (P i)) = + G.prod m (fun r => G.zpow (monomial G x (M r)) (W i r)) := by + have hi : (rowGroup N).sub (basis N i) ((matMul P Q) i) = + rowMul (W i) M := + congrArg (fun A : Mat N N => A i) h.residual + rw [residual_exponent_formula G, hi] + exact Monomial.substitution G x (W i) M + +theorem residual_eq_one (h : MatrixIdentities M P Q W) + (x : Fin N → D) (hx : Relations G M x) (i : Fin N) : + G.div (x i) (monomial G (parameters G Q x) (P i)) = G.one := by + rw [reconstruct_coordinate G h x hx i] + exact G.mul_inv _ + +/-- Existence and uniqueness are both stated without a choice operator. -/ +theorem unique_parameterization (h : MatrixIdentities M P Q W) + (x : Fin N → D) (hx : Relations G M x) : + (∀ i, x i = monomial G (parameters G Q x) (P i)) ∧ + (∀ theta : Fin d → D, + (∀ i, x i = monomial G theta (P i)) → parameters G Q x = theta) := by + constructor + · exact reconstruct_coordinate G h x hx + · intro theta ht + exact parameters_unique G h x theta ht + +end MonomialBridge + +end PR1497 + +/-! ## Complete axiom-query inventory (output requires actual Lean replay). -/ +set_option pp.fullNames true +#print axioms PR1497.AbGroup +#print axioms PR1497.AbGroup.sub +#print axioms PR1497.AbGroup.add_left_cancel +#print axioms PR1497.AbGroup.add_right_cancel +#print axioms PR1497.AbGroup.add_left_comm +#print axioms PR1497.AbGroup.add_four +#print axioms PR1497.AbGroup.neg_zero +#print axioms PR1497.AbGroup.neg_neg +#print axioms PR1497.AbGroup.neg_add_distrib +#print axioms PR1497.AbGroup.sub_zero +#print axioms PR1497.AbGroup.sub_self +#print axioms PR1497.AbGroup.sub_add_cancel +#print axioms PR1497.AbGroup.add_sub_cancel +#print axioms PR1497.AbGroup.sub_eq_zero_iff +#print axioms PR1497.AbGroup.eq_of_sub_eq +#print axioms PR1497.AbGroup.nsmul +#print axioms PR1497.AbGroup.zsmul +#print axioms PR1497.AbGroup.nsmul_zero +#print axioms PR1497.AbGroup.zsmul_zero +#print axioms PR1497.AbGroup.zsmul_zero_right +#print axioms PR1497.AbGroup.zsmul_one +#print axioms PR1497.AbGroup.int_induction +#print axioms PR1497.AbGroup.zsmul_succ +#print axioms PR1497.AbGroup.zsmul_pred +#print axioms PR1497.AbGroup.zsmul_add +#print axioms PR1497.Hom +#print axioms PR1497.Hom.id +#print axioms PR1497.Hom.comp +#print axioms PR1497.Hom.ext +#print axioms PR1497.Hom.map_neg +#print axioms PR1497.Hom.map_sub +#print axioms PR1497.Hom.map_nsmul +#print axioms PR1497.Hom.map_zsmul +#print axioms PR1497.fsum +#print axioms PR1497.Finite.sum_congr +#print axioms PR1497.Finite.sum_zero +#print axioms PR1497.Finite.sum_add +#print axioms PR1497.Finite.sum_neg +#print axioms PR1497.Finite.sum_sub +#print axioms PR1497.Finite.sum_swap +#print axioms PR1497.Finite.sum_single +#print axioms PR1497.Finite.map_sum +#print axioms PR1497.intGroup +#print axioms PR1497.functionGroup +#print axioms PR1497.Row +#print axioms PR1497.Mat +#print axioms PR1497.rowGroup +#print axioms PR1497.scale +#print axioms PR1497.basis +#print axioms PR1497.eye +#print axioms PR1497.zeroMat +#print axioms PR1497.matSub +#print axioms PR1497.rowMul +#print axioms PR1497.matMul +#print axioms PR1497.Rows.sum_apply +#print axioms PR1497.Rows.nsmul_apply +#print axioms PR1497.Rows.zsmul_apply +#print axioms PR1497.Rows.int_nsmul +#print axioms PR1497.Rows.int_zsmul +#print axioms PR1497.Rows.row_zsmul +#print axioms PR1497.Rows.sum_mul_right +#print axioms PR1497.Rows.sum_mul_left +#print axioms PR1497.Rows.rowMul_zero_left +#print axioms PR1497.Rows.rowMul_zero_right +#print axioms PR1497.Rows.rowMul_add +#print axioms PR1497.Rows.rowMul_matSub +#print axioms PR1497.Rows.rowMul_assoc +#print axioms PR1497.Rows.rowMul_basis +#print axioms PR1497.Rows.rowMul_eye +#print axioms PR1497.Rows.rowMul_linear_combination +#print axioms PR1497.Rows.rowHom +#print axioms PR1497.Retraction +#print axioms PR1497.AddIso +#print axioms PR1497.TorsionFree +#print axioms PR1497.Retraction.L +#print axioms PR1497.Retraction.mem_image_iff +#print axioms PR1497.Retraction.image_eq_kernel +#print axioms PR1497.Retraction.surjective +#print axioms PR1497.Retraction.decomposition +#print axioms PR1497.Retraction.Rel +#print axioms PR1497.Retraction.rel_iff +#print axioms PR1497.Retraction.latticeSetoid +#print axioms PR1497.Retraction.LQuot +#print axioms PR1497.Retraction.qmk +#print axioms PR1497.Retraction.qmap +#print axioms PR1497.Retraction.qinv +#print axioms PR1497.Retraction.qmap_mk +#print axioms PR1497.Retraction.qmap_qinv +#print axioms PR1497.Retraction.qinv_qmap +#print axioms PR1497.Retraction.qmap_injective +#print axioms PR1497.Retraction.qadd +#print axioms PR1497.Retraction.qneg +#print axioms PR1497.Retraction.qmap_zero +#print axioms PR1497.Retraction.qmap_add +#print axioms PR1497.Retraction.qmap_neg +#print axioms PR1497.Retraction.quotientGroup +#print axioms PR1497.Retraction.quotientMap +#print axioms PR1497.Retraction.quotientInv +#print axioms PR1497.Retraction.quotientIso +#print axioms PR1497.Retraction.saturated +#print axioms PR1497.Retraction.character_factor +#print axioms PR1497.Retraction.character_unique +#print axioms PR1497.MatrixIdentities +#print axioms PR1497.matrixRetraction +#print axioms PR1497.MatrixBridge.Lattice +#print axioms PR1497.MatrixBridge.lattice_iff_integer_span +#print axioms PR1497.MatrixBridge.lattice_eq_kernel +#print axioms PR1497.MatrixBridge.lattice_eq_kernel_as_predicate +#print axioms PR1497.MatrixBridge.quotient_relation +#print axioms PR1497.MatrixBridge.quotient_equal_iff +#print axioms PR1497.MatrixBridge.phi_surjective +#print axioms PR1497.MatrixBridge.quotientIso +#print axioms PR1497.MatrixBridge.quotient_forward_on_representative +#print axioms PR1497.MatrixBridge.quotient_inverse_on_parameter +#print axioms PR1497.MatrixBridge.quotient_left_inverse +#print axioms PR1497.MatrixBridge.quotient_right_inverse +#print axioms PR1497.MatrixBridge.row_torsion_free +#print axioms PR1497.MatrixBridge.lattice_saturated +#print axioms PR1497.CommGroup +#print axioms PR1497.CommGroup.asAdd +#print axioms PR1497.CommGroup.npow +#print axioms PR1497.CommGroup.zpow +#print axioms PR1497.CommGroup.prod +#print axioms PR1497.CommGroup.div +#print axioms PR1497.CommGroup.npow_zero +#print axioms PR1497.CommGroup.npow_succ +#print axioms PR1497.CommGroup.zpow_nat +#print axioms PR1497.CommGroup.zpow_negative +#print axioms PR1497.CommGroup.zpow_zero +#print axioms PR1497.CommGroup.zpow_one +#print axioms PR1497.CommGroup.one_zpow +#print axioms PR1497.CommGroup.zpow_add +#print axioms PR1497.CommGroup.prod_zero +#print axioms PR1497.CommGroup.prod_succ +#print axioms PR1497.CommGroup.prod_mul +#print axioms PR1497.monomial +#print axioms PR1497.monomialHom +#print axioms PR1497.Character.row_image +#print axioms PR1497.Character.rows_annihilate_span +#print axioms PR1497.Monomial.zero +#print axioms PR1497.Monomial.add +#print axioms PR1497.Monomial.sub +#print axioms PR1497.Monomial.scale +#print axioms PR1497.Monomial.on_basis +#print axioms PR1497.Monomial.substitution +#print axioms PR1497.Monomial.individual_rows_to_span +#print axioms PR1497.MonomialBridge.parameters +#print axioms PR1497.MonomialBridge.realization +#print axioms PR1497.MonomialBridge.Relations +#print axioms PR1497.MonomialBridge.reconstruction_all_exponents +#print axioms PR1497.MonomialBridge.reconstruct_coordinate +#print axioms PR1497.MonomialBridge.reconstruction +#print axioms PR1497.MonomialBridge.converse_relations +#print axioms PR1497.MonomialBridge.parameters_recover +#print axioms PR1497.MonomialBridge.parameters_unique +#print axioms PR1497.MonomialBridge.residual_exponent_formula +#print axioms PR1497.MonomialBridge.residual_relations_formula +#print axioms PR1497.MonomialBridge.residual_eq_one +#print axioms PR1497.MonomialBridge.unique_parameterization diff --git a/research/p112-integral-retraction-instance/source/PRODUCER_CHECKS.json b/research/p112-integral-retraction-instance/source/PRODUCER_CHECKS.json new file mode 100644 index 0000000000..14ff758c19 --- /dev/null +++ b/research/p112-integral-retraction-instance/source/PRODUCER_CHECKS.json @@ -0,0 +1,119 @@ +{ + "status": "PRODUCER_NON_LEAN_CHECKS_PASSED; NEW KERNEL REPLAY PENDING", + "python_version": "3.13.5 (main, Jul 15 2026, 20:25:40) [GCC 14.2.0]", + "commands_actually_executed": [ + { + "label": "regeneration", + "command": [ + "/opt/pyvenv/bin/python", + "generate.py", + "--check" + ], + "returncode": 0, + "elapsed_seconds": 0.6661432789999253, + "stdout": "producer/regeneration.stdout", + "stderr": "producer/regeneration.stderr", + "lean_invoked": false + }, + { + "label": "source-audit", + "command": [ + "/opt/pyvenv/bin/python", + "audit_sources.py" + ], + "returncode": 0, + "elapsed_seconds": 0.8213819400000375, + "stdout": "producer/source-audit.stdout", + "stderr": "producer/source-audit.stderr", + "lean_invoked": false + }, + { + "label": "integer-check", + "command": [ + "/opt/pyvenv/bin/python", + "check_numeric.py" + ], + "returncode": 0, + "elapsed_seconds": 0.9055207979999977, + "stdout": "producer/integer-check.stdout", + "stderr": "producer/integer-check.stderr", + "lean_invoked": false + }, + { + "label": "tooling-tests", + "command": [ + "/opt/pyvenv/bin/python", + "test_tooling.py" + ], + "returncode": 0, + "elapsed_seconds": 1.178418941000018, + "stdout": "producer/tooling-tests.stdout", + "stderr": "producer/tooling-tests.stderr", + "lean_invoked": false + } + ], + "python_syntax_checked_files": [ + "audit_sources.py", + "check_axioms.py", + "check_numeric.py", + "generate.py", + "replay.py", + "test_tooling.py" + ], + "actual_lean_runs": [], + "new_lean_axiom_reports": null, + "new_lean_kernel_runtime_seconds": null, + "new_lean_positive_control_executed": false, + "new_lean_negative_control_executed": false, + "source_queries_not_observed_axiom_records": { + "inherited": 159, + "new": 477, + "combined": 636 + }, + "named_new_theorems": 457, + "named_new_definitions": 20, + "tooling_tests_passed": 14, + "new_lean_source_sha256": { + "P112/MP00.lean": "13f94407d2f564d1df02abd05d65c789f9ef0fd146ea83f219cc2b0790530da5", + "P112/MP01.lean": "374fac864b91f4d3be22c064933bd04fe68479e0aae3a2d47f417c053ebf7c26", + "P112/MP02.lean": "a2d4ce0941183e59c87d89a1369bd8cae8e5aa17457a20352ecbcdd0eec847ac", + "P112/MP03.lean": "25846cbeac859682f102a4eba089f88fd6aece81538d368422b0347323d9a450", + "P112/MP04.lean": "9c9694edc8e991dcc669d37de9116309c86bf408743993384b01c6bf7eae0e64", + "P112/MP05.lean": "e90fd3cebc97e91d1fec063ccd50fa67e82375c23e317d755ee52de07c6e2840", + "P112/MP06.lean": "02d4f4c3dc89e560e8f1109b051bb912f26e6a238c8f3c25237b67b144321f7e", + "P112/MP07.lean": "39452ad57ba92c9cd54e9868a663b1b773c25143e0c24556899153cbcdae3842", + "P112/MP08.lean": "5905bb732b9976adba77dab859b52f1a3dbd01a2368ca92e1144d98db0c0b967", + "P112/MP09.lean": "580c7521ccf594444d673a66280d448d36f5111bdfdc5303ad95547420c49ca2", + "P112/MP10.lean": "317283042cdb1844c55de12c5fc9afaaf8efbd97552f64d7a3172a3b51fbd4d3", + "P112/MP11.lean": "e8898d45d1e5d0e39235b6a1eaf1880cdb9928442b4238d3a909a0b725ca394e", + "P112/MP12.lean": "9244768a96a7351430167c9865051fcac394f591cd37bb21b8a93c59a0d9295a", + "P112/MP13.lean": "b84a8d8657b85161f98fb8971b574526a6d53fce9e50847f59bf816a91351a38", + "P112/MP14.lean": "03915213d9aec2110071dcfd205de00e929220d092ea8238ed9036f96ac1fc4f", + "P112/MP15.lean": "c1342bca97cb22f3773f16453fa88ec4a4ec4a5b2ad8deaa8f37317cc131fa04", + "P112/MP16.lean": "47336a6652bdfb9efac4291b73be99f41efe2fc68014562bd86ff092a34f2368", + "P112/MP17.lean": "7da6a378c8e262cd027a7b8391df3f9b8c445eb750a5e2e11a2fa988314368a5", + "P112/QP00.lean": "b5015a85de7edf9df93f1b00fd6433113ef25ef177b75a840cdaa29068e5edff", + "P112/QP01.lean": "e00cc8dd0c6798387436fa2625ef7bc59d61bfdf0b67efc4d5b132d1b9679f43", + "P112/QP02.lean": "4fa1e2783b8082d03b434d7acc6549de4027d3e72685c9913158283c76957ea7", + "P112/Residual00.lean": "f0018130a836f72d6a830da8247d4cd37df7df7c9418f5c528785227e364b577", + "P112/Residual01.lean": "c31b6b2d62e7b4dc0ff2d7d93c9510160c4015da8cf03729345fa4afec6e7db2", + "P112/Residual02.lean": "fd3d9e3ec624ef77309b78f21214f9e1d44ad97b96c1268bf3f10924a50ca1f2", + "P112/Residual03.lean": "fee2b63b5a52a3f0cd88973c0b1e9ec75a3966ff152e42cf540cb20cc737cc05", + "P112/Residual04.lean": "45bf845eb22460635f81d85757ed29e33622a5b123dc858b5f0673f3ad968c42", + "P112/Residual05.lean": "1fce648ce627b596a758be98790829f4df7f414a90d29cec34bdcefe749c08dd", + "P112/Residual06.lean": "fc26879525f376ee93a7d4c037ca42e49c597372a30b82d4f1107c9f0c36d1bb", + "P112/Residual07.lean": "828f358afed3c9ea4839a3e15400294b77e313b31dcfd58b278f309e5f4854fd", + "P112/Residual08.lean": "665f03ae5197ee1b90c585613e717da85b682cae471d8b00da97846b28732497", + "P112/Residual09.lean": "ada3f0b6e1e66fd4a16f56bbcfb62e02f248d3d085889697ff818f95ade3b95d", + "P112/Residual10.lean": "3dfeb23cd21058c8b98b58cc97d0fc2812d49efad5b1752dcb52cd2b47ff317f", + "P112/Residual11.lean": "6d7604d36d7879801758de815fbfbdf38b2975ae6cd5ce722c20709bd00c50bc", + "P112/Residual12.lean": "6a727a2c56358da83565fc27474cef83c02fb0fa5af53dae4e18af6d55675810", + "P112Certificate.lean": "7a2717b923e4fb37fd9d9cf6f30f091f38f899b9feb92b140113e7bbc62a58e1", + "P112Consequences.lean": "bf2d28f786f2aeee4ea0e0d733ad3f6973c133fe9cde452c21fc36ca709444bc", + "P112Damaged.lean": "226d1d71548fd816f3e01c00b19c28d6a938b94717ad6da23d269ba56557186b", + "P112Data.lean": "c5619fb4e1b10663f48deb39272d191ba444f7052b0170a65186422e8177d967", + "P112Sparse.lean": "1f9cae94b0767d117cd0c30c5852df385a1e98f6d255f130303130d9b7b4d071", + "fixtures/RejectDamagedW.lean": "7796f968b92e57759776b10c9a37847ffde62bbc6d8a7fda321f09b3cba2dda5" + }, + "important_boundary": "Python source/numerical/test outputs are not evidence of Lean compilation, kernel acceptance, new axiom dependencies, or resource feasibility." +} diff --git a/research/p112-integral-retraction-instance/source/PROVENANCE.json b/research/p112-integral-retraction-instance/source/PROVENANCE.json new file mode 100644 index 0000000000..043d9bb3b8 --- /dev/null +++ b/research/p112-integral-retraction-instance/source/PROVENANCE.json @@ -0,0 +1,55 @@ +{ + "status": "NEW SUCCESSOR SOURCE ONLY / NOT YET KERNEL CHECKED", + "dependency": { + "file": "PR1497Bridge.lean", + "utf8_bytes": 48758, + "sha256": "a27494b0d40bbf7874fd9a875e468c67d11545b266e17bc98f2ca75c77f6ee40", + "git_blob": "950829a2871b4d069bf7c286525214ab1724ce5f", + "pr": 1610, + "commit": "985fd79ffea7ae7375fe6aa3ce9940b125c7dca2", + "url": "https://github.com/CrocSwap/integer-mult-bounds/blob/985fd79ffea7ae7375fe6aa3ce9940b125c7dca2/research/integral-retraction-monomial-bridge/PR1497Bridge.lean", + "transport": "Recovered from the actually accessible earlier source body and the exact embedded published header; accepted only after byte count, supplied SHA256 and Git blob match. No executable source changes. No public dependency fetch was required.", + "predecessor_kernel_status": "Successful local replay reported by requester; not newly executed here." + }, + "fragment": { + "file": "P112.json", + "utf8_bytes": 13183, + "sha256": "a1b43a5a7a8dcce0b84858244c512e53e6c344877cc35e87937fedd2601f29d5", + "transport": "Transcribed supplied complete JSON; exact requested digest verified before source generation.", + "source_pointer": "/units/P112/gluing_lattice_certificate", + "value_binding": "Exact regeneration plus independent inverse literal parsing of all emitted source fields.", + "full_saved_certificate_reported_bytes": 1019927, + "full_saved_certificate_reported_sha256": "102cb8ddda027286b010b6edfd80c2b1c201a24020dfe32b0caee0f2a827c57e", + "full_saved_certificate_rehashed_by_producer": false + }, + "numerical_predecessor": { + "pr": 1497, + "commit": "7a1309f18f56d04c2db33bf1607e0332d19f72b3", + "audit_path": "research/complex-rank8-ratio-gluing-audit/audit.md", + "audit_sections": "8.2-8.3", + "audit_reported_sha256": "2e6bf15efc5293e85b4a0cc486fbd84989209ee22c6e04a8d741bb2f76405d4c", + "checker_path": "research/complex-rank8-ratio-gluing-audit/verify.py", + "checker_reported_sha256": "224355b93102d22bea4bc8c818baa13cfc9149f9e2752ec1722b959b77d59c42", + "checker_independently_fetched_here": false + }, + "coordination_supplied_by_requester": { + "claim_url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1527#discussioncomment-18915722", + "node": "DC_kwDOU-508s4BIKGK", + "created": "2026-10-14T05:24:58Z", + "expires": "2026-10-14T07:20:00Z", + "checkpoint": "c24fb5e6537d19d79c62265e4a12781aef9309cb", + "priority_revision": 3, + "live_status_rechecked_by_producer": false, + "external_posts_by_producer": false + }, + "credits": [ + "PR1497/PR1610: Andrey Mas with substantial GPT-6 Pro assistance through ChatGPT.", + "Codex: source coordination, auditing and operator replay; no claim that it authored these new proofs.", + "PR1212 lineage: Brett Halligan/@burntout76 and Ninefold.", + "PR717 lineage: DreamingOfClouds.", + "PR968 lineage: themilkman216.", + "New proof/source assistance: GPT-6 Pro, using the operator-selected ChatGPT label.", + "No independent human verification and no new kernel execution by the producer." + ], + "license": "Apache-2.0" +} diff --git a/research/p112-integral-retraction-instance/source/README.md b/research/p112-integral-retraction-instance/source/README.md new file mode 100644 index 0000000000..00b5469ec3 --- /dev/null +++ b/research/p112-integral-retraction-instance/source/README.md @@ -0,0 +1,127 @@ +# P112 pinned integer-retraction instance — source candidate + +**SOURCE ONLY / NOT YET KERNEL CHECKED for this successor.** + +No Lean compiler was executed by the producer. No new `.olean`, successful Lean +log, measured Lean runtime, or observed new axiom-dependency report is supplied. +The unchanged dependency's header describes its predecessor's reported local +replay, not acceptance of this numerical instance. Operator source review and +actual exact-toolchain replay remain necessary. + +## Supplied proposition + +`P112Cert.certificate : PR1497.MatrixIdentities P112Cert.M P112Cert.P +P112Cert.Q P112Cert.W` has **no numerical-certificate hypothesis**. Its fields +are proof bodies for the actual imported `matMul` equations: + +```text +M : Mat 288 104 P : Mat 104 33 +Q : Mat 33 104 W : Mat 104 288 +MP = 0 QP = I_33 I_104 - PQ = WM +``` + +`P112Consequences.lean` applies existing bridge results to that term: the actual +image/kernel equality, surjectivity, image-difference quotient isomorphism and +its inverse equations, saturation, and the existing conditional monomial +interface. The ordinary `CommGroup` and individual-row relation hypotheses +remain explicit. This supplies neither a particular field adapter nor geometric +relation hypotheses. See `SCOPE.md` for the precise boundary. + +## Source binding + +The two canonical inputs match the requested bytes exactly, including final LF: + +| File | UTF8 bytes | SHA256 | +|---|---:|---| +| `P112.json` | 13,183 | `a1b43a5a7a8dcce0b84858244c512e53e6c344877cc35e87937fedd2601f29d5` | +| `PR1497Bridge.lean` | 48,758 | `a27494b0d40bbf7874fd9a875e468c67d11545b266e17bc98f2ca75c77f6ee40` | + +All 1,524 stored matrix entries, empty rows, coordinate labels, anchors, +representative keys/values, parameter ordering, and inherited rank metadata +are emitted without reordering. `generate.py --check` performs exact read-only +regeneration. A separate inverse literal parser reconstructs **the entire JSON +object** from `P112Data.lean`; canonical serialization reproduces the pinned +13,183-byte JSON hash. `BINDING.tsv` inventories every JSON node, including +container shapes and empty rows. These are transport/value-binding checks, not +a formal JSON parser or a proof of the E8 constructor's geometry. + +## Bounded replay after source review + +Python 3.12+ and only the already-installed official Lean **4.30.0**, commit +`d024af099ca4bf2c86f649261ebf59565dc8c622`, are used. No package manager, network, +installation, `lake`, Mathlib, or elan-selected compiler is invoked. + +```sh +cd /path/to/p112-lean430 +python3 audit_sources.py --manifest +python3 check_numeric.py +python3 test_tooling.py +python3 replay.py \ + --lean /Users/andrejmas/.elan/toolchains/leanprover--lean4---v4.30.0/bin/lean \ + --output /tmp/p112-lean430-operator-replay +``` + +The output directory must not already exist. The runner checks `--short-version` +and `--githash`, copies the exact Lean files to an isolated source tree, removes +inherited `LEAN_PATH`, `LEAN_SRC_PATH`, and `LEAN_SYSROOT`, then sets only the +isolated `LEAN_PATH`. Each compiler call is literally the supplied executable +with `-o `. Actual stdout, stderr, hashes, +durations, axiom records, and any stopped unit are saved in that output directory. + +There are **39 new positive units**, one unchanged dependency unit, and one +intentional compile-fail control. New source commands have nonzero bounds of +1,000,000 heartbeats and recursion depth 4,096. An external **120-second cap per +unit** and **600-second total successor cap** are enforced; only the unchanged +dependency stage is excluded from the total. No larger-limit retry is attempted. +Runtime feasibility within these caps is **unmeasured**, not promised. A timeout +is a stopped, incomplete replay, never a negative mathematical conclusion. + +## Proof strategy and acceptance + +One small adapter proves sparse left-row evaluation equal to the dependency's +ordinary finite sum. Balanced tables and balanced finite-index proof assembly +avoid long row lookup/assembly chains. Each ordinary `decide` proves one whole +row of 33 or 104 scalar equations; no dense whole-matrix `decide` is attempted. +Stages contain at most 16 MP/QP rows or 8 residual rows. The final matrix +identities are assembled using proved adapters and function extensionality. + +`DECLARATIONS.tsv` lists all names and locations. All **477 new named +declarations** (457 theorems, 20 definitions) and the dependency's **159** names +have axiom queries: **636** records are required in a complete replay. Only +`propext`, `Quot.sound`, and `Classical.choice` are allowed; these are an allowed +set, not an observed new dependency list. Errors, warnings, missing `.olean` +outputs, missing/duplicate records, or other axioms stop acceptance. + +`P112Damaged.lean` supplies proof bodies rejecting W[5,0] changed from +1 to -1. +`fixtures/RejectDamagedW.lean` must fail specifically because ordinary `decide` +rejects `1 = -1` after rewriting by proved entry values. An import, syntax, +missing-file, or unrelated failure is not an accepted control. + +## Producer observations, not kernel evidence + +Producer Python checks passed the exact input pins, full regeneration, inverse +literal parsing, all 21,409 scalar identity comparisons using ordinary dense +integer products, and the explicit W corruption (four residual cells differ). +All 14 tooling tests passed. Their parser-test strings are synthetic tests, +**not Lean receipts**. Exact executed commands/output are under `producer/` and +`PRODUCER_CHECKS.json`. Neither these checks nor Python itself discharge a Lean +proof obligation. The Lean control and new proofs have not been executed here. + +## Inventory, scope, and credit + +`MANIFEST.tsv` records exact UTF8 byte counts and SHA256 for every payload file, +excluding the manifest and checksum list themselves. `SHA256SUMS` additionally +covers the manifest and excludes itself. The separately delivered archive +receipt covers the ZIP and both inventory files; no self-hash is claimed. + +This is source-bound corroboration of an existing numerical certificate and an +existing bridge, not a novelty, numeric rank, kappa, or multiplication claim. +No E8 geometry/coverage, P120, field/Units adapter, local Lemma 5, decoder K, +helper reduction, paid invoice, or frontier change is supplied. + +Credit: PR1497/PR1610; Andrey Mas with substantial GPT-6 Pro through ChatGPT; +Codex source coordination, auditing, and operator replay. Retained lineage: +Brett Halligan/@burntout76 and Ninefold (PR1212), DreamingOfClouds (PR717), and +themilkman216 (PR968). New proof/source assistance is labeled GPT-6 Pro using the +operator-selected ChatGPT label. No independent human verification is claimed. +Apache-2.0; see `LICENSE` and `PROVENANCE.json`. diff --git a/research/p112-integral-retraction-instance/source/REPLAY_PLAN.json b/research/p112-integral-retraction-instance/source/REPLAY_PLAN.json new file mode 100644 index 0000000000..c3dac6ec2e --- /dev/null +++ b/research/p112-integral-retraction-instance/source/REPLAY_PLAN.json @@ -0,0 +1,53 @@ +{ + "positive_units": [ + "PR1497Bridge.lean", + "P112Sparse.lean", + "P112Data.lean", + "P112/MP00.lean", + "P112/MP01.lean", + "P112/MP02.lean", + "P112/MP03.lean", + "P112/MP04.lean", + "P112/MP05.lean", + "P112/MP06.lean", + "P112/MP07.lean", + "P112/MP08.lean", + "P112/MP09.lean", + "P112/MP10.lean", + "P112/MP11.lean", + "P112/MP12.lean", + "P112/MP13.lean", + "P112/MP14.lean", + "P112/MP15.lean", + "P112/MP16.lean", + "P112/MP17.lean", + "P112/QP00.lean", + "P112/QP01.lean", + "P112/QP02.lean", + "P112/Residual00.lean", + "P112/Residual01.lean", + "P112/Residual02.lean", + "P112/Residual03.lean", + "P112/Residual04.lean", + "P112/Residual05.lean", + "P112/Residual06.lean", + "P112/Residual07.lean", + "P112/Residual08.lean", + "P112/Residual09.lean", + "P112/Residual10.lean", + "P112/Residual11.lean", + "P112/Residual12.lean", + "P112Certificate.lean", + "P112Consequences.lean", + "P112Damaged.lean" + ], + "negative_units": [ + "fixtures/RejectDamagedW.lean" + ], + "per_unit_seconds": 120, + "successor_total_seconds": 600, + "dependency_excluded_from_successor_total": "PR1497Bridge.lean", + "maximum_columns_per_decision": 104, + "new_heartbeat_limit_per_command": 1000000, + "new_recursion_limit": 4096 +} diff --git a/research/p112-integral-retraction-instance/source/SCOPE.md b/research/p112-integral-retraction-instance/source/SCOPE.md new file mode 100644 index 0000000000..e85397b2dc --- /dev/null +++ b/research/p112-integral-retraction-instance/source/SCOPE.md @@ -0,0 +1,279 @@ +# Exact proposition, source connection, and remaining obligations + +## 1. Acceptance boundary + +The new Lean files are a **SOURCE ONLY / NOT YET KERNEL CHECKED** candidate. +They contain actual proof bodies, including a closed numerical certificate +term, but successful elaboration and kernel checking have not been observed by +the producer. No success follows merely from supplying these files. The +operator must compile every positive unit without errors/warnings, inspect the +complete axiom census, and run the intended failure control within the caps. + +The request reports the predecessor's successful exact-toolchain local replay. +The delivered dependency is the requested published 48,758-byte version, not a +silently modified source. Its existing status/attribution text and all 159 axiom +queries are retained. Its report about a predecessor replay does not apply to +`P112Cert.certificate` or any other newly supplied declaration. + +## 2. Canonical numerical object + +`P112.json` is the complete supplied subobject for +`/units/P112/gluing_lattice_certificate`. Its canonical bytes and hash are checked +before generation. The four matrices have exactly 288/104/33/104 rows and +104/33/104/288 columns, respectively. Their stored entry counts are +1,152/195/66/111. Every source row and every within-row entry keeps its position. + +Each emitted entry is `(⟨column, by decide⟩, (coefficient : Int))`. Thus columns +have explicit bounds proofs; the converter does not rely on Fin numeral wrap- +around. The source validator rejects out-of-range columns, duplicates, unsorted +columns, zero stored coefficients, Boolean-as-integer values, duplicate JSON +keys, missing/extra schema fields, wrong dimensions, or a nonpinned byte stream. + +Balanced selectors `M_entries`, `P_entries`, `Q_entries`, `W_entries` dispatch on +the original zero-based row index. For every valid index the corresponding leaf +is the original literal row. A source-converter check enumerates those paths; +exact regeneration checks the full tree text, not just its leaf comments. +An independent inverse literal parser reconstructs all sparse rows and every +metadata field from the emitted constants, and compares the full resulting +object with the input. The reconstructed canonical JSON also has the original +13,183-byte hash. `BINDING.tsv` separately records every scalar and container +node. These checks deliberately include metadata that is not needed for the +three algebraic identities. + +The metadata constants `anchors`, `basePairRepresentatives`, `coordinateLabels`, +`freeParameters`, `parameterClassCount`, `gPoints`, and `rankMetadata` preserve +source values; their presence asserts no geometric correctness. In particular, +`rankMetadata := 71` is just an integer copied from JSON, **not** a theorem about +rank. No rank operation, rank API, or numeric-rank proposition is defined here. + +The full 1,019,927-byte saved certificate was not supplied as a separate file to +this producer and was not rehashed here. Its full-certificate digest and the +operator's extraction history are retained as reported provenance only. + +## 3. Small sound adapter, not a replacement matrix product + +All universal algebra comes from the unmodified PR1497 namespace: + +```lean +abbrev Row (n : Nat) := Fin n → Int +abbrev Mat (m n : Nat) := Fin m → Fin n → Int +``` + +The delivered matrices are actual objects of these types, not arrays that only +look like them. `Sparse.row` is the finite list's ordinary integer linear +combination of the dependency's coordinate basis rows. For each column its +meaning is formally exposed by `P112Cert.Sparse.row_apply`: + +```text +row xs j = xs.foldr (fun e s => (if j = e.1 then e.2 else 0) + s) 0. +``` + +The pinned lists have distinct columns, so this is their ordinary sparse +interpretation: the listed coefficient at its column and zero when absent. +No source entry is dropped, cancelled, sorted, or simplified by the converter. + +`Sparse.eval xs B` only sums `coefficient * B row column` over the short list. +It is connected to the exact imported recursive finite sum by the proved +function equality + +```lean +P112Cert.Sparse.rowMul_row + (xs : List (Fin n × Int)) (B : PR1497.Mat n d) : + PR1497.rowMul (P112Cert.Sparse.row xs) B = P112Cert.Sparse.eval xs B +``` + +The proof is structural induction on the list. The empty case uses the +inherited `Rows.rowMul_zero_left`. The successor case uses the inherited +`Rows.rowMul_add` and `Rows.rowMul_basis`, and the small derived scalar-linearity +lemma `Sparse.rowMul_scale`. That lemma is derived from the already proved +`Rows.rowHom`/`Hom.map_zsmul` and `Rows.row_zsmul`, not from an assumed scalar +preservation field. Thus the dense finite sum is avoided computationally, not +redefined or postulated away. + +The only other new generic helper is `Sparse.allFinAdd`, a short wrapper around +core `Fin.addCases`. It assembles two proved finite index ranges; it makes no +matrix or group assumption. The new helper file has two definitions and four +theorems, with a query for every one. There is no new sparse-matrix algebra +library, custom evaluator, proof macro, or general algebra-law structure. + +## 4. Complete finite proof obligations + +The staged sources provide these complete row families: + +| Family | Named row theorems | Columns in each row | Scalar obligations | +|---|---:|---:|---:| +| `mp_row_000` through `mp_row_287` | 288 | 33 | 9,504 | +| `qp_row_000` through `qp_row_032` | 33 | 33 | 1,089 | +| `residual_row_000` through `residual_row_103` | 104 | 104 | 10,816 | + +Each theorem invokes ordinary `decide` on a closed proposition +quantified over the entire indicated `Fin` column range. Its proof must still +be checked by the operator's kernel run. A Python calculation +is not passed as a proof. There are no Boolean-checker soundness assumptions, +precomputed theorem receipts, or certificates accepted by unchecked evaluation. +The intended 21,409 scalar obligations are not replaced by sampled cells. + +In `P112Certificate.lean`, core `Fin.forall_fin_one` and the proved +`Sparse.allFinAdd` assemble the row proofs using a balanced tree. Each leaf's +finite index reduces to its original numeric row. This yields +`mp_sparse_all`, `qp_sparse_all`, and `residual_sparse_all` over every row index. +Function extensionality plus `Sparse.rowMul_row` then proves the actual imported +matrix identities `P112Cert.mp`, `P112Cert.qp`, and `P112Cert.residual`. + +The final declaration is a closed proof term: + +```lean +theorem P112Cert.certificate : + PR1497.MatrixIdentities P112Cert.M P112Cert.P P112Cert.Q P112Cert.W +``` + +Its proof is exactly the structure assembled from those three proved fields. +No `h : MatrixIdentities ...` binder occurs in the claimed finite result. +Neither lattice/kernel equality nor reconstruction is postulated or added as a +field, and no smaller matrix fixture is substituted for the P112 data. + +## 5. Existing bridge conclusions bound to these constants + +`P112Consequences.lean` instantiates only inherited results. The significant +interfaces are listed below; their exact names, locations, and declaration +kinds are in `DECLARATIONS.tsv`. + +`P112Cert.lattice_eq_kernel` states, for every `v : Row 104`, that the **image** +`∃ z : Row 288, rowMul z M = v` is equivalent to `rowMul v P = 0`. +`P112Cert.phi_surjective` gives a preimage for every `Row 33` parameter vector. +`P112Cert.lattice_saturated` keeps the explicit nonzero-integer-multiple premise +and uses the inherited integral torsion-freeness proof. + +`P112Cert.quotientIso` is an `AddIso` between the inherited actual image- +difference quotient group and `rowGroup 33`. `quotient_relation` exposes that +`v - w` is an integer row image, rather than defining the quotient by the desired +kernel conclusion. The forward-on-representative and inverse-on-parameter +lemmas identify the maps as `[v] ↦ vP` and `z ↦ [zQ]`. Both left and right inverse +equations are instantiated. The definition is an inherited proved isomorphism, +not a new assumed isomorphism field. + +The monomial declarations quantify over arbitrary `D : Type u` and an explicit +ordinary `PR1497.CommGroup D`. `reconstruction`, `reconstruct_coordinate`, and +`unique_parameterization` also retain + +```lean +hx : PR1497.MonomialBridge.Relations G P112Cert.M x +``` + +which literally means that **each of the 288 relation-row monomials equals +`G.one`**. They do not assume annihilation of the entire span: that bridge is +already proved in the inherited source. `converse_relations` and +`parameters_recover` apply to arbitrary 33-tuples of parameters. The inherited +`residual_relations_formula` is instantiated with the actual W coefficients, +without assuming that relation-row values are one. These declarations still +refer to actual finite products and signed powers, not arbitrary characters +with reconstruction built into their laws. + +Nothing here constructs nonzero field elements, a units group, field coercions, +or a Laurent-scheme interpretation. The existence of a lawful group or the +geometric truth of the individual relation hypotheses is not inferred merely +from the numerical integer identities. + +## 6. Bounded kernel strategy and what a timeout means + +The candidate deliberately avoids a single dense decision procedure. In the +four dense products there are 4,573,608 scalar multiplication summands. The +proved left-row adapter reduces the corresponding listed coefficient terms to +72,018, before accounting for right-row lookup. That is a source-specific +arithmetic work comparison, **not a measured speedup or runtime guarantee**. + +Balanced dispatch has depth at most 9 for M, 7 for P/W, and 6 for Q. Balanced +proof assembly likewise has depth at most 9/6/7. One decision handles only one +complete row of at most 104 columns. A compilation unit contains at most 16 +MP/QP row theorems or 8 residual row theorems. The unchanged dependency is +compiled first, followed by the adapter/data, 34 row-stage files, certificate, +consequences, and damaged-certificate proofs. + +Every new unit sets `maxRecDepth 4096` and `maxHeartbeats 1000000`; neither is +zero. The external runner caps each process at 120 seconds and the complete +successor at 600 seconds, excluding only the unchanged dependency stage. The +total includes preflight and acceptance bookkeeping. The runner terminates the +process group on timeout, records the exact stopped unit, and never retries +with raised limits. On an operator interruption it also stops the child process. + +No authoring-runtime Lean executable was found or executed. Whether these +proof scripts elaborate and fit the resource budget is therefore the remaining +empirical obligation. If a stage times out, already accepted row theorems may +be reported as partial finite obligations, but the full certificate or final +applications must not be called kernel checked. An elaboration error must be +repaired in the new files, not by altering the accepted dependency or assuming +the failed identity. There is no assertion that an unexecuted timing cap was met. + +## 7. Genuine mathematical negative control + +The original sparse row W[5] is exactly `[[0,1]]`. The control changes it to +`[[0,-1]]` and retains every other row. In ordinary integer matrices: + +```text +(I_104 - PQ)[5,0] = 1 +(W_bad M)[5,0] = -1. +``` + +`P112Cert.Damaged.residual_entry` and `damaged_product_entry` contain Lean proof +bodies for these statements through the same sound adapter. `not_residual` +uses the entry discrepancy to contradict the whole residual identity, and +`no_certificate` refutes `MatrixIdentities M P Q W_bad`. No malformed type or +missing-file premise is involved. MP and QP are unaffected because M/P/Q are +not changed. + +The separate compile-fail fixture imports these positive proofs and attempts +the false residual-entry equality. After rewriting, ordinary `decide` must +reject `1 = -1`. Acceptance requires exactly that diagnostic, exit code 1, no +output `.olean`, and no unrelated diagnostics. The Python producer independently +observed four differing residual cells: (5,0), (5,1), (5,4), (5,5). The **Lean** +positive/negative controls were not run by the producer. + +The request identifies PR1497 `verify.py` lines 605–607 as a W-corruption-control +precedent. The exact `(5,0)` sign flip and proof here are source-specific new +control code, not a claim to have inspected or duplicated the old control's +precise mutation. + +## 8. Trust, axiom census, and omissions + +All source-named declarations are enumerated: 477 new queries and 159 unchanged +inherited queries. There are no manually declared private auxiliaries. Compiler- +generated eliminators/recursors, if any, are covered transitively by the parent +queries; no fresh proof axiom is inserted. Ordinary `decide` is used without +native or unchecked execution options. The source guard and Python parser are +supplementary checks, not a substitute for source audit or the Lean kernel. + +The replay accepts only the allowed foundational set `propext`, `Quot.sound`, +and `Classical.choice`, and requires a complete census after a successful fresh +compilation. No observed new axiom list is asserted in this delivery. Failed +elaboration followed by printed axiom messages is categorically not acceptance. + +Excluded: E8 roots and geometric generator correctness; class completeness, +coverage, anchors' geometric roles, source-relation geometric validity; actual +field/Units adapters and nonzero-element premises; numeric rank; P120; zero +exclusion; local Lemma 5; decoder K; helper reduction; paid invoices; kappa; +full multiplication/analytic/hosting/precision/tape theorems; frontier changes. +This work does not establish novelty, terminate another study, or post any +external update. It is a finite source-binding successor to existing work. + +## 9. Sources and credit + +The mathematical/finite source pins and full lineage are recorded in +`PROVENANCE.json`. The requested PR1610/PR1497 repository contents were supplied +in the prompt; no claim of fetching their full audit or saved certificate is +made. During development, only official Lean source at the exact required +commit was consulted online for the core finite-index and ordinary decision +interfaces: + +- https://raw.githubusercontent.com/leanprover/lean4/d024af099ca4bf2c86f649261ebf59565dc8c622/src/Init/Data/Fin/Basic.lean +- https://raw.githubusercontent.com/leanprover/lean4/d024af099ca4bf2c86f649261ebf59565dc8c622/src/Init/Data/Fin/Lemmas.lean +- https://raw.githubusercontent.com/leanprover/lean4/d024af099ca4bf2c86f649261ebf59565dc8c622/src/Lean/Elab/Tactic/Decide.lean + +The existing `check_axioms.py` parser was retained from the actual earlier +repair archive, with fresh tests and strict compiler-status gates in `replay.py`. +The new converter, inverse parser, adapter, balanced proof assembly, staged +Lean declarations, final applications, and mathematical corruption proof are +new deliverables. Their proof/source assistance is attributed to GPT-6 Pro +through ChatGPT using the operator-selected label, not a more-specific backend +claim. Andrey Mas and the prior PR1497/PR1610 audit/bridge, Codex coordination/ +auditing/replay, and PR1212/PR717/PR968 lineage are credited separately. This is +not independent human verification. Apache-2.0. diff --git a/research/p112-integral-retraction-instance/source/SHA256SUMS b/research/p112-integral-retraction-instance/source/SHA256SUMS new file mode 100644 index 0000000000..2ccdc25b48 --- /dev/null +++ b/research/p112-integral-retraction-instance/source/SHA256SUMS @@ -0,0 +1,66 @@ +2706652f5ab357ec00ae5d549eb750a289c10b587343ebf6695a9be756390246 BINDING.tsv +c27eed09af9db4cec1dabe690f9c81efbdb2c9a9830083b2e2656d20c1f964f0 DECLARATIONS.tsv +f2d5d48ebf1f55edac441fea1b8f3a879d7d7471fa7e7b6dca63a59fb1dc927d GENERATED_FILES.txt +cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30 LICENSE +4303973a433b61faf34a59f6d785cfd9bb85e59b500de8c4a54d3effb431963e MANIFEST.tsv +a1b43a5a7a8dcce0b84858244c512e53e6c344877cc35e87937fedd2601f29d5 P112.json +13f94407d2f564d1df02abd05d65c789f9ef0fd146ea83f219cc2b0790530da5 P112/MP00.lean +374fac864b91f4d3be22c064933bd04fe68479e0aae3a2d47f417c053ebf7c26 P112/MP01.lean +a2d4ce0941183e59c87d89a1369bd8cae8e5aa17457a20352ecbcdd0eec847ac P112/MP02.lean +25846cbeac859682f102a4eba089f88fd6aece81538d368422b0347323d9a450 P112/MP03.lean +9c9694edc8e991dcc669d37de9116309c86bf408743993384b01c6bf7eae0e64 P112/MP04.lean +e90fd3cebc97e91d1fec063ccd50fa67e82375c23e317d755ee52de07c6e2840 P112/MP05.lean +02d4f4c3dc89e560e8f1109b051bb912f26e6a238c8f3c25237b67b144321f7e P112/MP06.lean +39452ad57ba92c9cd54e9868a663b1b773c25143e0c24556899153cbcdae3842 P112/MP07.lean +5905bb732b9976adba77dab859b52f1a3dbd01a2368ca92e1144d98db0c0b967 P112/MP08.lean +580c7521ccf594444d673a66280d448d36f5111bdfdc5303ad95547420c49ca2 P112/MP09.lean +317283042cdb1844c55de12c5fc9afaaf8efbd97552f64d7a3172a3b51fbd4d3 P112/MP10.lean +e8898d45d1e5d0e39235b6a1eaf1880cdb9928442b4238d3a909a0b725ca394e P112/MP11.lean +9244768a96a7351430167c9865051fcac394f591cd37bb21b8a93c59a0d9295a P112/MP12.lean +b84a8d8657b85161f98fb8971b574526a6d53fce9e50847f59bf816a91351a38 P112/MP13.lean +03915213d9aec2110071dcfd205de00e929220d092ea8238ed9036f96ac1fc4f P112/MP14.lean +c1342bca97cb22f3773f16453fa88ec4a4ec4a5b2ad8deaa8f37317cc131fa04 P112/MP15.lean +47336a6652bdfb9efac4291b73be99f41efe2fc68014562bd86ff092a34f2368 P112/MP16.lean +7da6a378c8e262cd027a7b8391df3f9b8c445eb750a5e2e11a2fa988314368a5 P112/MP17.lean +b5015a85de7edf9df93f1b00fd6433113ef25ef177b75a840cdaa29068e5edff P112/QP00.lean +e00cc8dd0c6798387436fa2625ef7bc59d61bfdf0b67efc4d5b132d1b9679f43 P112/QP01.lean +4fa1e2783b8082d03b434d7acc6549de4027d3e72685c9913158283c76957ea7 P112/QP02.lean +f0018130a836f72d6a830da8247d4cd37df7df7c9418f5c528785227e364b577 P112/Residual00.lean +c31b6b2d62e7b4dc0ff2d7d93c9510160c4015da8cf03729345fa4afec6e7db2 P112/Residual01.lean +fd3d9e3ec624ef77309b78f21214f9e1d44ad97b96c1268bf3f10924a50ca1f2 P112/Residual02.lean +fee2b63b5a52a3f0cd88973c0b1e9ec75a3966ff152e42cf540cb20cc737cc05 P112/Residual03.lean +45bf845eb22460635f81d85757ed29e33622a5b123dc858b5f0673f3ad968c42 P112/Residual04.lean +1fce648ce627b596a758be98790829f4df7f414a90d29cec34bdcefe749c08dd P112/Residual05.lean +fc26879525f376ee93a7d4c037ca42e49c597372a30b82d4f1107c9f0c36d1bb P112/Residual06.lean +828f358afed3c9ea4839a3e15400294b77e313b31dcfd58b278f309e5f4854fd P112/Residual07.lean +665f03ae5197ee1b90c585613e717da85b682cae471d8b00da97846b28732497 P112/Residual08.lean +ada3f0b6e1e66fd4a16f56bbcfb62e02f248d3d085889697ff818f95ade3b95d P112/Residual09.lean +3dfeb23cd21058c8b98b58cc97d0fc2812d49efad5b1752dcb52cd2b47ff317f P112/Residual10.lean +6d7604d36d7879801758de815fbfbdf38b2975ae6cd5ce722c20709bd00c50bc P112/Residual11.lean +6a727a2c56358da83565fc27474cef83c02fb0fa5af53dae4e18af6d55675810 P112/Residual12.lean +3cc91d09e6f743a3e2e0ed02b8d73246b306965c2f12e82f49deac8d16899ff0 P112Certificate.lean +bf2d28f786f2aeee4ea0e0d733ad3f6973c133fe9cde452c21fc36ca709444bc P112Consequences.lean +e915b6ca54379292462315ca613ccfe46e5d77acd2b31e07e83dbcd7f0f3fd32 P112Damaged.lean +c5619fb4e1b10663f48deb39272d191ba444f7052b0170a65186422e8177d967 P112Data.lean +1f9cae94b0767d117cd0c30c5852df385a1e98f6d255f130303130d9b7b4d071 P112Sparse.lean +a27494b0d40bbf7874fd9a875e468c67d11545b266e17bc98f2ca75c77f6ee40 PR1497Bridge.lean +7255a96dad702adae230a08a231f708e1191821c13d63d51e535f6fa4f6fa341 PRODUCER_CHECKS.json +76063decdff483be76ca871619ad7360ce9b40ee43e6c5d1188e7d570a0ac3eb PROVENANCE.json +b551eb494b04f314f1e844f32d69fd7e43e8830133bd54557dbcca33f2b98fac README.md +cd587bce837cf4204b2a78194c45e53109a11f0b6c545505d99207dde1da8d3c REPLAY_PLAN.json +754dbc101e4a1e52e6c4e809cccd6c4e40c2d1ed9b07414532b71006911e7103 SCOPE.md +c55d731d66c52a424c6aaee75ae854b8da1a822901ee473a425892ae822c526d audit_sources.py +23e86145231da2080a362aa69a01faa4bba9c2408d642155c83d57a29ab43a54 check_axioms.py +0abe2ff45db7e064d6ca01d7c9eee32b4ced2fd026e2e8c62e60e8105a5096d3 check_numeric.py +7796f968b92e57759776b10c9a37847ffde62bbc6d8a7fda321f09b3cba2dda5 fixtures/RejectDamagedW.lean +ebd2d4eeb44064c04ff6097d8b7e50e14370f893d56bd5b11536f225a10aa319 generate.py +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 producer/integer-check.stderr +808f025e73edf581cb4d0f232f375ed1447be3a7bdd1d38e5621ffc68805cfb4 producer/integer-check.stdout +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 producer/regeneration.stderr +c30455250b56b4ad8d3184e7e9e3ec87bf30762e3144e14584c35eb29982d096 producer/regeneration.stdout +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 producer/source-audit.stderr +4bee7de0aa02385c1afd581b1ea9726c603e3c2ecd18c68a19c4a5a8af674181 producer/source-audit.stdout +2a9466d31616e93b0d5a055b32791ce466a2e14f55d89320d4686df1596fbba0 producer/tooling-tests.stderr +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 producer/tooling-tests.stdout +cf32f674bfdc1b62903b8fa7d647d1c918f319f21d6e882bb59c38186e8f55c6 replay.py +d34f2b4212dced3c922f77ccf5c702c108baef8b374c41aff7188036fb13d559 test_tooling.py diff --git a/research/p112-integral-retraction-instance/source/audit_sources.py b/research/p112-integral-retraction-instance/source/audit_sources.py new file mode 100644 index 0000000000..907af38330 --- /dev/null +++ b/research/p112-integral-retraction-instance/source/audit_sources.py @@ -0,0 +1,171 @@ +#!/usr/bin/env python3 +"""Read-only source/census/transport checks; NOT a Lean parser or proof checker. +SPDX-License-Identifier: Apache-2.0. Python 3.12+, standard library only. +""" +from __future__ import annotations +import argparse +import hashlib +import json +import re +from pathlib import Path +from typing import Any +from generate import ROOT, check_generated, require +from check_numeric import read_emitted_values +from check_axioms import QUERY + + +def strip_comments(text: str) -> str: + """Retain line positions while excluding nested Lean comments and strings.""" + out: list[str] = [] + i, depth, in_string = 0, 0, False + while i < len(text): + pair, char = text[i:i+2], text[i] + if depth: + if pair == "/-": + depth += 1; out.extend(" "); i += 2; continue + if pair == "-/": + depth -= 1; out.extend(" "); i += 2; continue + out.append("\n" if char == "\n" else " "); i += 1; continue + if in_string: + if char == "\\" and i + 1 < len(text): + out.extend(" "); i += 2; continue + if char == '"': + in_string = False + out.append("\n" if char == "\n" else " "); i += 1; continue + if pair == "/-": + depth = 1; out.extend(" "); i += 2; continue + if pair == "--": + end = text.find("\n", i) + if end == -1: end = len(text) + out.extend(" " * (end-i)); i = end; continue + if char == '"': + in_string = True; out.append(" "); i += 1; continue + out.append(char); i += 1 + require(depth == 0 and not in_string, "Unclosed source comment/string") + return "".join(out) + + +def declaration_rows(root: Path) -> list[tuple[str, int, str, str, str]]: + result: list[tuple[str, int, str, str, str]] = [] + for path in sorted(root.rglob("*.lean")): + rel = path.relative_to(root).as_posix() + stack: list[str] = [] + code = strip_comments(path.read_text(encoding="utf-8")) + for lineno, line in enumerate(code.splitlines(), 1): + ns = re.fullmatch(r"namespace\s+(\w+(?:\.\w+)*)\s*", line) + if ns: + stack.append(ns.group(1)); continue + if re.fullmatch(r"end(?:\s+[\w.]+)?\s*", line): + require(bool(stack), f"Unexpected end in {rel}:{lineno}") + stack.pop(); continue + decl = re.match(r"^(def|theorem|structure|abbrev)\s+([A-Za-z_][\w]*)\b", line) + if decl: + kind, name = decl.groups() + qualified = ".".join([*stack, name]) + origin = "inherited" if rel == "PR1497Bridge.lean" else "new" + result.append((rel, lineno, kind, qualified, origin)) + require(not stack, f"Unclosed namespace in {rel}") + return result + + +def census_bytes(root: Path) -> bytes: + rows = declaration_rows(root) + text = "file\tline\tkind\tdeclaration\torigin\n" + text += "".join(f"{p}\t{line}\t{kind}\t{name}\t{origin}\n" + for p, line, kind, name, origin in rows) + return text.encode("utf-8") + + +def audit(root: Path = ROOT, check_census: bool = True) -> dict[str, Any]: + binding = check_generated(root) + original = json.loads((root / "P112.json").read_text(encoding="utf-8")) + recovered = read_emitted_values((root / "P112Data.lean").read_text(encoding="utf-8")) + require(recovered == original, "Inverse literal parser found a value mismatch") + declarations = declaration_rows(root) + all_names = [row[3] for row in declarations] + require(len(all_names) == len(set(all_names)), "Duplicate named declaration") + by_file: dict[str, list[str]] = {} + for rel, _, _, name, _ in declarations: + by_file.setdefault(rel, []).append(name) + plan = json.loads((root / "REPLAY_PLAN.json").read_text(encoding="utf-8")) + require(plan["per_unit_seconds"] == 120 and plan["successor_total_seconds"] == 600, + "Resource limits changed") + positive = plan["positive_units"] + negative = plan["negative_units"] + actual_files = {p.relative_to(root).as_posix() for p in root.rglob("*.lean")} + require(actual_files == set(positive + negative), "Replay plan is not the full Lean file set") + forbidden = re.compile(r"\b(?:axiom|sorry|admit|unsafe|native_decide|macro|elab|syntax|run_tac)\b|#(?:eval|reduce|compile)\b") + compiled_modules: set[str] = set() + for rel in positive + negative: + text = (root / rel).read_text(encoding="utf-8") + code = strip_comments(text) + require(not forbidden.search(code), f"Forbidden executable token in {rel}") + for module in re.findall(r"^import\s+([\w.]+)\s*$", code, re.M): + require(module == "Std" or module in compiled_modules, + f"Unresolved/out-of-order import in {rel}: {module}") + compiled_modules.add(rel[:-5].replace("/", ".")) + if rel != "PR1497Bridge.lean": + require(re.findall(r"^set_option maxRecDepth\s+(\d+)\s*$", code, re.M) == ["4096"], + f"Unexpected recursion bound in {rel}") + require(re.findall(r"^set_option maxHeartbeats\s+(\d+)\s*$", code, re.M) == ["1000000"], + f"Unexpected heartbeat bound in {rel}") + queries = QUERY.findall(text) + require(len(queries) == len(set(queries)), f"Duplicate query in {rel}") + require(set(queries) == set(by_file.get(rel, [])), f"Incomplete axiom queries in {rel}") + if rel in positive: + require(bool(queries), f"No axiom queries in positive unit {rel}") + if check_census: + require((root / "DECLARATIONS.tsv").read_bytes() == census_bytes(root), "Stale declaration census") + return {"status": "SOURCE_AUDIT_ONLY_NOT_KERNEL_EVIDENCE", + "binding": binding, + "inherited_named_queries": sum(r[4] == "inherited" for r in declarations), + "new_named_queries": sum(r[4] == "new" for r in declarations), + "new_theorems": sum(r[4] == "new" and r[2] == "theorem" for r in declarations), + "positive_units_including_dependency": len(positive), + "negative_units": len(negative), + "new_lean_executed": False} + + +def verify_manifest(root: Path) -> None: + lines = (root / "MANIFEST.tsv").read_text(encoding="utf-8").splitlines() + require(lines[0] == "path\tutf8_bytes\tsha256", "Bad manifest header") + seen: set[str] = set() + for line in lines[1:]: + name, count, digest = line.split("\t") + require(name not in seen, f"Duplicate manifest entry {name}") + require(not Path(name).is_absolute() and ".." not in Path(name).parts, "Unsafe manifest path") + seen.add(name) + raw = (root / name).read_bytes() + raw.decode("utf-8") + require(len(raw) == int(count), f"Byte count mismatch: {name}") + require(hashlib.sha256(raw).hexdigest() == digest, f"SHA256 mismatch: {name}") + expected = {p.relative_to(root).as_posix() for p in root.rglob("*") if p.is_file() + and "__pycache__" not in p.parts + and p.name not in {"MANIFEST.tsv", "SHA256SUMS"}} + require(seen == expected, "Manifest payload set mismatch") + sums = (root / "SHA256SUMS").read_text(encoding="utf-8").splitlines() + checksum_names: set[str] = set() + for line in sums: + digest, name = line.split(" ", 1) + require(name not in checksum_names, "Duplicate SHA256SUMS entry") + checksum_names.add(name) + require(name in seen | {"MANIFEST.tsv"}, "Unexpected SHA256SUMS path") + require(hashlib.sha256((root / name).read_bytes()).hexdigest() == digest, + f"SHA256SUMS mismatch: {name}") + require(checksum_names == seen | {"MANIFEST.tsv"}, "SHA256SUMS inventory mismatch") + + +def main() -> None: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--root", type=Path, default=ROOT) + parser.add_argument("--manifest", action="store_true") + args = parser.parse_args() + report = audit(args.root.resolve()) + if args.manifest: + verify_manifest(args.root.resolve()) + report["manifest_verified"] = True + print(json.dumps(report, indent=2)) + + +if __name__ == "__main__": + main() diff --git a/research/p112-integral-retraction-instance/source/check_axioms.py b/research/p112-integral-retraction-instance/source/check_axioms.py new file mode 100644 index 0000000000..bc2500c714 --- /dev/null +++ b/research/p112-integral-retraction-instance/source/check_axioms.py @@ -0,0 +1,73 @@ +#!/usr/bin/env python3 +"""Audit actual Lean #print axioms output. This is NOT a proof checker. + +Usage: python3 check_axioms.py SOURCE LOG [SOURCE LOG ...] +Stdlib only. Accepts no missing/duplicate queries or non-whitelisted axioms. +Only successful fresh Lean compilations should be supplied by replay.sh. +The parser also rejects error diagnostics; parsing is not proof checking. +""" +from __future__ import annotations +import json +import re +import sys +from pathlib import Path + +ALLOWED = frozenset({"Quot.sound", "propext", "Classical.choice"}) +QUERY = re.compile(r"^#print axioms ([A-Za-z_][A-Za-z_0-9.]*)\s*$", re.M) +RECORD = re.compile( + r"'([^']+)'\s+(?:does not depend on any axioms|" + r"depends on axioms:\s*\[([^\]]*)\])", re.M +) + + +def parse_records(text: str) -> dict[str, list[str]]: + # Even a complete-looking census cannot certify an error-bearing compilation. + if re.search(r"(?mi)^.*\berror:", text): + raise ValueError("Compiler error diagnostic in axiom log") + if re.search(r"(?i)declaration uses [\"'`]sorry[\"'`]", text): + raise ValueError("Incomplete-proof diagnostic in axiom log") + records: dict[str, list[str]] = {} + for match in RECORD.finditer(text): + name = match.group(1) + if name in records: + raise ValueError(f"Duplicate axiom record: {name}") + deps = sorted({a.strip().strip('`') for a in (match.group(2) or '').split(',') + if a.strip()}) + extra = set(deps) - ALLOWED + if extra: + raise ValueError(f"Disallowed axiom dependencies for {name}: {sorted(extra)}") + records[name] = deps + return records + + +def main(argv: list[str]) -> int: + if not argv or len(argv) % 2: + print(__doc__, file=sys.stderr) + return 2 + report: dict[str, list[str]] = {} + for src_arg, log_arg in zip(argv[0::2], argv[1::2]): + source = Path(src_arg).read_text(encoding="utf-8") + expected = QUERY.findall(source) + if not expected or len(set(expected)) != len(expected): + raise ValueError(f"Empty/duplicate axiom-query inventory: {src_arg}") + actual = parse_records(Path(log_arg).read_text(encoding="utf-8")) + missing = set(expected) - actual.keys() + unexpected = actual.keys() - set(expected) + if missing or unexpected: + raise ValueError(f"Axiom inventory mismatch for {src_arg}; " + f"missing={sorted(missing)}, unexpected={sorted(unexpected)}") + if report.keys() & actual.keys(): + raise ValueError("Duplicate declarations across supplied logs") + report.update(actual) + print(json.dumps({"allowed_axioms": sorted(ALLOWED), + "declaration_count": len(report), + "observed_dependencies": dict(sorted(report.items()))}, indent=2)) + return 0 + + +if __name__ == "__main__": + try: + raise SystemExit(main(sys.argv[1:])) + except (OSError, ValueError) as exc: + print(f"AXIOM AUDIT FAILED: {exc}", file=sys.stderr) + raise SystemExit(1) diff --git a/research/p112-integral-retraction-instance/source/check_numeric.py b/research/p112-integral-retraction-instance/source/check_numeric.py new file mode 100644 index 0000000000..b31896d29f --- /dev/null +++ b/research/p112-integral-retraction-instance/source/check_numeric.py @@ -0,0 +1,115 @@ +#!/usr/bin/env python3 +"""Independent integer arithmetic and inverse source parsing; NOT a Lean checker. +Python 3.12+, standard library only. SPDX-License-Identifier: Apache-2.0 +""" +from __future__ import annotations +import ast +import hashlib +import json +import re +from pathlib import Path +from typing import Any +from generate import ROOT, SHAPES, load_source, require, sparse_literal, check_generated + + +def dense(rows: list[list[list[int]]], columns: int) -> list[list[int]]: + result = [[0] * columns for _ in rows] + for i, entries in enumerate(rows): + for j, a in entries: + result[i][j] += a + return result + + +def multiply(a: list[list[int]], b: list[list[int]]) -> list[list[int]]: + require(bool(a) and bool(b), "Empty dense matrix") + require(all(len(row) == len(b) for row in a), "Multiplication shape mismatch") + columns = list(zip(*b)) + require(all(len(row) == len(b[0]) for row in b), "Ragged matrix") + # All summands are retained, including zeros. Exact Python integers only. + return [[sum(x * y for x, y in zip(row, col)) for col in columns] for row in a] + + +def read_emitted_values(text: str) -> dict[str, Any]: + """Inverse parser for the emitted literal grammar, independent of render_data. + Exact whole-source regeneration separately verifies the dispatch trees. + This parser checks every emitted sparse row and metadata value, including empties. + """ + obj: dict[str, Any] = {} + leaf = re.compile(r"^\s*(\[.*\]) -- /([MPQW])/(\d+)$", re.M) + entry = re.compile(r"\(⟨(\d+), by decide⟩, \((-?\d+) : Int\)\)") + found: dict[str, dict[int, list[list[int]]]] = {k: {} for k in SHAPES} + for match in leaf.finditer(text): + literal, name, index_text = match.groups() + index = int(index_text) + require(index not in found[name], f"Duplicate emitted row {name}/{index}") + values = [[int(c), int(a)] for c, a in entry.findall(literal)] + require(sparse_literal(values) == literal, f"Bad emitted literal grammar {name}/{index}") + found[name][index] = values + for name, (nr, _) in SHAPES.items(): + require(set(found[name]) == set(range(nr)), f"Missing/extra emitted row {name}") + obj[name] = [found[name][i] for i in range(nr)] + + def literal(name: str) -> Any: + matches = re.findall(r"^def " + re.escape(name) + r"\s*:[^\n]*? := (.*)$", text, re.M) + require(len(matches) == 1, f"Missing/duplicate metadata declaration {name}") + # literal_eval is a bounded literal parser; never eval/exec or code execution. + return ast.literal_eval(matches[0]) + + obj["anchors"] = literal("anchors") + reps = literal("basePairRepresentatives") + require(len(reps) == len(dict(reps)), "Duplicate emitted representative key") + obj["base_pair_representatives"] = dict(reps) + obj["coordinates"] = [list(pair) for pair in literal("coordinateLabels")] + obj["free_parameters"] = literal("freeParameters") + obj["parameter_order"] = {"class_parameters": literal("parameterClassCount"), + "g_points": literal("gPoints")} + obj["rank"] = literal("rankMetadata") + return obj + + +def numeric_result(obj: dict[str, Any]) -> dict[str, Any]: + matrices = {name: dense(obj[name], nc) for name, (_, nc) in SHAPES.items()} + m, p, q, w = (matrices[name] for name in ("M", "P", "Q", "W")) + mp, qp = multiply(m, p), multiply(q, p) + pq, wm = multiply(p, q), multiply(w, m) + mp_ok = all(a == 0 for row in mp for a in row) + qp_ok = all(qp[i][j] == int(i == j) for i in range(33) for j in range(33)) + residual_ok = all(int(i == j) - pq[i][j] == wm[i][j] + for i in range(104) for j in range(104)) + require(mp_ok and qp_ok and residual_ok, "A genuine dense matrix identity failed") + require(w[5][0] == 1 and obj["W"][5] == [[0, 1]], "Wrong corruption starting entry") + bad = [row[:] for row in w] + bad[5][0] = -1 + badwm = multiply(bad, m) + mismatches = [[i, j, int(i == j) - pq[i][j], badwm[i][j]] + for i in range(104) for j in range(104) + if int(i == j) - pq[i][j] != badwm[i][j]] + require(mismatches == [[5, 0, 1, -1], [5, 1, -1, 1], + [5, 4, -1, 1], [5, 5, 1, -1]], + "Unexpected W corruption behavior") + return {"status": "PYTHON_INTEGER_CHECK_ONLY_NOT_KERNEL_EVIDENCE", + "identities": {"MP=0": mp_ok, "QP=I_33": qp_ok, "I_104-PQ=WM": residual_ok}, + "identity_scalar_obligations": 288 * 33 + 33 * 33 + 104 * 104, + "dense_scalar_multiplications_four_products": 288*104*33 + 33*104*33 + + 104*33*104 + 104*288*104, + "damaged_entry": {"row": 5, "column": 0, "original": 1, "damaged": -1}, + "damaged_residual_mismatches_row_column_lhs_rhs": mismatches, + "new_lean_executed": False} + + +def main() -> None: + check_generated(ROOT) + obj = load_source(ROOT) + recovered = read_emitted_values((ROOT / "P112Data.lean").read_text(encoding="utf-8")) + require(recovered == obj, "Inverse-parsed Lean constants differ from the JSON object") + canonical = (json.dumps(recovered, sort_keys=True, ensure_ascii=False, + separators=(",", ":")) + "\n").encode("utf-8") + report = numeric_result(recovered) + report["inverse_literal_parser_all_fields_equal"] = True + report["recovered_canonical_json_bytes"] = len(canonical) + report["recovered_canonical_json_sha256"] = hashlib.sha256(canonical).hexdigest() + print(json.dumps(report, indent=2)) + + +if __name__ == "__main__": + main() diff --git a/research/p112-integral-retraction-instance/source/fixtures/RejectDamagedW.lean b/research/p112-integral-retraction-instance/source/fixtures/RejectDamagedW.lean new file mode 100644 index 0000000000..9364ea689b --- /dev/null +++ b/research/p112-integral-retraction-instance/source/fixtures/RejectDamagedW.lean @@ -0,0 +1,18 @@ +/- +SPDX-License-Identifier: Apache-2.0 +INTENTIONAL COMPILE-FAIL CONTROL. Not imported by any positive source. +After rewriting with proved entry values, ordinary decide must reject 1 = -1. +An import, syntax, elaboration, timeout, or other failure is NOT acceptance. +-/ +import P112Damaged + +set_option autoImplicit false +set_option maxRecDepth 4096 +set_option maxHeartbeats 1000000 + +open PR1497 P112Cert P112Cert.Damaged + +example : matSub (eye 104) (matMul P Q) (5 : Fin 104) (0 : Fin 104) = + matMul W_bad M (5 : Fin 104) (0 : Fin 104) := by + rw [residual_entry, damaged_product_entry] + decide diff --git a/research/p112-integral-retraction-instance/source/generate.py b/research/p112-integral-retraction-instance/source/generate.py new file mode 100644 index 0000000000..f443b5b70b --- /dev/null +++ b/research/p112-integral-retraction-instance/source/generate.py @@ -0,0 +1,374 @@ +#!/usr/bin/env python3 +"""Deterministic source binding for the fixed P112 fragment; Python 3.12+, stdlib. + +--check is read-only. --write writes generated files ONLY, never the dependency +or the handwritten proof adapter/consequences. This is a source converter, not +a Lean verifier and not an E8 geometry verifier. All new Lean units need replay. +SPDX-License-Identifier: Apache-2.0 +""" +from __future__ import annotations + +import argparse +import hashlib +import json +from pathlib import Path +from typing import Any + +ROOT = Path(__file__).resolve().parent +JSON_BYTES = 13183 +JSON_SHA = "a1b43a5a7a8dcce0b84858244c512e53e6c344877cc35e87937fedd2601f29d5" +BRIDGE_BYTES = 48758 +BRIDGE_SHA = "a27494b0d40bbf7874fd9a875e468c67d11545b266e17bc98f2ca75c77f6ee40" +SHAPES = {"M": (288, 104), "P": (104, 33), "Q": (33, 104), "W": (104, 288)} +ENTRIES = {"M": 1152, "P": 195, "Q": 66, "W": 111} +TOP_KEYS = {"M", "P", "Q", "W", "anchors", "base_pair_representatives", + "coordinates", "free_parameters", "parameter_order", "rank"} +HEADER = """/- +Copyright (c) 2026 Andrey Mas and contributors. +SPDX-License-Identifier: Apache-2.0 +P112 numerical instance of the unchanged PR1497/PR1610 bridge. +SOURCE ONLY / NOT YET KERNEL CHECKED. Generated deterministically by generate.py. +Proof/source assistance: GPT-6 Pro through ChatGPT (operator-selected label). +-/ +""" +OPTIONS = """ +set_option autoImplicit false +set_option maxRecDepth 4096 +set_option maxHeartbeats 1000000 + +namespace P112Cert +open PR1497 + +""" + + +def require(test: bool, message: str) -> None: + if not test: + raise ValueError(message) + + +def reject_duplicate_keys(pairs: list[tuple[str, Any]]) -> dict[str, Any]: + result: dict[str, Any] = {} + for key, value in pairs: + require(key not in result, f"Duplicate JSON key {key!r}") + result[key] = value + return result + + +def pinned_file(path: Path, size: int, digest: str) -> bytes: + data = path.read_bytes() + require(len(data) == size, f"{path.name}: unexpected byte count") + require(hashlib.sha256(data).hexdigest() == digest, + f"{path.name}: unexpected SHA256") + require(data.endswith(b"\n") and b"\r" not in data, + f"{path.name}: not the pinned LF-terminated UTF8 file") + data.decode("utf-8") + return data + + +def load_source(root: Path = ROOT) -> dict[str, Any]: + raw = pinned_file(root / "P112.json", JSON_BYTES, JSON_SHA) + pinned_file(root / "PR1497Bridge.lean", BRIDGE_BYTES, BRIDGE_SHA) + obj = json.loads(raw, object_pairs_hook=reject_duplicate_keys) + validate_values(obj) + return obj + + +def validate_values(obj: Any) -> None: + require(type(obj) is dict and set(obj) == TOP_KEYS, "Wrong top-level schema") + for name, (nr, nc) in SHAPES.items(): + rows = obj[name] + require(type(rows) is list and len(rows) == nr, f"{name}: wrong row count") + count = 0 + for i, row in enumerate(rows): + require(type(row) is list, f"{name}/{i}: not a list") + previous = -1 + for e in row: + require(type(e) is list and len(e) == 2, f"{name}/{i}: bad entry") + col, coefficient = e + require(type(col) is int and 0 <= col < nc, f"{name}/{i}: bad column") + require(type(coefficient) is int and coefficient != 0, + f"{name}/{i}: noninteger/zero stored coefficient") + require(previous < col, f"{name}/{i}: duplicate or reordered columns") + previous = col + count += 1 + require(count == ENTRIES[name], f"{name}: wrong stored entry count") + require(type(obj["coordinates"]) is list and len(obj["coordinates"]) == 104, + "Wrong coordinate count") + for row in obj["coordinates"]: + require(type(row) is list and len(row) == 2, "Bad coordinate label") + require(all(type(x) is int for x in row), "Coordinate label is not integral") + require(0 <= row[0] < 26 and 0 <= row[1] < 8, "Coordinate label out of bounds") + require(type(obj["anchors"]) is list and len(obj["anchors"]) == 26, + "Wrong anchor count") + require(all(type(x) is int and 0 <= x < 8 for x in obj["anchors"]), "Bad anchor") + reps = obj["base_pair_representatives"] + require(type(reps) is dict and set(reps) == set(map(str, range(1, 8))), "Bad representatives") + require(all(type(x) is int and 0 <= x < 26 for x in reps.values()), "Bad representative value") + order = obj["parameter_order"] + require(type(order) is dict and set(order) == {"class_parameters", "g_points"}, + "Wrong parameter_order schema") + require(type(order["class_parameters"]) is int and order["class_parameters"] == 26, + "Wrong class parameter count") + require(order["g_points"] == [1, 2, 3, 4, 5, 6, 7] and + all(type(x) is int for x in order["g_points"]), "Wrong parameter order") + require(type(obj["free_parameters"]) is int and obj["free_parameters"] == 33, + "Wrong free parameter count") + require(type(obj["rank"]) is int and obj["rank"] == 71, "Wrong rank METADATA") + + +def footer(names: list[str]) -> str: + return ("\nend P112Cert\n\nset_option pp.fullNames true\n" + + "".join(f"#print axioms P112Cert.{name}\n" for name in names)) + + +def finlit(i: int) -> str: + # A bound proof, rather than Fin's modulo-reducing numeral notation. + return f"⟨{i}, by decide⟩" + + +def sparse_literal(row: list[list[int]]) -> str: + return "[" + ", ".join(f"({finlit(c)}, ({a} : Int))" for c, a in row) + "]" + + +def tree(rows: list[list[list[int]]], name: str, + lo: int, hi: int, indent: int = 2) -> str: + """Balanced ordinary if tree. For a valid index each leaf is its source row.""" + require(0 <= lo < hi <= len(rows), "Bad tree interval") + sp = " " * indent + if hi - lo == 1: + return f"{sp}{sparse_literal(rows[lo])} -- /{name}/{lo}\n" + mid = (lo + hi) // 2 + return (f"{sp}if i.val < {mid} then\n" + tree(rows, name, lo, mid, indent + 2) + + f"{sp}else\n" + tree(rows, name, mid, hi, indent + 2)) + + +def tree_leaf(index: int, lo: int, hi: int) -> int: + # Source-converter sanity check. This does not stand in for any Lean theorem. + while hi - lo > 1: + mid = (lo + hi) // 2 + if index < mid: + hi = mid + else: + lo = mid + return lo + + +def render_data(obj: dict[str, Any]) -> str: + lines = [HEADER, "import P112Sparse\n", OPTIONS] + names: list[str] = [] + used: set[str] = set() + for name, (nr, nc) in SHAPES.items(): + used.add(name) + require(all(tree_leaf(i, 0, nr) == i for i in range(nr)), "Tree order mismatch") + lines.append(f"/-- Original sparse {name} rows, in original row/entry order. -/\n") + lines.append(f"def {name}_entries (i : Fin {nr}) : List (Fin {nc} × Int) :=\n") + lines.append(tree(obj[name], name, 0, nr)) + lines.append(f"\ndef {name} : Mat {nr} {nc} := fun i => Sparse.row ({name}_entries i)\n\n") + names += [f"{name}_entries", name] + used.add("anchors") + lines.append("/-- Provenance metadata only; no class-completeness theorem is asserted. -/\n") + lines.append("def anchors : List Nat := [" + ", ".join(map(str, obj["anchors"])) + "]\n\n") + names.append("anchors") + used.add("base_pair_representatives") + pairs = ", ".join(f"({json.dumps(k)}, {v})" for k, v in obj["base_pair_representatives"].items()) + lines.append(f"def basePairRepresentatives : List (String × Nat) := [{pairs}]\n\n") + names.append("basePairRepresentatives") + used.add("coordinates") + labels = ", ".join(f"({c}, {k})" for c, k in obj["coordinates"]) + lines.append(f"def coordinateLabels : List (Nat × Nat) := [{labels}]\n\n") + names.append("coordinateLabels") + used.add("free_parameters") + lines.append(f"def freeParameters : Nat := {obj['free_parameters']}\n\n") + names.append("freeParameters") + used.add("parameter_order") + lines.append(f"def parameterClassCount : Nat := {obj['parameter_order']['class_parameters']}\n\n") + lines.append("def gPoints : List Nat := [" + ", ".join(map(str, obj["parameter_order"]["g_points"])) + "]\n\n") + names += ["parameterClassCount", "gPoints"] + used.add("rank") + lines.append("/-- Inherited JSON metadata, NOT a formal matrix-rank statement. -/\n") + lines.append(f"def rankMetadata : Nat := {obj['rank']}\n") + names.append("rankMetadata") + require(used == set(obj), "An input field was not rendered") + return "".join(lines) + footer(names) + + +def pointer_escape(key: str) -> str: + return key.replace("~", "~0").replace("/", "~1") + + +def binding_ledger(obj: dict[str, Any]) -> str: + """Every JSON node, including empty rows, is explicitly assigned a target.""" + lines = ["json_pointer\tnode_kind\tvalue_or_shape\tlean_binding\n"] + targets = {"M": "M_entries", "P": "P_entries", "Q": "Q_entries", "W": "W_entries", + "anchors": "anchors", "base_pair_representatives": "basePairRepresentatives", + "coordinates": "coordinateLabels", "free_parameters": "freeParameters", + "rank": "rankMetadata"} + + def walk(value: Any, path: str, target: str) -> None: + if type(value) is dict: + rep = json.dumps(list(value), ensure_ascii=False, separators=(",", ":")) + lines.append(f"{path or '/'}\tobject_keys\t{rep}\t{target}\n") + for key, child in value.items(): + if path == "": + dest = targets.get(key, "parameter_order (split below)") + elif path == "/parameter_order": + dest = {"class_parameters": "parameterClassCount", "g_points": "gPoints"}[key] + else: + dest = target + f"[{json.dumps(key)}]" + walk(child, path + "/" + pointer_escape(key), dest) + elif type(value) is list: + lines.append(f"{path}\tarray_length\t{len(value)}\t{target}\n") + for i, child in enumerate(value): + walk(child, path + f"/{i}", target + f"[{i}]") + else: + require(type(value) is int, f"Unexpected JSON scalar at {path}") + lines.append(f"{path}\tinteger\t{value}\t{target}\n") + + walk(obj, "", "P112Cert constants and fixed matrix shapes") + return "".join(lines) + + +def row_statement(kind: str, row: str) -> str: + if kind == "mp": + return f"∀ j : Fin 33, Sparse.eval (M_entries {row}) P j = 0" + if kind == "qp": + return f"∀ j : Fin 33, Sparse.eval (Q_entries {row}) P j = eye 33 {row} j" + if kind == "residual": + return (f"∀ j : Fin 104, eye 104 {row} j - Sparse.eval (P_entries {row}) Q j =\n" + f" Sparse.eval (W_entries {row}) M j") + raise ValueError(kind) + + +def render_rows(kind: str, lo: int, hi: int) -> str: + text = HEADER + "import P112Data\n" + OPTIONS + names: list[str] = [] + for i in range(lo, hi): + name = f"{kind}_row_{i:03}" + names.append(name) + text += (f"/-- Complete {kind} row {i}, not a sampled set of columns. -/\n" + f"theorem {name} :\n {row_statement(kind, finlit(i))} := by\n" + " decide\n\n") + return text + footer(names) + + +def forall_assembly(kind: str, n: int) -> str: + # Balance the proof tree too: no 288-deep nested eliminator expression. + # Expected types supply the restricted predicates under castAdd/natAdd. + def assemble(lo: int, hi: int, indent: int) -> str: + sp = " " * indent + if hi - lo == 1: + return f"{sp}(Fin.forall_fin_one.mpr {kind}_row_{lo:03})" + mid = (lo + hi) // 2 + return (f"{sp}(Sparse.allFinAdd (a := {mid-lo}) (b := {hi-mid})\n" + + assemble(lo, mid, indent + 2) + "\n" + + assemble(mid, hi, indent + 2) + ")") + return (f"theorem {kind}_sparse_all : ∀ i : Fin {n},\n" + f" {row_statement(kind, 'i')} := by\n exact\n" + + assemble(0, n, 4) + "\n\n") + + +def render_certificate(modules: list[str]) -> str: + text = HEADER + "".join(f"import {m}\n" for m in modules) + OPTIONS + for kind, n in (("mp", 288), ("qp", 33), ("residual", 104)): + text += forall_assembly(kind, n) + text += """/-- Equality for the imported bridge's ordinary Int matrix product. -/ +theorem mp : matMul M P = zeroMat 288 33 := by + funext i j + change rowMul (Sparse.row (M_entries i)) P j = (0 : Int) + exact (congrArg (fun v : Row 33 => v j) + (Sparse.rowMul_row (M_entries i) P)).trans (mp_sparse_all i j) + +/-- Equality for the imported bridge's ordinary Int matrix product. -/ +theorem qp : matMul Q P = eye 33 := by + funext i j + change rowMul (Sparse.row (Q_entries i)) P j = eye 33 i j + exact (congrArg (fun v : Row 33 => v j) + (Sparse.rowMul_row (Q_entries i) P)).trans (qp_sparse_all i j) + +/-- The full 104-by-104 residual, with the original row orientation and W signs. -/ +theorem residual : matSub (eye 104) (matMul P Q) = matMul W M := by + funext i j + change eye 104 i j - rowMul (Sparse.row (P_entries i)) Q j = + rowMul (Sparse.row (W_entries i)) M j + have hp := congrArg (fun v : Row 104 => v j) + (Sparse.rowMul_row (P_entries i) Q) + change rowMul (Sparse.row (P_entries i)) Q j = + Sparse.eval (P_entries i) Q j at hp + have hw := congrArg (fun v : Row 104 => v j) + (Sparse.rowMul_row (W_entries i) M) + change rowMul (Sparse.row (W_entries i)) M j = + Sparse.eval (W_entries i) M j at hw + rw [hp, hw] + exact residual_sparse_all i j + +/-- No certificate hypothesis: the three fields are the proved numerical equalities. -/ +theorem certificate : MatrixIdentities M P Q W := + { mp := mp, qp := qp, residual := residual } +""" + return text + footer(["mp_sparse_all", "qp_sparse_all", "residual_sparse_all", + "mp", "qp", "residual", "certificate"]) + + +def generated_files(obj: dict[str, Any]) -> dict[str, bytes]: + result: dict[str, str] = {"P112Data.lean": render_data(obj), + "BINDING.tsv": binding_ledger(obj)} + modules: list[str] = [] + for kind, n, batch, prefix in (("mp", 288, 16, "MP"), + ("qp", 33, 16, "QP"), + ("residual", 104, 8, "Residual")): + for unit, lo in enumerate(range(0, n, batch)): + module = f"P112.{prefix}{unit:02}" + modules.append(module) + result[module.replace(".", "/") + ".lean"] = render_rows(kind, lo, min(n, lo + batch)) + result["P112Certificate.lean"] = render_certificate(modules) + plan = ["PR1497Bridge.lean", "P112Sparse.lean", "P112Data.lean"] + plan += [m.replace(".", "/") + ".lean" for m in modules] + plan += ["P112Certificate.lean", "P112Consequences.lean", "P112Damaged.lean"] + result["REPLAY_PLAN.json"] = json.dumps({ + "positive_units": plan, + "negative_units": ["fixtures/RejectDamagedW.lean"], + "per_unit_seconds": 120, + "successor_total_seconds": 600, + "dependency_excluded_from_successor_total": "PR1497Bridge.lean", + "maximum_columns_per_decision": 104, + "new_heartbeat_limit_per_command": 1000000, + "new_recursion_limit": 4096, + }, indent=2, ensure_ascii=False) + "\n" + result["GENERATED_FILES.txt"] = "".join(x + "\n" for x in sorted([*result, "GENERATED_FILES.txt"])) + return {name: content.encode("utf-8") for name, content in result.items()} + + +def check_generated(root: Path = ROOT) -> dict[str, Any]: + obj = load_source(root) + files = generated_files(obj) + for name, expected in files.items(): + require((root / name).read_bytes() == expected, f"Generated source mismatch: {name}") + expected_staged = {name for name in files if name.startswith("P112/")} + actual_staged = {str(p.relative_to(root)) for p in (root / "P112").glob("*.lean")} + require(actual_staged == expected_staged, "Missing/extra staged Lean file") + return {"status": "SOURCE_BINDING_ONLY", "generated_files": len(files), + "pinned_json_bytes": JSON_BYTES, "pinned_json_sha256": JSON_SHA, + "pinned_bridge_bytes": BRIDGE_BYTES, "pinned_bridge_sha256": BRIDGE_SHA, + "stored_entries": ENTRIES, "no_lean_execution": True} + + +def main() -> None: + parser = argparse.ArgumentParser(description=__doc__) + mode = parser.add_mutually_exclusive_group(required=True) + mode.add_argument("--check", action="store_true", help="Read-only exact regeneration check") + mode.add_argument("--write", action="store_true", help="Write deterministic generated files") + parser.add_argument("--root", type=Path, default=ROOT) + args = parser.parse_args() + root = args.root.resolve() + if args.write: + obj = load_source(root) + for name, data in generated_files(obj).items(): + path = root / name + path.parent.mkdir(parents=True, exist_ok=True) + path.write_bytes(data) + print(json.dumps(check_generated(root), indent=2)) + + +if __name__ == "__main__": + main() diff --git a/research/p112-integral-retraction-instance/source/producer/integer-check.stderr b/research/p112-integral-retraction-instance/source/producer/integer-check.stderr new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/p112-integral-retraction-instance/source/producer/integer-check.stdout b/research/p112-integral-retraction-instance/source/producer/integer-check.stdout new file mode 100644 index 0000000000..997a3a17c7 --- /dev/null +++ b/research/p112-integral-retraction-instance/source/producer/integer-check.stdout @@ -0,0 +1,46 @@ +{ + "status": "PYTHON_INTEGER_CHECK_ONLY_NOT_KERNEL_EVIDENCE", + "identities": { + "MP=0": true, + "QP=I_33": true, + "I_104-PQ=WM": true + }, + "identity_scalar_obligations": 21409, + "dense_scalar_multiplications_four_products": 4573608, + "damaged_entry": { + "row": 5, + "column": 0, + "original": 1, + "damaged": -1 + }, + "damaged_residual_mismatches_row_column_lhs_rhs": [ + [ + 5, + 0, + 1, + -1 + ], + [ + 5, + 1, + -1, + 1 + ], + [ + 5, + 4, + -1, + 1 + ], + [ + 5, + 5, + 1, + -1 + ] + ], + "new_lean_executed": false, + "inverse_literal_parser_all_fields_equal": true, + "recovered_canonical_json_bytes": 13183, + "recovered_canonical_json_sha256": "a1b43a5a7a8dcce0b84858244c512e53e6c344877cc35e87937fedd2601f29d5" +} diff --git a/research/p112-integral-retraction-instance/source/producer/regeneration.stderr b/research/p112-integral-retraction-instance/source/producer/regeneration.stderr new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/p112-integral-retraction-instance/source/producer/regeneration.stdout b/research/p112-integral-retraction-instance/source/producer/regeneration.stdout new file mode 100644 index 0000000000..41c0eeba83 --- /dev/null +++ b/research/p112-integral-retraction-instance/source/producer/regeneration.stdout @@ -0,0 +1,15 @@ +{ + "status": "SOURCE_BINDING_ONLY", + "generated_files": 39, + "pinned_json_bytes": 13183, + "pinned_json_sha256": "a1b43a5a7a8dcce0b84858244c512e53e6c344877cc35e87937fedd2601f29d5", + "pinned_bridge_bytes": 48758, + "pinned_bridge_sha256": "a27494b0d40bbf7874fd9a875e468c67d11545b266e17bc98f2ca75c77f6ee40", + "stored_entries": { + "M": 1152, + "P": 195, + "Q": 66, + "W": 111 + }, + "no_lean_execution": true +} diff --git a/research/p112-integral-retraction-instance/source/producer/source-audit.stderr b/research/p112-integral-retraction-instance/source/producer/source-audit.stderr new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/p112-integral-retraction-instance/source/producer/source-audit.stdout b/research/p112-integral-retraction-instance/source/producer/source-audit.stdout new file mode 100644 index 0000000000..e0e501e8f9 --- /dev/null +++ b/research/p112-integral-retraction-instance/source/producer/source-audit.stdout @@ -0,0 +1,24 @@ +{ + "status": "SOURCE_AUDIT_ONLY_NOT_KERNEL_EVIDENCE", + "binding": { + "status": "SOURCE_BINDING_ONLY", + "generated_files": 39, + "pinned_json_bytes": 13183, + "pinned_json_sha256": "a1b43a5a7a8dcce0b84858244c512e53e6c344877cc35e87937fedd2601f29d5", + "pinned_bridge_bytes": 48758, + "pinned_bridge_sha256": "a27494b0d40bbf7874fd9a875e468c67d11545b266e17bc98f2ca75c77f6ee40", + "stored_entries": { + "M": 1152, + "P": 195, + "Q": 66, + "W": 111 + }, + "no_lean_execution": true + }, + "inherited_named_queries": 159, + "new_named_queries": 477, + "new_theorems": 457, + "positive_units_including_dependency": 40, + "negative_units": 1, + "new_lean_executed": false +} diff --git a/research/p112-integral-retraction-instance/source/producer/tooling-tests.stderr b/research/p112-integral-retraction-instance/source/producer/tooling-tests.stderr new file mode 100644 index 0000000000..af0e26dbcb --- /dev/null +++ b/research/p112-integral-retraction-instance/source/producer/tooling-tests.stderr @@ -0,0 +1,19 @@ +test_10_synthetic_positive_parser (__main__.AcceptanceTests.test_10_synthetic_positive_parser) ... ok +test_11_errors_warnings_missing_olean_never_pass (__main__.AcceptanceTests.test_11_errors_warnings_missing_olean_never_pass) ... ok +test_12_axioms_and_missing_duplicate_census_rejected (__main__.AcceptanceTests.test_12_axioms_and_missing_duplicate_census_rejected) ... ok +test_13_negative_requires_exact_mathematical_failure (__main__.AcceptanceTests.test_13_negative_requires_exact_mathematical_failure) ... ok +test_14_exact_toolchain_identity_required (__main__.AcceptanceTests.test_14_exact_toolchain_identity_required) ... ok +test_01_pins_and_full_regeneration (__main__.SourceTests.test_01_pins_and_full_regeneration) ... ok +test_02_inverse_parser_recovers_every_field (__main__.SourceTests.test_02_inverse_parser_recovers_every_field) ... ok +test_03_all_matrix_identities_and_real_corruption (__main__.SourceTests.test_03_all_matrix_identities_and_real_corruption) ... ok +test_04_unknown_input_field_rejected (__main__.SourceTests.test_04_unknown_input_field_rejected) ... ok +test_05_duplicate_json_key_rejected (__main__.SourceTests.test_05_duplicate_json_key_rejected) ... ok +test_06_duplicate_sparse_column_rejected (__main__.SourceTests.test_06_duplicate_sparse_column_rejected) ... ok +test_07_out_of_range_column_rejected (__main__.SourceTests.test_07_out_of_range_column_rejected) ... ok +test_08_empty_row_and_metadata_changes_are_visible (__main__.SourceTests.test_08_empty_row_and_metadata_changes_are_visible) ... ok +test_09_complete_census (__main__.SourceTests.test_09_complete_census) ... ok + +---------------------------------------------------------------------- +Ran 14 tests in 0.520s + +OK diff --git a/research/p112-integral-retraction-instance/source/producer/tooling-tests.stdout b/research/p112-integral-retraction-instance/source/producer/tooling-tests.stdout new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/p112-integral-retraction-instance/source/replay.py b/research/p112-integral-retraction-instance/source/replay.py new file mode 100644 index 0000000000..80b35de91e --- /dev/null +++ b/research/p112-integral-retraction-instance/source/replay.py @@ -0,0 +1,209 @@ +#!/usr/bin/env python3 +"""Operator-only, exact-toolchain bounded replay. No installation or networking. + +Audit the complete package before executing this program. Uses only the supplied +absolute compiler, in a fresh isolated source tree. Outputs actual logs and an +operator report outside this package. The presence of this script is NOT replay. +Python 3.12+, standard library. SPDX-License-Identifier: Apache-2.0 +""" +from __future__ import annotations +import argparse +import hashlib +import json +import os +import re +import signal +import subprocess +import tempfile +import time +from pathlib import Path +from typing import Any +from audit_sources import audit, verify_manifest +from check_axioms import ALLOWED, QUERY, parse_records +from generate import ROOT, require + +LEAN = "/Users/andrejmas/.elan/toolchains/leanprover--lean4---v4.30.0/bin/lean" +VERSION = "4.30.0" +COMMIT = "d024af099ca4bf2c86f649261ebf59565dc8c622" +UNIT_LIMIT = 120.0 +TOTAL_LIMIT = 600.0 + + +class ReplayFailure(RuntimeError): + pass + + +def validate_version(short: str, commit: str) -> None: + if short.strip() != VERSION or commit.strip() != COMMIT: + raise ReplayFailure("Compiler version/commit differs from the exact pin") + + +def check_positive(source: str, stdout: str, stderr: str, + returncode: int, olean_present: bool) -> dict[str, list[str]]: + if returncode != 0 or not olean_present: + raise ReplayFailure("Positive unit did not produce an .olean with exit 0") + if stderr.strip() or re.search(r"(?mi)^.*\b(?:error|warning):", stdout): + raise ReplayFailure("Positive compilation has diagnostics/stderr") + actual = parse_records(stdout) + expected = QUERY.findall(source) + if not expected or len(expected) != len(set(expected)) or set(expected) != set(actual): + raise ReplayFailure("Positive axiom census missing, duplicated, or unexpected") + return actual + + +def check_negative(stdout: str, stderr: str, returncode: int, + olean_present: bool) -> None: + if returncode != 1 or olean_present or stderr.strip(): + raise ReplayFailure("Negative control did not fail cleanly without an .olean") + errors = re.findall(r"(?m)^.*:\d+:\d+: error:", stdout) + diagnostic = re.search(r"Tactic [`']decide[`'] proved that the proposition\s+" + r"1\s*=\s*-1\s+is false", stdout) + if len(errors) != 1 or not diagnostic or re.search(r"(?mi)\bwarning:", stdout): + raise ReplayFailure("Negative failure was not the intended decide rejection of 1 = -1") + + +def run_process(args: list[str], cwd: Path, env: dict[str, str], timeout: float, + stdout_path: Path, stderr_path: Path) -> tuple[int, float]: + if timeout <= 0: + raise ReplayFailure("Global successor wall-clock budget exhausted before next unit") + start = time.monotonic() + with stdout_path.open("wb") as out, stderr_path.open("wb") as err: + proc = subprocess.Popen(args, cwd=cwd, env=env, stdout=out, stderr=err, + start_new_session=True) + try: + rc = proc.wait(timeout=timeout) + except subprocess.TimeoutExpired as exc: + # No task is left running. This runner is for the specified macOS/Unix host. + try: + os.killpg(proc.pid, signal.SIGKILL) + except ProcessLookupError: + pass + proc.wait() + raise ReplayFailure(f"External wall-clock cap reached ({timeout:.3f}s): {args[-1]}") from exc + except BaseException: + try: + os.killpg(proc.pid, signal.SIGKILL) + except ProcessLookupError: + pass + proc.wait() + raise + return rc, time.monotonic() - start + + +def replay(root: Path, compiler: Path, output: Path) -> None: + start = time.monotonic() + excluded_dependency = 0.0 + report: dict[str, Any] = { + "status": "RUNNING_NOT_YET_ACCEPTED", "compiler_requested": str(compiler), + "required_version": VERSION, "required_commit": COMMIT, + "per_unit_wall_limit_seconds": UNIT_LIMIT, + "successor_total_wall_limit_seconds": TOTAL_LIMIT, + "allowed_axioms": sorted(ALLOWED), "units": [], + "observed_axiom_dependencies": {}, + } + report_path = output / "OPERATOR_REPLAY.json" + current = "preflight" + try: + audit(root) + verify_manifest(root) + require(compiler.is_absolute() and compiler.is_file(), + "Supply the existing exact compiler at an absolute path; no PATH/elan fallback") + source_dir = output / "source" + logs = output / "logs" + source_dir.mkdir() + logs.mkdir() + plan = json.loads((root / "REPLAY_PLAN.json").read_text(encoding="utf-8")) + for rel in plan["positive_units"] + plan["negative_units"]: + src, dst = root / rel, source_dir / rel + dst.parent.mkdir(parents=True, exist_ok=True) + data = src.read_bytes() + dst.write_bytes(data) + require(dst.read_bytes() == data, "Source-copy mismatch") + env = os.environ.copy() + for key in ("LEAN_PATH", "LEAN_SRC_PATH", "LEAN_SYSROOT"): + env.pop(key, None) + env["LEAN_PATH"] = str(source_dir.resolve()) + versions: dict[str, str] = {} + for flag in ("--short-version", "--githash", "--version"): + label = flag[2:] + out, err = logs / f"compiler-{label}.stdout", logs / f"compiler-{label}.stderr" + rc, _ = run_process([str(compiler), flag], source_dir, env, 10.0, out, err) + require(rc == 0 and not err.read_bytes(), f"Compiler {flag} check failed") + versions[flag] = out.read_text(encoding="utf-8") + validate_version(versions["--short-version"], versions["--githash"]) + report["observed_version_output"] = versions + + for rel in plan["positive_units"] + plan["negative_units"]: + current = rel + stage_start = time.monotonic() + dependency = rel == "PR1497Bridge.lean" + remaining = TOTAL_LIMIT - (stage_start - start - excluded_dependency) + timeout = UNIT_LIMIT if dependency else min(UNIT_LIMIT, remaining) + src = source_dir / rel + olean = src.with_suffix(".olean") + require(not olean.exists(), f"Non-fresh output {olean}") + label = rel[:-5].replace("/", "_") + out, err = logs / f"{label}.stdout", logs / f"{label}.stderr" + record: dict[str, Any] = { + "source": rel, "source_utf8_bytes": len(src.read_bytes()), + "source_sha256": hashlib.sha256(src.read_bytes()).hexdigest(), + "stdout_log": str(out.relative_to(output)), "stderr_log": str(err.relative_to(output)), + "external_timeout_seconds": timeout, "accepted": False, + } + report["units"].append(record) + rc, elapsed = run_process([str(compiler), "-o", str(olean), rel], source_dir, env, + timeout, out, err) + record.update(returncode=rc, process_seconds=elapsed, + olean_produced=olean.is_file() and olean.stat().st_size > 0) + stdout, stderr = out.read_text(encoding="utf-8"), err.read_text(encoding="utf-8") + if rel in plan["positive_units"]: + actual = check_positive(src.read_text(encoding="utf-8"), stdout, stderr, + rc, record["olean_produced"]) + require(not set(actual) & set(report["observed_axiom_dependencies"]), + "Duplicate declaration across compiled units") + report["observed_axiom_dependencies"].update(actual) + record["axiom_query_count"] = len(actual) + record["olean_sha256"] = hashlib.sha256(olean.read_bytes()).hexdigest() + else: + check_negative(stdout, stderr, rc, record["olean_produced"]) + record["negative_control"] = "intended decide rejection of 1 = -1" + record["accepted"] = True + if dependency: + excluded_dependency += time.monotonic() - stage_start + require(time.monotonic() - start - excluded_dependency <= TOTAL_LIMIT, + "Global successor wall-clock budget exhausted") + report_path.write_text(json.dumps(report, indent=2) + "\n", encoding="utf-8") + print(f"ACCEPTED {rel}: {elapsed:.3f}s", flush=True) + report["status"] = "ACCEPTED_ON_THIS_ACTUAL_OPERATOR_REPLAY" + report["complete_named_axiom_census"] = len(report["observed_axiom_dependencies"]) + except BaseException as exc: + report["status"] = "STOPPED_NOT_ACCEPTED" + report["stopped_at"] = current + report["failure"] = f"{type(exc).__name__}: {exc}" + raise + finally: + report["total_seconds"] = time.monotonic() - start + report["excluded_unchanged_dependency_seconds"] = excluded_dependency + report["successor_seconds_including_preflight"] = report["total_seconds"] - excluded_dependency + report_path.write_text(json.dumps(report, indent=2) + "\n", encoding="utf-8") + print(f"Actual operator report: {report_path}", flush=True) + + +def main() -> None: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--lean", type=Path, default=Path(LEAN)) + parser.add_argument("--root", type=Path, default=ROOT) + parser.add_argument("--output", type=Path, + help="New output directory; it must not already exist") + args = parser.parse_args() + if args.output is None: + output = Path(tempfile.mkdtemp(prefix="p112-lean430-replay-")) + else: + output = args.output.resolve() + output.mkdir(parents=True, exist_ok=False) + print(f"Fresh replay directory: {output}", flush=True) + replay(args.root.resolve(), args.lean, output) + + +if __name__ == "__main__": + main() diff --git a/research/p112-integral-retraction-instance/source/test_tooling.py b/research/p112-integral-retraction-instance/source/test_tooling.py new file mode 100644 index 0000000000..d573998b58 --- /dev/null +++ b/research/p112-integral-retraction-instance/source/test_tooling.py @@ -0,0 +1,111 @@ +#!/usr/bin/env python3 +"""Source/transport/acceptance-tool unit tests. No Lean compiler is invoked. +Synthetic strings below test only parser behavior and are NOT compiler receipts. +SPDX-License-Identifier: Apache-2.0 +""" +from __future__ import annotations +import copy +import hashlib +import json +import unittest +from generate import (ROOT, JSON_SHA, BRIDGE_SHA, validate_values, load_source, + reject_duplicate_keys, check_generated) +from check_numeric import read_emitted_values, numeric_result +from audit_sources import audit +from check_axioms import parse_records +from replay import (ReplayFailure, check_positive, check_negative, + validate_version, VERSION, COMMIT) + + +class SourceTests(unittest.TestCase): + @classmethod + def setUpClass(cls) -> None: + cls.obj = load_source(ROOT) + cls.data_text = (ROOT / "P112Data.lean").read_text(encoding="utf-8") + + def test_01_pins_and_full_regeneration(self) -> None: + self.assertEqual(hashlib.sha256((ROOT/"P112.json").read_bytes()).hexdigest(), JSON_SHA) + self.assertEqual(hashlib.sha256((ROOT/"PR1497Bridge.lean").read_bytes()).hexdigest(), BRIDGE_SHA) + self.assertEqual(check_generated(ROOT)["generated_files"], 39) + + def test_02_inverse_parser_recovers_every_field(self) -> None: + self.assertEqual(read_emitted_values(self.data_text), self.obj) + + def test_03_all_matrix_identities_and_real_corruption(self) -> None: + result = numeric_result(self.obj) + self.assertEqual(result["identity_scalar_obligations"], 21409) + self.assertEqual(len(result["damaged_residual_mismatches_row_column_lhs_rhs"]), 4) + self.assertFalse(result["new_lean_executed"]) + + def test_04_unknown_input_field_rejected(self) -> None: + obj = copy.deepcopy(self.obj) + obj["unused"] = 1 + with self.assertRaises(ValueError): validate_values(obj) + + def test_05_duplicate_json_key_rejected(self) -> None: + with self.assertRaises(ValueError): + json.loads('{"rank":71,"rank":71}', object_pairs_hook=reject_duplicate_keys) + + def test_06_duplicate_sparse_column_rejected(self) -> None: + obj = copy.deepcopy(self.obj) + obj["M"][0][1][0] = obj["M"][0][0][0] + with self.assertRaises(ValueError): validate_values(obj) + + def test_07_out_of_range_column_rejected(self) -> None: + obj = copy.deepcopy(self.obj) + obj["W"][5][0][0] = 288 + with self.assertRaises(ValueError): validate_values(obj) + + def test_08_empty_row_and_metadata_changes_are_visible(self) -> None: + changed = self.data_text.replace("[] -- /W/0", "[(⟨0, by decide⟩, (1 : Int))] -- /W/0", 1) + self.assertNotEqual(read_emitted_values(changed), self.obj) + changed = self.data_text.replace("def rankMetadata : Nat := 71", "def rankMetadata : Nat := 72", 1) + self.assertNotEqual(read_emitted_values(changed), self.obj) + + def test_09_complete_census(self) -> None: + report = audit(ROOT) + self.assertEqual(report["inherited_named_queries"], 159) + self.assertEqual(report["new_named_queries"], 477) + self.assertEqual(report["new_theorems"], 457) + + +class AcceptanceTests(unittest.TestCase): + SOURCE = "#print axioms Toy.only\n" + LOG = "'Toy.only' does not depend on any axioms\n" + FALSE = "fixtures/RejectDamagedW.lean:18:2: error: Tactic `decide` proved that the proposition\n 1 = -1\nis false\n" + + def test_10_synthetic_positive_parser(self) -> None: + self.assertEqual(check_positive(self.SOURCE, self.LOG, "", 0, True), {"Toy.only": []}) + + def test_11_errors_warnings_missing_olean_never_pass(self) -> None: + for text, stderr, rc, present in [(self.LOG, "", 1, True), (self.LOG, "", 0, False), + (self.LOG+"file:1:1: error: bad\n", "", 0, True), + (self.LOG+"file:1:1: warning: bad\n", "", 0, True), + (self.LOG, "unexpected stderr", 0, True)]: + with self.assertRaises((ReplayFailure, ValueError)): + check_positive(self.SOURCE, text, stderr, rc, present) + + def test_12_axioms_and_missing_duplicate_census_rejected(self) -> None: + for text in ["'Toy.only' depends on axioms: [sorryAx]\n", "", self.LOG+self.LOG, + "'Toy.other' does not depend on any axioms\n"]: + with self.assertRaises((ReplayFailure, ValueError)): + check_positive(self.SOURCE, text, "", 0, True) + self.assertEqual(parse_records("'Toy.x' depends on axioms: [propext, Quot.sound]\n"), + {"Toy.x": ["Quot.sound", "propext"]}) + + def test_13_negative_requires_exact_mathematical_failure(self) -> None: + check_negative(self.FALSE, "", 1, False) + for text, rc, present in [("file:1:1: error: unknown module\n", 1, False), + (self.FALSE, 0, False), (self.FALSE, 1, True), + (self.FALSE, -9, False), (self.FALSE+self.FALSE, 1, False), + (self.FALSE.replace("1 = -1", "True = False"), 1, False)]: + with self.assertRaises(ReplayFailure): check_negative(text, "", rc, present) + + def test_14_exact_toolchain_identity_required(self) -> None: + validate_version(VERSION+"\n", COMMIT+"\n") + for v, c in [("4.29.0", COMMIT), (VERSION, "0"*40), (VERSION+"-rc1", COMMIT)]: + with self.assertRaises(ReplayFailure): validate_version(v, c) + + +if __name__ == "__main__": + unittest.main(verbosity=2)