From 9c75d0b4b6e1cfe74694edf52f2f238a741bbaf5 Mon Sep 17 00:00:00 2001 From: Jerry Jiaheng Chen <80299683+CubeJerry@users.noreply.github.com> Date: Fri, 13 Nov 2026 22:22:54 +1100 Subject: [PATCH 1/3] Prove the exact radius-five Gaussian rounding threshold with a compact Hall obstruction Retain an attaining injection and independently checked strict Hall certificate, reduce the lower proof to 38 signed-coordinate representatives, and verify the native pair transfer. Include exact replay, independent full-graph and orbit-flow evidence, limitations and predecessor credit. No new kappa; substantial OpenAI assistance for @CubeJerry. --- .../CHECKSUMS.sha256 | 19 + .../NOTICE.md | 14 + .../OPEN-NEXT-QUESTIONS.md | 26 + .../PR-DESCRIPTION.md | 72 ++ .../PR-DRAFT.md | 45 ++ .../PROOF.md | 150 ++++ .../PUBLICATION-MANIFEST.json | 170 ++++ .../R5-OPTIMUM.json.gz | Bin 0 -> 28950 bytes .../README.md | 54 ++ .../RESULT.json | 1 + .../SEARCH-PROVENANCE.md | 36 + .../SOURCES.json | 58 ++ .../VERIFY.json | 13 + .../VERIFY.md | 34 + .../compact-hall/ORBIT-FLOW-RESULT.json | 1 + .../compact-hall/PROOF.md | 159 ++++ .../compact-hall/README.md | 34 + .../compact-hall/RESULT.json | 1 + .../compact-hall/SOURCES.json | 53 ++ .../compact-hall/check.py | 316 ++++++++ .../compact-hall/orbit_cut.py | 595 ++++++++++++++ .../replay.py | 57 ++ .../review/PUBLICATION-REPLAY.json | 57 ++ .../review/REMOTE-SOURCE-CHECK.json | 24 + .../review/RESULT.json | 755 ++++++++++++++++++ .../review/ROOT-REVIEW.md | 76 ++ .../review/check_full_matching.py | 125 +++ .../verify.py | 364 +++++++++ 28 files changed, 3309 insertions(+) create mode 100644 research/sharp-finite-gaussian-outward-slack/CHECKSUMS.sha256 create mode 100644 research/sharp-finite-gaussian-outward-slack/NOTICE.md create mode 100644 research/sharp-finite-gaussian-outward-slack/OPEN-NEXT-QUESTIONS.md create mode 100644 research/sharp-finite-gaussian-outward-slack/PR-DESCRIPTION.md create mode 100644 research/sharp-finite-gaussian-outward-slack/PR-DRAFT.md create mode 100644 research/sharp-finite-gaussian-outward-slack/PROOF.md create mode 100644 research/sharp-finite-gaussian-outward-slack/PUBLICATION-MANIFEST.json create mode 100644 research/sharp-finite-gaussian-outward-slack/R5-OPTIMUM.json.gz create mode 100644 research/sharp-finite-gaussian-outward-slack/README.md create mode 100644 research/sharp-finite-gaussian-outward-slack/RESULT.json create mode 100644 research/sharp-finite-gaussian-outward-slack/SEARCH-PROVENANCE.md create mode 100644 research/sharp-finite-gaussian-outward-slack/SOURCES.json create mode 100644 research/sharp-finite-gaussian-outward-slack/VERIFY.json create mode 100644 research/sharp-finite-gaussian-outward-slack/VERIFY.md create mode 100644 research/sharp-finite-gaussian-outward-slack/compact-hall/ORBIT-FLOW-RESULT.json create mode 100644 research/sharp-finite-gaussian-outward-slack/compact-hall/PROOF.md create mode 100644 research/sharp-finite-gaussian-outward-slack/compact-hall/README.md create mode 100644 research/sharp-finite-gaussian-outward-slack/compact-hall/RESULT.json create mode 100644 research/sharp-finite-gaussian-outward-slack/compact-hall/SOURCES.json create mode 100644 research/sharp-finite-gaussian-outward-slack/compact-hall/check.py create mode 100644 research/sharp-finite-gaussian-outward-slack/compact-hall/orbit_cut.py create mode 100644 research/sharp-finite-gaussian-outward-slack/replay.py create mode 100644 research/sharp-finite-gaussian-outward-slack/review/PUBLICATION-REPLAY.json create mode 100644 research/sharp-finite-gaussian-outward-slack/review/REMOTE-SOURCE-CHECK.json create mode 100644 research/sharp-finite-gaussian-outward-slack/review/RESULT.json create mode 100644 research/sharp-finite-gaussian-outward-slack/review/ROOT-REVIEW.md create mode 100644 research/sharp-finite-gaussian-outward-slack/review/check_full_matching.py create mode 100644 research/sharp-finite-gaussian-outward-slack/verify.py diff --git a/research/sharp-finite-gaussian-outward-slack/CHECKSUMS.sha256 b/research/sharp-finite-gaussian-outward-slack/CHECKSUMS.sha256 new file mode 100644 index 0000000000..85754ed26d --- /dev/null +++ b/research/sharp-finite-gaussian-outward-slack/CHECKSUMS.sha256 @@ -0,0 +1,19 @@ +ae9947ad6c97d0a3808a52fc9f8c07e5d070c0925dfbbe00ed3cd163118e5558 NOTICE.md +dd3de25a78e22098a4b859ec7d683431a78543e8ad0c32d7d4d28f17f270bc6e OPEN-NEXT-QUESTIONS.md +9650647a4713b7c35e9a61834578ca0d83ec960a5d5eb666f37b906a91a7f1e6 PR-DRAFT.md +d00460ebf9579c49ae711079e3a21865571d82e7e42f8fc6bc11a08cf062f09b PROOF.md +d26f615aacff4b082c316e491aa1730aabc9cb6ceb377d33fb9a279b2d7f5f16 R5-OPTIMUM.json.gz +82365cb5f31d0c11f8531c9c1414219311dfaf7e8c931a66ae30e42a910cca97 README.md +87ee11560e99e440fa47d0fb5f6799e8e85a100b8467b284605e58ef306fd1ce RESULT.json +e010d96e3b44bb10a0dddbbff66fb00dcd316e620b8feebd0e8477a84e0b1d51 SOURCES.json +f1ea9f91bf0f6517b30e278e2ae32bb8b23d4a451901eaae5a0ed652d1d5689c VERIFY.json +a9e2c39ce39cfbc0327eed29bd249d1e7f02fe71c7847e9eeefac4e2b232de79 VERIFY.md +4c4647f16eb79881c324025c4e3a94d98b10750c12d345f730fed46c7569573c compact-hall/ORBIT-FLOW-RESULT.json +c0a9ee164d3a466a4b3996e1075ef7443123ac5e99b0e4e9e05585411352ad21 compact-hall/PROOF.md +224e4d93827ce23b89d8d5d4215875da9329d0b3b13469d4af1552b030ddb121 compact-hall/README.md +66e617085db593449e7204f94b438f4e9467095b6fdef4d8092a2cefdde888ef compact-hall/RESULT.json +5649af07ec67b10ca76b625250fe51e698fb2bb5ec25a82eaaaaaec5ca63dfdd compact-hall/SOURCES.json +0fc0f192cf541a3c94f87bb454187ca297e6ff28cbbd472126b6eba4bcc7275b compact-hall/check.py +98b2238a224aec3fbb35adb634b30ae00f7e7740293f06679c65b6c308029b9d compact-hall/orbit_cut.py +10b3c29f75e36d26bdf1f819554fb1181774121b9defca6c17b0e0a9212176e7 replay.py +611124563b42ec1c20d4755d190a850d1deac5ed743d6f98094ec97f7d893190 verify.py diff --git a/research/sharp-finite-gaussian-outward-slack/NOTICE.md b/research/sharp-finite-gaussian-outward-slack/NOTICE.md new file mode 100644 index 0000000000..5e55341d12 --- /dev/null +++ b/research/sharp-finite-gaussian-outward-slack/NOTICE.md @@ -0,0 +1,14 @@ +The R5 candidate certificate is retained byte-for-byte from the +@CubeJerry workstream input pinned in `SOURCES.json`. That candidate work was +prepared with substantial OpenAI assistance. `verify.py`, `replay.py`, the +compact Hall supplement, the independent finite proof, and this package +documentation were also prepared with substantial OpenAI Codex assistance. + +Predecessor credit: Nick Petalas (#6619 and its cited #2589 finite-sphere +predecessor) and Ali Romman (#6509). The #6509 proof and #6619 proof are +identified by exact commit, Git blob, and SHA-256 in `SOURCES.json`. No +upstream source code is copied into this package. Canonical base: +`e54523517d0f03e58352e647c403a5af3e525a57`. + +This note does not claim a new `kappa`, global sufficiency at the finite +threshold, or any change to the selected conditional multiplication result. diff --git a/research/sharp-finite-gaussian-outward-slack/OPEN-NEXT-QUESTIONS.md b/research/sharp-finite-gaussian-outward-slack/OPEN-NEXT-QUESTIONS.md new file mode 100644 index 0000000000..fb75635d73 --- /dev/null +++ b/research/sharp-finite-gaussian-outward-slack/OPEN-NEXT-QUESTIONS.md @@ -0,0 +1,26 @@ +# Open next questions + +## Global outward-slack infimum at error one + +**Question:** For global injective integer-output maps rounding the actual +#6509 ideal Gaussian pair with uniform Euclidean error at most one, what is +the infimum of the outward norm slack, and is it attained by a global map? + +**Current bound:** This package proves the necessary lower bound +\(\sqrt{21}-\sqrt{19}\) from the transferred radius-five Hall obstruction. +The inherited #6509 map and triangle inequality give the upper bound one. + +**First step:** Prove a global extension theorem for the finite matching, or +derive a stronger necessary bound under the same global hypotheses. Either +direction must retain injectivity and the uniform error bound on the entire +integer lattice. + +**Blocked by:** The radius-five matching is finite. Its existence does not +extend it to a global injective map, and the Hall witness proves necessity +only below its finite threshold. + +## Other scopes + +No result here treats other error caps, other operators, other grid scales, +physical implementation costs, or the selected \(\kappa\). These require +separate source-bound statements and are intentionally outside this package. diff --git a/research/sharp-finite-gaussian-outward-slack/PR-DESCRIPTION.md b/research/sharp-finite-gaussian-outward-slack/PR-DESCRIPTION.md new file mode 100644 index 0000000000..f120127f6d --- /dev/null +++ b/research/sharp-finite-gaussian-outward-slack/PR-DESCRIPTION.md @@ -0,0 +1,72 @@ +# Prove the exact Gaussian rounding threshold on the radius-five lattice ball with a compact Hall obstruction + +## Exact result + +For the complete radius-five ball in Z4, the minimum possible maximum +outward norm increment of an injective integer-output approximation to +H4/2 with pointwise Euclidean error at most 1 is exactly +`sqrt(21)-sqrt(19)`. A full 3,121-input injection attains this value. +The explicit signed-permutation identity `H4=L(2C+)R` transfers the result +to the actual ideal Gaussian pair from #6509 and to its conjugate C-. + +The lower bound has a short, independently checkable form. Let B19 be the +integer points of squared norm at most19. Remove the complete signed +coordinate orbits with sorted absolute coordinates(0,0,3,3) and(0,1,3,3), +obtaining N with 1,777 points. Add the 32 positive-product signed permutations +of(2,2,2,3), obtaining T with 1,809 points. Every error-one neighbor of T +whose outward increment is strictly below `sqrt(21)-sqrt(19)` lies in N. +Hall's inequality therefore fails by 32. + +## Why this advances the question + +#6619 asks about outward slack for rational orthogonal rounding; #2589 +provides its finite-sphere predecessor and #6509 supplies the Gaussian pair +and a global error-one construction. This package proves an exact finite +optimum and a necessary global lower bound without a period or conserved-sum +premise. The compact lower proof uses 38 signed-coordinate representatives, +rather than trusting a long list of witness inputs or search exclusions. + +The global infimum at error cap 1 is only bracketed here by +`[sqrt(21)-sqrt(19),1]`. The upper endpoint uses the inherited #6509 global +construction. A finite injection does not construct a global rounder at the +lower endpoint. The selected exact-layer multiplication route is not rejected. + +## Reproduction and independent verification + +Canonical base: `e54523517d0f03e58352e647c403a5af3e525a57`. + +```sh +python3 -I -W error -B research/sharp-finite-gaussian-outward-slack/verify.py +python3 -I -O -W error -B research/sharp-finite-gaussian-outward-slack/verify.py +python3 -I -W error -B research/sharp-finite-gaussian-outward-slack/compact-hall/check.py +python3 -I -W error -B research/sharp-finite-gaussian-outward-slack/compact-hall/orbit_cut.py +python3 -I -W error -B research/sharp-finite-gaussian-outward-slack/review/check_full_matching.py +``` + +Default runs are read-only and require only the Python standard library. +The primary checker validates the exact compressed certificate, complete +3,121-input injection, original strict Hall neighborhood and native transfer. +It detects corruption, duplicate output, omitted neighbors, erroneous strict +error and incorrect threshold ties. The standalone compact checker reads no +matching or Hall-list certificate. A separate orbit flow and an independent +full-vertex matching implementation agree on strict optimum 3,089 and the +deficit 32. Including beta equality restores a full matching. + +Exact source pins, output receipts, search domain and untouched regions, +proofs and independent review are included. The original proof and checker +remain available alongside the compact supplement. + +## Limits, kappa and credit + +This is a precision/analytic rounding obstruction, not a new complete +multiplication coefficient or an unconditional multiplication theorem. +**No new kappa; all five framework assumptions remain.** The selected +conditional kappa remains `0.00363005817`. Other radii/error caps, global +attainment, physical caller admission and complete numerical recovery are +outside this package's claim. + +Prepared for @CubeJerry with substantial OpenAI Astra/Sol/Luna assistance +in candidate construction, proofs, code and independent review. Credit Nick +Petalas (#6619), ywz65 (#2589), Ali Romman (#6509), and the source authors +identified in SOURCES.json and NOTICE.md. Independent AI implementations +are distinguished from human review or formal-kernel acceptance. diff --git a/research/sharp-finite-gaussian-outward-slack/PR-DRAFT.md b/research/sharp-finite-gaussian-outward-slack/PR-DRAFT.md new file mode 100644 index 0000000000..d4f7f82d5d --- /dev/null +++ b/research/sharp-finite-gaussian-outward-slack/PR-DRAFT.md @@ -0,0 +1,45 @@ +# Draft PR title + +Prove the sharp finite R5 Gaussian outward-slack threshold + +## Draft description + +This package establishes the exact finite optimum +\(\sqrt{21}-\sqrt{19}\) for injective integer-output maps on the complete +radius-five ball \(S_5\), with Euclidean error at most one for the Sylvester +Hadamard transform \(H_4/2\). The compact certificate contains a full +3,121-input injection and a 1,692-input set whose complete strict-threshold +neighborhood has only 1,691 outputs. The independent standard-library checker +recomputes both sides of the optimum using exact integer and radical +comparisons. + +The identity \(H_4=L(2C_+)R\), where \(L\) and \(R\) are signed +permutations, transfers the result to the actual #6509 ideal Gaussian pair. +This gives a necessary global lower bound at error cap one. #6509's inherited +global construction and the triangle inequality provide an upper bound of +one, so the unrestricted global infimum is currently only bracketed by +\([\sqrt{21}-\sqrt{19},1]\). No global construction at the lower endpoint is +claimed. + +The lower-bound witness also has a short certificate-independent description +in `compact-hall/PROOF.md`: delete the \((0,0,3,3)\) and \((0,1,3,3)\) +\(W(D_4)\) orbits from the squared-radius-19 ball and add the +positive-product \((2,2,2,3)\) orbit. This gives 1,809 inputs whose complete +strict-threshold neighborhood is contained in a 1,777-point set. A standalone +checker regenerates the 38 orbit representatives and all 9 or 16 possible +error-one outputs per representative without reading the matching or Hall +list. The quotient min-cut replay independently confirms equality and +deficiency 32. + +Canonical base: `e54523517d0f03e58352e647c403a5af3e525a57`. Exact hashes for +the candidate input and predecessor proofs are in `SOURCES.json`. Reproduce +the upper matching with `python3 -B verify.py`; check the standalone lower +bound with `python3 -B compact-hall/check.py`; replay the quotient flow with +`python3 -B compact-hall/orbit_cut.py`. The normal and optimized commands +all pass. Default runs are read-only. + +Credit @CubeJerry for the candidate workstream input; this package and the +candidate work were prepared with substantial OpenAI assistance. Credit Nick +Petalas (#6619, including its cited #2589 finite-sphere predecessor) and Ali +Romman (#6509) for the predecessor results. No new `kappa`, selected-frontier +change, or global sufficiency theorem is asserted. diff --git a/research/sharp-finite-gaussian-outward-slack/PROOF.md b/research/sharp-finite-gaussian-outward-slack/PROOF.md new file mode 100644 index 0000000000..51b9a76d3c --- /dev/null +++ b/research/sharp-finite-gaussian-outward-slack/PROOF.md @@ -0,0 +1,150 @@ +# Sharp finite radius-five Gaussian outward slack + +## Theorem + +Let + +\[ +S_5=\{x\in\mathbb Z^4:\|x\|_2^2\le25\},\qquad +U=H_4/2, +\] + +where + +\[ +H_4=\begin{pmatrix} +1&1&1&1\\ +1&-1&1&-1\\ +1&1&-1&-1\\ +1&-1&-1&1 +\end{pmatrix},\qquad H_4^T H_4=4I. +\] + +For an injection \(F:S_5\to\mathbb Z^4\), require the pointwise error +\(\|F(x)-Ux\|_2\le1\), and define its outward slack by + +\[ +\Delta(F)=\max_{x\in S_5}(\|F(x)\|_2-\|x\|_2). +\] + +The minimum of \(\Delta(F)\) over these finite injections is exactly + +\[ +\beta=\sqrt{21}-\sqrt{19}. +\] + +The same \(\beta\) is a necessary lower bound for the global outward slack of +any injective integer-output map on \(\mathbb Z^4\) with uniform error at most +one for \(U\). By an exact signed-permutation transfer, this applies to the +actual ideal Gaussian pair map \(C_+\) from #6509 and, by conjugation, to +\(C_-\). The global infimum at error cap one is only bounded here by +\([\beta,1]\); this note does not construct a global map attaining \(\beta\). + +## Finite proof + +The compressed certificate [R5-OPTIMUM.json.gz](R5-OPTIMUM.json.gz) is the +byte-exact expansion of the pinned R5 input in `SOURCES.json`. It contains a +pair \((x,F(x))\) for each point of \(S_5\), together with a Hall input set +\(T\) and its claimed strict-\(\beta\) output neighborhood. The checker +`verify.py` uses only the standard library and does not import the search, +constructor, or earlier author checker. + +First, it independently enumerates \(S_5\) and verifies the 3,121 listed +pairs. It checks that each input appears once, outputs are distinct, the +integer numerator of each squared error is at most four, and every outward +increment is at most \(\beta\). All square-root comparisons use integer +arithmetic: comparing \(\sqrt m-\sqrt n\) with \(\sqrt a-\sqrt b\) is +reduced to comparing the nonnegative sums \(\sqrt m+\sqrt b\) and +\(\sqrt a+\sqrt n\), then resolved by sign-aware integer squaring. Fifty-eight +matching edges attain \(\beta\), with squared input and output norms 19 and +21, so this injection has \(\Delta(F)=\beta\). + +For the lower bound, the certificate gives \(|T|=1,692\). For every \(x\in +T\), the verifier enumerates all integer outputs \(y\) satisfying +\(\|y-Ux\|_2\le1\). It uses the exhaustive coordinate interval + +\[ +\left\lceil\frac{(H_4x)_i-2}{2}\right\rceil +\le y_i\le +\left\lfloor\frac{(H_4x)_i+2}{2}\right\rfloor +\] + +and retains a candidate exactly when +\(\sum_i(2y_i-(H_4x)_i)^2\le4\). It then filters by the exact strict +condition \(\|y\|_2-\|x\|_2<\beta\). The complete union of these strict +neighbors has 1,691 outputs, exactly the certificate's declared set. Thus +Hall's inequality rules out an injection even at every threshold below +\(\beta\). Together with the matching at \(\beta\), this proves the exact +finite optimum. + +This lower-bound argument uses only a subset of the inputs and the complete +set of their allowed outputs. In particular, no search history or assumption +about a matching algorithm is part of the proof. The verifier also confirms +that if equality at \(\beta\) is incorrectly admitted into the Hall graph, +the neighborhood grows to 1,719 outputs; the strict inequality is essential. + +The same strict graph has a shorter, certificate-independent invariant Hall +witness. The set \(T_1\) has 1,809 inputs and its complete strict-\(\beta\) +neighborhood lies in the explicitly described 1,777-point set \(N_1\), so +it gives deficiency at least 32. Its two-exclusion orbit formula, exact +representative check, and full quotient min-cut are in +[compact-hall/PROOF.md](compact-hall/PROOF.md). This supplement does not +replace the matching witness needed for the upper bound. + +## Transfer to the actual pair map + +In real coordinates \((\Re x,\Im x,\Re y,\Im y)\), the numerator matrix for +the ideal pair \(2C_+\) is + +\[ +2C_+=\begin{pmatrix} +1&-1&1&1\\ +1&1&-1&1\\ +1&1&1&-1\\ +-1&1&1&1 +\end{pmatrix}. +\] + +Define the signed permutations + +\[ +R(a,b,c,d)=(a,-b,c,d),\qquad L(a,b,c,d)=(a,c,-d,b). +\] + +Direct integer multiplication gives + +\[ +H_4=L(2C_+)R. +\] + +Therefore \(H_4/2=L C_+R\). If \(F_C\) is a pair map for \(C_+\), then +\(F_H(x)=L F_C(Rx)\) is the corresponding map for \(H_4/2\). In the other +direction, \(F_C(x)=L^{-1}F_H(Rx)\), since \(R^{-1}=R\). These transformations +preserve the integer lattice, the complete input ball, injectivity, error, +and both input and output norms. Complex conjugation is another signed +permutation and transfers the result to \(C_-\). The checker verifies the +matrix identity and signed-permutation conditions exactly. + +Consequently any global injective \(C_+\) or \(C_-\) rounder with error at +most one has outward slack at least \(\beta\), by restriction to the +transferred copy of \(S_5\). The #6509 source supplies a global bijective +rounder with error at most one; the triangle inequality gives outward slack +at most one. Thus the global infimum lies in \([\beta,1]\), conditional on +that inherited #6509 construction. This package proves no global sufficiency +below one. + +## Scope and predecessor credit + +The R5 matching and Hall set were supplied as candidate data by the current +@CubeJerry workstream. This package independently checks the finite claim and +the native-pair transfer. Its exact source hashes, author context, and +canonical base are in `SOURCES.json`. + +Nick Petalas's #6619 studies radial error and norm contraction for rational +orthogonal maps; it cites ywz65's finite-sphere argument in #2589. Ali +Romman's #6509 supplies the ideal pair map, its inverse, and its global +error-one construction. Those are credited predecessor results. The finite +R5 Hall obstruction and its exact transfer are the claim established here. +The package makes no claim about other radii, other error caps, global +attainment at \(\beta\), a new \(\kappa\), or a change to the conditional +multiplication frontier. diff --git a/research/sharp-finite-gaussian-outward-slack/PUBLICATION-MANIFEST.json b/research/sharp-finite-gaussian-outward-slack/PUBLICATION-MANIFEST.json new file mode 100644 index 0000000000..eff8145f9f --- /dev/null +++ b/research/sharp-finite-gaussian-outward-slack/PUBLICATION-MANIFEST.json @@ -0,0 +1,170 @@ +{ + "canonical_base": "e54523517d0f03e58352e647c403a5af3e525a57", + "scope": "Exact finite S5 optimum sqrt(21)-sqrt(19), compact Hall deficit32, global necessary lower bound only; no new kappa", + "retained_author_manifest": "CHECKSUMS.sha256 preserved and verified19 files", + "independent_review": "review/ROOT-REVIEW.md", + "files": [ + { + "path": "CHECKSUMS.sha256", + "bytes": 1584, + "sha256": "27527db6406c1e113e96885999b0fe57425862ef9060be848ffcc3e20ae67f86", + "git_blob": "85754ed26de3a829a1a226307987d0422ea19677" + }, + { + "path": "NOTICE.md", + "bytes": 844, + "sha256": "ae9947ad6c97d0a3808a52fc9f8c07e5d070c0925dfbbe00ed3cd163118e5558", + "git_blob": "5e55341d1274e76200700eec853011623d9c76d0" + }, + { + "path": "OPEN-NEXT-QUESTIONS.md", + "bytes": 1184, + "sha256": "dd3de25a78e22098a4b859ec7d683431a78543e8ad0c32d7d4d28f17f270bc6e", + "git_blob": "fb75635d733ef126985432eb58174247fef0e516" + }, + { + "path": "PR-DESCRIPTION.md", + "bytes": 3932, + "sha256": "822b92a5a2948ae547bb92d5cecdd6ab2d8e28a185ba3c03f904305c06e2b541", + "git_blob": "f120127f6dcba91860e00a9f6d7e8fbbdd5e5f9d" + }, + { + "path": "PR-DRAFT.md", + "bytes": 2433, + "sha256": "9650647a4713b7c35e9a61834578ca0d83ec960a5d5eb666f37b906a91a7f1e6", + "git_blob": "d4f7f82d5d4c52d664aefad8f8c060ac5e67ba36" + }, + { + "path": "PROOF.md", + "bytes": 5812, + "sha256": "d00460ebf9579c49ae711079e3a21865571d82e7e42f8fc6bc11a08cf062f09b", + "git_blob": "51b9a76d3ced9c8f68b70bddf502f883b2d3284d" + }, + { + "path": "R5-OPTIMUM.json.gz", + "bytes": 28950, + "sha256": "d26f615aacff4b082c316e491aa1730aabc9cb6ceb377d33fb9a279b2d7f5f16", + "git_blob": "e25a058522e249291b5e099f6d28c76e0854d1a3" + }, + { + "path": "README.md", + "bytes": 2448, + "sha256": "82365cb5f31d0c11f8531c9c1414219311dfaf7e8c931a66ae30e42a910cca97", + "git_blob": "9525b074b4c802b2abb1c7e57b782e566e87f803" + }, + { + "path": "RESULT.json", + "bytes": 720, + "sha256": "87ee11560e99e440fa47d0fb5f6799e8e85a100b8467b284605e58ef306fd1ce", + "git_blob": "4c739a1558134bc53a3b7f25c36a792a67175e34" + }, + { + "path": "SEARCH-PROVENANCE.md", + "bytes": 2264, + "sha256": "3cfb46fb4dffae7ebbbea1b5decdb6b7114e1be0e728511c80468f4d297a24c4", + "git_blob": "1bd2e1b04b9b4ddc7708292c8a969b074c53075e" + }, + { + "path": "SOURCES.json", + "bytes": 2955, + "sha256": "e010d96e3b44bb10a0dddbbff66fb00dcd316e620b8feebd0e8477a84e0b1d51", + "git_blob": "12b14ee4d31596420435206c19eb1ec319309274" + }, + { + "path": "VERIFY.json", + "bytes": 462, + "sha256": "f1ea9f91bf0f6517b30e278e2ae32bb8b23d4a451901eaae5a0ed652d1d5689c", + "git_blob": "883e443f80b1fa34cf86af0d9bda593a5278b988" + }, + { + "path": "VERIFY.md", + "bytes": 1486, + "sha256": "a9e2c39ce39cfbc0327eed29bd249d1e7f02fe71c7847e9eeefac4e2b232de79", + "git_blob": "01f85c2ae7ef8adfa6510f138cc764819235ee77" + }, + { + "path": "compact-hall/ORBIT-FLOW-RESULT.json", + "bytes": 20261, + "sha256": "4c4647f16eb79881c324025c4e3a94d98b10750c12d345f730fed46c7569573c", + "git_blob": "a8ec5d2736b4070180707361b0e38389bef63f36" + }, + { + "path": "compact-hall/PROOF.md", + "bytes": 6065, + "sha256": "c0a9ee164d3a466a4b3996e1075ef7443123ac5e99b0e4e9e05585411352ad21", + "git_blob": "8eea447ec099623aaa990b0c033505b299f726c1" + }, + { + "path": "compact-hall/README.md", + "bytes": 1430, + "sha256": "224e4d93827ce23b89d8d5d4215875da9329d0b3b13469d4af1552b030ddb121", + "git_blob": "dd52bbb13684e781aaabc0957d9e1551f02ccd0a" + }, + { + "path": "compact-hall/RESULT.json", + "bytes": 9116, + "sha256": "66e617085db593449e7204f94b438f4e9467095b6fdef4d8092a2cefdde888ef", + "git_blob": "10c848be2ee75d9abb497d62cf53d6fe01e1cdbd" + }, + { + "path": "compact-hall/SOURCES.json", + "bytes": 1905, + "sha256": "5649af07ec67b10ca76b625250fe51e698fb2bb5ec25a82eaaaaaec5ca63dfdd", + "git_blob": "1ef5a3e6ff409ef7d8d565e41b98886e586180c8" + }, + { + "path": "compact-hall/check.py", + "bytes": 11799, + "sha256": "0fc0f192cf541a3c94f87bb454187ca297e6ff28cbbd472126b6eba4bcc7275b", + "git_blob": "67fe6c8c7a48b9fe519c89b48052d61f947a6eef" + }, + { + "path": "compact-hall/orbit_cut.py", + "bytes": 25449, + "sha256": "98b2238a224aec3fbb35adb634b30ae00f7e7740293f06679c65b6c308029b9d", + "git_blob": "0f023db2cc81f66166795a08cb691f7738d16105" + }, + { + "path": "replay.py", + "bytes": 1865, + "sha256": "10b3c29f75e36d26bdf1f819554fb1181774121b9defca6c17b0e0a9212176e7", + "git_blob": "0a11932bdf28f1dd4da847ca5fecd0a53ae0e1f4" + }, + { + "path": "review/PUBLICATION-REPLAY.json", + "bytes": 1343, + "sha256": "bac3b64005d0abe9124bfc753921f83f465b3915c22272e1168d005c07414094", + "git_blob": "0304374c59f683a6722414d4ea7b3fc113900d7f" + }, + { + "path": "review/REMOTE-SOURCE-CHECK.json", + "bytes": 1068, + "sha256": "f95b0ea46f4a724b78d7b2b30fab91628e2a18ab3bd875ec077f06522a5363b1", + "git_blob": "4cb854acd0985655d607d9444994415111e1a621" + }, + { + "path": "review/RESULT.json", + "bytes": 11183, + "sha256": "f649acf266eedbb89d41508997be6905d19e0194207154574aea56e711a3bbda", + "git_blob": "141749128f38692a35dba3a3555d7ed77fdc4756" + }, + { + "path": "review/ROOT-REVIEW.md", + "bytes": 4190, + "sha256": "6b50f9c8213ed49bb9e60362ea9aee909b29b9af9123ec6aefba8032b781ba58", + "git_blob": "633bbf66fafd29e2eec4e35b67e99c633a2be516" + }, + { + "path": "review/check_full_matching.py", + "bytes": 6957, + "sha256": "c43187b011400e8141b6ed86f8adc24587e3c320f7f56933809294f0bfb3c76f", + "git_blob": "3c19470499c4b1bd16078c0b452d21c2620a649e" + }, + { + "path": "verify.py", + "bytes": 13831, + "sha256": "611124563b42ec1c20d4755d190a850d1deac5ed743d6f98094ec97f7d893190", + "git_blob": "8346dd45e731110893fadd7110c254b6eb92d403" + } + ] +} diff --git a/research/sharp-finite-gaussian-outward-slack/R5-OPTIMUM.json.gz b/research/sharp-finite-gaussian-outward-slack/R5-OPTIMUM.json.gz new file mode 100644 index 0000000000000000000000000000000000000000..e25a058522e249291b5e099f6d28c76e0854d1a3 GIT binary patch literal 28950 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%0AOZhUPY5;E!95AFxxnsTjkwS(mHf|l0 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 a+du!)Ul#ixfA=51`~Lx!0-<=CsR;nMlZ{0H literal 0 HcmV?d00001 diff --git a/research/sharp-finite-gaussian-outward-slack/README.md b/research/sharp-finite-gaussian-outward-slack/README.md new file mode 100644 index 0000000000..9525b074b4 --- /dev/null +++ b/research/sharp-finite-gaussian-outward-slack/README.md @@ -0,0 +1,54 @@ +# Sharp finite Gaussian outward slack + +This package proves and checks the exact radius-five finite optimum +\(\beta=\sqrt{21}-\sqrt{19}\) for injective integer-output rounding of +\(H_4/2\) at Euclidean error at most one. A signed-permutation identity +transfers the finite optimum and global necessary lower bound to #6509's +actual ideal Gaussian pair map. + +## Files + +- `PROOF.md`: the finite matching, strict Hall obstruction, and exact native + pair transfer. +- `R5-OPTIMUM.json.gz`: compact, exact certificate containing the 3,121-pair + injection and Hall witness. Its expansion is pinned by SHA-256 in + `SOURCES.json`. +- `replay.py`: deterministic exact expansion of the compressed certificate; + the default command verifies and prints a receipt without writing files. +- `verify.py`: independent exact checker for the injection, Hall neighborhood, + signed-permutation transfer, and negative controls. It imports no search or + author checker. +- `RESULT.json`: receipt from the standard-library checker. +- `SOURCES.json`, `NOTICE.md`, `VERIFY.md`, `OPEN-NEXT-QUESTIONS.md`, and + `PR-DRAFT.md`: provenance, credits, replay instructions, scope, and draft + publication text. +- `compact-hall/`: a certificate-independent, two-exclusion \(W(D_4)\)-orbit + lower-bound checker plus the full orbit-capacity min-cut cross-check. +- `CHECKSUMS.sha256`: freeze manifest for package files, excluding itself and + transient Python caches. + +## Reproduction + +Requires Python 3.10+ and only the standard library. From this directory: + +```sh +python3 -B replay.py +python3 -B verify.py +python3 -O -B verify.py +python3 -B compact-hall/check.py +``` + +To write the expanded certificate to a chosen path, use +`python3 -B replay.py --write-certificate /tmp/R5-OPTIMUM.json`. To refresh +the committed checker receipt, redirect the exact verifier output to +`RESULT.json` explicitly. Normal verification is read-only. + +The result establishes the exact optimum on the complete finite ball \(S_5\) +and a necessary global lower bound. At the global error cap one, the available +interval is only \([\sqrt{21}-\sqrt{19},1]\). No global map attaining the +lower endpoint is provided. + +The compact Hall checker establishes the finite lower bound without reading +the matching certificate or its original Hall list. Its separate quotient +replay uses the pinned certificate and exact verifier to cross-check the +complete orbit min-cut and equality of the short-form neighborhood. diff --git a/research/sharp-finite-gaussian-outward-slack/RESULT.json b/research/sharp-finite-gaussian-outward-slack/RESULT.json new file mode 100644 index 0000000000..4c739a1558 --- /dev/null +++ b/research/sharp-finite-gaussian-outward-slack/RESULT.json @@ -0,0 +1 @@ +{"claim":"exact finite S5 optimum at beta=sqrt(21)-sqrt(19)","expanded_certificate_sha256":"b1fe3d866d2184227f46ec73ec2021c546bba056e98077e657e9205d9db5ad8b","global_scope":"necessary lower bound only; no global construction at beta","hall":{"error_boundary_candidates":20280,"inclusive_beta_neighbor_count":1719,"input_count":1692,"strict_beta_neighbor_count":1691},"input_count":3121,"matching":{"beta_edges":58,"error_boundary_edges":2480,"size":3121},"native_transfer":"H4=L(2C_+)R; inverse F_C=L^-1 F_H R","negative_controls":{"beta_tie_rule_detected":true,"certificate_corruption_rejected":true,"duplicate_output_rejected":true,"omitted_neighbor_detected":true,"strict_error_mutant_differs":true},"status":"PASS"} diff --git a/research/sharp-finite-gaussian-outward-slack/SEARCH-PROVENANCE.md b/research/sharp-finite-gaussian-outward-slack/SEARCH-PROVENANCE.md new file mode 100644 index 0000000000..1bd2e1b04b --- /dev/null +++ b/research/sharp-finite-gaussian-outward-slack/SEARCH-PROVENANCE.md @@ -0,0 +1,36 @@ +# Bounded candidate search and proof provenance + +Canonical base: `e54523517d0f03e58352e647c403a5af3e525a57`. +Operator: the exact Sylvester H4/2 fixture from #6619, transferred by explicit +signed permutations to #6509's ideal Gaussian pair. Uniform Euclidean error +cap:1. No random seed is used; candidate generation and order are deterministic. + +The originating bounded search tested complete integer balls of radii 3, 4, 5 +at the initial threshold sqrt(10)-3. Radii3 and 4 admitted full matchings; +radius 5 did not. It then generated all 39,681 error-one edges at radius 5, +ordered 130 distinct positive norm gaps with 128-bit rational enclosures, +and used eight threshold probes to locate sqrt(21)-sqrt(19). The resulting +full matching and strict-threshold Hall witness are the retained compressed +certificate. Its exact original byte hash and compressed byte hash are in +SOURCES.json. Replaying the optimizer is not a premise of the proof: +the certificate checker verifies the complete universe and both obligations. + +The original search and separate direct checker are preserved on the labelled +session recovery branch; this package retains the exact candidate certificate, +two independent lower-bound methods, a full-vertex cross-check, and the +portable direct verifier. Radius 6 and larger radii, other error caps, other +operators, and global sufficiency were not covered by this originating search. +Subsequent research is separate and cannot retrospectively enlarge this claim. + +The first symmetry preflight found that the supplied deficit-one witness has +trivial stabilizer and that balls, shells and parity-class unions alone did +not provide the desired compression. A new full-graph alternating cut and +independent orbit-capacity min cut instead found an invariant deficit 32. +The short two-exclusion witness is independently generated without the +original witness list. This is proof reduction for the same finite theorem, +not a larger-radius experiment or a global extrapolation. + +Prepared for @CubeJerry with substantial OpenAI Astra/Sol/Luna assistance. +Credit #6619, #2589 and #6509 for the preceding question, finite-sphere +method and Gaussian pair construction. Exact scientific dependencies remain +pinned in SOURCES.json and the proof documents. diff --git a/research/sharp-finite-gaussian-outward-slack/SOURCES.json b/research/sharp-finite-gaussian-outward-slack/SOURCES.json new file mode 100644 index 0000000000..12b14ee4d3 --- /dev/null +++ b/research/sharp-finite-gaussian-outward-slack/SOURCES.json @@ -0,0 +1,58 @@ +{ + "package": "sharp-finite-gaussian-outward-slack", + "canonical_base": { + "repository": "CrocSwap/integer-mult-bounds", + "commit": "e54523517d0f03e58352e647c403a5af3e525a57" + }, + "candidate_certificate": { + "author_context": "@CubeJerry workstream; candidate work prepared with substantial OpenAI assistance", + "origin_workspace_path": "root-work/outward-tradeoff-preflight/R5-OPTIMUM.json", + "origin_bytes": 633242, + "origin_sha256": "b1fe3d866d2184227f46ec73ec2021c546bba056e98077e657e9205d9db5ad8b", + "packaged_path": "R5-OPTIMUM.json.gz", + "packaged_bytes": 28950, + "packaged_sha256": "d26f615aacff4b082c316e491aa1730aabc9cb6ceb377d33fb9a279b2d7f5f16", + "replay": "gzip expansion is checked against origin_sha256; the verifier independently checks both pins" + }, + "reviewed_author_input": { + "author_context": "@CubeJerry workstream; substantial OpenAI assistance", + "origin_workspace_path": "root-work/outward-tradeoff-preflight/PROOF.md", + "bytes": 5597, + "sha256": "ea9b45d53ec52579dc58d3a650a96cde8a751b2e99fdabece07e49afbf0621c1", + "role": "scope, candidate provenance, and exact signed-permutation transfer reviewed; the packaged proof and checker restate and independently validate the finite claim" + }, + "upstream_sources": [ + { + "repository": "petalas/integer-mult-bounds", + "pr": 6619, + "author": "Nick Petalas", + "commit": "eaa967e7e8aa12cc53ec246a5fc00c5f8873a50b", + "path": "research/rational-norm-rounding/PROOF.md", + "git_blob": "ffb873b2749b1590df9267e802aea5af2c2a6eb5", + "sha256": "231b1b322b6be2a798d1807f5c0346ac4002323384b45cd4eff2a0ef7210bc00", + "role": "predecessor context on rational orthogonal rounding and radial error; cites #2589 finite-sphere argument" + }, + { + "repository": "aliromman/integer-mult-bounds", + "pr": 6509, + "author": "Ali Romman", + "commit": "a4173e810c4d34a1d13b9745af123ad0ec6cfed5", + "path": "research/conservative-gaussian-rounding/PROOF.md", + "git_blob": "b7047476aaa5e2bb149c92a8a40a9b2ab444ef73", + "sha256": "122eff335674d8de1bcba47d28feb0c420be62b2b6d4e84f91c4292383753380", + "role": "ideal pair definition, global bijective error-one construction, and source theorem for the upper endpoint one" + } + ], + "predecessor_credit": [ + { + "pr": 2589, + "author": "ywz65", + "credit_context": "finite-sphere predecessor cited by #6619; the finite Hall argument used here is stated directly and does not require importing its proof" + } + ], + "independent_work": { + "files": ["PROOF.md", "replay.py", "verify.py", "README.md", "compact-hall/"], + "method": "stdlib-only certificate authentication, full S5 injection check, certificate-independent W(D4) orbit Hall lower bound, complete strict-beta quotient min-cut and neighborhood checks, and integer signed-permutation matrix checks", + "search_or_optimizer_imported": false + } +} diff --git a/research/sharp-finite-gaussian-outward-slack/VERIFY.json b/research/sharp-finite-gaussian-outward-slack/VERIFY.json new file mode 100644 index 0000000000..883e443f80 --- /dev/null +++ b/research/sharp-finite-gaussian-outward-slack/VERIFY.json @@ -0,0 +1,13 @@ +{ + "package": "sharp-finite-gaussian-outward-slack", + "runtime": "Python 3.10+ standard library only", + "commands": [ + "python3 -B replay.py", + "python3 -O -B replay.py", + "python3 -B verify.py", + "python3 -O -B verify.py" + ], + "default_commands_write_files": false, + "checker_method": "independent exact finite enumeration; no search or optimizer imported", + "scope": "complete S5 optimum and transferred global necessary lower bound only" +} diff --git a/research/sharp-finite-gaussian-outward-slack/VERIFY.md b/research/sharp-finite-gaussian-outward-slack/VERIFY.md new file mode 100644 index 0000000000..01f85c2ae7 --- /dev/null +++ b/research/sharp-finite-gaussian-outward-slack/VERIFY.md @@ -0,0 +1,34 @@ +# Verification record + +Environment: Python standard library only; no third-party packages. + +Commands run from this directory: + +```sh +python3 -B replay.py +python3 -O -B replay.py +python3 -B verify.py +python3 -O -B verify.py +python3 -B compact-hall/check.py +python3 -O -B compact-hall/check.py +python3 -B compact-hall/orbit_cut.py +python3 -O -B compact-hall/orbit_cut.py +``` + +All commands passed. Normal and optimized runs produce identical receipts. +The default replay and checker commands write no files. Both checkers use +explicit `require` checks, so optimized mode does not disable validation. + +The checker expands the pinned certificate, enumerates all 3,121 points of +\(S_5\), validates every injection edge using integer arithmetic, enumerates +all error-one output candidates for each of the 1,692 Hall inputs, recomputes +the exact strict-\(\beta\) neighborhood, and checks the signed-permutation +identity. It also exercises certificate-corruption, duplicate-output, +omitted-neighbor, strict-error, and threshold-tie negative controls. + +The standalone `compact-hall/check.py` does not read the matching or Hall +certificate. It regenerates the 38 input-orbit representatives from the +closed-form predicate and checks all 9 or 16 error-one candidates at each +representative against \(N_1\). `compact-hall/orbit_cut.py` independently +rebuilds the full quotient graph from the authenticated matching certificate +and exact checker and verifies the flow/min-cut and exact neighborhood. diff --git a/research/sharp-finite-gaussian-outward-slack/compact-hall/ORBIT-FLOW-RESULT.json b/research/sharp-finite-gaussian-outward-slack/compact-hall/ORBIT-FLOW-RESULT.json new file mode 100644 index 0000000000..a8ec5d2736 --- /dev/null +++ b/research/sharp-finite-gaussian-outward-slack/compact-hall/ORBIT-FLOW-RESULT.json @@ -0,0 +1 @@ +{"graph":{"S5_input_count":3121,"all_error_one_candidate_output_count":5697,"orbit_adjacency_completeness_checked":true,"quotient_adjacency_count":236,"strict_beta_edge_count":23137},"group":{"W_D4_definition":"signed permutation matrices whose four nonzero entries have product +1","input_orbit_count":55,"output_candidate_orbit_count":87,"paired_graph_automorphism_order":192,"projection_is_W_D4":true,"signed_permutation_count":384},"input_orbit_table":[{"index":0,"norm_squared":25,"orbit_key":[[0,0,0,5],null],"representative":[-5,0,0,0],"selected":false,"size":8},{"index":1,"norm_squared":25,"orbit_key":[[0,0,3,4],null],"representative":[-4,-3,0,0],"selected":false,"size":48},{"index":2,"norm_squared":25,"orbit_key":[[1,2,2,4],1],"representative":[-4,-2,-2,-1],"selected":false,"size":96},{"index":3,"norm_squared":24,"orbit_key":[[0,2,2,4],null],"representative":[-4,-2,-2,0],"selected":false,"size":96},{"index":4,"norm_squared":25,"orbit_key":[[1,2,2,4],-1],"representative":[-4,-2,-2,1],"selected":false,"size":96},{"index":5,"norm_squared":22,"orbit_key":[[1,1,2,4],1],"representative":[-4,-2,-1,-1],"selected":false,"size":96},{"index":6,"norm_squared":21,"orbit_key":[[0,1,2,4],null],"representative":[-4,-2,-1,0],"selected":false,"size":192},{"index":7,"norm_squared":22,"orbit_key":[[1,1,2,4],-1],"representative":[-4,-2,-1,1],"selected":false,"size":96},{"index":8,"norm_squared":20,"orbit_key":[[0,0,2,4],null],"representative":[-4,-2,0,0],"selected":false,"size":48},{"index":9,"norm_squared":19,"orbit_key":[[1,1,1,4],1],"representative":[-4,-1,-1,-1],"selected":true,"size":32},{"index":10,"norm_squared":18,"orbit_key":[[0,1,1,4],null],"representative":[-4,-1,-1,0],"selected":true,"size":96},{"index":11,"norm_squared":19,"orbit_key":[[1,1,1,4],-1],"representative":[-4,-1,-1,1],"selected":true,"size":32},{"index":12,"norm_squared":17,"orbit_key":[[0,0,1,4],null],"representative":[-4,-1,0,0],"selected":true,"size":48},{"index":13,"norm_squared":16,"orbit_key":[[0,0,0,4],null],"representative":[-4,0,0,0],"selected":true,"size":8},{"index":14,"norm_squared":23,"orbit_key":[[1,2,3,3],1],"representative":[-3,-3,-2,-1],"selected":false,"size":96},{"index":15,"norm_squared":22,"orbit_key":[[0,2,3,3],null],"representative":[-3,-3,-2,0],"selected":false,"size":96},{"index":16,"norm_squared":23,"orbit_key":[[1,2,3,3],-1],"representative":[-3,-3,-2,1],"selected":false,"size":96},{"index":17,"norm_squared":20,"orbit_key":[[1,1,3,3],1],"representative":[-3,-3,-1,-1],"selected":false,"size":48},{"index":18,"norm_squared":19,"orbit_key":[[0,1,3,3],null],"representative":[-3,-3,-1,0],"selected":false,"size":96},{"index":19,"norm_squared":20,"orbit_key":[[1,1,3,3],-1],"representative":[-3,-3,-1,1],"selected":false,"size":48},{"index":20,"norm_squared":18,"orbit_key":[[0,0,3,3],null],"representative":[-3,-3,0,0],"selected":false,"size":24},{"index":21,"norm_squared":21,"orbit_key":[[2,2,2,3],1],"representative":[-3,-2,-2,-2],"selected":true,"size":32},{"index":22,"norm_squared":18,"orbit_key":[[1,2,2,3],1],"representative":[-3,-2,-2,-1],"selected":true,"size":96},{"index":23,"norm_squared":17,"orbit_key":[[0,2,2,3],null],"representative":[-3,-2,-2,0],"selected":true,"size":96},{"index":24,"norm_squared":18,"orbit_key":[[1,2,2,3],-1],"representative":[-3,-2,-2,1],"selected":true,"size":96},{"index":25,"norm_squared":21,"orbit_key":[[2,2,2,3],-1],"representative":[-3,-2,-2,2],"selected":false,"size":32},{"index":26,"norm_squared":15,"orbit_key":[[1,1,2,3],1],"representative":[-3,-2,-1,-1],"selected":true,"size":96},{"index":27,"norm_squared":14,"orbit_key":[[0,1,2,3],null],"representative":[-3,-2,-1,0],"selected":true,"size":192},{"index":28,"norm_squared":15,"orbit_key":[[1,1,2,3],-1],"representative":[-3,-2,-1,1],"selected":true,"size":96},{"index":29,"norm_squared":13,"orbit_key":[[0,0,2,3],null],"representative":[-3,-2,0,0],"selected":true,"size":48},{"index":30,"norm_squared":12,"orbit_key":[[1,1,1,3],1],"representative":[-3,-1,-1,-1],"selected":true,"size":32},{"index":31,"norm_squared":11,"orbit_key":[[0,1,1,3],null],"representative":[-3,-1,-1,0],"selected":true,"size":96},{"index":32,"norm_squared":12,"orbit_key":[[1,1,1,3],-1],"representative":[-3,-1,-1,1],"selected":true,"size":32},{"index":33,"norm_squared":10,"orbit_key":[[0,0,1,3],null],"representative":[-3,-1,0,0],"selected":true,"size":48},{"index":34,"norm_squared":9,"orbit_key":[[0,0,0,3],null],"representative":[-3,0,0,0],"selected":true,"size":8},{"index":35,"norm_squared":16,"orbit_key":[[2,2,2,2],1],"representative":[-2,-2,-2,-2],"selected":true,"size":8},{"index":36,"norm_squared":13,"orbit_key":[[1,2,2,2],1],"representative":[-2,-2,-2,-1],"selected":true,"size":32},{"index":37,"norm_squared":12,"orbit_key":[[0,2,2,2],null],"representative":[-2,-2,-2,0],"selected":true,"size":32},{"index":38,"norm_squared":13,"orbit_key":[[1,2,2,2],-1],"representative":[-2,-2,-2,1],"selected":true,"size":32},{"index":39,"norm_squared":16,"orbit_key":[[2,2,2,2],-1],"representative":[-2,-2,-2,2],"selected":true,"size":8},{"index":40,"norm_squared":10,"orbit_key":[[1,1,2,2],1],"representative":[-2,-2,-1,-1],"selected":true,"size":48},{"index":41,"norm_squared":9,"orbit_key":[[0,1,2,2],null],"representative":[-2,-2,-1,0],"selected":true,"size":96},{"index":42,"norm_squared":10,"orbit_key":[[1,1,2,2],-1],"representative":[-2,-2,-1,1],"selected":true,"size":48},{"index":43,"norm_squared":8,"orbit_key":[[0,0,2,2],null],"representative":[-2,-2,0,0],"selected":true,"size":24},{"index":44,"norm_squared":7,"orbit_key":[[1,1,1,2],1],"representative":[-2,-1,-1,-1],"selected":true,"size":32},{"index":45,"norm_squared":6,"orbit_key":[[0,1,1,2],null],"representative":[-2,-1,-1,0],"selected":true,"size":96},{"index":46,"norm_squared":7,"orbit_key":[[1,1,1,2],-1],"representative":[-2,-1,-1,1],"selected":true,"size":32},{"index":47,"norm_squared":5,"orbit_key":[[0,0,1,2],null],"representative":[-2,-1,0,0],"selected":true,"size":48},{"index":48,"norm_squared":4,"orbit_key":[[0,0,0,2],null],"representative":[-2,0,0,0],"selected":true,"size":8},{"index":49,"norm_squared":4,"orbit_key":[[1,1,1,1],1],"representative":[-1,-1,-1,-1],"selected":true,"size":8},{"index":50,"norm_squared":3,"orbit_key":[[0,1,1,1],null],"representative":[-1,-1,-1,0],"selected":true,"size":32},{"index":51,"norm_squared":4,"orbit_key":[[1,1,1,1],-1],"representative":[-1,-1,-1,1],"selected":true,"size":8},{"index":52,"norm_squared":2,"orbit_key":[[0,0,1,1],null],"representative":[-1,-1,0,0],"selected":true,"size":24},{"index":53,"norm_squared":1,"orbit_key":[[0,0,0,1],null],"representative":[-1,0,0,0],"selected":true,"size":8},{"index":54,"norm_squared":0,"orbit_key":[[0,0,0,0],null],"representative":[0,0,0,0],"selected":true,"size":1}],"maximal_invariant_hall_set":{"complete_strict_beta_neighbor_count":1777,"deficiency":32,"input_count":1809,"maximal_min_cut_source_side":true,"quotient_min_cut":3089,"selected_input_orbit_indices":[9,10,11,12,13,21,22,23,24,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54],"selected_input_orbit_keys":[[[1,1,1,4],1],[[0,1,1,4],null],[[1,1,1,4],-1],[[0,0,1,4],null],[[0,0,0,4],null],[[2,2,2,3],1],[[1,2,2,3],1],[[0,2,2,3],null],[[1,2,2,3],-1],[[1,1,2,3],1],[[0,1,2,3],null],[[1,1,2,3],-1],[[0,0,2,3],null],[[1,1,1,3],1],[[0,1,1,3],null],[[1,1,1,3],-1],[[0,0,1,3],null],[[0,0,0,3],null],[[2,2,2,2],1],[[1,2,2,2],1],[[0,2,2,2],null],[[1,2,2,2],-1],[[2,2,2,2],-1],[[1,1,2,2],1],[[0,1,2,2],null],[[1,1,2,2],-1],[[0,0,2,2],null],[[1,1,1,2],1],[[0,1,1,2],null],[[1,1,1,2],-1],[[0,0,1,2],null],[[0,0,0,2],null],[[1,1,1,1],1],[[0,1,1,1],null],[[1,1,1,1],-1],[[0,0,1,1],null],[[0,0,0,1],null],[[0,0,0,0],null]],"selected_output_orbit_indices":[33,34,35,36,37,54,55,56,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86],"selected_output_orbit_keys":[[[1,1,1,4],1],[[0,1,1,4],null],[[1,1,1,4],-1],[[0,0,1,4],null],[[0,0,0,4],null],[[1,2,2,3],1],[[0,2,2,3],null],[[1,2,2,3],-1],[[1,1,2,3],1],[[0,1,2,3],null],[[1,1,2,3],-1],[[0,0,2,3],null],[[1,1,1,3],1],[[0,1,1,3],null],[[1,1,1,3],-1],[[0,0,1,3],null],[[0,0,0,3],null],[[2,2,2,2],1],[[1,2,2,2],1],[[0,2,2,2],null],[[1,2,2,2],-1],[[2,2,2,2],-1],[[1,1,2,2],1],[[0,1,2,2],null],[[1,1,2,2],-1],[[0,0,2,2],null],[[1,1,1,2],1],[[0,1,1,2],null],[[1,1,1,2],-1],[[0,0,1,2],null],[[0,0,0,2],null],[[1,1,1,1],1],[[0,1,1,1],null],[[1,1,1,1],-1],[[0,0,1,1],null],[[0,0,0,1],null],[[0,0,0,0],null]]},"membership_rule":{"W_D4_orbit_key":"(sorted absolute coordinates, product of coordinate signs if no coordinate is zero else null)","closed_form_inputs":"T1=(B19\\O0033\\O0133) union O2223plus","closed_form_outputs":"N1=B19\\O0033\\O0133","domain":"S5 points satisfying the closed-form T1 predicate","neighbor_rule":"error-one candidate output orbit_key appears among selected_output_orbit_keys; quotient adjacency is exact"},"minimal_min_cut_witness":{"complete_strict_beta_neighbor_count":1769,"deficiency":32,"input_count":1801,"same_min_cut_value":3089},"output_orbit_table":[{"index":0,"norm_squared":34,"orbit_key":[[1,2,2,5],1],"representative":[-5,-2,-2,-1],"selected":false,"size":96},{"index":1,"norm_squared":33,"orbit_key":[[0,2,2,5],null],"representative":[-5,-2,-2,0],"selected":false,"size":96},{"index":2,"norm_squared":31,"orbit_key":[[1,1,2,5],1],"representative":[-5,-2,-1,-1],"selected":false,"size":96},{"index":3,"norm_squared":30,"orbit_key":[[0,1,2,5],null],"representative":[-5,-2,-1,0],"selected":false,"size":192},{"index":4,"norm_squared":31,"orbit_key":[[1,1,2,5],-1],"representative":[-5,-2,-1,1],"selected":false,"size":96},{"index":5,"norm_squared":29,"orbit_key":[[0,0,2,5],null],"representative":[-5,-2,0,0],"selected":false,"size":48},{"index":6,"norm_squared":28,"orbit_key":[[1,1,1,5],1],"representative":[-5,-1,-1,-1],"selected":false,"size":32},{"index":7,"norm_squared":27,"orbit_key":[[0,1,1,5],null],"representative":[-5,-1,-1,0],"selected":false,"size":96},{"index":8,"norm_squared":28,"orbit_key":[[1,1,1,5],-1],"representative":[-5,-1,-1,1],"selected":false,"size":32},{"index":9,"norm_squared":26,"orbit_key":[[0,0,1,5],null],"representative":[-5,-1,0,0],"selected":false,"size":48},{"index":10,"norm_squared":25,"orbit_key":[[0,0,0,5],null],"representative":[-5,0,0,0],"selected":false,"size":8},{"index":11,"norm_squared":34,"orbit_key":[[1,1,4,4],1],"representative":[-4,-4,-1,-1],"selected":false,"size":48},{"index":12,"norm_squared":33,"orbit_key":[[0,1,4,4],null],"representative":[-4,-4,-1,0],"selected":false,"size":96},{"index":13,"norm_squared":32,"orbit_key":[[0,0,4,4],null],"representative":[-4,-4,0,0],"selected":false,"size":24},{"index":14,"norm_squared":34,"orbit_key":[[0,3,3,4],null],"representative":[-4,-3,-3,0],"selected":false,"size":96},{"index":15,"norm_squared":35,"orbit_key":[[1,3,3,4],-1],"representative":[-4,-3,-3,1],"selected":false,"size":96},{"index":16,"norm_squared":30,"orbit_key":[[1,2,3,4],1],"representative":[-4,-3,-2,-1],"selected":false,"size":192},{"index":17,"norm_squared":29,"orbit_key":[[0,2,3,4],null],"representative":[-4,-3,-2,0],"selected":false,"size":192},{"index":18,"norm_squared":30,"orbit_key":[[1,2,3,4],-1],"representative":[-4,-3,-2,1],"selected":false,"size":192},{"index":19,"norm_squared":33,"orbit_key":[[2,2,3,4],-1],"representative":[-4,-3,-2,2],"selected":false,"size":96},{"index":20,"norm_squared":27,"orbit_key":[[1,1,3,4],1],"representative":[-4,-3,-1,-1],"selected":false,"size":96},{"index":21,"norm_squared":26,"orbit_key":[[0,1,3,4],null],"representative":[-4,-3,-1,0],"selected":false,"size":192},{"index":22,"norm_squared":27,"orbit_key":[[1,1,3,4],-1],"representative":[-4,-3,-1,1],"selected":false,"size":96},{"index":23,"norm_squared":25,"orbit_key":[[0,0,3,4],null],"representative":[-4,-3,0,0],"selected":false,"size":48},{"index":24,"norm_squared":28,"orbit_key":[[2,2,2,4],1],"representative":[-4,-2,-2,-2],"selected":false,"size":32},{"index":25,"norm_squared":25,"orbit_key":[[1,2,2,4],1],"representative":[-4,-2,-2,-1],"selected":false,"size":96},{"index":26,"norm_squared":24,"orbit_key":[[0,2,2,4],null],"representative":[-4,-2,-2,0],"selected":false,"size":96},{"index":27,"norm_squared":25,"orbit_key":[[1,2,2,4],-1],"representative":[-4,-2,-2,1],"selected":false,"size":96},{"index":28,"norm_squared":28,"orbit_key":[[2,2,2,4],-1],"representative":[-4,-2,-2,2],"selected":false,"size":32},{"index":29,"norm_squared":22,"orbit_key":[[1,1,2,4],1],"representative":[-4,-2,-1,-1],"selected":false,"size":96},{"index":30,"norm_squared":21,"orbit_key":[[0,1,2,4],null],"representative":[-4,-2,-1,0],"selected":false,"size":192},{"index":31,"norm_squared":22,"orbit_key":[[1,1,2,4],-1],"representative":[-4,-2,-1,1],"selected":false,"size":96},{"index":32,"norm_squared":20,"orbit_key":[[0,0,2,4],null],"representative":[-4,-2,0,0],"selected":false,"size":48},{"index":33,"norm_squared":19,"orbit_key":[[1,1,1,4],1],"representative":[-4,-1,-1,-1],"selected":true,"size":32},{"index":34,"norm_squared":18,"orbit_key":[[0,1,1,4],null],"representative":[-4,-1,-1,0],"selected":true,"size":96},{"index":35,"norm_squared":19,"orbit_key":[[1,1,1,4],-1],"representative":[-4,-1,-1,1],"selected":true,"size":32},{"index":36,"norm_squared":17,"orbit_key":[[0,0,1,4],null],"representative":[-4,-1,0,0],"selected":true,"size":48},{"index":37,"norm_squared":16,"orbit_key":[[0,0,0,4],null],"representative":[-4,0,0,0],"selected":true,"size":8},{"index":38,"norm_squared":36,"orbit_key":[[3,3,3,3],1],"representative":[-3,-3,-3,-3],"selected":false,"size":8},{"index":39,"norm_squared":31,"orbit_key":[[2,3,3,3],1],"representative":[-3,-3,-3,-2],"selected":false,"size":32},{"index":40,"norm_squared":28,"orbit_key":[[1,3,3,3],1],"representative":[-3,-3,-3,-1],"selected":false,"size":32},{"index":41,"norm_squared":27,"orbit_key":[[0,3,3,3],null],"representative":[-3,-3,-3,0],"selected":false,"size":32},{"index":42,"norm_squared":28,"orbit_key":[[1,3,3,3],-1],"representative":[-3,-3,-3,1],"selected":false,"size":32},{"index":43,"norm_squared":31,"orbit_key":[[2,3,3,3],-1],"representative":[-3,-3,-3,2],"selected":false,"size":32},{"index":44,"norm_squared":26,"orbit_key":[[2,2,3,3],1],"representative":[-3,-3,-2,-2],"selected":false,"size":48},{"index":45,"norm_squared":23,"orbit_key":[[1,2,3,3],1],"representative":[-3,-3,-2,-1],"selected":false,"size":96},{"index":46,"norm_squared":22,"orbit_key":[[0,2,3,3],null],"representative":[-3,-3,-2,0],"selected":false,"size":96},{"index":47,"norm_squared":23,"orbit_key":[[1,2,3,3],-1],"representative":[-3,-3,-2,1],"selected":false,"size":96},{"index":48,"norm_squared":26,"orbit_key":[[2,2,3,3],-1],"representative":[-3,-3,-2,2],"selected":false,"size":48},{"index":49,"norm_squared":20,"orbit_key":[[1,1,3,3],1],"representative":[-3,-3,-1,-1],"selected":false,"size":48},{"index":50,"norm_squared":19,"orbit_key":[[0,1,3,3],null],"representative":[-3,-3,-1,0],"selected":false,"size":96},{"index":51,"norm_squared":20,"orbit_key":[[1,1,3,3],-1],"representative":[-3,-3,-1,1],"selected":false,"size":48},{"index":52,"norm_squared":18,"orbit_key":[[0,0,3,3],null],"representative":[-3,-3,0,0],"selected":false,"size":24},{"index":53,"norm_squared":21,"orbit_key":[[2,2,2,3],1],"representative":[-3,-2,-2,-2],"selected":false,"size":32},{"index":54,"norm_squared":18,"orbit_key":[[1,2,2,3],1],"representative":[-3,-2,-2,-1],"selected":true,"size":96},{"index":55,"norm_squared":17,"orbit_key":[[0,2,2,3],null],"representative":[-3,-2,-2,0],"selected":true,"size":96},{"index":56,"norm_squared":18,"orbit_key":[[1,2,2,3],-1],"representative":[-3,-2,-2,1],"selected":true,"size":96},{"index":57,"norm_squared":21,"orbit_key":[[2,2,2,3],-1],"representative":[-3,-2,-2,2],"selected":false,"size":32},{"index":58,"norm_squared":15,"orbit_key":[[1,1,2,3],1],"representative":[-3,-2,-1,-1],"selected":true,"size":96},{"index":59,"norm_squared":14,"orbit_key":[[0,1,2,3],null],"representative":[-3,-2,-1,0],"selected":true,"size":192},{"index":60,"norm_squared":15,"orbit_key":[[1,1,2,3],-1],"representative":[-3,-2,-1,1],"selected":true,"size":96},{"index":61,"norm_squared":13,"orbit_key":[[0,0,2,3],null],"representative":[-3,-2,0,0],"selected":true,"size":48},{"index":62,"norm_squared":12,"orbit_key":[[1,1,1,3],1],"representative":[-3,-1,-1,-1],"selected":true,"size":32},{"index":63,"norm_squared":11,"orbit_key":[[0,1,1,3],null],"representative":[-3,-1,-1,0],"selected":true,"size":96},{"index":64,"norm_squared":12,"orbit_key":[[1,1,1,3],-1],"representative":[-3,-1,-1,1],"selected":true,"size":32},{"index":65,"norm_squared":10,"orbit_key":[[0,0,1,3],null],"representative":[-3,-1,0,0],"selected":true,"size":48},{"index":66,"norm_squared":9,"orbit_key":[[0,0,0,3],null],"representative":[-3,0,0,0],"selected":true,"size":8},{"index":67,"norm_squared":16,"orbit_key":[[2,2,2,2],1],"representative":[-2,-2,-2,-2],"selected":true,"size":8},{"index":68,"norm_squared":13,"orbit_key":[[1,2,2,2],1],"representative":[-2,-2,-2,-1],"selected":true,"size":32},{"index":69,"norm_squared":12,"orbit_key":[[0,2,2,2],null],"representative":[-2,-2,-2,0],"selected":true,"size":32},{"index":70,"norm_squared":13,"orbit_key":[[1,2,2,2],-1],"representative":[-2,-2,-2,1],"selected":true,"size":32},{"index":71,"norm_squared":16,"orbit_key":[[2,2,2,2],-1],"representative":[-2,-2,-2,2],"selected":true,"size":8},{"index":72,"norm_squared":10,"orbit_key":[[1,1,2,2],1],"representative":[-2,-2,-1,-1],"selected":true,"size":48},{"index":73,"norm_squared":9,"orbit_key":[[0,1,2,2],null],"representative":[-2,-2,-1,0],"selected":true,"size":96},{"index":74,"norm_squared":10,"orbit_key":[[1,1,2,2],-1],"representative":[-2,-2,-1,1],"selected":true,"size":48},{"index":75,"norm_squared":8,"orbit_key":[[0,0,2,2],null],"representative":[-2,-2,0,0],"selected":true,"size":24},{"index":76,"norm_squared":7,"orbit_key":[[1,1,1,2],1],"representative":[-2,-1,-1,-1],"selected":true,"size":32},{"index":77,"norm_squared":6,"orbit_key":[[0,1,1,2],null],"representative":[-2,-1,-1,0],"selected":true,"size":96},{"index":78,"norm_squared":7,"orbit_key":[[1,1,1,2],-1],"representative":[-2,-1,-1,1],"selected":true,"size":32},{"index":79,"norm_squared":5,"orbit_key":[[0,0,1,2],null],"representative":[-2,-1,0,0],"selected":true,"size":48},{"index":80,"norm_squared":4,"orbit_key":[[0,0,0,2],null],"representative":[-2,0,0,0],"selected":true,"size":8},{"index":81,"norm_squared":4,"orbit_key":[[1,1,1,1],1],"representative":[-1,-1,-1,-1],"selected":true,"size":8},{"index":82,"norm_squared":3,"orbit_key":[[0,1,1,1],null],"representative":[-1,-1,-1,0],"selected":true,"size":32},{"index":83,"norm_squared":4,"orbit_key":[[1,1,1,1],-1],"representative":[-1,-1,-1,1],"selected":true,"size":8},{"index":84,"norm_squared":2,"orbit_key":[[0,0,1,1],null],"representative":[-1,-1,0,0],"selected":true,"size":24},{"index":85,"norm_squared":1,"orbit_key":[[0,0,0,1],null],"representative":[-1,0,0,0],"selected":true,"size":8},{"index":86,"norm_squared":0,"orbit_key":[[0,0,0,0],null],"representative":[0,0,0,0],"selected":true,"size":1}],"previous_witness":{"deficiency":1,"input_count":1692,"neighbor_count":1691,"provided_as_input_data_only":true},"scope":"exact invariant Hall witness on complete S5 at strict beta only","short_closed_form_witness":{"N0_size":1769,"N1_size":1777,"T0_exact_neighborhood":true,"T0_size":1801,"T1_exact_neighborhood":true,"T1_size":1809,"added_balanced_orbit_preserves_deficiency":true,"definition":{"B19":"{x in Z^4: ||x||^2<=19}","N0":"B19 \\ O0033 \\ O0133 \\ O2222minus","N1":"N0 union O2222minus = B19 \\ O0033 \\ O0133","O0033":"sorted absolute coordinates (0,0,3,3)","O0133":"sorted absolute coordinates (0,1,3,3)","O2222minus":"sorted absolute coordinates (2,2,2,2), sign product -1","O2223plus":"sorted absolute coordinates (2,2,2,3), sign product +1","T0":"B19 \\ O0033 \\ O0133 \\ O2222minus union O2223plus","T1":"T0 union O2222minus = B19 \\ O0033 \\ O0133 union O2223plus"},"orbit_sizes":{"B19":1897,"O0033":24,"O0133":96,"O2222minus":8,"O2223plus":32}},"source_pins":{"base_commit":"e54523517d0f03e58352e647c403a5af3e525a57","certificate_expanded_sha256":"b1fe3d866d2184227f46ec73ec2021c546bba056e98077e657e9205d9db5ad8b","exact_verifier_sha256":"611124563b42ec1c20d4755d190a850d1deac5ed743d6f98094ec97f7d893190"},"status":"PASS"} diff --git a/research/sharp-finite-gaussian-outward-slack/compact-hall/PROOF.md b/research/sharp-finite-gaussian-outward-slack/compact-hall/PROOF.md new file mode 100644 index 0000000000..8eea447ec0 --- /dev/null +++ b/research/sharp-finite-gaussian-outward-slack/compact-hall/PROOF.md @@ -0,0 +1,159 @@ +# Compact two-exclusion Hall proof + +## Statement + +Write \(H=H_4\) for the Sylvester Hadamard matrix in the parent `PROOF.md`, +\(U=H/2\), and \(\beta=\sqrt{21}-\sqrt{19}\). An edge of the strict graph +joins \(x\in S_5\) to an integer vector \(y\) when + +\[ +\|y-Ux\|_2\le1, +\qquad +\|y\|_2-\|x\|_2<\beta. +\] + +For \(x\) with no zero coordinates, let \(\epsilon(x)=\prod_i +\operatorname{sgn}(x_i)\). Define the full signed-coordinate orbits + +\[ +\begin{aligned} +O_{0033}&=\{x:\operatorname{sort}(|x_i|)=(0,0,3,3)\},\\ +O_{0133}&=\{x:\operatorname{sort}(|x_i|)=(0,1,3,3)\},\\ +O_{2223}^{+}&=\{x:\operatorname{sort}(|x_i|)=(2,2,2,3),\ \epsilon(x)=+1\}. +\end{aligned} +\] + +Then + +\[ +T_1=\{x:\|x\|_2^2\le19\}\setminus(O_{0033}\cup O_{0133}) +\quad\cup\quad O_{2223}^{+} +\] + +has 1,809 inputs. Put + +\[ +N_1=\{y:\|y\|_2^2\le19\}\setminus(O_{0033}\cup O_{0133}), +\] + +which has 1,777 points. The exact lower-bound check proves + +\[ +N_\beta(T_1)\subseteq N_1, +\] + +so \(|T_1|-|N_\beta(T_1)|\ge32\). The full quotient-flow replay +`orbit_cut.py` additionally checks equality and finds the maximum invariant +deficiency 32. This proof does not use the 1,692-point candidate Hall list. + +## Signed-permutation action and orbit membership + +The paired signed-permutation graph action is + +\[ +(x,y)\longmapsto(Ax,By),\qquad A,B\in W_4, +\] + +and preserves error and both norms when \(BH=HA\). The full quotient replay +checks all 384 signed permutations \(A\); the compatible pairs number 192, +and both projections are exactly + +\[ +W(D_4)=\{\text{signed permutations with an even number of sign changes}\}. +\] + +The compact checker independently verifies that every \(A\in W(D_4)\) has +an output action \(B=HAH^T/4\in W(D_4)\), with \(BH=HA\), and that the +output actions cover \(W(D_4)\). + +For a sorted absolute-coordinate pattern with multiplicities \(m_r\), let +\(m_0\) count zero coordinates. If some coordinate is zero, its sign can +absorb the parity of sign changes, so the pattern gives one orbit. If no +coordinate is zero, the two product-sign classes are separate orbits. Their +point counts are + +\[ +\frac{4!}{\prod_r m_r!}\,2^{4-m_0} +\quad(m_0>0), +\qquad +\frac{4!}{\prod_{r>0}m_r!}\,2^3 +\quad(m_0=0,\text{ for each fixed product sign}). +\] + +This gives \(|O_{0033}|=24\), \(|O_{0133}|=96\), and +\(|O_{2223}^{+}|=32\). The script generates all 38 required input orbit +representatives from sorted nonnegative patterns with squared norm at most +19, deleting the two excluded patterns, using one representative when a zero +is present and one per product sign otherwise, then adding the special +\((2,2,2,3,+)\) orbit. It does not read an input-list certificate. + +## Counts + +The count \(|B_{19}|=1,897\) is the sum of coefficients through degree 19 +in + +\[ +(1+2z+2z^4+2z^9+2z^{16})^4. +\] + +For one coordinate, these terms count zero and the choices \(\pm1\) through +\(\pm4\); larger absolute coordinates cannot occur in \(B_{19}\). The +checker computes these coefficients by exact integer convolution and also +checks the orbit-size sum. Removing the two +excluded orbits gives \(|N_1|=1,897-24-96=1,777\). Adding the special +positive-product orbit, whose squared norm is 21, gives +\(|T_1|=1,777+32=1,809\). All of \(T_1\) lies in \(S_5\). + +## Complete representative neighbor check + +Each Hadamard image coordinate has parity \(\sum_i x_i\pmod2\), since every +entry of \(H\) is odd. + +- If \(\sum_i x_i\) is even, \(Ux\in\mathbb Z^4\). The only integer + displacements of Euclidean norm at most one are zero and the eight signed + coordinate unit vectors: exactly nine candidates. +- If \(\sum_i x_i\) is odd, all four coordinates of \(Ux\) are + half-integers. Every integer point within Euclidean distance one must + choose one of the two nearest integers in each coordinate; all 16 such + choices have squared error exactly one. + +The checker enumerates the complete 9 or 16 candidates at each of the 38 +orbit representatives. It computes every strict-\(\beta\) comparison by +integer arithmetic, with no floating point, and verifies that each resulting +output satisfies the defining \(N_1\) predicate. Since the paired group +preserves the graph, applying \((A,B)\) transports each representative edge +to an edge from every point in that input orbit, and \(N_1\) is invariant +under the output action. Thus every strict neighbor of every input in +\(T_1\) lies in \(N_1\). This proves the Hall lower bound. It does not +assert that every input is adjacent to every output in the same pair of +orbits. + +The compact checker verifies 20 integer-image and 18 half-integer-image +representatives, enumerating 254 strict representative edges in total. The +separate full orbit-flow check verifies the exact union \(N_\beta(T_1)=N_1\). + +## Quotient min-cut cross-check + +`orbit_cut.py` reconstructs the complete graph on all 3,121 inputs and all +5,697 error-one candidate outputs. It finds 55 input orbits, 87 output +orbits, 236 quotient adjacencies, and 23,137 strict edges. One strict edge +between two orbits implies every input in the source orbit has some strict +neighbor in the target output orbit, and every output in that orbit has a +neighbor from the input orbit: apply the same paired group element to the +edge. Orbit capacities therefore give exact neighborhoods. + +The integer min-cut is 3,089, so the maximum invariant deficiency is +3,121-3,089=32. The minimal residual source side is the equivalent witness +\(T_0,N_0\) that separately excludes the negative-product \((2,2,2,2)\) +orbit of size eight from both sides. The maximal residual source side adds +that orbit to both and gives the shorter two-exclusion formula \(T_1,N_1\). +Both cuts and both complete neighborhoods are checked directly. + +## Limits + +This is a finite Hall obstruction at \(S_5\) and strict threshold \(\beta\). +It proves no global construction at \(\beta\), does not change the upper +injection verification, and makes no new \(\kappa\) or multiplication-frontier +claim. The complete matching and its original verifier remain in the parent +package. This compact lower checker is an addition to the same R5 contribution, +not a separate PR. diff --git a/research/sharp-finite-gaussian-outward-slack/compact-hall/README.md b/research/sharp-finite-gaussian-outward-slack/compact-hall/README.md new file mode 100644 index 0000000000..dd52bbb136 --- /dev/null +++ b/research/sharp-finite-gaussian-outward-slack/compact-hall/README.md @@ -0,0 +1,34 @@ +# Compact invariant Hall witness + +This folder adds a certificate-independent lower-bound checker for the R5 +finite optimum. It defines the 1,809-point input set and 1,777-point output +container by two excluded (W(D_4)) orbits, generates the 38 input-orbit +representatives, and checks every strict-β error-one neighbor of each +representative. + +Files: + +- `PROOF.md`: the closed-form set, orbit and shell counts, group action, and + exact neighborhood argument. +- `check.py`: standalone lower-bound checker. It does not read the matching + certificate or any Hall input list. +- `RESULT.json`: the 38 representative checks and exact counts. +- `orbit_cut.py`: full integer orbit-capacity min-cut reconstruction using + the certificate and exact verifier in the parent package. +- `ORBIT-FLOW-RESULT.json`: full quotient and min-cut receipt, including + canonical representatives for all input and output orbits. + +Run from this directory with Python 3.10+ and the standard library: + +```sh +python3 -B check.py +python3 -O -B check.py +python3 -B orbit_cut.py +python3 -O -B orbit_cut.py +``` + +The first two commands are standalone and certificate-independent. The +quotient-flow replay reads only pinned sibling files and cross-checks exact +neighborhood equality and the minimum cut. All default runs write no files. +The top-level `CHECKSUMS.sha256` freezes this addition along with the parent +R5 package, excluding itself and Python caches. diff --git a/research/sharp-finite-gaussian-outward-slack/compact-hall/RESULT.json b/research/sharp-finite-gaussian-outward-slack/compact-hall/RESULT.json new file mode 100644 index 0000000000..10c848be2e --- /dev/null +++ b/research/sharp-finite-gaussian-outward-slack/compact-hall/RESULT.json @@ -0,0 +1 @@ +{"B19_shell_counts_from_polynomial":[[0,1],[1,8],[2,24],[3,32],[4,24],[5,48],[6,96],[7,64],[8,24],[9,104],[10,144],[11,96],[12,96],[13,112],[14,192],[15,192],[16,24],[17,144],[18,312],[19,160]],"beta":"sqrt(21)-sqrt(19)","neighbor_check":{"all_strict_neighbors_in_N1":true,"half_integer_representatives":18,"integer_image_representatives":20,"representative_strict_edges_checked":254,"representatives_checked":38},"operator_numerator":[[1,1,1,1],[1,-1,1,-1],[1,1,-1,-1],[1,-1,-1,1]],"paired_W_D4_group":{"checked_identity":"B H=H A","input_projection_order":192,"output_projection_order":192},"representative_checks":[{"error_one_candidates":9,"image_parity":"integer","neighbors_outside_N1":0,"norm_squared":0,"orbit_size":1,"representative":[0,0,0,0],"sign_product":null,"sorted_abs":[0,0,0,0],"strict_beta_neighbors_checked":1},{"error_one_candidates":16,"image_parity":"half-integer","neighbors_outside_N1":0,"norm_squared":1,"orbit_size":8,"representative":[0,0,0,1],"sign_product":null,"sorted_abs":[0,0,0,1],"strict_beta_neighbors_checked":5},{"error_one_candidates":9,"image_parity":"integer","neighbors_outside_N1":0,"norm_squared":4,"orbit_size":8,"representative":[0,0,0,2],"sign_product":null,"sorted_abs":[0,0,0,2],"strict_beta_neighbors_checked":5},{"error_one_candidates":16,"image_parity":"half-integer","neighbors_outside_N1":0,"norm_squared":9,"orbit_size":8,"representative":[0,0,0,3],"sign_product":null,"sorted_abs":[0,0,0,3],"strict_beta_neighbors_checked":11},{"error_one_candidates":9,"image_parity":"integer","neighbors_outside_N1":0,"norm_squared":16,"orbit_size":8,"representative":[0,0,0,4],"sign_product":null,"sorted_abs":[0,0,0,4],"strict_beta_neighbors_checked":5},{"error_one_candidates":9,"image_parity":"integer","neighbors_outside_N1":0,"norm_squared":2,"orbit_size":24,"representative":[0,0,1,1],"sign_product":null,"sorted_abs":[0,0,1,1],"strict_beta_neighbors_checked":3},{"error_one_candidates":16,"image_parity":"half-integer","neighbors_outside_N1":0,"norm_squared":5,"orbit_size":48,"representative":[0,0,1,2],"sign_product":null,"sorted_abs":[0,0,1,2],"strict_beta_neighbors_checked":10},{"error_one_candidates":9,"image_parity":"integer","neighbors_outside_N1":0,"norm_squared":10,"orbit_size":48,"representative":[0,0,1,3],"sign_product":null,"sorted_abs":[0,0,1,3],"strict_beta_neighbors_checked":5},{"error_one_candidates":16,"image_parity":"half-integer","neighbors_outside_N1":0,"norm_squared":17,"orbit_size":48,"representative":[0,0,1,4],"sign_product":null,"sorted_abs":[0,0,1,4],"strict_beta_neighbors_checked":10},{"error_one_candidates":9,"image_parity":"integer","neighbors_outside_N1":0,"norm_squared":8,"orbit_size":24,"representative":[0,0,2,2],"sign_product":null,"sorted_abs":[0,0,2,2],"strict_beta_neighbors_checked":7},{"error_one_candidates":16,"image_parity":"half-integer","neighbors_outside_N1":0,"norm_squared":13,"orbit_size":48,"representative":[0,0,2,3],"sign_product":null,"sorted_abs":[0,0,2,3],"strict_beta_neighbors_checked":10},{"error_one_candidates":16,"image_parity":"half-integer","neighbors_outside_N1":0,"norm_squared":3,"orbit_size":32,"representative":[0,1,1,1],"sign_product":null,"sorted_abs":[0,1,1,1],"strict_beta_neighbors_checked":7},{"error_one_candidates":9,"image_parity":"integer","neighbors_outside_N1":0,"norm_squared":6,"orbit_size":96,"representative":[0,1,1,2],"sign_product":null,"sorted_abs":[0,1,1,2],"strict_beta_neighbors_checked":6},{"error_one_candidates":16,"image_parity":"half-integer","neighbors_outside_N1":0,"norm_squared":11,"orbit_size":96,"representative":[0,1,1,3],"sign_product":null,"sorted_abs":[0,1,1,3],"strict_beta_neighbors_checked":9},{"error_one_candidates":9,"image_parity":"integer","neighbors_outside_N1":0,"norm_squared":18,"orbit_size":96,"representative":[0,1,1,4],"sign_product":null,"sorted_abs":[0,1,1,4],"strict_beta_neighbors_checked":5},{"error_one_candidates":16,"image_parity":"half-integer","neighbors_outside_N1":0,"norm_squared":9,"orbit_size":96,"representative":[0,1,2,2],"sign_product":null,"sorted_abs":[0,1,2,2],"strict_beta_neighbors_checked":9},{"error_one_candidates":9,"image_parity":"integer","neighbors_outside_N1":0,"norm_squared":14,"orbit_size":192,"representative":[0,1,2,3],"sign_product":null,"sorted_abs":[0,1,2,3],"strict_beta_neighbors_checked":6},{"error_one_candidates":9,"image_parity":"integer","neighbors_outside_N1":0,"norm_squared":12,"orbit_size":32,"representative":[0,2,2,2],"sign_product":null,"sorted_abs":[0,2,2,2],"strict_beta_neighbors_checked":5},{"error_one_candidates":16,"image_parity":"half-integer","neighbors_outside_N1":0,"norm_squared":17,"orbit_size":96,"representative":[0,2,2,3],"sign_product":null,"sorted_abs":[0,2,2,3],"strict_beta_neighbors_checked":9},{"error_one_candidates":9,"image_parity":"integer","neighbors_outside_N1":0,"norm_squared":4,"orbit_size":8,"representative":[1,1,1,1],"sign_product":1,"sorted_abs":[1,1,1,1],"strict_beta_neighbors_checked":2},{"error_one_candidates":9,"image_parity":"integer","neighbors_outside_N1":0,"norm_squared":4,"orbit_size":8,"representative":[-1,1,1,1],"sign_product":-1,"sorted_abs":[1,1,1,1],"strict_beta_neighbors_checked":5},{"error_one_candidates":16,"image_parity":"half-integer","neighbors_outside_N1":0,"norm_squared":7,"orbit_size":32,"representative":[1,1,1,2],"sign_product":1,"sorted_abs":[1,1,1,2],"strict_beta_neighbors_checked":8},{"error_one_candidates":16,"image_parity":"half-integer","neighbors_outside_N1":0,"norm_squared":7,"orbit_size":32,"representative":[-1,1,1,2],"sign_product":-1,"sorted_abs":[1,1,1,2],"strict_beta_neighbors_checked":8},{"error_one_candidates":9,"image_parity":"integer","neighbors_outside_N1":0,"norm_squared":12,"orbit_size":32,"representative":[1,1,1,3],"sign_product":1,"sorted_abs":[1,1,1,3],"strict_beta_neighbors_checked":5},{"error_one_candidates":9,"image_parity":"integer","neighbors_outside_N1":0,"norm_squared":12,"orbit_size":32,"representative":[-1,1,1,3],"sign_product":-1,"sorted_abs":[1,1,1,3],"strict_beta_neighbors_checked":6},{"error_one_candidates":16,"image_parity":"half-integer","neighbors_outside_N1":0,"norm_squared":19,"orbit_size":32,"representative":[1,1,1,4],"sign_product":1,"sorted_abs":[1,1,1,4],"strict_beta_neighbors_checked":8},{"error_one_candidates":16,"image_parity":"half-integer","neighbors_outside_N1":0,"norm_squared":19,"orbit_size":32,"representative":[-1,1,1,4],"sign_product":-1,"sorted_abs":[1,1,1,4],"strict_beta_neighbors_checked":8},{"error_one_candidates":9,"image_parity":"integer","neighbors_outside_N1":0,"norm_squared":10,"orbit_size":48,"representative":[1,1,2,2],"sign_product":1,"sorted_abs":[1,1,2,2],"strict_beta_neighbors_checked":7},{"error_one_candidates":9,"image_parity":"integer","neighbors_outside_N1":0,"norm_squared":10,"orbit_size":48,"representative":[-1,1,2,2],"sign_product":-1,"sorted_abs":[1,1,2,2],"strict_beta_neighbors_checked":5},{"error_one_candidates":16,"image_parity":"half-integer","neighbors_outside_N1":0,"norm_squared":15,"orbit_size":96,"representative":[1,1,2,3],"sign_product":1,"sorted_abs":[1,1,2,3],"strict_beta_neighbors_checked":8},{"error_one_candidates":16,"image_parity":"half-integer","neighbors_outside_N1":0,"norm_squared":15,"orbit_size":96,"representative":[-1,1,2,3],"sign_product":-1,"sorted_abs":[1,1,2,3],"strict_beta_neighbors_checked":8},{"error_one_candidates":16,"image_parity":"half-integer","neighbors_outside_N1":0,"norm_squared":13,"orbit_size":32,"representative":[1,2,2,2],"sign_product":1,"sorted_abs":[1,2,2,2],"strict_beta_neighbors_checked":8},{"error_one_candidates":16,"image_parity":"half-integer","neighbors_outside_N1":0,"norm_squared":13,"orbit_size":32,"representative":[-1,2,2,2],"sign_product":-1,"sorted_abs":[1,2,2,2],"strict_beta_neighbors_checked":8},{"error_one_candidates":9,"image_parity":"integer","neighbors_outside_N1":0,"norm_squared":18,"orbit_size":96,"representative":[1,2,2,3],"sign_product":1,"sorted_abs":[1,2,2,3],"strict_beta_neighbors_checked":6},{"error_one_candidates":9,"image_parity":"integer","neighbors_outside_N1":0,"norm_squared":18,"orbit_size":96,"representative":[-1,2,2,3],"sign_product":-1,"sorted_abs":[1,2,2,3],"strict_beta_neighbors_checked":5},{"error_one_candidates":9,"image_parity":"integer","neighbors_outside_N1":0,"norm_squared":16,"orbit_size":8,"representative":[2,2,2,2],"sign_product":1,"sorted_abs":[2,2,2,2],"strict_beta_neighbors_checked":8},{"error_one_candidates":9,"image_parity":"integer","neighbors_outside_N1":0,"norm_squared":16,"orbit_size":8,"representative":[-2,2,2,2],"sign_product":-1,"sorted_abs":[2,2,2,2],"strict_beta_neighbors_checked":5},{"error_one_candidates":16,"image_parity":"half-integer","neighbors_outside_N1":0,"norm_squared":21,"orbit_size":32,"representative":[2,2,2,3],"sign_product":1,"sorted_abs":[2,2,2,3],"strict_beta_neighbors_checked":8}],"scope":"certificate-independent Hall lower bound at strict beta on S5","sets":{"B19_count_from_polynomial_coefficients":1897,"Hall_deficiency_lower_bound":32,"N1_count":1777,"T1_count":1809,"T1_orbit_count":38,"excluded_orbit_sizes":{"O0033":24,"O0133":96}},"status":"PASS"} diff --git a/research/sharp-finite-gaussian-outward-slack/compact-hall/SOURCES.json b/research/sharp-finite-gaussian-outward-slack/compact-hall/SOURCES.json new file mode 100644 index 0000000000..1ef5a3e6ff --- /dev/null +++ b/research/sharp-finite-gaussian-outward-slack/compact-hall/SOURCES.json @@ -0,0 +1,53 @@ +{ + "supplement": "compact-hall", + "base": { + "repository": "CrocSwap/integer-mult-bounds", + "commit": "e54523517d0f03e58352e647c403a5af3e525a57" + }, + "certificate_independent_checker": { + "file": "check.py", + "external_runtime_inputs": [], + "method": "generates W(D4) orbit representatives from the explicit predicates and enumerates 9 or 16 nearest error-one outputs per representative" + }, + "quotient_flow_checker_inputs": [ + { + "relative_path": "../R5-OPTIMUM.json.gz", + "expanded_sha256": "b1fe3d866d2184227f46ec73ec2021c546bba056e98077e657e9205d9db5ad8b", + "compressed_sha256": "d26f615aacff4b082c316e491aa1730aabc9cb6ceb377d33fb9a279b2d7f5f16" + }, + { + "relative_path": "../verify.py", + "sha256": "611124563b42ec1c20d4755d190a850d1deac5ed743d6f98094ec97f7d893190" + } + ], + "predecessor_credit": [ + { + "pr": 6619, + "author": "Nick Petalas", + "repository": "petalas/integer-mult-bounds", + "commit": "eaa967e7e8aa12cc53ec246a5fc00c5f8873a50b", + "path": "research/rational-norm-rounding/PROOF.md", + "git_blob": "ffb873b2749b1590df9267e802aea5af2c2a6eb5", + "sha256": "231b1b322b6be2a798d1807f5c0346ac4002323384b45cd4eff2a0ef7210bc00" + }, + { + "pr": 2589, + "author": "ywz65", + "role": "finite-sphere predecessor cited by #6619" + }, + { + "pr": 6509, + "author": "Ali Romman", + "repository": "aliromman/integer-mult-bounds", + "commit": "a4173e810c4d34a1d13b9745af123ad0ec6cfed5", + "path": "research/conservative-gaussian-rounding/PROOF.md", + "git_blob": "b7047476aaa5e2bb149c92a8a40a9b2ab444ef73", + "sha256": "122eff335674d8de1bcba47d28feb0c420be62b2b6d4e84f91c4292383753380" + }, + { + "author": "@CubeJerry", + "role": "R5 candidate workstream provenance" + } + ], + "assistance": "Prepared with substantial OpenAI Codex assistance." +} diff --git a/research/sharp-finite-gaussian-outward-slack/compact-hall/check.py b/research/sharp-finite-gaussian-outward-slack/compact-hall/check.py new file mode 100644 index 0000000000..67fe6c8c7a --- /dev/null +++ b/research/sharp-finite-gaussian-outward-slack/compact-hall/check.py @@ -0,0 +1,316 @@ +#!/usr/bin/env python3 +"""Standalone lower-bound check for the two-exclusion invariant Hall set. + +This checker does not load the R5 matching, Hall list, or any sibling file. +It generates all W(D4) orbit representatives of T1, checks their orbit +capacities, enumerates each representative's complete error-one outputs, and +proves N_beta(T1) is contained in the closed-form set N1. +""" + +from __future__ import annotations + +import itertools +import json +from collections import Counter +from math import factorial + + +H = ( + (1, 1, 1, 1), + (1, -1, 1, -1), + (1, 1, -1, -1), + (1, -1, -1, 1), +) +BETA = (21, 19) +RADIUS_SQUARED = 25 +B19_SQUARED = 19 +EXCLUDED_ABS_PATTERNS = {(0, 0, 3, 3), (0, 1, 3, 3)} +SPECIAL_PLUS_PATTERN = (2, 2, 2, 3) + + +def require(condition: bool, explanation: str) -> None: + if not condition: + raise RuntimeError(explanation) + + +def norm_squared(point): + return sum(value * value for value in point) + + +def sorted_abs(point): + return tuple(sorted(abs(value) for value in point)) + + +def sign_product(point): + require(all(value != 0 for value in point), + "sign product is defined only for nonzero coordinates") + result = 1 + for value in point: + result *= 1 if value > 0 else -1 + return result + + +def orbit_capacity(pattern, epsilon): + multiplicities = Counter(pattern) + zero_count = multiplicities.pop(0, 0) + denominator = factorial(zero_count) + for multiplicity in multiplicities.values(): + denominator *= factorial(multiplicity) + permutation_count = factorial(4) // denominator + nonzero_signs = 1 << (4 - zero_count) + if zero_count == 0: + require(epsilon in (-1, 1), "nonzero orbit needs a sign-product label") + nonzero_signs //= 2 + else: + require(epsilon is None, "orbit with zeros has no sign-product label") + return permutation_count * nonzero_signs + + +def canonical_representatives(): + """Generate exactly T1's 38 W(D4) orbit representatives.""" + patterns = { + tuple(sorted(values)) + for values in itertools.product(range(5), repeat=4) + if sum(value * value for value in values) <= B19_SQUARED + } + patterns -= EXCLUDED_ABS_PATTERNS + representatives = [] + for pattern in sorted(patterns): + if 0 in pattern: + representatives.append((pattern, None, pattern)) + else: + representatives.append((pattern, 1, pattern)) + negative = (-pattern[0], pattern[1], pattern[2], pattern[3]) + representatives.append((pattern, -1, negative)) + representatives.append((SPECIAL_PLUS_PATTERN, 1, SPECIAL_PLUS_PATTERN)) + return representatives + + +def signed_permutation_matrices(even_signs_only): + matrices = [] + for permutation in itertools.permutations(range(4)): + for signs in itertools.product((-1, 1), repeat=4): + if even_signs_only and signs[0] * signs[1] * signs[2] * signs[3] != 1: + continue + matrix = [[0] * 4 for _ in range(4)] + for row, column in enumerate(permutation): + matrix[row][column] = signs[row] + matrices.append(tuple(tuple(row) for row in matrix)) + return matrices + + +def matrix_multiply(left, right): + return tuple( + tuple(sum(left[i][k] * right[k][j] for k in range(4)) + for j in range(4)) + for i in range(4) + ) + + +def matrix_transpose(matrix): + return tuple(tuple(matrix[i][j] for i in range(4)) for j in range(4)) + + +def graph_group_check(): + """Check every even-sign input action has an even-sign output action.""" + input_group = signed_permutation_matrices(even_signs_only=True) + all_signed = set(signed_permutation_matrices(even_signs_only=False)) + require(len(input_group) == 192 and len(all_signed) == 384, + "signed-permutation group cardinalities changed") + ht = matrix_transpose(H) + output_group = set() + for a in input_group: + numerator = matrix_multiply(matrix_multiply(H, a), ht) + require(all(value % 4 == 0 for row in numerator for value in row), + "W(D4) action did not produce an integral output action") + b = tuple(tuple(value // 4 for value in row) for row in numerator) + require(b in all_signed and b in set(input_group), + "input action does not map to an even-sign output action") + require(matrix_multiply(b, H) == matrix_multiply(H, a), + "paired action fails B H=H A") + output_group.add(b) + require(output_group == set(input_group), + "paired action is not onto the output W(D4) projection") + return len(input_group), len(output_group) + + +def sum_sqrt_le(a: int, b: int, c: int, d: int) -> bool: + """Exact comparison sqrt(a)+sqrt(b) <= sqrt(c)+sqrt(d).""" + require(min(a, b, c, d) >= 0, "negative radical") + k = c + d - a - b + p = a * b + q = c * d + if k >= 0: + if p <= q: + return True + if k == 0: + return False + e = 4 * (p - q) - k * k + if e <= 0: + return True + return e * e <= 16 * k * k * q + r = -k + e = 4 * (q - p) - r * r + if e < 0: + return False + return e * e >= 16 * r * r * p + + +def compare_gaps(m: int, n: int, a: int, b: int) -> int: + """Sign of (sqrt(m)-sqrt(n))-(sqrt(a)-sqrt(b)), exactly.""" + left_le = sum_sqrt_le(m, b, a, n) + right_le = sum_sqrt_le(a, n, m, b) + require(left_le or right_le, "radical comparison is inconsistent") + if left_le and right_le: + return 0 + return -1 if left_le else 1 + + +def strict_beta_gap(point, output) -> bool: + return compare_gaps(norm_squared(output), norm_squared(point), *BETA) < 0 + + +def error_one_candidates(point): + """Return exactly the 9 integer-image or 16 half-integer-image neighbors.""" + hx = tuple(sum(H[i][j] * point[j] for j in range(4)) for i in range(4)) + parity = sum(point) & 1 + require(all((value & 1) == parity for value in hx), + "Hadamard image coordinates do not have common parity") + if parity == 0: + center = tuple(value // 2 for value in hx) + outputs = {center} + for coordinate in range(4): + for sign in (-1, 1): + changed = list(center) + changed[coordinate] += sign + outputs.add(tuple(changed)) + require(len(outputs) == 9, "integer-image candidate count is not nine") + else: + floors = tuple(value // 2 for value in hx) + outputs = { + tuple(floors[i] + bit[i] for i in range(4)) + for bit in itertools.product((0, 1), repeat=4) + } + require(len(outputs) == 16, "half-integer candidate count is not sixteen") + for output in outputs: + error_numerator = sum((2 * output[i] - hx[i]) ** 2 for i in range(4)) + require(error_numerator <= 4, + "enumerated output exceeds Euclidean error one") + if parity == 1: + require(error_numerator == 4, + "half-integer candidate has unexpected error") + return sorted(outputs), parity + + +def output_in_n1(output): + return ( + norm_squared(output) <= B19_SQUARED + and sorted_abs(output) not in EXCLUDED_ABS_PATTERNS + ) + + +def b19_shell_counts(): + """Coefficients through degree 19 of (1+2z+2z^4+2z^9+2z^16)^4.""" + one_coordinate = ((0, 1), (1, 2), (4, 2), (9, 2), (16, 2)) + coefficients = [1] + [0] * 19 + for _ in range(4): + next_coefficients = [0] * 20 + for degree, coefficient in enumerate(coefficients): + if coefficient == 0: + continue + for added_degree, multiplicity in one_coordinate: + target = degree + added_degree + if target <= 19: + next_coefficients[target] += coefficient * multiplicity + coefficients = next_coefficients + return coefficients + + +def main(): + group_input_count, group_output_count = graph_group_check() + representatives = canonical_representatives() + keys = [(pattern, epsilon) for pattern, epsilon, _ in representatives] + require(len(keys) == len(set(keys)) == 38, + "closed-form T1 orbit representative count changed") + + t1_count = 0 + b19_shells = b19_shell_counts() + n1_count = sum(b19_shells) + require(n1_count == 1897, "four-square count for B19 changed") + + excluded_orbit_sizes = { + "O0033": orbit_capacity((0, 0, 3, 3), None), + "O0133": orbit_capacity((0, 1, 3, 3), None), + } + require(excluded_orbit_sizes == {"O0033": 24, "O0133": 96}, + "two excluded orbit sizes changed") + n1_count -= sum(excluded_orbit_sizes.values()) + require(n1_count == 1777, "closed-form N1 count changed") + + rows = [] + total_strict_representative_edges = 0 + for pattern, epsilon, representative in representatives: + orbit_size = orbit_capacity(pattern, epsilon) + require(norm_squared(representative) <= RADIUS_SQUARED, + "T1 representative is outside S5") + require(sorted_abs(representative) == pattern, + "representative absolute-coordinate key changed") + if epsilon is not None: + require(sign_product(representative) == epsilon, + "representative sign-product key changed") + t1_count += orbit_size + + outputs, parity = error_one_candidates(representative) + strict_neighbors = [y for y in outputs + if strict_beta_gap(representative, y)] + outside = [y for y in strict_neighbors if not output_in_n1(y)] + require(not outside, + f"strict-beta neighbor escaped N1 at representative {representative}") + total_strict_representative_edges += len(strict_neighbors) + rows.append({ + "representative": list(representative), + "sorted_abs": list(pattern), + "sign_product": epsilon, + "orbit_size": orbit_size, + "norm_squared": norm_squared(representative), + "image_parity": "integer" if parity == 0 else "half-integer", + "error_one_candidates": len(outputs), + "strict_beta_neighbors_checked": len(strict_neighbors), + "neighbors_outside_N1": len(outside), + }) + require(t1_count == 1809, "closed-form T1 orbit-capacity count changed") + require(t1_count - n1_count == 32, + "closed-form Hall deficiency is not 32") + + print(json.dumps({ + "status": "PASS", + "scope": "certificate-independent Hall lower bound at strict beta on S5", + "operator_numerator": [list(row) for row in H], + "beta": "sqrt(21)-sqrt(19)", + "paired_W_D4_group": { + "input_projection_order": group_input_count, + "output_projection_order": group_output_count, + "checked_identity": "B H=H A", + }, + "sets": { + "B19_count_from_polynomial_coefficients": n1_count + 24 + 96, + "excluded_orbit_sizes": excluded_orbit_sizes, + "N1_count": n1_count, + "T1_count": t1_count, + "Hall_deficiency_lower_bound": t1_count - n1_count, + "T1_orbit_count": len(representatives), + }, + "neighbor_check": { + "representatives_checked": len(rows), + "integer_image_representatives": sum(row["image_parity"] == "integer" for row in rows), + "half_integer_representatives": sum(row["image_parity"] == "half-integer" for row in rows), + "representative_strict_edges_checked": total_strict_representative_edges, + "all_strict_neighbors_in_N1": True, + }, + "B19_shell_counts_from_polynomial": [[n, count] for n, count in enumerate(b19_shells)], + "representative_checks": rows, + }, sort_keys=True, separators=(",", ":"))) + + +if __name__ == "__main__": + main() diff --git a/research/sharp-finite-gaussian-outward-slack/compact-hall/orbit_cut.py b/research/sharp-finite-gaussian-outward-slack/compact-hall/orbit_cut.py new file mode 100644 index 0000000000..0f023db2cc --- /dev/null +++ b/research/sharp-finite-gaussian-outward-slack/compact-hall/orbit_cut.py @@ -0,0 +1,595 @@ +#!/usr/bin/env python3 +"""Construct the maximal invariant Hall-deficient set on complete S5. + +Inputs are the frozen R5 certificate and exact checker in the sibling +sharp-finite-gaussian-outward-slack package. The only flow is an exact +integer min-cut on signed-permutation orbit capacities; no matching search +or radius expansion is performed. +""" + +from __future__ import annotations + +import gzip +import hashlib +import itertools +import json +from collections import deque +from pathlib import Path + + +HERE = Path(__file__).resolve().parent +PACKAGE = HERE.parent +CERT_PATH = PACKAGE / "R5-OPTIMUM.json.gz" +VERIFY_PATH = PACKAGE / "verify.py" +PACKED_CERT_SHA256 = "d26f615aacff4b082c316e491aa1730aabc9cb6ceb377d33fb9a279b2d7f5f16" +RAW_CERT_SHA256 = "b1fe3d866d2184227f46ec73ec2021c546bba056e98077e657e9205d9db5ad8b" +VERIFY_SHA256 = "611124563b42ec1c20d4755d190a850d1deac5ed743d6f98094ec97f7d893190" + + +def require(condition: bool, explanation: str) -> None: + if not condition: + raise RuntimeError(explanation) + + +def load_pinned_inputs(): + packed = CERT_PATH.read_bytes() + require(hashlib.sha256(packed).hexdigest() == PACKED_CERT_SHA256, + "compressed certificate pin mismatch") + raw = gzip.decompress(packed) + require(hashlib.sha256(raw).hexdigest() == RAW_CERT_SHA256, + "expanded certificate pin mismatch") + source = VERIFY_PATH.read_bytes() + require(hashlib.sha256(source).hexdigest() == VERIFY_SHA256, + "frozen exact verifier pin mismatch") + namespace = {"__name__": "pinned_exact_r5_verifier", "__file__": str(VERIFY_PATH)} + exec(compile(source, str(VERIFY_PATH), "exec"), namespace) + return json.loads(raw), namespace + + +def multiply(left, right): + return tuple( + tuple(sum(left[i][k] * right[k][j] for k in range(4)) + for j in range(4)) + for i in range(4) + ) + + +def transpose(matrix): + return tuple(tuple(matrix[i][j] for i in range(4)) for j in range(4)) + + +def is_signed_permutation(matrix): + return ( + len(matrix) == 4 + and all(len(row) == 4 for row in matrix) + and all(sum(abs(value) for value in row) == 1 for row in matrix) + and all(sum(abs(matrix[i][j]) for i in range(4)) == 1 + for j in range(4)) + ) + + +def matrix_sign_product(matrix): + result = 1 + for row in matrix: + result *= next(value for value in row if value) + return result + + +def signed_permutations(): + for permutation in itertools.permutations(range(4)): + for signs in itertools.product((-1, 1), repeat=4): + matrix = [[0] * 4 for _ in range(4)] + for i, j in enumerate(permutation): + matrix[i][j] = signs[i] + yield tuple(tuple(row) for row in matrix) + + +def action(matrix, point): + return tuple(sum(matrix[i][j] * point[j] for j in range(4)) + for i in range(4)) + + +def neighborhood(points, graph): + result = set() + for point in points: + result.update(graph[point]) + return result + + +def graph_group(h): + """All paired signed permutations (A,B) satisfying B H=H A.""" + ht = transpose(h) + pairs = [] + for a in signed_permutations(): + numerator = multiply(multiply(h, a), ht) + if any(value % 4 for row in numerator for value in row): + continue + b = tuple(tuple(value // 4 for value in row) for row in numerator) + if is_signed_permutation(b): + require(multiply(b, h) == multiply(h, a), + "derived pair fails B H=H A") + pairs.append((a, b)) + return pairs + + +def orbit_partition(points, matrices, norm): + remaining = set(points) + orbits = [] + point_to_orbit = {} + while remaining: + representative = min(remaining) + orbit = {action(matrix, representative) for matrix in matrices} + require(orbit <= points, "signed-permutation orbit leaves candidate universe") + require(orbit <= remaining, + "orbit partition produced intersecting blocks") + index = len(orbits) + for point in orbit: + point_to_orbit[point] = index + orbits.append({ + "representative": representative, + "points": orbit, + "capacity": len(orbit), + "norm_squared": norm(representative), + "key": list(orbit_key(representative)), + }) + remaining -= orbit + return orbits, point_to_orbit + + +def orbit_key(point): + absolute = tuple(sorted(abs(value) for value in point)) + if 0 in point: + sign_parity = None + else: + sign_parity = 1 + for value in point: + sign_parity *= 1 if value > 0 else -1 + return absolute, sign_parity + + +def orbit_capacity_formula(point): + from collections import Counter + from math import factorial + + counts = Counter(abs(value) for value in point) + zero_count = counts.pop(0, 0) + permutation_count = factorial(4) + permutation_count //= factorial(zero_count) + for multiplicity in counts.values(): + permutation_count //= factorial(multiplicity) + sign_count = 1 << (4 - zero_count) + if zero_count == 0: + sign_count //= 2 + return permutation_count * sign_count + + +class Dinic: + """Integer-capacity Dinic flow with explicit residual reverse edges.""" + + def __init__(self, node_count): + self.graph = [[] for _ in range(node_count)] + + def add_edge(self, source, target, capacity): + forward = [target, capacity, len(self.graph[target])] + reverse = [source, 0, len(self.graph[source])] + self.graph[source].append(forward) + self.graph[target].append(reverse) + + def max_flow(self, source, sink): + flow = 0 + n = len(self.graph) + while True: + level = [-1] * n + level[source] = 0 + queue = deque([source]) + while queue: + node = queue.popleft() + for target, capacity, _ in self.graph[node]: + if capacity > 0 and level[target] < 0: + level[target] = level[node] + 1 + queue.append(target) + if level[sink] < 0: + return flow + next_edge = [0] * n + + def send(node, amount): + if node == sink: + return amount + while next_edge[node] < len(self.graph[node]): + edge_index = next_edge[node] + target, capacity, reverse_index = self.graph[node][edge_index] + if capacity > 0 and level[target] == level[node] + 1: + sent = send(target, min(amount, capacity)) + if sent: + self.graph[node][edge_index][1] -= sent + self.graph[target][reverse_index][1] += sent + return sent + next_edge[node] += 1 + return 0 + + while True: + sent = send(source, 1 << 60) + if not sent: + break + flow += sent + + def maximal_source_side(self, sink): + """Complement of residual vertices that can reach sink.""" + reverse_residual = [[] for _ in self.graph] + for source, edges in enumerate(self.graph): + for target, capacity, _ in edges: + if capacity > 0: + reverse_residual[target].append(source) + can_reach_sink = {sink} + queue = deque([sink]) + while queue: + node = queue.popleft() + for predecessor in reverse_residual[node]: + if predecessor not in can_reach_sink: + can_reach_sink.add(predecessor) + queue.append(predecessor) + return set(range(len(self.graph))) - can_reach_sink + + def minimal_source_side(self, source): + """Residual vertices reachable from source; the minimal min-cut side.""" + reachable = {source} + queue = deque([source]) + while queue: + node = queue.popleft() + for target, capacity, _ in self.graph[node]: + if capacity > 0 and target not in reachable: + reachable.add(target) + queue.append(target) + return reachable + + +def main(): + certificate, verify = load_pinned_inputs() + h = tuple(tuple(row) for row in certificate["matrix_numerator"]) + require(certificate["denominator"] == 2 + and certificate["radius"] == 5 + and certificate["error_bound_squared"] == 1, + "certificate domain changed") + norm = verify["sqnorm"] + points = { + point for point in itertools.product(range(-5, 6), repeat=4) + if norm(point) <= 25 + } + require(len(points) == 3121, "complete S5 enumeration changed") + + pairs = graph_group(h) + require(len(pairs) == 192, "paired signed-permutation group size changed") + input_matrices = sorted({a for a, _ in pairs}) + output_matrices = sorted({b for _, b in pairs}) + all_signed = set(signed_permutations()) + w_d4 = {matrix for matrix in all_signed if matrix_sign_product(matrix) == 1} + require(len(w_d4) == 192, "W(D4) sign-parity count changed") + require(set(input_matrices) == w_d4, + "input projection is not exactly the even-sign subgroup W(D4)") + require(set(output_matrices) == w_d4, + "output projection is not exactly the even-sign subgroup W(D4)") + + input_orbits, input_orbit_of = orbit_partition(points, input_matrices, norm) + require(sum(orbit["capacity"] for orbit in input_orbits) == len(points), + "input orbit capacities do not cover S5") + require(len({tuple(orbit["key"][0]) + (orbit["key"][1],) + for orbit in input_orbits}) == len(input_orbits), + "input signed-coordinate orbit keys are not unique") + require(all(orbit["capacity"] == orbit_capacity_formula(orbit["representative"]) + for orbit in input_orbits), + "input orbit capacity differs from signed-coordinate formula") + + error_outputs = set() + strict_graph = {} + strict_edge_count = 0 + for point in sorted(points): + strict_neighbors = set() + for output, _ in verify["all_error_one_outputs"](point, h): + error_outputs.add(output) + if verify["compare_gaps"](norm(output), norm(point), 21, 19) < 0: + strict_neighbors.add(output) + strict_edge_count += 1 + strict_graph[point] = strict_neighbors + + output_orbits, output_orbit_of = orbit_partition( + error_outputs, output_matrices, norm + ) + require(sum(orbit["capacity"] for orbit in output_orbits) == len(error_outputs), + "output orbit capacities do not cover every error-one candidate output") + require(len({tuple(orbit["key"][0]) + (orbit["key"][1],) + for orbit in output_orbits}) == len(output_orbits), + "output signed-coordinate orbit keys are not unique") + require(all(orbit["capacity"] == orbit_capacity_formula(orbit["representative"]) + for orbit in output_orbits), + "output orbit capacity differs from signed-coordinate formula") + + quotient_edges = set() + for point, outputs in strict_graph.items(): + i = input_orbit_of[point] + for output in outputs: + require(output in output_orbit_of, + "strict neighbor is outside error-one output universe") + quotient_edges.add((i, output_orbit_of[output])) + + # Completeness of an orbit adjacency for neighborhoods: one edge (x,y) + # and transitivity of the paired group projection imply that every x' + # in O_x has some strict neighbor in O_y, and every y' in O_y is reached + # from some x' in O_x. Check these statements on every quotient edge. + for input_index, output_index in quotient_edges: + input_orbit = input_orbits[input_index]["points"] + output_orbit = output_orbits[output_index]["points"] + for point in input_orbit: + require(strict_graph[point] & output_orbit, + "orbit adjacency is not complete across input representatives") + for output in output_orbit: + require(any(output in strict_graph[point] for point in input_orbit), + "orbit adjacency misses an output representative") + + input_count = len(input_orbits) + output_count = len(output_orbits) + source = 0 + input_offset = 1 + output_offset = input_offset + input_count + sink = output_offset + output_count + flow_graph = Dinic(sink + 1) + total_input_capacity = sum(orbit["capacity"] for orbit in input_orbits) + total_output_capacity = sum(orbit["capacity"] for orbit in output_orbits) + infinity = total_input_capacity + total_output_capacity + 1 + for i, orbit in enumerate(input_orbits): + flow_graph.add_edge(source, input_offset + i, orbit["capacity"]) + for i, j in sorted(quotient_edges): + flow_graph.add_edge(input_offset + i, output_offset + j, infinity) + for j, orbit in enumerate(output_orbits): + flow_graph.add_edge(output_offset + j, sink, orbit["capacity"]) + + cut_value = flow_graph.max_flow(source, sink) + minimal_source = flow_graph.minimal_source_side(source) + maximal_source = flow_graph.maximal_source_side(sink) + require(source in minimal_source and sink not in minimal_source, + "residual reachable set is not a source-side cut") + require(source in maximal_source and sink not in maximal_source, + "maximal residual source side is not a cut") + + def cut_capacity(source_side): + input_cut = sum( + orbit["capacity"] for i, orbit in enumerate(input_orbits) + if input_offset + i not in source_side + ) + output_cut = sum( + orbit["capacity"] for j, orbit in enumerate(output_orbits) + if output_offset + j in source_side + ) + infinite_crossings = sum( + 1 for i, j in quotient_edges + if input_offset + i in source_side + and output_offset + j not in source_side + ) + require(infinite_crossings == 0, + "minimum cut crosses an orbit-adjacency infinite edge") + return input_cut + output_cut + + require(cut_capacity(minimal_source) == cut_value, + "minimal source-side cut capacity differs from max flow") + require(cut_capacity(maximal_source) == cut_value, + "maximal source-side cut capacity differs from max flow") + minimal_input_orbits = { + i for i in range(input_count) if input_offset + i in minimal_source + } + minimal_output_orbits = { + j for j in range(output_count) if output_offset + j in minimal_source + } + selected_input_orbits = { + i for i in range(input_count) if input_offset + i in maximal_source + } + selected_output_orbits = { + j for j in range(output_count) if output_offset + j in maximal_source + } + selected_inputs = set().union(*( + input_orbits[i]["points"] for i in selected_input_orbits + )) if selected_input_orbits else set() + predicted_output_orbit_ids = { + j for i, j in quotient_edges if i in selected_input_orbits + } + require(predicted_output_orbit_ids == selected_output_orbits, + "maximal min-cut output side is not exactly the selected neighborhood") + actual_neighbors = set().union(*(strict_graph[x] for x in selected_inputs)) \ + if selected_inputs else set() + selected_orbit_neighbors = set().union(*( + output_orbits[j]["points"] for j in selected_output_orbits + )) if selected_output_orbits else set() + require(actual_neighbors == selected_orbit_neighbors, + "lifted orbit neighborhood differs from direct exact graph enumeration") + + minimal_inputs = set().union(*( + input_orbits[i]["points"] for i in minimal_input_orbits + )) if minimal_input_orbits else set() + minimal_predicted_outputs = { + j for i, j in quotient_edges if i in minimal_input_orbits + } + require(minimal_predicted_outputs == minimal_output_orbits, + "minimal min-cut output side is not exactly the selected neighborhood") + minimal_actual_neighbors = set().union(*(strict_graph[x] for x in minimal_inputs)) \ + if minimal_inputs else set() + minimal_orbit_neighbors = set().union(*( + output_orbits[j]["points"] for j in minimal_output_orbits + )) if minimal_output_orbits else set() + require(minimal_actual_neighbors == minimal_orbit_neighbors, + "minimal min-cut lifted neighborhood differs from direct enumeration") + + selected_input_capacity = sum( + input_orbits[i]["capacity"] for i in selected_input_orbits + ) + selected_output_capacity = sum( + output_orbits[j]["capacity"] for j in selected_output_orbits + ) + deficiency = selected_input_capacity - selected_output_capacity + require(deficiency > 0, "maximum invariant deficiency is not positive") + require(deficiency == total_input_capacity - cut_value, + "Hall deficiency does not equal total input capacity minus min-cut") + + minimal_input_capacity = sum(input_orbits[i]["capacity"] + for i in minimal_input_orbits) + minimal_output_capacity = sum(output_orbits[j]["capacity"] + for j in minimal_output_orbits) + minimal_deficiency = minimal_input_capacity - minimal_output_capacity + require(minimal_deficiency == total_input_capacity - cut_value, + "minimal min-cut does not attain the same maximum deficiency") + require(minimal_input_orbits <= selected_input_orbits + and minimal_output_orbits <= selected_output_orbits, + "minimal and maximal min-cut source sides are improperly ordered") + + # Closed-form orbit witnesses. For W(D4), an orbit is determined by + # sorted absolute coordinates and, with no zeros, the product of signs. + def sign_product(point): + product = 1 + for value in point: + require(value != 0, "sign product requested for a zero coordinate") + product *= 1 if value > 0 else -1 + return product + + def has_abs_pattern(point, pattern): + return tuple(sorted(abs(value) for value in point)) == pattern + + ball19 = {point for point in points if norm(point) <= 19} + orbit_0033 = {point for point in points if has_abs_pattern(point, (0, 0, 3, 3))} + orbit_0133 = {point for point in points if has_abs_pattern(point, (0, 1, 3, 3))} + orbit_2222_minus = { + point for point in points + if has_abs_pattern(point, (2, 2, 2, 2)) and sign_product(point) == -1 + } + orbit_2223_plus = { + point for point in points + if has_abs_pattern(point, (2, 2, 2, 3)) and sign_product(point) == 1 + } + small_t = (ball19 - orbit_0033 - orbit_0133 - orbit_2222_minus) | orbit_2223_plus + small_n = ball19 - orbit_0033 - orbit_0133 - orbit_2222_minus + expanded_t = small_t | orbit_2222_minus + expanded_n = small_n | orbit_2222_minus + require((len(ball19), len(orbit_0033), len(orbit_0133), + len(orbit_2222_minus), len(orbit_2223_plus)) == (1897, 24, 96, 8, 32), + "closed-form orbit capacities changed") + require(len(small_t) == 1801 and len(small_n) == 1769, + "base closed-form witness counts changed") + require(len(expanded_t) == 1809 and len(expanded_n) == 1777, + "expanded closed-form witness counts changed") + require(small_t == minimal_inputs and small_n == minimal_actual_neighbors, + "closed-form base witness differs from minimal min-cut") + require(expanded_t == selected_inputs and expanded_n == actual_neighbors, + "closed-form expanded witness differs from maximal min-cut") + require(neighborhood(small_t, strict_graph) == small_n, + "base closed-form strict neighborhood is incomplete or overinclusive") + require(neighborhood(expanded_t, strict_graph) == expanded_n, + "expanded closed-form strict neighborhood is incomplete or overinclusive") + + # Cross-check the selected cut's relation to the supplied deficient set. + cert_t = {tuple(point) for point in certificate["hall"]["input_set"]} + cert_n = {tuple(point) for point in certificate["hall"]["output_neighbors"]} + require(len(cert_t) == 1692 and len(cert_n) == 1691, + "pinned predecessor Hall witness changed") + require(len(cert_t) - len(cert_n) == 1, + "pinned predecessor witness is no longer deficit one") + + def orbit_table(orbits, selected_ids): + rows = [] + for index, orbit in enumerate(orbits): + representative = orbit["representative"] + rows.append({ + "index": index, + "representative": list(representative), + "orbit_key": orbit["key"], + "size": orbit["capacity"], + "norm_squared": orbit["norm_squared"], + "selected": index in selected_ids, + }) + return rows + + print(json.dumps({ + "status": "PASS", + "scope": "exact invariant Hall witness on complete S5 at strict beta only", + "source_pins": { + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "certificate_expanded_sha256": RAW_CERT_SHA256, + "exact_verifier_sha256": VERIFY_SHA256, + }, + "group": { + "signed_permutation_count": len(all_signed), + "paired_graph_automorphism_order": len(pairs), + "projection_is_W_D4": True, + "W_D4_definition": "signed permutation matrices whose four nonzero entries have product +1", + "input_orbit_count": input_count, + "output_candidate_orbit_count": output_count, + }, + "graph": { + "S5_input_count": len(points), + "all_error_one_candidate_output_count": len(error_outputs), + "strict_beta_edge_count": strict_edge_count, + "quotient_adjacency_count": len(quotient_edges), + "orbit_adjacency_completeness_checked": True, + }, + "maximal_invariant_hall_set": { + "selected_input_orbit_indices": sorted(selected_input_orbits), + "selected_input_orbit_keys": [input_orbits[i]["key"] for i in sorted(selected_input_orbits)], + "selected_output_orbit_indices": sorted(selected_output_orbits), + "selected_output_orbit_keys": [output_orbits[j]["key"] for j in sorted(selected_output_orbits)], + "input_count": selected_input_capacity, + "complete_strict_beta_neighbor_count": selected_output_capacity, + "deficiency": deficiency, + "quotient_min_cut": cut_value, + "maximal_min_cut_source_side": True, + }, + "minimal_min_cut_witness": { + "input_count": minimal_input_capacity, + "complete_strict_beta_neighbor_count": minimal_output_capacity, + "deficiency": minimal_deficiency, + "same_min_cut_value": cut_value, + }, + "short_closed_form_witness": { + "definition": { + "B19": "{x in Z^4: ||x||^2<=19}", + "O0033": "sorted absolute coordinates (0,0,3,3)", + "O0133": "sorted absolute coordinates (0,1,3,3)", + "O2222minus": "sorted absolute coordinates (2,2,2,2), sign product -1", + "O2223plus": "sorted absolute coordinates (2,2,2,3), sign product +1", + "T0": "B19 \\ O0033 \\ O0133 \\ O2222minus union O2223plus", + "N0": "B19 \\ O0033 \\ O0133 \\ O2222minus", + "T1": "T0 union O2222minus = B19 \\ O0033 \\ O0133 union O2223plus", + "N1": "N0 union O2222minus = B19 \\ O0033 \\ O0133", + }, + "orbit_sizes": { + "B19": len(ball19), + "O0033": len(orbit_0033), + "O0133": len(orbit_0133), + "O2222minus": len(orbit_2222_minus), + "O2223plus": len(orbit_2223_plus), + }, + "T0_size": len(small_t), + "N0_size": len(small_n), + "T1_size": len(expanded_t), + "N1_size": len(expanded_n), + "T0_exact_neighborhood": True, + "T1_exact_neighborhood": True, + "added_balanced_orbit_preserves_deficiency": ( + len(expanded_t) - len(expanded_n) + == len(small_t) - len(small_n) == 32 + ), + }, + "previous_witness": { + "input_count": len(cert_t), + "neighbor_count": len(cert_n), + "deficiency": len(cert_t) - len(cert_n), + "provided_as_input_data_only": True, + }, + "membership_rule": { + "closed_form_inputs": "T1=(B19\\O0033\\O0133) union O2223plus", + "closed_form_outputs": "N1=B19\\O0033\\O0133", + "domain": "S5 points satisfying the closed-form T1 predicate", + "W_D4_orbit_key": "(sorted absolute coordinates, product of coordinate signs if no coordinate is zero else null)", + "neighbor_rule": "error-one candidate output orbit_key appears among selected_output_orbit_keys; quotient adjacency is exact", + }, + "input_orbit_table": orbit_table(input_orbits, selected_input_orbits), + "output_orbit_table": orbit_table(output_orbits, selected_output_orbits), + }, sort_keys=True, separators=(",", ":"))) + + +if __name__ == "__main__": + main() diff --git a/research/sharp-finite-gaussian-outward-slack/replay.py b/research/sharp-finite-gaussian-outward-slack/replay.py new file mode 100644 index 0000000000..0a11932bdf --- /dev/null +++ b/research/sharp-finite-gaussian-outward-slack/replay.py @@ -0,0 +1,57 @@ +#!/usr/bin/env python3 +"""Replay the portable, compressed R5 certificate without modifying files.""" + +from __future__ import annotations + +import argparse +import gzip +import hashlib +import json +from pathlib import Path +import sys + + +HERE = Path(__file__).resolve().parent +CERTIFICATE = HERE / "R5-OPTIMUM.json.gz" +RAW_SHA256 = "b1fe3d866d2184227f46ec73ec2021c546bba056e98077e657e9205d9db5ad8b" +PACKED_SHA256 = "d26f615aacff4b082c316e491aa1730aabc9cb6ceb377d33fb9a279b2d7f5f16" + + +def require(condition: bool, explanation: str) -> None: + if not condition: + raise RuntimeError(explanation) + + +def replay() -> bytes: + packed = CERTIFICATE.read_bytes() + require(hashlib.sha256(packed).hexdigest() == PACKED_SHA256, + "compressed certificate SHA-256 mismatch") + raw = gzip.decompress(packed) + require(hashlib.sha256(raw).hexdigest() == RAW_SHA256, + "expanded certificate SHA-256 mismatch") + # Parse it too: this confirms the recovered bytes are a usable certificate. + document = json.loads(raw) + require(document.get("radius") == 5 and document.get("inputs") == 3121, + "expanded certificate has an unexpected domain") + return raw + + +def main() -> None: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--write-certificate", metavar="PATH", + help="write the exact expanded JSON bytes to PATH") + args = parser.parse_args() + raw = replay() + if args.write_certificate: + Path(args.write_certificate).write_bytes(raw) + print(json.dumps({ + "status": "PASS", + "expanded_certificate_sha256": RAW_SHA256, + "expanded_bytes": len(raw), + "certificate_output": args.write_certificate, + "default_run_writes_nothing": args.write_certificate is None, + }, sort_keys=True)) + + +if __name__ == "__main__": + main() diff --git a/research/sharp-finite-gaussian-outward-slack/review/PUBLICATION-REPLAY.json b/research/sharp-finite-gaussian-outward-slack/review/PUBLICATION-REPLAY.json new file mode 100644 index 0000000000..0304374c59 --- /dev/null +++ b/research/sharp-finite-gaussian-outward-slack/review/PUBLICATION-REPLAY.json @@ -0,0 +1,57 @@ +{ + "canonical_base": "e54523517d0f03e58352e647c403a5af3e525a57", + "runs": [ + { + "script": "verify.py", + "optimized": false, + "exit_code": 0, + "receipt_matches": true + }, + { + "script": "verify.py", + "optimized": true, + "exit_code": 0, + "receipt_matches": true + }, + { + "script": "compact-hall/check.py", + "optimized": false, + "exit_code": 0, + "receipt_matches": true + }, + { + "script": "compact-hall/check.py", + "optimized": true, + "exit_code": 0, + "receipt_matches": true + }, + { + "script": "compact-hall/orbit_cut.py", + "optimized": false, + "exit_code": 0, + "receipt_matches": true + }, + { + "script": "compact-hall/orbit_cut.py", + "optimized": true, + "exit_code": 0, + "receipt_matches": true + }, + { + "script": "review/check_full_matching.py", + "exit_code": 0, + "prior_receipt_matches": true, + "new_compact_witness": { + "closed_witness": { + "inputs": 1809, + "complete_neighbors": 1777, + "deficiency": 32, + "wrong_tie_extra_outputs": 32 + } + } + } + ], + "all_default_runs_read_only": true, + "retained_manifest_files_verified": 19, + "binary_certificate_git_blob": "e25a058522e249291b5e099f6d28c76e0854d1a3" +} diff --git a/research/sharp-finite-gaussian-outward-slack/review/REMOTE-SOURCE-CHECK.json b/research/sharp-finite-gaussian-outward-slack/review/REMOTE-SOURCE-CHECK.json new file mode 100644 index 0000000000..4cb854acd0 --- /dev/null +++ b/research/sharp-finite-gaussian-outward-slack/review/REMOTE-SOURCE-CHECK.json @@ -0,0 +1,24 @@ +[ + { + "repository": "petalas/integer-mult-bounds", + "pr": 6619, + "author": "Nick Petalas", + "commit": "eaa967e7e8aa12cc53ec246a5fc00c5f8873a50b", + "path": "research/rational-norm-rounding/PROOF.md", + "git_blob": "ffb873b2749b1590df9267e802aea5af2c2a6eb5", + "sha256": "231b1b322b6be2a798d1807f5c0346ac4002323384b45cd4eff2a0ef7210bc00", + "role": "predecessor context on rational orthogonal rounding and radial error; cites #2589 finite-sphere argument", + "independently_fetched_and_matched": true + }, + { + "repository": "aliromman/integer-mult-bounds", + "pr": 6509, + "author": "Ali Romman", + "commit": "a4173e810c4d34a1d13b9745af123ad0ec6cfed5", + "path": "research/conservative-gaussian-rounding/PROOF.md", + "git_blob": "b7047476aaa5e2bb149c92a8a40a9b2ab444ef73", + "sha256": "122eff335674d8de1bcba47d28feb0c420be62b2b6d4e84f91c4292383753380", + "role": "ideal pair definition, global bijective error-one construction, and source theorem for the upper endpoint one", + "independently_fetched_and_matched": true + } +] diff --git a/research/sharp-finite-gaussian-outward-slack/review/RESULT.json b/research/sharp-finite-gaussian-outward-slack/review/RESULT.json new file mode 100644 index 0000000000..141749128f --- /dev/null +++ b/research/sharp-finite-gaussian-outward-slack/review/RESULT.json @@ -0,0 +1,755 @@ +{ + "marker": "PASS_FULL_GRAPH_ALTERNATING_HALL_CUT", + "inputs": 3121, + "error_one_edges": 39681, + "strict_edges": 23137, + "strict_maximum_matching": 3089, + "strict_cut_inputs": 1801, + "strict_cut_outputs": 1769, + "strict_cut_deficiency": 32, + "closed_witness": { + "inputs": 1809, + "complete_neighbors": 1777, + "deficiency": 32, + "wrong_tie_extra_outputs": 32 + }, + "matching_rounds": 6, + "group_order": 192, + "group": "all coordinate permutations with an even number of sign changes", + "input_orbits": [ + { + "absolute_coordinates": [ + 0, + 0, + 0, + 0 + ], + "negative_product": 0, + "size": 1 + }, + { + "absolute_coordinates": [ + 0, + 0, + 0, + 1 + ], + "negative_product": 0, + "size": 8 + }, + { + "absolute_coordinates": [ + 0, + 0, + 0, + 2 + ], + "negative_product": 0, + "size": 8 + }, + { + "absolute_coordinates": [ + 0, + 0, + 0, + 3 + ], + "negative_product": 0, + "size": 8 + }, + { + "absolute_coordinates": [ + 0, + 0, + 0, + 4 + ], + "negative_product": 0, + "size": 8 + }, + { + "absolute_coordinates": [ + 0, + 0, + 1, + 1 + ], + "negative_product": 0, + "size": 24 + }, + { + "absolute_coordinates": [ + 0, + 0, + 1, + 2 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 0, + 0, + 1, + 3 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 0, + 0, + 1, + 4 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 0, + 0, + 2, + 2 + ], + "negative_product": 0, + "size": 24 + }, + { + "absolute_coordinates": [ + 0, + 0, + 2, + 3 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 0, + 1, + 1, + 1 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 0, + 1, + 1, + 2 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 1, + 1, + 3 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 1, + 1, + 4 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 1, + 2, + 2 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 1, + 2, + 3 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 0, + 2, + 2, + 2 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 0, + 2, + 2, + 3 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 1, + 1, + 1 + ], + "negative_product": 0, + "size": 8 + }, + { + "absolute_coordinates": [ + 1, + 1, + 1, + 1 + ], + "negative_product": 1, + "size": 8 + }, + { + "absolute_coordinates": [ + 1, + 1, + 1, + 2 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 1, + 1, + 2 + ], + "negative_product": 1, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 1, + 1, + 3 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 1, + 1, + 3 + ], + "negative_product": 1, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 1, + 1, + 4 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 1, + 1, + 4 + ], + "negative_product": 1, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 1, + 2, + 2 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 1, + 1, + 2, + 2 + ], + "negative_product": 1, + "size": 48 + }, + { + "absolute_coordinates": [ + 1, + 1, + 2, + 3 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 1, + 2, + 3 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 2, + 2, + 2 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 2, + 2, + 2 + ], + "negative_product": 1, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 2, + 2, + 3 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 2, + 2, + 3 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 2, + 2, + 2 + ], + "negative_product": 0, + "size": 8 + }, + { + "absolute_coordinates": [ + 2, + 2, + 2, + 3 + ], + "negative_product": 0, + "size": 32 + } + ], + "output_orbits": [ + { + "absolute_coordinates": [ + 0, + 0, + 0, + 0 + ], + "negative_product": 0, + "size": 1 + }, + { + "absolute_coordinates": [ + 0, + 0, + 0, + 1 + ], + "negative_product": 0, + "size": 8 + }, + { + "absolute_coordinates": [ + 0, + 0, + 0, + 2 + ], + "negative_product": 0, + "size": 8 + }, + { + "absolute_coordinates": [ + 0, + 0, + 0, + 3 + ], + "negative_product": 0, + "size": 8 + }, + { + "absolute_coordinates": [ + 0, + 0, + 0, + 4 + ], + "negative_product": 0, + "size": 8 + }, + { + "absolute_coordinates": [ + 0, + 0, + 1, + 1 + ], + "negative_product": 0, + "size": 24 + }, + { + "absolute_coordinates": [ + 0, + 0, + 1, + 2 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 0, + 0, + 1, + 3 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 0, + 0, + 1, + 4 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 0, + 0, + 2, + 2 + ], + "negative_product": 0, + "size": 24 + }, + { + "absolute_coordinates": [ + 0, + 0, + 2, + 3 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 0, + 1, + 1, + 1 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 0, + 1, + 1, + 2 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 1, + 1, + 3 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 1, + 1, + 4 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 1, + 2, + 2 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 1, + 2, + 3 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 0, + 2, + 2, + 2 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 0, + 2, + 2, + 3 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 1, + 1, + 1 + ], + "negative_product": 0, + "size": 8 + }, + { + "absolute_coordinates": [ + 1, + 1, + 1, + 1 + ], + "negative_product": 1, + "size": 8 + }, + { + "absolute_coordinates": [ + 1, + 1, + 1, + 2 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 1, + 1, + 2 + ], + "negative_product": 1, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 1, + 1, + 3 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 1, + 1, + 3 + ], + "negative_product": 1, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 1, + 1, + 4 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 1, + 1, + 4 + ], + "negative_product": 1, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 1, + 2, + 2 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 1, + 1, + 2, + 2 + ], + "negative_product": 1, + "size": 48 + }, + { + "absolute_coordinates": [ + 1, + 1, + 2, + 3 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 1, + 2, + 3 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 2, + 2, + 2 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 2, + 2, + 2 + ], + "negative_product": 1, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 2, + 2, + 3 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 2, + 2, + 3 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 2, + 2, + 2 + ], + "negative_product": 0, + "size": 8 + } + ], + "negative_control": "including the 19-to-21 beta edges restores a complete matching", + "method": "full vertex Hopcroft-Karp and alternating reachability; independent of compressed orbit min-cut" +} diff --git a/research/sharp-finite-gaussian-outward-slack/review/ROOT-REVIEW.md b/research/sharp-finite-gaussian-outward-slack/review/ROOT-REVIEW.md new file mode 100644 index 0000000000..633bbf66fa --- /dev/null +++ b/research/sharp-finite-gaussian-outward-slack/review/ROOT-REVIEW.md @@ -0,0 +1,76 @@ +# Independent finite optimum and compact Hall review + +Base: `e54523517d0f03e58352e647c403a5af3e525a57`. +This is independent AI-assisted mathematical and implementation review, +not human review or formal-kernel acceptance. + +## Exact finite theorem + +The original candidate generator and the independent certificate checker +use different comparison and enumeration methods. The generator orders +radical gaps by128-bit rational square-root enclosures; the independent +checker uses sign-aware integer squaring. Its full matching covers all 3,121 +points of the complete radius-five integer ball, has distinct outputs, +error at most one, and maximum outward increment sqrt(21)-sqrt(19). +The 58 attaining edges have squared input/output norms19 and21. The +1,692/1,691 strict-threshold Hall certificate proves the matching is optimal. +Integer coordinate boxes enumerate every possible error-one neighbor; +checking only the declared neighbor list would not suffice. + +The left/right signed-permutation identity H4=L(2C+)R was checked directly. +Both maps preserve the integer lattice, the full ball and the two norms. +The converse uses L inverse, not L. Conjugation gives C-. Consequently the +finite obstruction is a necessary lower bound for unrestricted global +injections with error at most one. It does not give a global construction, +unit-ball escape, or a selected physical caller. + +## Independent full-vertex cross-check of the short witness + +`check_full_matching.py` does not import the author search, certificate, +checker or orbit-flow implementation. It forms the ball by combining two +two-coordinate sums of squares, generates the complete error-one graph by +integer/half-integer parity, and compares gaps using rational square-root +enclosures. It solves the full vertex graph by augmenting paths and obtains +maximum strict matching size 3,089 and an alternating cut 1,801/1,769. +There are 39,681 error-one edges and 23,137 strict-beta edges. The paired +signed-permutation group is independently reconstructed and verified to be +the 192 even-sign permutations. The cut is invariant under every paired action. + +The independent orbit-capacity flow finds the same optimum and extends the +cut by the balanced negative-product (2,2,2,2) orbit. This gives the compact +1,809/1,777 witness. Its two exclusions and one added positive-product orbit +were checked against both full graph data and exact formula membership. +The compact standalone checker needs no matching/Hall list:38 representatives +cover its entire input set, and the paired group maps each allowed neighbor +into the declared output container. The elementary generating polynomial +counts B19 as 1,897; orbit multiplicities include the zero-coordinate factorial. + +Group adjacency means the neighborhood of an entire input orbit is a union +of output orbits. It does not assert a complete bipartite graph between the +two orbits. The final proof and code preserve this distinction. + +Including equality at beta restores a full 3,121 matching in the independent +full-vertex code. The primary checker also detects certificate corruption, +duplicate outputs, an omitted neighbor, a strict-error mutant, and a wrong +threshold tie rule. The full comparison and Hall counts use exact integers. + +From the repository root: + +```sh +python3 -I -W error -B research/sharp-finite-gaussian-outward-slack/review/check_full_matching.py +``` + +Expected marker: `PASS_FULL_GRAPH_ALTERNATING_HALL_CUT`. +Default output omits the long point lists; `--full-points` reproduces them. +The compact receipt is `review/RESULT.json`. The publication replay additionally generates the two-exclusion witness +directly, checks its complete neighborhood, and detects the erroneous +inclusive tie rule without importing the compact checker. + +## Limits + +The exact finite claim is at radius 5 and error cap 1. No search outside its +recorded domain is implied. The inherited #6509 global construction gives +upper bound 1, leaving the global infimum in [sqrt(21)-sqrt(19),1]. The +selected multiplication argument retains all five assumptions and its +unchanged kappa. The obstruction concerns a possible rounding contract; +it is not a contradiction of the selected exact-layer route. diff --git a/research/sharp-finite-gaussian-outward-slack/review/check_full_matching.py b/research/sharp-finite-gaussian-outward-slack/review/check_full_matching.py new file mode 100644 index 0000000000..3c19470499 --- /dev/null +++ b/research/sharp-finite-gaussian-outward-slack/review/check_full_matching.py @@ -0,0 +1,125 @@ +"""Independent full-vertex matching and alternating Hall cut; no orbit optimizer.""" +from collections import Counter, deque +from itertools import product, permutations +from math import isqrt, prod +import json, sys + +H = ((1,1,1,1),(1,-1,1,-1),(1,1,-1,-1),(1,-1,-1,1)) +Q = 1 << 128 +def need(ok, why): + if not ok: raise ValueError(why) +def n2(v): return sum(t*t for t in v) +def root_interval(n): + a=isqrt(n*Q*Q) + return a,a+int(a*a!=n*Q*Q) +def gap_interval(a,b): + la,ua=root_interval(a);lb,ub=root_interval(b) + return la-ub,ua-lb +BLO,BHI=gap_interval(21,19) +def strict(a,b): + if a<=b:return True + if (a,b)==(21,19):return False + lo,hi=gap_interval(a,b) + if hiBHI:return False + raise ValueError(('unseparated exact radical gaps',a,b)) +def candidates(x): + hx=tuple(sum(a*b for a,b in zip(row,x)) for row in H) + need(len({z%2 for z in hx})==1,'common Hadamard parity') + if hx[0]%2: + for bits in product((0,1),repeat=4): + yield tuple(z//2+t for z,t in zip(hx,bits)) + else: + c=tuple(z//2 for z in hx);yield c + for i in range(4): + for sign in (-1,1): + y=list(c);y[i]+=sign;yield tuple(y) +def maximum_matching(adj): + left=[None]*len(adj);right={};rounds=0 + while True: + dist=[-1]*len(adj);todo=deque() + for x,y in enumerate(left): + if y is None:dist[x]=0;todo.append(x) + end=False + while todo: + x=todo.popleft() + for y in adj[x]: + z=right.get(y) + if z is None:end=True + elif dist[z]<0:dist[z]=dist[x]+1;todo.append(z) + if not end:break + def augment(x): + for y in adj[x]: + z=right.get(y) + if z is None or (dist[z]==dist[x]+1 and augment(z)): + left[x]=y;right[y]=x;return True + dist[x]=-1;return False + gained=sum(augment(x) for x,y in enumerate(left) if y is None) + need(gained>0,'augmenting BFS progress');rounds+=1 + need(len(right)==sum(y is not None for y in left),'matching cardinality') + need(all(left[x]==y and y in adj[x] for y,x in right.items()),'matching edges') + lseen={x for x,y in enumerate(left) if y is None};rseen=set();todo=deque(lseen) + while todo: + x=todo.popleft() + for y in adj[x]: + if y in rseen:continue + rseen.add(y);need(y in right,'augmenting path remains') + z=right[y] + if z not in lseen:lseen.add(z);todo.append(z) + need(rseen=={y for x in lseen for y in adj[x]},'complete Hall neighborhood') + need(len(lseen)-len(rseen)==len(adj)-len(right),'maximal Hall deficiency') + return left,lseen,rseen,rounds +def dtype(x): + return tuple(sorted(map(abs,x))), (0 if 0 in x else int(prod(x)<0)) +def main(): + pairs=[(a,b) for a in range(-5,6) for b in range(-5,6) if a*a+b*b<=25] + xs=sorted((a,b,c,d) for a,b in pairs for c,d in pairs if a*a+b*b+c*c+d*d<=25) + need(len(xs)==3121,'complete ball count') + all_edges=[tuple(candidates(x)) for x in xs] + need(sum(map(len,all_edges))==39681,'complete error-one edge count') + for x,ys in zip(xs,all_edges): + hx=[sum(a*b for a,b in zip(row,x)) for row in H] + need(all(sum((2*a-b)**2 for a,b in zip(y,hx))<=4 for y in ys),'exact edge error') + adj=[tuple(y for y in ys if strict(n2(y),n2(x))) for x,ys in zip(xs,all_edges)] + matching,ls,ns,rounds=maximum_matching(adj);ts={xs[i] for i in ls} + group=[] + for perm in permutations(range(4)): + for signs in product((-1,1),repeat=4): + A=[[signs[i]*int(j==perm[i]) for j in range(4)] for i in range(4)] + num=[[sum(H[i][a]*A[a][b]*H[j][b] for a in range(4) for b in range(4)) for j in range(4)] for i in range(4)] + if any(z%4 for row in num for z in row):continue + B=[[z//4 for z in row] for row in num] + if not (all(sum(map(abs,row))==1 for row in B) and all(sum(abs(B[i][j]) for i in range(4))==1 for j in range(4))):continue + group.append((perm,signs,B)) + need({tuple(signs[i]*x[perm[i]] for i in range(4)) for x in ts}==ts,'input cut symmetry') + need({tuple(sum(B[i][j]*y[j] for j in range(4)) for i in range(4)) for y in ns}==ns,'output cut symmetry') + need(len(group)==192,'paired graph group count') + need(all(prod(s)==1 for _,s,_ in group),'group is even sign changes') + counts=Counter(dtype(x) for x in xs);tc=Counter(dtype(x) for x in ts) + need(all(v==counts[k] for k,v in tc.items()),'complete W(D4) input orbits') + output_universe={y for ys in all_edges for y in ys};oc=Counter(dtype(y) for y in output_universe);nc=Counter(dtype(y) for y in ns) + need(all(v==oc[k] for k,v in nc.items()),'complete W(D4) output orbits') + n1={x for x in xs if n2(x)<=19 and tuple(sorted(map(abs,x))) not in ((0,0,3,3),(0,1,3,3))} + extra={x for x in xs if tuple(sorted(map(abs,x)))==(2,2,2,3) and prod(x)>0} + t1=n1|extra + actual={y for x in t1 for y in candidates(x) if strict(n2(y),n2(x))} + need(len(n1)==1777 and len(extra)==32 and len(t1)==1809 and actual==n1,'independent closed witness equality') + wrong_ties={y for x in t1 for y in candidates(x) if strict(n2(y),n2(x)) or (n2(y),n2(x))==(21,19)} + need(wrong_ties-n1,'wrong inclusive tie breaks compact output container') + inclusive=[tuple(y for y in ys if strict(n2(y),n2(x)) or (n2(y),n2(x))==(21,19)) for x,ys in zip(xs,all_edges)] + im,il,ir,_=maximum_matching(inclusive) + need(all(y is not None for y in im) and not il and not ir,'inclusive threshold permits full matching') + out={'marker':'PASS_FULL_GRAPH_ALTERNATING_HALL_CUT','inputs':len(xs),'error_one_edges':sum(map(len,all_edges)), + 'strict_edges':sum(map(len,adj)),'strict_maximum_matching':sum(y is not None for y in matching), + 'strict_cut_inputs':len(ts),'strict_cut_outputs':len(ns),'strict_cut_deficiency':len(ts)-len(ns), + 'closed_witness':{'inputs':len(t1),'complete_neighbors':len(actual),'deficiency':len(t1)-len(actual),'wrong_tie_extra_outputs':len(wrong_ties-n1)}, + 'matching_rounds':rounds,'group_order':len(group),'group':'all coordinate permutations with an even number of sign changes', + 'input_orbits':[{'absolute_coordinates':k[0],'negative_product':k[1],'size':v} for k,v in sorted(tc.items())], + 'output_orbits':[{'absolute_coordinates':k[0],'negative_product':k[1],'size':v} for k,v in sorted(nc.items())], + 'strict_cut_input_points':sorted(ts),'strict_cut_output_points':sorted(ns), + 'negative_control':'including the 19-to-21 beta edges restores a complete matching', + 'method':'full vertex Hopcroft-Karp and alternating reachability; independent of compressed orbit min-cut'} + if "--full-points" not in sys.argv: + out={k:v for k,v in out.items() if not k.endswith("_points")} + print(json.dumps(out,indent=2)) +if __name__=='__main__':main() diff --git a/research/sharp-finite-gaussian-outward-slack/verify.py b/research/sharp-finite-gaussian-outward-slack/verify.py new file mode 100644 index 0000000000..8346dd45e7 --- /dev/null +++ b/research/sharp-finite-gaussian-outward-slack/verify.py @@ -0,0 +1,364 @@ +#!/usr/bin/env python3 +"""Independent exact checker for the radius-five Gaussian rounding claim. + +Only Python's standard library and the compressed certificate beside this +file are used. No search, optimizer, or author checker is imported. +""" + +from __future__ import annotations + +import gzip +import hashlib +import itertools +import json +from pathlib import Path + + +HERE = Path(__file__).resolve().parent +CERTIFICATE = HERE / "R5-OPTIMUM.json.gz" +RAW_SHA256 = "b1fe3d866d2184227f46ec73ec2021c546bba056e98077e657e9205d9db5ad8b" +PACKED_SHA256 = "d26f615aacff4b082c316e491aa1730aabc9cb6ceb377d33fb9a279b2d7f5f16" + + +def require(condition: bool, explanation: str) -> None: + if not condition: + raise RuntimeError(explanation) + + +def unpack_certificate(packed: bytes) -> tuple[bytes, dict]: + require(hashlib.sha256(packed).hexdigest() == PACKED_SHA256, + "compressed certificate SHA-256 mismatch") + raw = gzip.decompress(packed) + authenticate_expansion(raw) + decoded = json.loads(raw) + require(isinstance(decoded, dict), "certificate root must be an object") + return raw, decoded + + +def authenticate_expansion(raw: bytes) -> None: + require(hashlib.sha256(raw).hexdigest() == RAW_SHA256, + "expanded certificate SHA-256 mismatch") + + +def sqnorm(vector: tuple[int, ...] | list[int]) -> int: + return sum(value * value for value in vector) + + +def ceil_div(numerator: int, denominator: int) -> int: + return -((-numerator) // denominator) + + +def dot_row(row: list[int], vector: tuple[int, ...]) -> int: + return sum(a * b for a, b in zip(row, vector)) + + +def matmul(left: list[list[int]], right: list[list[int]]) -> list[list[int]]: + return [ + [sum(left[i][k] * right[k][j] for k in range(len(right))) + for j in range(len(right[0]))] + for i in range(len(left)) + ] + + +def transpose(matrix: list[list[int]]) -> list[list[int]]: + return [list(column) for column in zip(*matrix)] + + +def sum_sqrt_le(a: int, b: int, c: int, d: int) -> bool: + """Decide sqrt(a)+sqrt(b) <= sqrt(c)+sqrt(d) by integer arithmetic.""" + require(min(a, b, c, d) >= 0, "negative square-root radicand") + k = c + d - a - b + p = a * b + q = c * d + # The comparison is 2(sqrt(p)-sqrt(q)) <= k. + if k >= 0: + if p <= q: + return True + if k == 0: + return False + e = 4 * (p - q) - k * k + if e <= 0: + return True + return e * e <= 16 * k * k * q + r = -k + e = 4 * (q - p) - r * r + if e < 0: + return False + return e * e >= 16 * r * r * p + + +def compare_gaps(m: int, n: int, a: int, b: int) -> int: + """Return sign of (sqrt(m)-sqrt(n))-(sqrt(a)-sqrt(b)).""" + left_le = sum_sqrt_le(m, b, a, n) + right_le = sum_sqrt_le(a, n, m, b) + require(left_le or right_le, "exact radical order comparison is inconsistent") + if left_le and right_le: + return 0 + return -1 if left_le else 1 + + +def parse_vector(raw, label: str) -> tuple[int, int, int, int]: + require(isinstance(raw, list) and len(raw) == 4, + f"{label} must have four coordinates") + require(all(type(value) is int for value in raw), + f"{label} coordinates must be integers") + return tuple(raw) # type: ignore[return-value] + + +def error_numerator(x: tuple[int, ...], y: tuple[int, ...], + matrix: list[list[int]]) -> int: + """Four times ||y-Hx/2||^2, with no rounding.""" + hx = [dot_row(row, x) for row in matrix] + return sum((2 * y[i] - hx[i]) ** 2 for i in range(4)) + + +def all_error_one_outputs(x: tuple[int, ...], matrix: list[list[int]]): + """Enumerate every integer y with ||y-Hx/2|| <= 1.""" + hx = [dot_row(row, x) for row in matrix] + intervals = [ + range(ceil_div(value - 2, 2), (value + 2) // 2 + 1) + for value in hx + ] + for y_raw in itertools.product(*intervals): + y = tuple(y_raw) + error = sum((2 * y[i] - hx[i]) ** 2 for i in range(4)) + if error <= 4: + yield y, error + + +def validate_matching(pairs, inputs: set[tuple[int, ...]], + matrix: list[list[int]]) -> dict: + seen_inputs: set[tuple[int, ...]] = set() + seen_outputs: set[tuple[int, ...]] = set() + boundary_edges = 0 + threshold_edges = 0 + for raw_pair in pairs: + require(isinstance(raw_pair, list) and len(raw_pair) == 2, + "matching entry must be an input/output pair") + x = parse_vector(raw_pair[0], "matching input") + y = parse_vector(raw_pair[1], "matching output") + require(x in inputs, "matching input is outside S5") + require(x not in seen_inputs, "matching repeats an input") + require(y not in seen_outputs, "matching outputs are not injective") + seen_inputs.add(x) + seen_outputs.add(y) + error = error_numerator(x, y, matrix) + require(error <= 4, "matching edge exceeds error bound one") + boundary_edges += int(error == 4) + sign = compare_gaps(sqnorm(y), sqnorm(x), 21, 19) + require(sign <= 0, "matching outward increment exceeds beta") + threshold_edges += int(sign == 0) + require(seen_inputs == inputs, "matching does not cover every S5 input") + require(len(seen_outputs) == 3121, "matching output count is not 3121") + require(threshold_edges == 58, + "certificate should have 58 edges attaining beta") + return { + "size": len(seen_outputs), + "error_boundary_edges": boundary_edges, + "beta_edges": threshold_edges, + } + + +def signed_permutation(matrix: list[list[int]]) -> bool: + return ( + len(matrix) == 4 + and all(len(row) == 4 for row in matrix) + and all(sum(abs(value) for value in row) == 1 for row in matrix) + and all(sum(abs(matrix[i][j]) for i in range(4)) == 1 + for j in range(4)) + ) + + +def validate_native_transfer(matrix: list[list[int]]) -> None: + cplus = [ + [1, -1, 1, 1], + [1, 1, -1, 1], + [1, 1, 1, -1], + [-1, 1, 1, 1], + ] + left = [ + [1, 0, 0, 0], + [0, 0, 1, 0], + [0, 0, 0, -1], + [0, 1, 0, 0], + ] + right = [ + [1, 0, 0, 0], + [0, -1, 0, 0], + [0, 0, 1, 0], + [0, 0, 0, 1], + ] + identity = [[int(i == j) for j in range(4)] for i in range(4)] + require(signed_permutation(left) and signed_permutation(right), + "native transfer matrices are not signed permutations") + require(matmul(left, transpose(left)) == identity + and matmul(right, transpose(right)) == identity, + "native transfer does not preserve Euclidean norm") + require(matmul(matmul(left, cplus), right) == matrix, + "exact H4=L(2C_+)R identity failed") + conjugation = [ + [1, 0, 0, 0], + [0, -1, 0, 0], + [0, 0, 1, 0], + [0, 0, 0, -1], + ] + cminus = matmul(matmul(conjugation, cplus), conjugation) + expected_cminus = [ + [1, 1, 1, -1], + [-1, 1, 1, 1], + [1, -1, 1, 1], + [1, 1, -1, 1], + ] + require(signed_permutation(conjugation), + "complex conjugation is not a lattice isometry") + require(cminus == expected_cminus, + "complex conjugation does not transfer C+ to C-") + + +def validate_certificate(document: dict) -> dict: + matrix = document.get("matrix_numerator") + expected_matrix = [ + [1, 1, 1, 1], + [1, -1, 1, -1], + [1, 1, -1, -1], + [1, -1, -1, 1], + ] + require(matrix == expected_matrix, "certificate matrix is not the stated H4") + require(document.get("denominator") == 2 + and document.get("radius") == 5 + and document.get("inputs") == 3121 + and document.get("error_bound_squared") == 1, + "certificate domain/error cap differs from the theorem") + for i in range(4): + for j in range(4): + dot = sum(matrix[k][i] * matrix[k][j] for k in range(4)) + require(dot == (4 if i == j else 0), + "H4 columns fail H^T H=4I") + validate_native_transfer(matrix) + + inputs = { + vector for vector in itertools.product(range(-5, 6), repeat=4) + if sqnorm(vector) <= 25 + } + require(len(inputs) == 3121, "independent S5 enumeration has wrong size") + beta = document.get("threshold_pair") + require(beta == [21, 19] + and document.get("threshold_expression") == "sqrt(21)-sqrt(19)", + "certificate threshold is not beta=sqrt(21)-sqrt(19)") + require(compare_gaps(21, 19, 21, 19) == 0, + "exact beta equality control failed") + + matching = document.get("matching") + require(isinstance(matching, list), "certificate matching is absent") + matching_receipt = validate_matching(matching, inputs, matrix) + + hall = document.get("hall") + require(isinstance(hall, dict), "Hall witness is absent") + raw_hall_inputs = hall.get("input_set") + raw_declared_neighbors = hall.get("output_neighbors") + require(isinstance(raw_hall_inputs, list) + and isinstance(raw_declared_neighbors, list), + "Hall witness fields are malformed") + hall_inputs = {parse_vector(value, "Hall input") for value in raw_hall_inputs} + declared_neighbors = { + parse_vector(value, "declared Hall output") + for value in raw_declared_neighbors + } + require(len(hall_inputs) == 1692 and len(raw_hall_inputs) == 1692, + "Hall input set must have 1692 distinct points") + require(hall_inputs <= inputs, "Hall input set leaves the complete S5 ball") + require(len(declared_neighbors) == 1691 + and len(raw_declared_neighbors) == 1691, + "declared strict-beta neighborhood must have 1691 distinct points") + + actual_neighbors: set[tuple[int, ...]] = set() + inclusive_neighbors: set[tuple[int, ...]] = set() + strict_error_neighbors: set[tuple[int, ...]] = set() + boundary_candidates = 0 + for x in hall_inputs: + norm_x = sqnorm(x) + for y, error in all_error_one_outputs(x, matrix): + boundary_candidates += int(error == 4) + sign = compare_gaps(sqnorm(y), norm_x, 21, 19) + if sign < 0: + actual_neighbors.add(y) + if error < 4: + strict_error_neighbors.add(y) + if sign <= 0: + inclusive_neighbors.add(y) + require(actual_neighbors == declared_neighbors, + "declared Hall set differs from the complete strict-beta neighborhood") + require(len(actual_neighbors) == 1691 < len(hall_inputs), + "strict-beta graph violates no Hall deficiency") + require(inclusive_neighbors > actual_neighbors, + "tie-inclusive negative control did not add beta equality outputs") + require(boundary_candidates > 0, + "error-boundary negative control has no boundary candidates") + require(strict_error_neighbors != actual_neighbors, + "strict-error mutant did not remove a strict-beta output") + + # Negative controls: compressed-source mutation, duplicate output, one + # missing Hall neighbor, strict-error truncation, and wrong tie handling. + corrupted_packed = bytearray(CERTIFICATE.read_bytes()) + corrupted_packed[0] ^= 1 + source_pin_rejected = False + try: + unpack_certificate(bytes(corrupted_packed)) + except RuntimeError as error: + source_pin_rejected = "compressed certificate SHA-256" in str(error) + require(source_pin_rejected, "certificate-corruption control was not detected") + + corrupt_matching = [[list(pair[0]), list(pair[1])] for pair in matching] + corrupt_matching[-1][1] = list(corrupt_matching[0][1]) + duplicate_output_rejected = False + try: + validate_matching(corrupt_matching, inputs, matrix) + except RuntimeError as error: + duplicate_output_rejected = "outputs are not injective" in str(error) + require(duplicate_output_rejected, + "duplicate-output negative control was not rejected") + + omitted_set = set(actual_neighbors) + omitted_set.remove(min(omitted_set)) + omitted_neighbor_detected = omitted_set != declared_neighbors + require(omitted_neighbor_detected, + "one-neighbor omission negative control was not detected") + strict_error_mutant_differs = strict_error_neighbors != actual_neighbors + require(strict_error_mutant_differs, + "error<1 mutant failed to remove any candidate") + wrong_tie_rule_detected = inclusive_neighbors != actual_neighbors + require(wrong_tie_rule_detected, + "using <= beta in the Hall obstruction was not detected") + + return { + "status": "PASS", + "claim": "exact finite S5 optimum at beta=sqrt(21)-sqrt(19)", + "global_scope": "necessary lower bound only; no global construction at beta", + "expanded_certificate_sha256": RAW_SHA256, + "input_count": len(inputs), + "matching": matching_receipt, + "hall": { + "input_count": len(hall_inputs), + "strict_beta_neighbor_count": len(actual_neighbors), + "inclusive_beta_neighbor_count": len(inclusive_neighbors), + "error_boundary_candidates": boundary_candidates, + }, + "native_transfer": "H4=L(2C_+)R; inverse F_C=L^-1 F_H R", + "negative_controls": { + "certificate_corruption_rejected": source_pin_rejected, + "duplicate_output_rejected": duplicate_output_rejected, + "omitted_neighbor_detected": omitted_neighbor_detected, + "strict_error_mutant_differs": strict_error_mutant_differs, + "beta_tie_rule_detected": wrong_tie_rule_detected, + }, + } + + +def main() -> None: + _, document = unpack_certificate(CERTIFICATE.read_bytes()) + receipt = validate_certificate(document) + print(json.dumps(receipt, sort_keys=True, separators=(",", ":"))) + + +if __name__ == "__main__": + main() From 58a8facd7fbae9212774925349fbb617f114f040 Mon Sep 17 00:00:00 2001 From: Jerry Jiaheng Chen <80299683+CubeJerry@users.noreply.github.com> Date: Fri, 13 Nov 2026 22:50:17 +1100 Subject: [PATCH 2/3] Extend exact finite Gaussian thresholds with certified orbit flows and independent full-point verification --- .../CHECKSUMS.sha256 | 29 +- .../OPEN-NEXT-QUESTIONS.md | 36 +- .../PR-DESCRIPTION.md | 115 +- .../PUBLICATION-MANIFEST.json | 168 +- .../README.md | 108 +- .../SEARCH-PROVENANCE.md | 14 + .../orbit-extension/CHECKSUMS.sha256 | 10 + .../orbit-extension/FREEZE.md | 75 + .../orbit-extension/NOTICE.md | 32 + .../orbit-extension/OPEN-NEXT-QUESTIONS.md | 14 + .../orbit-extension/PROOF.md | 172 + .../orbit-extension/README.md | 46 + .../orbit-extension/RESULT.json | 1 + .../orbit-extension/SEARCH-PROVENANCE.md | 31 + .../orbit-extension/SOURCES.json | 40 + .../orbit-extension/sweep.py | 671 ++ .../orbit-extension/verify.py | 251 + .../review/extension/FULL-POINT-RESULT.json | 75 + .../review/extension/PUBLICATION-REPLAY.json | 83 + .../review/extension/R9-RESULT.json | 5401 +++++++++++++++++ .../review/extension/ROOT-REVIEW.md | 51 + .../extension/check_full_certificates.py | 133 + .../review/extension/check_full_r9.py | 55 + .../review/extension/full_graph_library.py | 115 + 24 files changed, 7584 insertions(+), 142 deletions(-) create mode 100644 research/sharp-finite-gaussian-outward-slack/orbit-extension/CHECKSUMS.sha256 create mode 100644 research/sharp-finite-gaussian-outward-slack/orbit-extension/FREEZE.md create mode 100644 research/sharp-finite-gaussian-outward-slack/orbit-extension/NOTICE.md create mode 100644 research/sharp-finite-gaussian-outward-slack/orbit-extension/OPEN-NEXT-QUESTIONS.md create mode 100644 research/sharp-finite-gaussian-outward-slack/orbit-extension/PROOF.md create mode 100644 research/sharp-finite-gaussian-outward-slack/orbit-extension/README.md create mode 100644 research/sharp-finite-gaussian-outward-slack/orbit-extension/RESULT.json create mode 100644 research/sharp-finite-gaussian-outward-slack/orbit-extension/SEARCH-PROVENANCE.md create mode 100644 research/sharp-finite-gaussian-outward-slack/orbit-extension/SOURCES.json create mode 100644 research/sharp-finite-gaussian-outward-slack/orbit-extension/sweep.py create mode 100644 research/sharp-finite-gaussian-outward-slack/orbit-extension/verify.py create mode 100644 research/sharp-finite-gaussian-outward-slack/review/extension/FULL-POINT-RESULT.json create mode 100644 research/sharp-finite-gaussian-outward-slack/review/extension/PUBLICATION-REPLAY.json create mode 100644 research/sharp-finite-gaussian-outward-slack/review/extension/R9-RESULT.json create mode 100644 research/sharp-finite-gaussian-outward-slack/review/extension/ROOT-REVIEW.md create mode 100644 research/sharp-finite-gaussian-outward-slack/review/extension/check_full_certificates.py create mode 100644 research/sharp-finite-gaussian-outward-slack/review/extension/check_full_r9.py create mode 100644 research/sharp-finite-gaussian-outward-slack/review/extension/full_graph_library.py diff --git a/research/sharp-finite-gaussian-outward-slack/CHECKSUMS.sha256 b/research/sharp-finite-gaussian-outward-slack/CHECKSUMS.sha256 index 85754ed26d..367230cb3a 100644 --- a/research/sharp-finite-gaussian-outward-slack/CHECKSUMS.sha256 +++ b/research/sharp-finite-gaussian-outward-slack/CHECKSUMS.sha256 @@ -1,10 +1,12 @@ ae9947ad6c97d0a3808a52fc9f8c07e5d070c0925dfbbe00ed3cd163118e5558 NOTICE.md -dd3de25a78e22098a4b859ec7d683431a78543e8ad0c32d7d4d28f17f270bc6e OPEN-NEXT-QUESTIONS.md +759c4548e32944514385927d803d75d18bf463b9f422b3d883e09a67654bb499 OPEN-NEXT-QUESTIONS.md +ba7a1125ae2c502e5f90de0214b37eefe03762818621f63891434b80d1250ef3 PR-DESCRIPTION.md 9650647a4713b7c35e9a61834578ca0d83ec960a5d5eb666f37b906a91a7f1e6 PR-DRAFT.md d00460ebf9579c49ae711079e3a21865571d82e7e42f8fc6bc11a08cf062f09b PROOF.md d26f615aacff4b082c316e491aa1730aabc9cb6ceb377d33fb9a279b2d7f5f16 R5-OPTIMUM.json.gz -82365cb5f31d0c11f8531c9c1414219311dfaf7e8c931a66ae30e42a910cca97 README.md +6ca5638f4beed6b70a2d10b201bde9bbf66d49923608b753791f9fcb5fc5ed26 README.md 87ee11560e99e440fa47d0fb5f6799e8e85a100b8467b284605e58ef306fd1ce RESULT.json +58359532905649cd8c57f9400ae8e6858174a882e3be81824e063a714a1cd9e2 SEARCH-PROVENANCE.md e010d96e3b44bb10a0dddbbff66fb00dcd316e620b8feebd0e8477a84e0b1d51 SOURCES.json f1ea9f91bf0f6517b30e278e2ae32bb8b23d4a451901eaae5a0ed652d1d5689c VERIFY.json a9e2c39ce39cfbc0327eed29bd249d1e7f02fe71c7847e9eeefac4e2b232de79 VERIFY.md @@ -15,5 +17,28 @@ c0a9ee164d3a466a4b3996e1075ef7443123ac5e99b0e4e9e05585411352ad21 compact-hall/P 5649af07ec67b10ca76b625250fe51e698fb2bb5ec25a82eaaaaaec5ca63dfdd compact-hall/SOURCES.json 0fc0f192cf541a3c94f87bb454187ca297e6ff28cbbd472126b6eba4bcc7275b compact-hall/check.py 98b2238a224aec3fbb35adb634b30ae00f7e7740293f06679c65b6c308029b9d compact-hall/orbit_cut.py +36a53de8d0fdb7527b3c81903c9d586858e6db5b92badd364d11d613d65cf674 orbit-extension/CHECKSUMS.sha256 +2cc3e738fe82ef0905d60da810497b1e5d27c0d4a69c9bd45b74921bee4de765 orbit-extension/FREEZE.md +d3656b0679dcfd9d8935d2175987a722f7266f75599537d4b8154a40262e52d1 orbit-extension/NOTICE.md +b23eef8709c7a5027d0dc77134cc4a9b0d65bdf7d664b426030d1c0875c08154 orbit-extension/OPEN-NEXT-QUESTIONS.md +27399559bdbe52e425dc169c3f58a6ce7581b33fd3be2457df46c9e9d94e5749 orbit-extension/PROOF.md +32c828d75871bfd812109d957f738427cc6f5e85db4835e5e0c293390bff5d00 orbit-extension/README.md +f6b3c5be0fd3e619dbbc44496ebef11d0f06ff5f5c1364e854020505baac85ef orbit-extension/RESULT.json +16a763b3369614f511778b47a871550a638852a5541fc6526beb1e175271f631 orbit-extension/SEARCH-PROVENANCE.md +31d13db28c45e7a6247798c838188b7e8949f9a0b5bd3703c40cc114967020ac orbit-extension/SOURCES.json +c3eea3f6c9786406cb2448e25f388a140ee782175eb16225e58590f9cf2c5fd4 orbit-extension/sweep.py +2bbcd0c87545bbb8054e52cd8dd15bd142031a4bc49bae104e4ed208de4709e4 orbit-extension/verify.py 10b3c29f75e36d26bdf1f819554fb1181774121b9defca6c17b0e0a9212176e7 replay.py +bac3b64005d0abe9124bfc753921f83f465b3915c22272e1168d005c07414094 review/PUBLICATION-REPLAY.json +f95b0ea46f4a724b78d7b2b30fab91628e2a18ab3bd875ec077f06522a5363b1 review/REMOTE-SOURCE-CHECK.json +f649acf266eedbb89d41508997be6905d19e0194207154574aea56e711a3bbda review/RESULT.json +6b50f9c8213ed49bb9e60362ea9aee909b29b9af9123ec6aefba8032b781ba58 review/ROOT-REVIEW.md +c43187b011400e8141b6ed86f8adc24587e3c320f7f56933809294f0bfb3c76f review/check_full_matching.py +68899512d88b253dfb42978e3aa450d2f6a424ce8265757625e92075a18663f3 review/extension/FULL-POINT-RESULT.json +81a82d848e14881e743d77e43f28c599c37111b16138fa38c88d386c849bd1d5 review/extension/PUBLICATION-REPLAY.json +4919c129ac90751d5105b73c1e4a00af9b72d9610fb872ba7ecf76d83f80a67f review/extension/R9-RESULT.json +14ece9c6caa845521d19aac8fd814c066829585a9f22f7dfc850a74c8407c383 review/extension/ROOT-REVIEW.md +a7028b653052c0b5df9a205dda0877d3ced9e2eec1767eb5bc36e981f25c5394 review/extension/check_full_certificates.py +e40896d2603f8ce660f6949710bfc7782f966d4da57ccffbe18f0a295e5d18a5 review/extension/check_full_r9.py +114e3bf3197c618aa17faf8d2d232a3d52ba8d973cf7514f6edd55c1f973f0af review/extension/full_graph_library.py 611124563b42ec1c20d4755d190a850d1deac5ed743d6f98094ec97f7d893190 verify.py diff --git a/research/sharp-finite-gaussian-outward-slack/OPEN-NEXT-QUESTIONS.md b/research/sharp-finite-gaussian-outward-slack/OPEN-NEXT-QUESTIONS.md index fb75635d73..943ee7fdd9 100644 --- a/research/sharp-finite-gaussian-outward-slack/OPEN-NEXT-QUESTIONS.md +++ b/research/sharp-finite-gaussian-outward-slack/OPEN-NEXT-QUESTIONS.md @@ -2,25 +2,25 @@ ## Global outward-slack infimum at error one -**Question:** For global injective integer-output maps rounding the actual -#6509 ideal Gaussian pair with uniform Euclidean error at most one, what is -the infimum of the outward norm slack, and is it attained by a global map? +For global injective integer-output maps rounding the ideal #6509 Gaussian +pair with uniform Euclidean error at most one, what is the infimum of the +outward norm slack, and is a global map attaining it possible? -**Current bound:** This package proves the necessary lower bound -\(\sqrt{21}-\sqrt{19}\) from the transferred radius-five Hall obstruction. -The inherited #6509 map and triangle inequality give the upper bound one. +The current necessary lower bound is \(\sqrt{78}-\sqrt{73}\), from the +radius-nine Hall obstruction. The inherited #6509 map gives upper bound one. +The original R5 proof remains a smaller, compact obstruction. The four later +finite upper certificates do not supply a global construction. -**First step:** Prove a global extension theorem for the finite matching, or -derive a stronger necessary bound under the same global hypotheses. Either -direction must retain injectivity and the uniform error bound on the entire -integer lattice. +A useful next step is a global matching construction, a uniform Hall proof, +or a stronger necessary bound under the same hypotheses. A map must retain +injectivity and the error bound on the entire lattice; pointwise selection, +finite success and a limit guessed from small radii are insufficient. -**Blocked by:** The radius-five matching is finite. Its existence does not -extend it to a global injective map, and the Hall witness proves necessity -only below its finite threshold. +## Finite domains and interfaces -## Other scopes - -No result here treats other error caps, other operators, other grid scales, -physical implementation costs, or the selected \(\kappa\). These require -separate source-bound statements and are intentionally outside this package. +The exact radius-8 optimum and larger radii beyond11 were not determined. +Radius10 follows by inclusion from the equal radius9/radius11 values, without +a separate computation. The bounded sweep does not prove a formula for all +radii. Other error caps and operators, an efficient global selector, actual +physical caller admission, and selected multiplication precision recovery +remain outside this package's conclusions. No selected kappa changes. diff --git a/research/sharp-finite-gaussian-outward-slack/PR-DESCRIPTION.md b/research/sharp-finite-gaussian-outward-slack/PR-DESCRIPTION.md index f120127f6d..0bce5c3657 100644 --- a/research/sharp-finite-gaussian-outward-slack/PR-DESCRIPTION.md +++ b/research/sharp-finite-gaussian-outward-slack/PR-DESCRIPTION.md @@ -1,72 +1,79 @@ -# Prove the exact Gaussian rounding threshold on the radius-five lattice ball with a compact Hall obstruction +# Prove exact finite Gaussian rounding thresholds with compact Hall witnesses and independently checked orbit-flow certificates -## Exact result +## Exact result and why it matters -For the complete radius-five ball in Z4, the minimum possible maximum -outward norm increment of an injective integer-output approximation to -H4/2 with pointwise Euclidean error at most 1 is exactly -`sqrt(21)-sqrt(19)`. A full 3,121-input injection attains this value. -The explicit signed-permutation identity `H4=L(2C+)R` transfers the result -to the actual ideal Gaussian pair from #6509 and to its conjugate C-. +For injective integer-output rounding of H4/2 with uniform Euclidean error +at most1, the complete radius-five lattice ball has exact optimal outward +slack `sqrt(21)-sqrt(19)`. The exact optima are `sqrt(31)-sqrt(28)` on +radii6 and7, and `sqrt(78)-sqrt(73)` on radii9 and11. Radius10 follows by +inclusion, without a separate computation. The explicit signed-permutation +identity `H4=L(2C+)R` transfers these results to the ideal Gaussian pair of +#6509 and its conjugate. -The lower bound has a short, independently checkable form. Let B19 be the -integer points of squared norm at most19. Remove the complete signed -coordinate orbits with sorted absolute coordinates(0,0,3,3) and(0,1,3,3), -obtaining N with 1,777 points. Add the 32 positive-product signed permutations -of(2,2,2,3), obtaining T with 1,809 points. Every error-one neighbor of T -whose outward increment is strictly below `sqrt(21)-sqrt(19)` lies in N. -Hall's inequality therefore fails by 32. +Thus any global injection under these error hypotheses needs outward slack +at least `sqrt(78)-sqrt(73)`. The available global interval is +`[sqrt(78)-sqrt(73),1]`; the upper endpoint is inherited from #6509. +Finite injections do not establish global attainment. -## Why this advances the question +## What changed and novelty relative to predecessors -#6619 asks about outward slack for rational orthogonal rounding; #2589 -provides its finite-sphere predecessor and #6509 supplies the Gaussian pair -and a global error-one construction. This package proves an exact finite -optimum and a necessary global lower bound without a period or conserved-sum -premise. The compact lower proof uses 38 signed-coordinate representatives, -rather than trusting a long list of witness inputs or search exclusions. +#6619 raises the rational norm-rounding question and credits #2589's +finite-sphere method; #6509 supplies the Gaussian map and a global error-one +construction. This package supplies exact finite optima and a necessary +global lower bound without period, conserved-sum or equivariance premises +on the unknown rounder. Classical Hall and symmetry facts are credited as +such; the explicit certificates and source-bound transfer are the new work. -The global infimum at error cap 1 is only bracketed here by -`[sqrt(21)-sqrt(19),1]`. The upper endpoint uses the inherited #6509 global -construction. A finite injection does not construct a global rounder at the -lower endpoint. The selected exact-layer multiplication route is not rejected. +The radius-five lower bound has a short two-exclusion proof. Remove the +signed coordinate orbits(0,0,3,3) and(0,1,3,3) from the squared-norm19 ball, +obtaining1,777 points. Add the32 positive-product permutations of(2,2,2,3), +obtaining1,809 inputs; every error-one neighbor below the strict threshold +lies in the1,777-point set. Only38 input-orbit representatives need checking. -## Reproduction and independent verification +The extension gives reusable positive flow and Hall-cut certificates on +paired W(D4) orbits. Biregularity, rather than complete bipartite adjacency, +lifts a saturated quotient flow to a fractional matching and then an actual +finite injection. At radii6/7 the strict Hall sizes are3,569/3,537; at9/11 +they are23,561/23,497. Full orbit predicates and exact capacities are retained. +This extends the same mathematical package and does not create a separate +PR for each finite radius. + +## Reproduction and independent checks Canonical base: `e54523517d0f03e58352e647c403a5af3e525a57`. +Original verified R5 package: `9c75d0b4b6e1cfe74694edf52f2f238a741bbaf5`. ```sh python3 -I -W error -B research/sharp-finite-gaussian-outward-slack/verify.py -python3 -I -O -W error -B research/sharp-finite-gaussian-outward-slack/verify.py python3 -I -W error -B research/sharp-finite-gaussian-outward-slack/compact-hall/check.py -python3 -I -W error -B research/sharp-finite-gaussian-outward-slack/compact-hall/orbit_cut.py -python3 -I -W error -B research/sharp-finite-gaussian-outward-slack/review/check_full_matching.py +python3 -I -W error -B research/sharp-finite-gaussian-outward-slack/orbit-extension/verify.py +python3 -I -O -W error -B research/sharp-finite-gaussian-outward-slack/orbit-extension/verify.py +python3 -I -W error -B research/sharp-finite-gaussian-outward-slack/review/extension/check_full_certificates.py +python3 -I -W error -B research/sharp-finite-gaussian-outward-slack/review/extension/check_full_r9.py ``` -Default runs are read-only and require only the Python standard library. -The primary checker validates the exact compressed certificate, complete -3,121-input injection, original strict Hall neighborhood and native transfer. -It detects corruption, duplicate output, omitted neighbors, erroneous strict -error and incorrect threshold ties. The standalone compact checker reads no -matching or Hall-list certificate. A separate orbit flow and an independent -full-vertex matching implementation agree on strict optimum 3,089 and the -deficit 32. Including beta equality restores a full matching. - -Exact source pins, output receipts, search domain and untouched regions, -proofs and independent review are included. The original proof and checker -remain available alongside the compact supplement. +These standard-library commands are read-only. Normal/optimized search and +verification receipts agree. The independent full-point checker reconstructs +all1,551,060 candidate edges over the four extension domains, checks actual +point-count orbit capacities, positive-flow conservation and complete Hall +neighborhoods, and imports no author generator or radical comparator. It +rejects changed flows, missing neighbor orbits and strict/inclusive boundary +confusion. A separate full-vertex radius-nine matching has32,633 inputs, +strict maximum32,569 and full saturation when equality edges are admitted. +Its different Hall set has23,057 inputs and22,993 outputs, agreeing on +maximum deficiency64. The original certificate, compact checker and source +transfer also retain their corruption and tie controls. -## Limits, kappa and credit +## Limitations, kappa and credit -This is a precision/analytic rounding obstruction, not a new complete -multiplication coefficient or an unconditional multiplication theorem. -**No new kappa; all five framework assumptions remain.** The selected -conditional kappa remains `0.00363005817`. Other radii/error caps, global -attainment, physical caller admission and complete numerical recovery are -outside this package's claim. +This is a scoped rounding obstruction and exact finite verification package. +It supplies no global map at the lower endpoint, unrestricted forward1/2 +bound, selected caller admission or physical rounding tariff. It does not +reject the selected exact-layer route. **No new kappa; all five multiplication +assumptions remain.** Selected conditional kappa is `0.00363005817`. -Prepared for @CubeJerry with substantial OpenAI Astra/Sol/Luna assistance -in candidate construction, proofs, code and independent review. Credit Nick -Petalas (#6619), ywz65 (#2589), Ali Romman (#6509), and the source authors -identified in SOURCES.json and NOTICE.md. Independent AI implementations -are distinguished from human review or formal-kernel acceptance. +Prepared for @CubeJerry with substantial OpenAI Astra/Sol/Luna assistance in +candidate construction, proofs, code and independent checking. Credit Nick +Petalas (#6619), ywz65 (#2589), Ali Romman (#6509), and the retained source +authors in SOURCES.json and NOTICE.md. Independent AI implementations are +not human review or formal-kernel acceptance. No upstream PR is submitted. diff --git a/research/sharp-finite-gaussian-outward-slack/PUBLICATION-MANIFEST.json b/research/sharp-finite-gaussian-outward-slack/PUBLICATION-MANIFEST.json index eff8145f9f..262fc5e9eb 100644 --- a/research/sharp-finite-gaussian-outward-slack/PUBLICATION-MANIFEST.json +++ b/research/sharp-finite-gaussian-outward-slack/PUBLICATION-MANIFEST.json @@ -1,14 +1,38 @@ { "canonical_base": "e54523517d0f03e58352e647c403a5af3e525a57", - "scope": "Exact finite S5 optimum sqrt(21)-sqrt(19), compact Hall deficit32, global necessary lower bound only; no new kappa", - "retained_author_manifest": "CHECKSUMS.sha256 preserved and verified19 files", - "independent_review": "review/ROOT-REVIEW.md", + "previous_published_head": "9c75d0b4b6e1cfe74694edf52f2f238a741bbaf5", + "scope": "Exact finite optima R5,6,7,9,11; R10 by inclusion; global necessary lower sqrt78-sqrt73 only; no new kappa", + "original_scientific_files_unchanged": [ + "NOTICE.md", + "PR-DRAFT.md", + "PROOF.md", + "R5-OPTIMUM.json.gz", + "RESULT.json", + "SOURCES.json", + "VERIFY.json", + "VERIFY.md", + "compact-hall/ORBIT-FLOW-RESULT.json", + "compact-hall/PROOF.md", + "compact-hall/README.md", + "compact-hall/RESULT.json", + "compact-hall/SOURCES.json", + "compact-hall/check.py", + "compact-hall/orbit_cut.py", + "replay.py", + "review/check_full_matching.py", + "verify.py" + ], + "author_extension_manifest": "orbit-extension/CHECKSUMS.sha256", + "independent_reviews": [ + "review/ROOT-REVIEW.md", + "review/extension/ROOT-REVIEW.md" + ], "files": [ { "path": "CHECKSUMS.sha256", - "bytes": 1584, - "sha256": "27527db6406c1e113e96885999b0fe57425862ef9060be848ffcc3e20ae67f86", - "git_blob": "85754ed26de3a829a1a226307987d0422ea19677" + "bytes": 3989, + "sha256": "cf6e51d7d3ed42dc9ee9c4164c5e794e1ba54262e707036c48efbac962210e34", + "git_blob": "367230cb3ad309a972e5b93447c924e55307a124" }, { "path": "NOTICE.md", @@ -18,15 +42,15 @@ }, { "path": "OPEN-NEXT-QUESTIONS.md", - "bytes": 1184, - "sha256": "dd3de25a78e22098a4b859ec7d683431a78543e8ad0c32d7d4d28f17f270bc6e", - "git_blob": "fb75635d733ef126985432eb58174247fef0e516" + "bytes": 1350, + "sha256": "759c4548e32944514385927d803d75d18bf463b9f422b3d883e09a67654bb499", + "git_blob": "943ee7fdd9f857ed76e0b7177d9d4ea31a472fbe" }, { "path": "PR-DESCRIPTION.md", - "bytes": 3932, - "sha256": "822b92a5a2948ae547bb92d5cecdd6ab2d8e28a185ba3c03f904305c06e2b541", - "git_blob": "f120127f6dcba91860e00a9f6d7e8fbbdd5e5f9d" + "bytes": 4603, + "sha256": "ba7a1125ae2c502e5f90de0214b37eefe03762818621f63891434b80d1250ef3", + "git_blob": "0bce5c3657e4a1e7c9ac9256318671c0239777cd" }, { "path": "PR-DRAFT.md", @@ -48,9 +72,9 @@ }, { "path": "README.md", - "bytes": 2448, - "sha256": "82365cb5f31d0c11f8531c9c1414219311dfaf7e8c931a66ae30e42a910cca97", - "git_blob": "9525b074b4c802b2abb1c7e57b782e566e87f803" + "bytes": 3026, + "sha256": "6ca5638f4beed6b70a2d10b201bde9bbf66d49923608b753791f9fcb5fc5ed26", + "git_blob": "927111d98f0b2ff7423b9660e470ea439b0bd46a" }, { "path": "RESULT.json", @@ -60,9 +84,9 @@ }, { "path": "SEARCH-PROVENANCE.md", - "bytes": 2264, - "sha256": "3cfb46fb4dffae7ebbbea1b5decdb6b7114e1be0e728511c80468f4d297a24c4", - "git_blob": "1bd2e1b04b9b4ddc7708292c8a969b074c53075e" + "bytes": 2982, + "sha256": "58359532905649cd8c57f9400ae8e6858174a882e3be81824e063a714a1cd9e2", + "git_blob": "6d69c753685376b2a31c17be2b9af131d271ea6f" }, { "path": "SOURCES.json", @@ -124,6 +148,72 @@ "sha256": "98b2238a224aec3fbb35adb634b30ae00f7e7740293f06679c65b6c308029b9d", "git_blob": "0f023db2cc81f66166795a08cb691f7738d16105" }, + { + "path": "orbit-extension/CHECKSUMS.sha256", + "bytes": 787, + "sha256": "36a53de8d0fdb7527b3c81903c9d586858e6db5b92badd364d11d613d65cf674", + "git_blob": "2fd34b8f5faed42612f94a647990d3789aaaf053" + }, + { + "path": "orbit-extension/FREEZE.md", + "bytes": 3397, + "sha256": "2cc3e738fe82ef0905d60da810497b1e5d27c0d4a69c9bd45b74921bee4de765", + "git_blob": "9994dd79459d8bf605f55314e3807932d00b4a22" + }, + { + "path": "orbit-extension/NOTICE.md", + "bytes": 1537, + "sha256": "d3656b0679dcfd9d8935d2175987a722f7266f75599537d4b8154a40262e52d1", + "git_blob": "37f15d008589d70811865df407b9752471026d9e" + }, + { + "path": "orbit-extension/OPEN-NEXT-QUESTIONS.md", + "bytes": 763, + "sha256": "b23eef8709c7a5027d0dc77134cc4a9b0d65bdf7d664b426030d1c0875c08154", + "git_blob": "15851d4f4d1f4da5121e185015337edf3c3e1e54" + }, + { + "path": "orbit-extension/PROOF.md", + "bytes": 8072, + "sha256": "27399559bdbe52e425dc169c3f58a6ce7581b33fd3be2457df46c9e9d94e5749", + "git_blob": "4aa6ad9d2fd60423be26d6ce87021704cb24d841" + }, + { + "path": "orbit-extension/README.md", + "bytes": 2344, + "sha256": "32c828d75871bfd812109d957f738427cc6f5e85db4835e5e0c293390bff5d00", + "git_blob": "6b288d663fecd04dc11ce1a4e508b879cc236e06" + }, + { + "path": "orbit-extension/RESULT.json", + "bytes": 398445, + "sha256": "f6b3c5be0fd3e619dbbc44496ebef11d0f06ff5f5c1364e854020505baac85ef", + "git_blob": "5feffcc84d25346a2dd704a5339c6b9b366b75f3" + }, + { + "path": "orbit-extension/SEARCH-PROVENANCE.md", + "bytes": 1574, + "sha256": "16a763b3369614f511778b47a871550a638852a5541fc6526beb1e175271f631", + "git_blob": "829134b76ea3d3cd8664dcf6ee4550d5174ee3ef" + }, + { + "path": "orbit-extension/SOURCES.json", + "bytes": 1672, + "sha256": "31d13db28c45e7a6247798c838188b7e8949f9a0b5bd3703c40cc114967020ac", + "git_blob": "460ef8f8d5b6811471daf9e3f935bdbfbd3a37b2" + }, + { + "path": "orbit-extension/sweep.py", + "bytes": 25546, + "sha256": "c3eea3f6c9786406cb2448e25f388a140ee782175eb16225e58590f9cf2c5fd4", + "git_blob": "44e292db5e26fd141757cd6cab511edc7d06393c" + }, + { + "path": "orbit-extension/verify.py", + "bytes": 11064, + "sha256": "2bbcd0c87545bbb8054e52cd8dd15bd142031a4bc49bae104e4ed208de4709e4", + "git_blob": "78fbe11fb22d247ea380e9bba6e1b6b204f35fb0" + }, { "path": "replay.py", "bytes": 1865, @@ -160,6 +250,48 @@ "sha256": "c43187b011400e8141b6ed86f8adc24587e3c320f7f56933809294f0bfb3c76f", "git_blob": "3c19470499c4b1bd16078c0b452d21c2620a649e" }, + { + "path": "review/extension/FULL-POINT-RESULT.json", + "bytes": 1689, + "sha256": "68899512d88b253dfb42978e3aa450d2f6a424ce8265757625e92075a18663f3", + "git_blob": "8cc8b464c91bc72f58bcf58bdcfd116400100bc7" + }, + { + "path": "review/extension/PUBLICATION-REPLAY.json", + "bytes": 3549, + "sha256": "81a82d848e14881e743d77e43f28c599c37111b16138fa38c88d386c849bd1d5", + "git_blob": "ec96f625efa635bf05fc49cdd6da8641add44a76" + }, + { + "path": "review/extension/R9-RESULT.json", + "bytes": 99441, + "sha256": "4919c129ac90751d5105b73c1e4a00af9b72d9610fb872ba7ecf76d83f80a67f", + "git_blob": "e9180e512fa828638da62eac0986bd4455330099" + }, + { + "path": "review/extension/ROOT-REVIEW.md", + "bytes": 2938, + "sha256": "14ece9c6caa845521d19aac8fd814c066829585a9f22f7dfc850a74c8407c383", + "git_blob": "589bfd806063ddbfa9faf4c5f632bc584b71a299" + }, + { + "path": "review/extension/check_full_certificates.py", + "bytes": 8044, + "sha256": "a7028b653052c0b5df9a205dda0877d3ced9e2eec1767eb5bc36e981f25c5394", + "git_blob": "1812ae267bff5f5b5cd38265814cd6a9204fd1bc" + }, + { + "path": "review/extension/check_full_r9.py", + "bytes": 3350, + "sha256": "e40896d2603f8ce660f6949710bfc7782f966d4da57ccffbe18f0a295e5d18a5", + "git_blob": "6fe6b373dcf49dac22bb629265bdc6ce8847e3f2" + }, + { + "path": "review/extension/full_graph_library.py", + "bytes": 6126, + "sha256": "114e3bf3197c618aa17faf8d2d232a3d52ba8d973cf7514f6edd55c1f973f0af", + "git_blob": "8b104b6ce54019598d8d365fac0352ca475a9cf0" + }, { "path": "verify.py", "bytes": 13831, diff --git a/research/sharp-finite-gaussian-outward-slack/README.md b/research/sharp-finite-gaussian-outward-slack/README.md index 9525b074b4..927111d98f 100644 --- a/research/sharp-finite-gaussian-outward-slack/README.md +++ b/research/sharp-finite-gaussian-outward-slack/README.md @@ -1,54 +1,62 @@ -# Sharp finite Gaussian outward slack - -This package proves and checks the exact radius-five finite optimum -\(\beta=\sqrt{21}-\sqrt{19}\) for injective integer-output rounding of -\(H_4/2\) at Euclidean error at most one. A signed-permutation identity -transfers the finite optimum and global necessary lower bound to #6509's -actual ideal Gaussian pair map. - -## Files - -- `PROOF.md`: the finite matching, strict Hall obstruction, and exact native - pair transfer. -- `R5-OPTIMUM.json.gz`: compact, exact certificate containing the 3,121-pair - injection and Hall witness. Its expansion is pinned by SHA-256 in - `SOURCES.json`. -- `replay.py`: deterministic exact expansion of the compressed certificate; - the default command verifies and prints a receipt without writing files. -- `verify.py`: independent exact checker for the injection, Hall neighborhood, - signed-permutation transfer, and negative controls. It imports no search or - author checker. -- `RESULT.json`: receipt from the standard-library checker. -- `SOURCES.json`, `NOTICE.md`, `VERIFY.md`, `OPEN-NEXT-QUESTIONS.md`, and - `PR-DRAFT.md`: provenance, credits, replay instructions, scope, and draft - publication text. -- `compact-hall/`: a certificate-independent, two-exclusion \(W(D_4)\)-orbit - lower-bound checker plus the full orbit-capacity min-cut cross-check. -- `CHECKSUMS.sha256`: freeze manifest for package files, excluding itself and - transient Python caches. - -## Reproduction - -Requires Python 3.10+ and only the standard library. From this directory: +# Exact finite Gaussian outward slack -```sh -python3 -B replay.py -python3 -B verify.py -python3 -O -B verify.py -python3 -B compact-hall/check.py -``` +This package proves exact finite optima for injective integer-output +rounding of \(U=H_4/2\) with Euclidean error at most one. For +\(S_R=\{x\in\mathbb Z^4:\|x\|_2\le R\}\), the verified optima are: + +| Radius | Inputs | Optimal outward slack | Strict Hall witness size | +|---:|---:|---|---:| +| 5 | 3,121 | \(\sqrt{21}-\sqrt{19}\) | 1,809 / 1,777 | +| 6 | 6,577 | \(\sqrt{31}-\sqrt{28}\) | 3,569 / 3,537 | +| 7 | 11,833 | \(\sqrt{31}-\sqrt{28}\) | 3,569 / 3,537 | +| 9 | 32,633 | \(\sqrt{78}-\sqrt{73}\) | 23,561 / 23,497 | +| 11 | 72,465 | \(\sqrt{78}-\sqrt{73}\) | 23,561 / 23,497 | + +The same value at radii 9 and 11 implies the radius-10 optimum by set +inclusion; radius 10 was not separately computed. A signed-permutation +identity transfers these finite results and the necessary global lower +bound to #6509's ideal Gaussian pair and its conjugate. + +The global outward-slack infimum at error cap one is consequently in +\([\sqrt{78}-\sqrt{73},1]\), using the inherited #6509 construction for +the upper endpoint. No global map attaining the lower endpoint is supplied. +All five selected multiplication assumptions remain; no new kappa is claimed. + +## Proof and verification modules -To write the expanded certificate to a chosen path, use -`python3 -B replay.py --write-certificate /tmp/R5-OPTIMUM.json`. To refresh -the committed checker receipt, redirect the exact verifier output to -`RESULT.json` explicitly. Normal verification is read-only. +`PROOF.md`, `R5-OPTIMUM.json.gz`, `verify.py` and `compact-hall/` retain the +original radius-five result and compact two-exclusion Hall proof. The +original proof, draft and review discuss that module's earlier lower bound. +Their scientific inputs and code are unchanged by the extension. -The result establishes the exact optimum on the complete finite ball \(S_5\) -and a necessary global lower bound. At the global error cap one, the available -interval is only \([\sqrt{21}-\sqrt{19},1]\). No global map attaining the -lower endpoint is provided. +`orbit-extension/` contains the four later, explicitly bounded radius checks, +full positive quotient-flow certificates and strict Hall orbit predicates. +Its proof shows why flow between paired signed-coordinate orbits lifts to +an actual finite injection: each orbit-pair edge relation is biregular, so +uniformly distributed flow supplies a fractional matching, hence Hall's +inequality. No complete-bipartite assumption is made for an orbit pair. + +`review/extension/` contains an independent full-point certificate checker +that imports no author generator or comparator, and an independent full +radius-nine matching. Both methods agree with the extension. The standalone +radius-five compact check does not read the original matching certificate. + +## Read-only reproduction + +Python 3.10+ and the standard library suffice. From this directory: + +```sh +python3 -I -B verify.py +python3 -I -B compact-hall/check.py +python3 -I -B orbit-extension/verify.py +python3 -I -O -B orbit-extension/verify.py +python3 -I -B review/extension/check_full_certificates.py +python3 -I -B review/extension/check_full_r9.py +``` -The compact Hall checker establishes the finite lower bound without reading -the matching certificate or its original Hall list. Its separate quotient -replay uses the pinned certificate and exact verifier to cross-check the -complete orbit min-cut and equality of the short-form neighborhood. +The four-radius search is reproducible with +`python3 -I -B orbit-extension/sweep.py`; redirect its output to a temporary +file to compare against `orbit-extension/RESULT.json`. Default checks do not +write files. Exact source pins, search coverage, controls, limitations and +AI/predecessor credit are retained. `PR-DESCRIPTION.md` is the current full +proposed description; `PR-DRAFT.md` is the original R5-only draft. diff --git a/research/sharp-finite-gaussian-outward-slack/SEARCH-PROVENANCE.md b/research/sharp-finite-gaussian-outward-slack/SEARCH-PROVENANCE.md index 1bd2e1b04b..6d69c75368 100644 --- a/research/sharp-finite-gaussian-outward-slack/SEARCH-PROVENANCE.md +++ b/research/sharp-finite-gaussian-outward-slack/SEARCH-PROVENANCE.md @@ -34,3 +34,17 @@ Prepared for @CubeJerry with substantial OpenAI Astra/Sol/Luna assistance. Credit #6619, #2589 and #6509 for the preceding question, finite-sphere method and Gaussian pair construction. Exact scientific dependencies remain pinned in SOURCES.json and the proof documents. + + +## Later bounded extension + +After publication of the R5 package at +`9c75d0b4b6e1cfe74694edf52f2f238a741bbaf5`, a fresh allocation evaluated +only radii6,7,9,11. Its exact graph counts, attained gaps, binary probes, +positive flows, strict cuts and untouched regions are in +`orbit-extension/SEARCH-PROVENANCE.md` and `orbit-extension/RESULT.json`. +The root independently expanded all individual points and candidate edges +at all four radii and checked capacities, flows and complete neighborhoods. +A separate full-vertex maximum matching confirms the radius-nine optimum. +The radius-ten statement is a monotonicity deduction, not an extra search. +The initial R3/R4/R5 search coverage described above remains unchanged. diff --git a/research/sharp-finite-gaussian-outward-slack/orbit-extension/CHECKSUMS.sha256 b/research/sharp-finite-gaussian-outward-slack/orbit-extension/CHECKSUMS.sha256 new file mode 100644 index 0000000000..2fd34b8f5f --- /dev/null +++ b/research/sharp-finite-gaussian-outward-slack/orbit-extension/CHECKSUMS.sha256 @@ -0,0 +1,10 @@ +2cc3e738fe82ef0905d60da810497b1e5d27c0d4a69c9bd45b74921bee4de765 FREEZE.md +d3656b0679dcfd9d8935d2175987a722f7266f75599537d4b8154a40262e52d1 NOTICE.md +b23eef8709c7a5027d0dc77134cc4a9b0d65bdf7d664b426030d1c0875c08154 OPEN-NEXT-QUESTIONS.md +27399559bdbe52e425dc169c3f58a6ce7581b33fd3be2457df46c9e9d94e5749 PROOF.md +32c828d75871bfd812109d957f738427cc6f5e85db4835e5e0c293390bff5d00 README.md +f6b3c5be0fd3e619dbbc44496ebef11d0f06ff5f5c1364e854020505baac85ef RESULT.json +16a763b3369614f511778b47a871550a638852a5541fc6526beb1e175271f631 SEARCH-PROVENANCE.md +31d13db28c45e7a6247798c838188b7e8949f9a0b5bd3703c40cc114967020ac SOURCES.json +c3eea3f6c9786406cb2448e25f388a140ee782175eb16225e58590f9cf2c5fd4 sweep.py +2bbcd0c87545bbb8054e52cd8dd15bd142031a4bc49bae104e4ed208de4709e4 verify.py diff --git a/research/sharp-finite-gaussian-outward-slack/orbit-extension/FREEZE.md b/research/sharp-finite-gaussian-outward-slack/orbit-extension/FREEZE.md new file mode 100644 index 0000000000..9994dd7945 --- /dev/null +++ b/research/sharp-finite-gaussian-outward-slack/orbit-extension/FREEZE.md @@ -0,0 +1,75 @@ +# Frozen finite-radii orbit-flow result + +## Scope lock + +This package evaluates only the following finite graphs: + +- \(H_4/2\), Gaussian integer inputs, Euclidean error cap \(1\). +- Radii \(R=6,7,9,11\), with target thresholds beta_2 at \(R=6\) and + beta_3, beta_4, beta_5 at \(R=7,9,11\), respectively. +- No other radius, operator, or error cap was evaluated. + +The bounded search provenance, all gap counts, binary-search indices, exact +flow probes, positive quotient flows, orbit capacities, and full Hall-cut +orbit predicates are frozen in RESULT.json and summarized in +SEARCH-PROVENANCE.md. The matching lift and complete-neighborhood argument +are proved in PROOF.md. + +## Frozen hashes + +| Artifact or replay | SHA-256 | +|---|---| +| RESULT.json | f6b3c5be0fd3e619dbbc44496ebef11d0f06ff5f5c1364e854020505baac85ef | +| Normal isolated sweep output | f6b3c5be0fd3e619dbbc44496ebef11d0f06ff5f5c1364e854020505baac85ef | +| Optimized isolated sweep output | f6b3c5be0fd3e619dbbc44496ebef11d0f06ff5f5c1364e854020505baac85ef | +| Normal isolated verifier output | 5669fb69c55a3ede5cd907f59c892ef1e1f020932fc3654af9c1d62c05fb26ca | +| Optimized isolated verifier output | 5669fb69c55a3ede5cd907f59c892ef1e1f020932fc3654af9c1d62c05fb26ca | +| sweep.py | c3eea3f6c9786406cb2448e25f388a140ee782175eb16225e58590f9cf2c5fd4 | +| verify.py | 2bbcd0c87545bbb8054e52cd8dd15bd142031a4bc49bae104e4ed208de4709e4 | + +The normal and optimized sweep receipts are byte-identical. The normal and +optimized verifier summaries are byte-identical. Both isolated verification +runs reject the incremented-flow and deleted-neighbor negative controls. +The exact radical gap ordering also agreed with an independent 100-digit +Decimal adjacent-order check at all four radii; this is a numerical sanity +check, not part of the exact proof. + +## Independent review receipts + +The exact RESULT.json digest above is the receipt digest checked by the +separate full-point verifier at +/workspace/scratch/92c9920affc2/root-work/finite-orbit-review/. That +checker does not import the orbit generator or radical comparator; it +independently enumerated individual points and edges, checked orbit +capacities, positive-flow conservation, complete Hall neighborhoods, and +three mutation/tie controls per radius. Its review summary has SHA-256 +68899512d88b253dfb42978e3aa450d2f6a424ce8265757625e92075a18663f3. +The parent separately confirmed the R9 full-vertex matching and strict +deficit. + +## Source pins + +- Canonical CrocSwap base: e54523517d0f03e58352e647c403a5af3e525a57. +- Published R5 workstream context: 9c75d0b4b6e1cfe74694edf52f2f238a741bbaf5. +- Predecessors and author attribution: SOURCES.json and NOTICE.md. + +## Replay + +Run from this directory: + +~~~~sh +python3 -I -B sweep.py > /tmp/finite-radii-result-normal.json +python3 -I -O -B sweep.py > /tmp/finite-radii-result-optimized.json +cmp /tmp/finite-radii-result-normal.json RESULT.json +cmp /tmp/finite-radii-result-optimized.json RESULT.json +python3 -I -B verify.py +python3 -I -O -B verify.py +~~~~ + +verify.py loads the sibling sweep.py bytes directly with compile/exec, so +isolated mode does not depend on ambient import paths or stale bytecode. +CHECKSUMS.sha256 pins every package artifact except itself. + +This freeze makes no inference about untested radii, no global construction, +and no multiplication-frontier or kappa claim. It is a bounded evidence +package for review and integration. diff --git a/research/sharp-finite-gaussian-outward-slack/orbit-extension/NOTICE.md b/research/sharp-finite-gaussian-outward-slack/orbit-extension/NOTICE.md new file mode 100644 index 0000000000..37f15d0085 --- /dev/null +++ b/research/sharp-finite-gaussian-outward-slack/orbit-extension/NOTICE.md @@ -0,0 +1,32 @@ +# Provenance and credit + +This bounded sweep is a follow-on check in the finite Gaussian-rounding +thread. It uses the same explicit Hadamard operator (H_4/2) and the +paired (W(D_4)) symmetry documented in the R5 package next door, but it +does not load or depend on the R5 matching certificate. + +Relevant prior work and attribution: + +- CrocSwap/integer-mult-bounds canonical base: commit + `e54523517d0f03e58352e647c403a5af3e525a57`. +- PR #6509, Ali Romman, head + `a4173e810c4d34a1d13b9745af123ad0ec6cfed5`, + `research/conservative-gaussian-rounding/PROOF.md`, Git blob + `b7047476aaa5e2bb149c92a8a40a9b2ab444ef73`. +- PR #6619, Nick Petalas, head + `eaa967e7e8aa12cc53ec246a5fc00c5f8873a50b`, + `research/rational-norm-rounding/PROOF.md`, Git blob + `ffb873b2749b1590df9267e802aea5af2c2a6eb5`. +- PR #2589, ywz65, the finite-sphere predecessor cited by #6619. +- @CubeJerry, R5 candidate workstream and exact compact (W(D_4)) orbit + proof that motivated these four bounded probes, published at commit + 9c75d0b4b6e1cfe74694edf52f2f238a741bbaf5. The corresponding local + proof is + `../sharp-finite-gaussian-outward-slack/compact-hall/PROOF.md` + (SHA-256 `c0a9ee164d3a466a4b3996e1075ef7443123ac5e99b0e4e9e05585411352ad21`). + Its R5 certificate has expanded SHA-256 + `b1fe3d866d2184227f46ec73ec2021c546bba056e98077e657e9205d9db5ad8b`. + +The new finite calculations and write-up were prepared with substantial +OpenAI Codex assistance. No claim here replaces the cited predecessor +results or extends them beyond the four enumerated radii. diff --git a/research/sharp-finite-gaussian-outward-slack/orbit-extension/OPEN-NEXT-QUESTIONS.md b/research/sharp-finite-gaussian-outward-slack/orbit-extension/OPEN-NEXT-QUESTIONS.md new file mode 100644 index 0000000000..15851d4f4d --- /dev/null +++ b/research/sharp-finite-gaussian-outward-slack/orbit-extension/OPEN-NEXT-QUESTIONS.md @@ -0,0 +1,14 @@ +# Open questions after the bounded sweep + +- Whether the finite optima at (R=6,7,9,11) reflect any theorem for other + radii remains open. No other radius was evaluated. +- The β-a family is only probed at (R=7,9,11), and the inherited + β₂ threshold is only probed at (R=6). These checks neither prove nor + refute a general formula. +- A quotient flow proves existence of an integral finite injection through + bipartite matching polytope integrality; this package does not provide a + closed-form assignment rule. +- This bounded numerical result alone does not merit a separate PR. The + reusable orbit quotient, exact capacity accounting, flow certificates, + and Hall-cut receipts may be reviewed for integration into the existing + finite-rounding branch. diff --git a/research/sharp-finite-gaussian-outward-slack/orbit-extension/PROOF.md b/research/sharp-finite-gaussian-outward-slack/orbit-extension/PROOF.md new file mode 100644 index 0000000000..4aa6ad9d2f --- /dev/null +++ b/research/sharp-finite-gaussian-outward-slack/orbit-extension/PROOF.md @@ -0,0 +1,172 @@ +# Exact finite quotient-flow proof + +## Claim and exact scope + +Let + +\[ +H=\begin{pmatrix} +1&1&1&1\\1&-1&1&-1\\1&1&-1&-1\\1&-1&-1&1 +\end{pmatrix},\qquad U=H/2. +\] + +For each of (R=6,7,9,11), form the finite bipartite graph whose left side is + +\[ +S_R=\{x\in\mathbb Z^4:\|x\|_2\le R\}, +\] + +and whose right side is the union of integer (y) for which +\(\|y-Ux\|_2\le1\) for some (x\in S_R\). Join (x) to each such (y). +Give an edge the exact outward gap +\(\|y\|_2-\|x\|_2=\sqrt{m}-\sqrt{n}\), where (m=\|y\|_2^2\) and +\(n=\|x\|_2^2\). + +The exact optimum is \(\sqrt{31}-\sqrt{28}\) at (R=6,7), and +\(\sqrt{78}-\sqrt{73}\) at (R=9,11). At each reported optimum the +inclusive edge graph has a matching saturating all inputs, while the strict +edge graph has the Hall cut listed in `RESULT.json`, with deficiencies +32, 32, 64, 64 respectively. Therefore no smaller maximum edge gap is +possible in these four finite domains. At the separately tested thresholds, +\(\sqrt{21}-\sqrt{19}\) for (R=6), \(\sqrt{43}-\sqrt{39}\) for (R=7), +\(\sqrt{73}-\sqrt{67}\) for (R=9), and \(\sqrt{111}-\sqrt{103}\) for +\(R=11), the first graph is infeasible and the remaining three are +feasible. + +## The paired (W(D_4)) action + +Let (A) be a signed permutation of four coordinates with an even number +of sign changes. Set + +\[ +B=HAH^T/4. +\] + +The complete finite group check in `sweep.py` examines all 384 signed +permutation matrices (A). Exactly 192 induce integral signed-permutation +matrices (B); both projections are the 192-element group +\(W(D_4)\), the signed permutations with sign product (+1). For every +paired element, (BH=HA), so (BU=UA). Since (A,B) are orthogonal, the +action \((x,y)\mapsto(Ax,By)\) preserves both norms and the error +\(\|y-Ux\|_2\). This is the group action used below; no claim about +non-signed-permutation graph automorphisms is needed. + +## Orbit construction and capacities + +An orbit is encoded by the sorted tuple of absolute coordinates. If no +coordinate is zero, the product of coordinate signs is also part of its +key; the two product-sign classes are distinct. If a zero is present, its +sign absorbs parity and the pattern is one orbit. For a pattern with +multiplicities (m_r) and zero multiplicity (m_0), its exact capacity is + +\[ +\frac{4!}{m_0!\prod_{r>0}m_r!}\,2^{4-m_0} +\quad(m_0>0), +\qquad +\frac{4!}{\prod_{r>0}m_r!}\,2^3 +\quad(m_0=0,\text{ for each sign-product class}). +\] + +The generator visits nonnegative sorted-coordinate patterns of squared norm +at most (R^2), then makes one orbit key per zero-containing pattern or two +keys per nonzero pattern. It checks the capacity sum for the input and +candidate-output universes. The JSON receipt preserves every representative +and capacity, so each cut's orbit predicate is the listed union of keys. + +For a representative (x), each coordinate of (Hx) has parity +\(\sum_i x_i\pmod2\). If the sum is even, (Ux\in\mathbb Z^4), and the +complete set of integer outputs within distance one consists of the center +and its eight signed unit displacements: 9 candidates. If the sum is odd, +all four coordinates of (Ux) are half-integers; the complete set consists +of all 16 nearest-integer corners, each at squared error one. The group +action transports this complete neighbor set over the orbit. Thus the +enumeration at representatives constructs the full candidate graph. + +## Quotient graph, matching lift, and Hall cuts + +For any input orbit (I) and output orbit (O), adjacency is the invariant +relation “some point of (I) is joined to some point of (O).” The paired +group is transitive on each orbit, so each adjacent orbit pair is biregular: +every input point has the same number of neighbors in (O), and every +output point has the same number of neighbors in (I). The implementation +checks the exact double-count identity +\(|I|d_I=|O|d_O\) by requiring divisibility of the computed left degree by +\(|O|). Norms are constant on orbits, so every edge in an orbit pair has +the same exact gap. + +The quotient network has source-to-input capacity \(|I|\), output-to-sink +capacity \(|O|\), and one input-to-output edge for each active adjacent orbit +pair, with capacity greater than the sum of all finite node capacities. A +maximum flow of value \(|S_R|\) is a complete positive certificate when its +per-orbit-pair amounts conserve at each orbit and respect all sink +capacities. Those integer certificates are recorded in `RESULT.json` and +checked by `verify.py`. + +To lift such a quotient flow (f_{I,O}), put the constant weight +\(f_{I,O}/|E(I,O)|\) on each individual edge in that orbit pair. If +\(E(I,O)\) is its edge set, biregularity gives each input vertex total +fractional degree + +\[ +\sum_O\frac{f_{I,O}}{|I|}=1, +\] + +because the source orbit is saturated. Each output vertex has degree +\(\sum_I f_{I,O}/|O|\le1\), because its sink capacity is (|O|). This is a +fractional matching saturating the left side. For any set (T) of input +points, the total edge weight leaving (T) is (|T|), and it is at most the +total weight incident to its neighbors, which is at most (|N(T)|). Thus +Hall's condition holds, and Hall's theorem gives an actual injection +saturating every input. Conversely any injection induces a quotient flow, +so flow saturation is an exact feasibility test. + +For each recorded lower-bound cut, let (T) be its selected input orbits. +The result checker enumerates every active quotient adjacency out of (T) +and verifies that the stored output-orbit set is exactly (N(T)); this checks +the complete lifted neighborhood directly, without relying on min-cut +optimality. If the input and neighbor capacities are (t) and (n), the +corresponding Hall deficiency is (t-n). Every reported infeasible result +has (t-n>0), so this explicit union of input orbits proves that no injection +can exist. + +## Exact gaps and finite optimum + +All squared norms in an edge are nonnegative integers, so every gap is an +exact expression \(\sqrt m-\sqrt n\). The comparator reduces comparisons +to inequalities between sums of two square roots and decides them using +integer additions, products, and squares. In particular, for +\(\sqrt a+\sqrt b\le\sqrt c+\sqrt d\), set +\(k=c+d-a-b\), (P=ab), and (Q=cd). Squaring the nonnegative sides once +reduces the question to \(2(\sqrt P-\sqrt Q)\le k\). When (k\ge0), +\(P\le Q\) suffices; if (P>Q), put +\(e=4(P-Q)-k^2\): the inequality holds if (e\le0\), otherwise exactly +when \(e^2\le16k^2Q\). When (k<0), put (r=-k); the inequality holds +exactly when \(e=4(Q-P)-r^2\ge0\) and \(e^2\ge16r^2P\). This avoids +floating-point threshold decisions. + +The script sorts the finite set of attainable edge gaps by this comparator +and binary-searches the first gap whose inclusive quotient flow saturates +all inputs. At that gap it records a positive flow certificate. The strict +predecessor graph has an exact Hall cut with positive deficiency. Every +smaller threshold graph is a subgraph of that strict predecessor graph, so +the pair of receipts proves the stated exact finite optimum. + +## Reproduction, controls, and limits + +Run `python3 -I -B sweep.py > /tmp/finite-radii-result.json` and compare +that file with the frozen RESULT.json. Run `python3 -I -B verify.py` and +`python3 -I -O -B verify.py` to check all four radii and deliberately reject +(i) an incremented positive orbit-pair flow and (ii) a cut with one neighbor +orbit removed. Both sweep modes produce identical bytes; both verifier modes +produce identical summaries. The checker loads the local sweep source bytes +with compile/exec, independent of ambient import paths or cached bytecode. + +This is finite evidence restricted to the four named radii, (U=H_4/2), +and error cap one. It establishes no general radius pattern, global +construction, multiplication bound, or new kappa claim. The R5 source and +compact (W(D_4)) proof that motivated this extension are pinned to the +published R5 workstream commit +9c75d0b4b6e1cfe74694edf52f2f238a741bbaf5. Its local review copy is +../sharp-finite-gaussian-outward-slack/compact-hall/PROOF.md; the +canonical analysis base for this sweep is CrocSwap commit +e54523517d0f03e58352e647c403a5af3e525a57. diff --git a/research/sharp-finite-gaussian-outward-slack/orbit-extension/README.md b/research/sharp-finite-gaussian-outward-slack/orbit-extension/README.md new file mode 100644 index 0000000000..6b288d663f --- /dev/null +++ b/research/sharp-finite-gaussian-outward-slack/orbit-extension/README.md @@ -0,0 +1,46 @@ +# Bounded W(D4) orbit-flow sweep + +This package records exact finite matching evidence for (U=H_4/2), error +cap one, on only the Gaussian integer balls (S_R) with (R=6,7,9,11). +The script constructs sorted-absolute-coordinate/product-sign orbit +representatives and their exact (W(D_4)) capacities; it never enumerates all +points and then applies 192 group elements. + +## Results + +| Radius | Inputs / candidate outputs | Tested threshold | Threshold flow / inputs | Exact finite optimum | Strict optimum cut \(|T|/|N(T)|\) | +|---:|---:|---|---:|---|---:| +| 6 | 6,577 / 10,713 | \(\sqrt{21}-\sqrt{19}\) (inherited beta_2) | 6,545 / 6,577 | \(\sqrt{31}-\sqrt{28}\) | 3,569 / 3,537 (deficit 32) | +| 7 | 11,833 / 18,457 | \(\sqrt{43}-\sqrt{39}\) (beta_3) | 11,833 / 11,833 | \(\sqrt{31}-\sqrt{28}\) | 3,569 / 3,537 (deficit 32) | +| 9 | 32,633 / 46,401 | \(\sqrt{73}-\sqrt{67}\) (beta_4) | 32,633 / 32,633 | \(\sqrt{78}-\sqrt{73}\) | 23,561 / 23,497 (deficit 64) | +| 11 | 72,465 / 96,449 | \(\sqrt{111}-\sqrt{103}\) (beta_5) | 72,465 / 72,465 | \(\sqrt{78}-\sqrt{73}\) | 23,561 / 23,497 (deficit 64) | + +The exact orbit-flow and Hall-cut receipts, including every orbit capacity, +positive quotient flow, and complete cut neighborhood, are in +[`RESULT.json`](RESULT.json). A quotient matching lifts to a full finite +injection by distributing each orbit-pair flow uniformly over its +biregular edge set and applying Hall's theorem; the proof is in +[`PROOF.md`](PROOF.md). + +## Replay + +From this directory, run: + +```sh +python3 -I -B sweep.py > /tmp/finite-radii-result.json +cmp /tmp/finite-radii-result.json RESULT.json +python3 -I -B verify.py +python3 -I -O -B verify.py +``` + +`verify.py` checks flow conservation, orbit capacities, target and optimum +cuts, exact complete neighborhoods, and two deliberately corrupted +certificates. Its default behavior reads the saved receipt and emits a +summary. The bounded gap search checks 380, 608, 1,287, and 2,346 distinct +attainable radicals at radii 6, 7, 9, and 11, using 9, 10, 11, and 12 exact +flow probes respectively. The sweep result is byte-identical under normal +and optimized Python execution; the frozen output hashes are in FREEZE.md. + +No PR is proposed from these bounded radius checks alone. The results are +finite evidence only and do not establish a pattern for other radii or a +global construction. diff --git a/research/sharp-finite-gaussian-outward-slack/orbit-extension/RESULT.json b/research/sharp-finite-gaussian-outward-slack/orbit-extension/RESULT.json new file mode 100644 index 0000000000..5feffcc84d --- /dev/null +++ b/research/sharp-finite-gaussian-outward-slack/orbit-extension/RESULT.json @@ -0,0 +1 @@ +{"completed_radii":[{"attainable_gap_count":380,"domain_and_graph":{"all_quotient_adjacencies":756,"error_one_candidate_output_count":10713,"error_one_edge_count":81873,"input_count":6577,"input_orbit_count":98,"output_candidate_orbit_count":142,"representative_count":98,"representative_error_one_candidate_total":1190,"representative_image_parities":{"half_integer":44,"integer":54},"strict_quotient_adjacencies":447,"strict_target_edge_count":48249},"exact_finite_optimum":{"binary_flow_probes":[{"active_quotient_adjacencies":756,"cut_capacity":6577,"deficiency":0,"edge_rule":"gap<=threshold","feasible":true,"flow":6577,"index":379,"input_capacity":6577,"threshold":"sqrt(1)-sqrt(0)","threshold_pair":[1,0]},{"active_quotient_adjacencies":427,"cut_capacity":6449,"deficiency":128,"edge_rule":"gap<=threshold","feasible":false,"flow":6449,"index":189,"input_capacity":6577,"threshold":"sqrt(10)-sqrt(9)","threshold_pair":[10,9]},{"active_quotient_adjacencies":609,"cut_capacity":6577,"deficiency":0,"edge_rule":"gap<=threshold","feasible":true,"flow":6577,"index":284,"input_capacity":6577,"threshold":"sqrt(37)-sqrt(30)","threshold_pair":[37,30]},{"active_quotient_adjacencies":519,"cut_capacity":6577,"deficiency":0,"edge_rule":"gap<=threshold","feasible":true,"flow":6577,"index":236,"input_capacity":6577,"threshold":"sqrt(16)-sqrt(13)","threshold_pair":[16,13]},{"active_quotient_adjacencies":472,"cut_capacity":6545,"deficiency":32,"edge_rule":"gap<=threshold","feasible":false,"flow":6545,"index":212,"input_capacity":6577,"threshold":"sqrt(4)-sqrt(3)","threshold_pair":[4,3]},{"active_quotient_adjacencies":496,"cut_capacity":6577,"deficiency":0,"edge_rule":"gap<=threshold","feasible":true,"flow":6577,"index":224,"input_capacity":6577,"threshold":"sqrt(39)-sqrt(35)","threshold_pair":[39,35]},{"active_quotient_adjacencies":486,"cut_capacity":6577,"deficiency":0,"edge_rule":"gap<=threshold","feasible":true,"flow":6577,"index":218,"input_capacity":6577,"threshold":"sqrt(26)-sqrt(23)","threshold_pair":[26,23]},{"active_quotient_adjacencies":481,"cut_capacity":6577,"deficiency":0,"edge_rule":"gap<=threshold","feasible":true,"flow":6577,"index":215,"input_capacity":6577,"threshold":"sqrt(29)-sqrt(26)","threshold_pair":[29,26]},{"active_quotient_adjacencies":476,"cut_capacity":6577,"deficiency":0,"edge_rule":"gap<=threshold","feasible":true,"flow":6577,"index":213,"input_capacity":6577,"threshold":"sqrt(31)-sqrt(28)","threshold_pair":[31,28]}],"exists":true,"gap_count":380,"optimum_expression":"sqrt(31)-sqrt(28)","optimum_gap_index":213,"optimum_pair":[31,28],"strict_lower_cut":{"active_quotient_adjacencies":472,"cut_capacity":6545,"deficiency":32,"edge_rule":"gap None: + if not condition: + raise RuntimeError(explanation) + + +def norm_squared(point): + return sum(value * value for value in point) + + +def orbit_key(point): + pattern = tuple(sorted(abs(value) for value in point)) + if 0 in point: + return pattern, None + product = 1 + for value in point: + product *= 1 if value > 0 else -1 + return pattern, product + + +def orbit_capacity(key): + pattern, sign_class = key + multiplicities = {} + for value in pattern: + multiplicities[value] = multiplicities.get(value, 0) + 1 + zero_count = multiplicities.pop(0, 0) + denominator = factorial(zero_count) + for multiplicity in multiplicities.values(): + denominator *= factorial(multiplicity) + placements = factorial(4) // denominator + sign_choices = 1 << (4 - zero_count) + if zero_count == 0: + require(sign_class in (-1, 1), "nonzero orbit needs a product-sign class") + sign_choices //= 2 + else: + require(sign_class is None, "zero-containing orbit has no sign-product class") + return placements * sign_choices + + +def canonical_rep(key): + pattern, sign_class = key + if sign_class is None: + return pattern + if sign_class == 1: + return pattern + return (-pattern[0], pattern[1], pattern[2], pattern[3]) + + +def matrix_multiply(left, right): + return tuple( + tuple(sum(left[i][k] * right[k][j] for k in range(4)) + for j in range(4)) + for i in range(4) + ) + + +def matrix_transpose(matrix): + return tuple(tuple(matrix[i][j] for i in range(4)) for j in range(4)) + + +def is_signed_permutation(matrix): + return ( + len(matrix) == 4 + and all(len(row) == 4 for row in matrix) + and all(sum(abs(value) for value in row) == 1 for row in matrix) + and all(sum(abs(matrix[i][j]) for i in range(4)) == 1 + for j in range(4)) + ) + + +def signed_permutations(even_signs_only=False): + result = [] + for permutation in itertools.permutations(range(4)): + for signs in itertools.product((-1, 1), repeat=4): + if even_signs_only and signs[0] * signs[1] * signs[2] * signs[3] != 1: + continue + matrix = [[0] * 4 for _ in range(4)] + for row, column in enumerate(permutation): + matrix[row][column] = signs[row] + result.append(tuple(tuple(row) for row in matrix)) + return result + + +def graph_group_check(): + w_d4 = set(signed_permutations(even_signs_only=True)) + all_signed = set(signed_permutations(even_signs_only=False)) + ht = matrix_transpose(H) + pairs = [] + input_projection = set() + output_projection = set() + for a in sorted(all_signed): + numerator = matrix_multiply(matrix_multiply(H, a), ht) + if not all(value % 4 == 0 for row in numerator for value in row): + continue + b = tuple(tuple(value // 4 for value in row) for row in numerator) + if not is_signed_permutation(b): + continue + require(matrix_multiply(b, H) == matrix_multiply(H, a), + "paired action fails B H=H A") + pairs.append((a, b)) + input_projection.add(a) + output_projection.add(b) + require(len(w_d4) == 192 and len(all_signed) == 384, + "signed-permutation group cardinality changed") + require(input_projection == w_d4, + "complete paired input projection is not exactly W(D4)") + require(output_projection == w_d4, + "complete paired output projection is not exactly W(D4)") + require(len(pairs) == 192, + "complete paired signed-permutation graph group is not W(D4)") + return { + "W4_order": len(all_signed), + "paired_group_order": len(pairs), + "input_projection_order": len(w_d4), + "output_projection_order": len(output_projection), + } + + +def input_orbits(radius): + patterns = { + tuple(sorted(values)) + for values in itertools.product(range(radius + 1), repeat=4) + if sum(value * value for value in values) <= radius * radius + } + orbits = [] + for pattern in sorted(patterns): + if 0 in pattern: + keys = [(pattern, None)] + else: + keys = [(pattern, 1), (pattern, -1)] + for key in keys: + capacity = orbit_capacity(key) + rep = canonical_rep(key) + require(norm_squared(rep) <= radius * radius, + "input representative is outside the radius ball") + orbits.append({ + "key": key, + "representative": rep, + "capacity": capacity, + "norm_squared": norm_squared(rep), + }) + return orbits + + +def error_one_candidates(point): + hx = tuple(sum(H[i][j] * point[j] for j in range(4)) for i in range(4)) + parity = sum(point) & 1 + require(all((value & 1) == parity for value in hx), + "Hadamard image coordinates do not have common parity") + if parity == 0: + center = tuple(value // 2 for value in hx) + candidates = {center} + for coordinate in range(4): + for sign in (-1, 1): + output = list(center) + output[coordinate] += sign + candidates.add(tuple(output)) + require(len(candidates) == 9, "integer image must have nine neighbors") + else: + lower = tuple(value // 2 for value in hx) + candidates = { + tuple(lower[i] + bits[i] for i in range(4)) + for bits in itertools.product((0, 1), repeat=4) + } + require(len(candidates) == 16, "half-integer image must have sixteen neighbors") + for output in candidates: + error_num = sum((2 * output[i] - hx[i]) ** 2 for i in range(4)) + require(error_num <= 4, "candidate violates error cap one") + if parity: + require(error_num == 4, "half-integer neighbor has nonunit error") + return sorted(candidates), parity + + +def sum_sqrt_le(a, b, c, d): + """Exact decision for sqrt(a)+sqrt(b) <= sqrt(c)+sqrt(d).""" + require(min(a, b, c, d) >= 0, "negative square-root radicand") + k = c + d - a - b + p = a * b + q = c * d + if k >= 0: + if p <= q: + return True + if k == 0: + return False + e = 4 * (p - q) - k * k + if e <= 0: + return True + return e * e <= 16 * k * k * q + r = -k + e = 4 * (q - p) - r * r + if e < 0: + return False + return e * e >= 16 * r * r * p + + +def compare_gaps(m, n, a, b): + """Sign of (sqrt(m)-sqrt(n))-(sqrt(a)-sqrt(b)).""" + left_le = sum_sqrt_le(m, b, a, n) + right_le = sum_sqrt_le(a, n, m, b) + require(left_le or right_le, "exact gap comparison is inconsistent") + if left_le and right_le: + return 0 + return -1 if left_le else 1 + + +def gap_label(pair): + m, n = pair + return f"sqrt({m})-sqrt({n})" + + +def compare_pair(left, right): + return compare_gaps(left[0], left[1], right[0], right[1]) + + +def prepare_radius(radius): + inputs = input_orbits(radius) + input_index = {orbit["key"]: i for i, orbit in enumerate(inputs)} + output_caps = {} + pair_degrees = {} + pair_gaps = {} + all_gaps = [] + total_error_edges = 0 + total_strict_edges_at_half = 0 + representative_candidate_total = 0 + representative_parity_counts = {"integer": 0, "half_integer": 0} + representatives = [] + + for i, orbit in enumerate(inputs): + rep = orbit["representative"] + candidates, parity = error_one_candidates(rep) + representative_parity_counts["integer" if parity == 0 else "half_integer"] += 1 + representative_candidate_total += len(candidates) + total_error_edges += orbit["capacity"] * len(candidates) + degrees = {} + gaps = {} + for output in candidates: + key = orbit_key(output) + capacity = orbit_capacity(key) + if key in output_caps: + require(output_caps[key] == capacity, + "output orbit capacity is inconsistent") + output_caps[key] = capacity + jgap = (norm_squared(output), orbit["norm_squared"]) + all_gaps.append(jgap) + pair_key = (i, key) + if pair_key in gaps: + require(gaps[pair_key] == jgap, + "one output orbit produced incompatible norm gaps") + degrees[key] = degrees.get(key, 0) + 1 + gaps[pair_key] = jgap + for output_key, degree in degrees.items(): + # Output orbit indices are assigned after collecting all keys. + pair_degrees[(i, output_key)] = degree + pair_gaps[(i, output_key)] = gaps[(i, output_key)] + representatives.append({ + "input_orbit_index": i, + "input_key": orbit["key"], + "representative": rep, + "orbit_capacity": orbit["capacity"], + "candidate_count": len(candidates), + "image_parity": "integer" if parity == 0 else "half_integer", + }) + + output_keys = sorted(output_caps) + output_index = {key: j for j, key in enumerate(output_keys)} + output_orbits = [ + {"key": key, "capacity": output_caps[key], + "norm_squared": sum(value * value for value in key[0])} + for key in output_keys + ] + quotient_edges = [] + pair_degree_indexed = {} + pair_gap_indexed = {} + for (i, key), degree in sorted(pair_degrees.items(), key=lambda item: (item[0][0], output_index[item[0][1]])): + j = output_index[key] + gap = pair_gaps[(i, key)] + pair_degree_indexed[(i, j)] = degree + pair_gap_indexed[(i, j)] = gap + quotient_edges.append((i, j)) + lhs = inputs[i]["capacity"] * degree + output_capacity = output_orbits[j]["capacity"] + require(lhs % output_capacity == 0, + "paired orbit relation is not biregular") + + total_inputs = sum(orbit["capacity"] for orbit in inputs) + total_outputs = sum(orbit["capacity"] for orbit in output_orbits) + require(total_inputs == sum( + orbit["capacity"] for orbit in inputs + ), "input orbit capacities fail their sum") + return { + "radius": radius, + "inputs": inputs, + "input_index": input_index, + "outputs": output_orbits, + "output_index": output_index, + "pair_degree": pair_degree_indexed, + "pair_gap": pair_gap_indexed, + "quotient_edges": quotient_edges, + "all_gaps": all_gaps, + "total_inputs": total_inputs, + "total_outputs": total_outputs, + "error_edge_count": total_error_edges, + "representative_candidate_total": representative_candidate_total, + "representative_parity_counts": representative_parity_counts, + "representatives": representatives, + } + + +class Dinic: + def __init__(self, node_count): + self.graph = [[] for _ in range(node_count)] + + def add_edge(self, source, target, capacity): + forward = [target, capacity, len(self.graph[target])] + reverse = [source, 0, len(self.graph[source])] + self.graph[source].append(forward) + self.graph[target].append(reverse) + return forward + + def max_flow(self, source, sink): + flow = 0 + count = len(self.graph) + while True: + level = [-1] * count + level[source] = 0 + queue = deque([source]) + while queue: + node = queue.popleft() + for target, capacity, _ in self.graph[node]: + if capacity > 0 and level[target] < 0: + level[target] = level[node] + 1 + queue.append(target) + if level[sink] < 0: + return flow + next_edge = [0] * count + + def push(node, available): + if node == sink: + return available + while next_edge[node] < len(self.graph[node]): + index = next_edge[node] + target, capacity, reverse_index = self.graph[node][index] + if capacity > 0 and level[target] == level[node] + 1: + sent = push(target, min(available, capacity)) + if sent: + self.graph[node][index][1] -= sent + self.graph[target][reverse_index][1] += sent + return sent + next_edge[node] += 1 + return 0 + + while True: + sent = push(source, 1 << 60) + if not sent: + break + flow += sent + + def residual_reachable(self, source): + found = {source} + queue = deque([source]) + while queue: + node = queue.popleft() + for target, capacity, _ in self.graph[node]: + if capacity > 0 and target not in found: + found.add(target) + queue.append(target) + return found + + def maximal_source_side(self, sink): + reverse_residual = [[] for _ in self.graph] + for source, edges in enumerate(self.graph): + for target, capacity, _ in edges: + if capacity > 0: + reverse_residual[target].append(source) + can_reach_sink = {sink} + queue = deque([sink]) + while queue: + node = queue.popleft() + for previous in reverse_residual[node]: + if previous not in can_reach_sink: + can_reach_sink.add(previous) + queue.append(previous) + return set(range(len(self.graph))) - can_reach_sink + + +def flow_at(data, threshold, inclusive=True, need_cut=True, + include_flow_certificate=False): + input_count = len(data["inputs"]) + output_count = len(data["outputs"]) + source = 0 + input_offset = 1 + output_offset = input_offset + input_count + sink = output_offset + output_count + network = Dinic(sink + 1) + inf = data["total_inputs"] + data["total_outputs"] + 1 + source_edges = [] + for i, orbit in enumerate(data["inputs"]): + edge = network.add_edge(source, input_offset + i, orbit["capacity"]) + source_edges.append((i, orbit["capacity"], edge)) + active_pairs = [] + pair_edges = [] + for i, j in data["quotient_edges"]: + gap = data["pair_gap"][(i, j)] + comparison = compare_pair(gap, threshold) + if comparison < 0 or (inclusive and comparison == 0): + active_pairs.append((i, j)) + edge = network.add_edge(input_offset + i, output_offset + j, inf) + pair_edges.append((i, j, edge)) + sink_edges = [] + for j, orbit in enumerate(data["outputs"]): + edge = network.add_edge(output_offset + j, sink, orbit["capacity"]) + sink_edges.append((j, orbit["capacity"], edge)) + + value = network.max_flow(source, sink) + feasible = value == data["total_inputs"] + result = { + "threshold_pair": list(threshold), + "threshold": gap_label(threshold), + "edge_rule": "gap<=threshold" if inclusive else "gap 1: + mid = (low + high) // 2 + result = flow_at(data, gaps[mid], inclusive=True, need_cut=False) + probes.append({"index": mid, **result}) + if result["feasible"]: + high = mid + else: + low = mid + optimum = gaps[high] + upper = flow_at(data, optimum, inclusive=True, need_cut=False, + include_flow_certificate=True) + strict_lower = flow_at(data, optimum, inclusive=False, need_cut=True) + require(upper["feasible"], "binary-search optimum is not feasible") + require(not strict_lower["feasible"] and strict_lower["deficiency"] > 0, + "strict predecessor graph lacks a Hall obstruction") + require(high == 0 or not flow_at(data, gaps[high - 1], inclusive=True, + need_cut=False)["feasible"], + "previous attainable gap unexpectedly feasible") + return { + "exists": True, + "gap_count": len(gaps), + "optimum_gap_index": high, + "optimum_pair": list(optimum), + "optimum_expression": gap_label(optimum), + "binary_flow_probes": probes, + "upper_flow": upper, + "strict_lower_cut": strict_lower, + } + + +def target_threshold_tests(data, target): + inclusive = flow_at(data, target, inclusive=True, need_cut=True, + include_flow_certificate=True) + strict = flow_at(data, target, inclusive=False, need_cut=True, + include_flow_certificate=True) + return {"inclusive": inclusive, "strict": strict} + + +def build_radius_record(radius, group_receipt): + data = prepare_radius(radius) + strict_edges = 0 + target = RADIUS_TARGETS[radius] + for (i, j), gap in data["pair_gap"].items(): + if compare_pair(gap, target) < 0: + strict_edges += data["inputs"][i]["capacity"] * data["pair_degree"][(i, j)] + gaps = distinct_sorted_gaps(data["all_gaps"]) + target_tests = target_threshold_tests(data, target) + optimum = binary_optimum(data, gaps) + return { + "radius": radius, + "threshold_family_index": (radius - 1) // 2, + "threshold_interpretation": ( + "inherited beta_2 from the R5 finite theorem" + if radius == 6 else "beta_a with a=(R-1)/2" + ), + "target_threshold": gap_label(target), + "target_pair": list(target), + "domain_and_graph": { + "input_count": data["total_inputs"], + "input_orbit_count": len(data["inputs"]), + "error_one_candidate_output_count": data["total_outputs"], + "output_candidate_orbit_count": len(data["outputs"]), + "error_one_edge_count": data["error_edge_count"], + "strict_target_edge_count": strict_edges, + "strict_quotient_adjacencies": sum( + compare_pair(gap, target) < 0 for gap in data["pair_gap"].values() + ), + "all_quotient_adjacencies": len(data["quotient_edges"]), + "representative_count": len(data["inputs"]), + "representative_error_one_candidate_total": data["representative_candidate_total"], + "representative_image_parities": data["representative_parity_counts"], + }, + "target_threshold_tests": target_tests, + "attainable_gap_count": len(gaps), + "exact_finite_optimum": optimum, + "orbit_capacity_tables": { + "inputs": [ + {"key": encode_key(o["key"]), "representative": list(o["representative"]), + "capacity": o["capacity"], "norm_squared": o["norm_squared"]} + for o in data["inputs"] + ], + "candidate_outputs": [ + {"key": encode_key(o["key"]), "capacity": o["capacity"], + "norm_squared": o["norm_squared"]} + for o in data["outputs"] + ], + }, + } + + +def main(): + group = graph_group_check() + records = [build_radius_record(radius, group) for radius in (6, 7, 9, 11)] + print(json.dumps({ + "status": "PASS", + "scope": "only radii 6, 7, 9, 11 at error cap one for H4/2", + "operator": [list(row) for row in H], + "group": { + **group, + "identified_as": "W(D4): signed permutations with even sign changes", + }, + "construction_and_feasibility_argument": { + "input_and_output_universes": "generated by W(D4) sorted-absolute-coordinate/product-sign orbit representatives and exact capacities; no expansion to all points times 192", + "candidate_neighbors": "9 for integer Ux, 16 for half-integer Ux", + "orbit_pair_adjacency": "paired action makes the bipartite relation biregular on every adjacent orbit pair", + "saturated_flow_lift": "uniform flow on each orbit-pair edge set gives a fractional matching; input degree 1 and output degree at most 1, hence an integral injection exists by bipartite matching polytope integrality", + "lower_bound": "the maximal source side of an exact min cut lifts to a complete union-of-orbits neighborhood with the recorded capacity deficiency", + }, + "completed_radii": records, + "untouched_radii": "all other radii, including 8 and 10, were not evaluated", + "limits": "finite evidence only; no inference about all radii or global maps", + }, sort_keys=True, separators=(",", ":"))) + + +if __name__ == "__main__": + main() diff --git a/research/sharp-finite-gaussian-outward-slack/orbit-extension/verify.py b/research/sharp-finite-gaussian-outward-slack/orbit-extension/verify.py new file mode 100644 index 0000000000..78fbe11fb2 --- /dev/null +++ b/research/sharp-finite-gaussian-outward-slack/orbit-extension/verify.py @@ -0,0 +1,251 @@ +#!/usr/bin/env python3 +"""Verify the saved finite-radius orbit-flow and Hall-cut receipts.""" + +from __future__ import annotations + +import json +from pathlib import Path +from types import ModuleType + +ROOT = Path(__file__).resolve().parent +RESULT = ROOT / "RESULT.json" +SWEEP_PATH = ROOT / "sweep.py" +sweep = ModuleType("finite_radii_sweep") +sweep.__file__ = str(SWEEP_PATH) +exec(compile(SWEEP_PATH.read_bytes(), str(SWEEP_PATH), "exec"), sweep.__dict__) + + +class VerificationError(RuntimeError): + pass + + +def require(condition, message): + if not condition: + raise VerificationError(message) + + +def decode_key(value): + pattern, sign = value + return tuple(pattern), sign + + +def key_set(entries): + return {decode_key(entry["key"]) for entry in entries} + + +def active_pairs(data, threshold, inclusive): + result = set() + for i, j in data["quotient_edges"]: + comparison = sweep.compare_pair(data["pair_gap"][(i, j)], threshold) + if comparison < 0 or (inclusive and comparison == 0): + result.add((i, j)) + return result + + +def verify_flow(data, receipt, threshold, inclusive): + require("flow_certificate" in receipt, "missing positive flow certificate") + certificate = receipt["flow_certificate"] + inputs = data["inputs"] + outputs = data["outputs"] + source = certificate["input_supplies"] + loads = certificate["output_loads"] + require(len(source) == len(inputs), "source supply vector has wrong length") + require(len(loads) == len(outputs), "output load vector has wrong length") + require(all(isinstance(value, int) and 0 <= value <= inputs[i]["capacity"] + for i, value in enumerate(source)), + "source supply violates an input-orbit capacity") + require(all(isinstance(value, int) and 0 <= value <= outputs[j]["capacity"] + for j, value in enumerate(loads)), + "output load violates an output-orbit capacity") + active = active_pairs(data, threshold, inclusive) + row_sums = [0] * len(inputs) + column_sums = [0] * len(outputs) + seen = set() + for triple in certificate["positive_orbit_pair_flows"]: + require(len(triple) == 3, "malformed orbit-pair flow entry") + i, j, value = triple + require(isinstance(i, int) and 0 <= i < len(inputs), + "flow source orbit index is out of range") + require(isinstance(j, int) and 0 <= j < len(outputs), + "flow destination orbit index is out of range") + require(isinstance(value, int) and value > 0, + "flow certificate contains a nonpositive amount") + require((i, j) in active, "positive flow uses an inactive orbit adjacency") + require((i, j) not in seen, "duplicate orbit-pair flow entry") + seen.add((i, j)) + row_sums[i] += value + column_sums[j] += value + require(row_sums == source, "input-orbit flow conservation failed") + require(column_sums == loads, "output-orbit flow conservation failed") + total = sum(source) + require(total == sum(loads) == receipt["flow"], + "flow total does not match the receipt") + require(total <= data["total_inputs"], "flow exceeds total input capacity") + if receipt["feasible"]: + require(total == data["total_inputs"], "feasible receipt is not saturated") + require(source == [orbit["capacity"] for orbit in inputs], + "saturated receipt omits an input orbit") + else: + require(total < data["total_inputs"], "infeasible receipt is saturated") + require(receipt["active_quotient_adjacencies"] == len(active), + "active quotient-adjacency count disagrees") + return total + + +def verify_cut(data, receipt, threshold, inclusive): + cut = receipt["maximal_hall_cut"] + input_map = {orbit["key"]: i for i, orbit in enumerate(data["inputs"])} + output_map = {orbit["key"]: j for j, orbit in enumerate(data["outputs"])} + selected_i_keys = key_set(cut["input_orbits"]) + selected_o_keys = key_set(cut["output_orbits"]) + require(selected_i_keys <= set(input_map), "cut contains unknown input orbit") + require(selected_o_keys <= set(output_map), "cut contains unknown output orbit") + selected_i = {input_map[key] for key in selected_i_keys} + selected_o = {output_map[key] for key in selected_o_keys} + active = active_pairs(data, threshold, inclusive) + actual_neighbors = {j for i, j in active if i in selected_i} + require(actual_neighbors == selected_o, + "cut output set is not the complete lifted neighborhood") + input_mass = sum(data["inputs"][i]["capacity"] for i in selected_i) + neighbor_mass = sum(data["outputs"][j]["capacity"] for j in selected_o) + total = data["total_inputs"] + cut_capacity = total - input_mass + neighbor_mass + require(input_mass == cut["input_count"], "cut input capacity disagrees") + require(neighbor_mass == cut["neighbor_count"], "cut neighbor capacity disagrees") + require(input_mass - neighbor_mass == cut["deficiency"], + "Hall deficiency disagrees") + require(total - cut_capacity == receipt["deficiency"], + "flow/min-cut duality receipt disagrees") + if "flow_certificate" in receipt: + require(cut_capacity == receipt["flow"], + "verified flow and cut capacities disagree") + return input_mass, neighbor_mass + + +def verify_radius(record): + radius = record["radius"] + data = sweep.prepare_radius(radius) + require(data["total_inputs"] == record["domain_and_graph"]["input_count"], + "input-universe capacity disagrees") + require(data["total_outputs"] == + record["domain_and_graph"]["error_one_candidate_output_count"], + "output-universe capacity disagrees") + require(len(data["inputs"]) == record["domain_and_graph"]["input_orbit_count"], + "input orbit count disagrees") + require(len(data["outputs"]) == + record["domain_and_graph"]["output_candidate_orbit_count"], + "output orbit count disagrees") + for side, actual in (("inputs", data["inputs"]), + ("candidate_outputs", data["outputs"])): + saved = record["orbit_capacity_tables"][side] + actual_by_key = {orbit["key"]: orbit for orbit in actual} + require(len(saved) == len(actual_by_key), f"{side} table length disagrees") + for item in saved: + key = decode_key(item["key"]) + require(key in actual_by_key, f"{side} table has unknown orbit") + orbit = actual_by_key[key] + require(orbit["capacity"] == item["capacity"], + f"{side} capacity disagrees") + require(data["error_edge_count"] == + record["domain_and_graph"]["error_one_edge_count"], + "full error-one edge count disagrees") + target = tuple(record["target_pair"]) + strict_target_edges = sum( + data["inputs"][i]["capacity"] * data["pair_degree"][(i, j)] + for i, j in data["quotient_edges"] + if sweep.compare_pair(data["pair_gap"][(i, j)], target) < 0 + ) + require(strict_target_edges == + record["domain_and_graph"]["strict_target_edge_count"], + "strict target edge count disagrees") + target_results = record["target_threshold_tests"] + for name, inclusive in (("inclusive", True), ("strict", False)): + receipt = target_results[name] + verify_flow(data, receipt, target, inclusive) + verify_cut(data, receipt, target, inclusive) + optimum = record["exact_finite_optimum"] + require(optimum["exists"], "an exact optimum receipt is required") + optimum_pair = tuple(optimum["optimum_pair"]) + require(sweep.compare_pair(optimum_pair, optimum_pair) == 0, + "optimum radical is not exactly comparable") + require(optimum["optimum_expression"] == sweep.gap_label(optimum_pair), + "optimum expression disagrees with exact radicands") + upper = optimum["upper_flow"] + verify_flow(data, upper, optimum_pair, True) + require(upper["feasible"], "optimum upper flow is not saturated") + strict = optimum["strict_lower_cut"] + verify_cut(data, strict, optimum_pair, False) + require(not strict["feasible"] and strict["deficiency"] > 0, + "strict predecessor graph has no Hall obstruction") + require(optimum["gap_count"] == record["attainable_gap_count"], + "attainable gap count disagrees") + return { + "radius": radius, + "input_points": data["total_inputs"], + "output_points": data["total_outputs"], + "optimum": optimum["optimum_expression"], + "strict_deficiency": strict["deficiency"], + "target_feasible": target_results["inclusive"]["feasible"], + } + + +def expect_rejection(callable_, explanation): + try: + callable_() + except VerificationError: + return + raise VerificationError(f"negative control was accepted: {explanation}") + + +def negative_controls(record): + radius = record["radius"] + data = sweep.prepare_radius(radius) + optimum = record["exact_finite_optimum"] + threshold = tuple(optimum["optimum_pair"]) + receipt = json.loads(json.dumps(optimum["upper_flow"])) + require(receipt["flow_certificate"]["positive_orbit_pair_flows"], + "cannot mutate an empty positive-flow witness") + receipt["flow_certificate"]["positive_orbit_pair_flows"][0][2] += 1 + expect_rejection(lambda: verify_flow(data, receipt, threshold, True), + "incremented flow edge") + + strict = json.loads(json.dumps(optimum["strict_lower_cut"])) + require(strict["maximal_hall_cut"]["output_orbits"], + "cannot mutate an empty cut neighborhood") + strict["maximal_hall_cut"]["output_orbits"].pop() + expect_rejection(lambda: verify_cut(data, strict, threshold, False), + "deleted cut-neighbor orbit") + + +def main(): + receipt = json.loads(RESULT.read_text()) + require(receipt["scope"] == + "only radii 6, 7, 9, 11 at error cap one for H4/2", + "saved result scope changed") + require(receipt["group"]["paired_group_order"] == 192, + "paired W(D4) action receipt changed") + group = sweep.graph_group_check() + require(group == { + "W4_order": 384, + "paired_group_order": 192, + "input_projection_order": 192, + "output_projection_order": 192, + }, "paired signed-permutation group recomputation disagrees") + reports = [verify_radius(record) for record in receipt["completed_radii"]] + require([item["radius"] for item in reports] == [6, 7, 9, 11], + "completed radius list expanded or changed") + for record in receipt["completed_radii"]: + negative_controls(record) + print(json.dumps({ + "status": "PASS", + "verified_radii": reports, + "negative_controls": [ + "incrementing a positive orbit-pair flow is rejected", + "deleting a Hall-neighbor orbit is rejected", + ], + "untouched_radii": "all radii except 6, 7, 9, 11", + }, sort_keys=True, separators=(",", ":"))) + + +if __name__ == "__main__": + main() diff --git a/research/sharp-finite-gaussian-outward-slack/review/extension/FULL-POINT-RESULT.json b/research/sharp-finite-gaussian-outward-slack/review/extension/FULL-POINT-RESULT.json new file mode 100644 index 0000000000..8cc8b464c9 --- /dev/null +++ b/research/sharp-finite-gaussian-outward-slack/review/extension/FULL-POINT-RESULT.json @@ -0,0 +1,75 @@ +{ + "status": "PASS_INDEPENDENT_FULL_POINT_CERTIFICATES", + "receipt_sha256": "f6b3c5be0fd3e619dbbc44496ebef11d0f06ff5f5c1364e854020505baac85ef", + "verified": [ + { + "radius": 6, + "inputs": 6577, + "candidate_outputs": 10713, + "error_one_edges": 81873, + "orbit_adjacencies": 756, + "optimum_pair": [ + 31, + 28 + ], + "strict_cut": [ + 3569, + 3537 + ], + "strict_deficiency": 32, + "negative_controls": 3 + }, + { + "radius": 7, + "inputs": 11833, + "candidate_outputs": 18457, + "error_one_edges": 149505, + "orbit_adjacencies": 1284, + "optimum_pair": [ + 31, + 28 + ], + "strict_cut": [ + 3569, + 3537 + ], + "strict_deficiency": 32, + "negative_controls": 3 + }, + { + "radius": 9, + "inputs": 32633, + "candidate_outputs": 46401, + "error_one_edges": 410569, + "orbit_adjacencies": 3151, + "optimum_pair": [ + 78, + 73 + ], + "strict_cut": [ + 23561, + 23497 + ], + "strict_deficiency": 64, + "negative_controls": 3 + }, + { + "radius": 11, + "inputs": 72465, + "candidate_outputs": 96449, + "error_one_edges": 909113, + "orbit_adjacencies": 6543, + "optimum_pair": [ + 78, + 73 + ], + "strict_cut": [ + 23561, + 23497 + ], + "strict_deficiency": 64, + "negative_controls": 3 + } + ], + "method": "full individual-point and edge enumeration, actual class counts, 128-bit rational radical intervals, direct certificate conservation and complete Hall neighborhoods; imports no author code" +} diff --git a/research/sharp-finite-gaussian-outward-slack/review/extension/PUBLICATION-REPLAY.json b/research/sharp-finite-gaussian-outward-slack/review/extension/PUBLICATION-REPLAY.json new file mode 100644 index 0000000000..ec96f625ef --- /dev/null +++ b/research/sharp-finite-gaussian-outward-slack/review/extension/PUBLICATION-REPLAY.json @@ -0,0 +1,83 @@ +{ + "status": "PASS_FINAL_EXTENSION_REPLAY", + "read_only": true, + "normal_optimized_identical": true, + "canonical_base": "e54523517d0f03e58352e647c403a5af3e525a57", + "original_published_head": "9c75d0b4b6e1cfe74694edf52f2f238a741bbaf5", + "runs": [ + { + "name": "original-r5", + "command": "python3 -I -W error -B research/sharp-finite-gaussian-outward-slack/verify.py", + "returncode": 0, + "seconds": 0.33, + "stdout_sha256": "87ee11560e99e440fa47d0fb5f6799e8e85a100b8467b284605e58ef306fd1ce", + "expected_scientific_receipt_matches": true + }, + { + "name": "original-compact", + "command": "python3 -I -W error -B research/sharp-finite-gaussian-outward-slack/compact-hall/check.py", + "returncode": 0, + "seconds": 0.048, + "stdout_sha256": "66e617085db593449e7204f94b438f4e9467095b6fdef4d8092a2cefdde888ef", + "expected_scientific_receipt_matches": true + }, + { + "name": "extension-normal", + "command": "python3 -I -W error -B research/sharp-finite-gaussian-outward-slack/orbit-extension/verify.py", + "returncode": 0, + "seconds": 0.389, + "stdout_sha256": "5669fb69c55a3ede5cd907f59c892ef1e1f020932fc3654af9c1d62c05fb26ca", + "expected_scientific_receipt_matches": false + }, + { + "name": "extension-optimized", + "command": "python3 -I -O -W error -B research/sharp-finite-gaussian-outward-slack/orbit-extension/verify.py", + "returncode": 0, + "seconds": 0.598, + "stdout_sha256": "5669fb69c55a3ede5cd907f59c892ef1e1f020932fc3654af9c1d62c05fb26ca", + "expected_scientific_receipt_matches": false + }, + { + "name": "sweep-normal", + "command": "python3 -I -W error -B research/sharp-finite-gaussian-outward-slack/orbit-extension/sweep.py", + "returncode": 0, + "seconds": 2.034, + "stdout_sha256": "f6b3c5be0fd3e619dbbc44496ebef11d0f06ff5f5c1364e854020505baac85ef", + "expected_scientific_receipt_matches": true + }, + { + "name": "sweep-optimized", + "command": "python3 -I -O -W error -B research/sharp-finite-gaussian-outward-slack/orbit-extension/sweep.py", + "returncode": 0, + "seconds": 2.135, + "stdout_sha256": "f6b3c5be0fd3e619dbbc44496ebef11d0f06ff5f5c1364e854020505baac85ef", + "expected_scientific_receipt_matches": true + }, + { + "name": "full-point-normal", + "command": "python3 -I -W error -B research/sharp-finite-gaussian-outward-slack/review/extension/check_full_certificates.py", + "returncode": 0, + "seconds": 7.871, + "stdout_sha256": "68899512d88b253dfb42978e3aa450d2f6a424ce8265757625e92075a18663f3", + "expected_scientific_receipt_matches": true + }, + { + "name": "full-point-optimized", + "command": "python3 -I -O -W error -B research/sharp-finite-gaussian-outward-slack/review/extension/check_full_certificates.py", + "returncode": 0, + "seconds": 7.292, + "stdout_sha256": "68899512d88b253dfb42978e3aa450d2f6a424ce8265757625e92075a18663f3", + "expected_scientific_receipt_matches": true + }, + { + "name": "full-radius-nine", + "command": "python3 -I -W error -B research/sharp-finite-gaussian-outward-slack/review/extension/check_full_r9.py", + "returncode": 0, + "seconds": 5.812, + "stdout_sha256": "4919c129ac90751d5105b73c1e4a00af9b72d9610fb872ba7ecf76d83f80a67f", + "expected_scientific_receipt_matches": true + } + ], + "source_freeze_verified": true, + "scope": "exact finite optima and necessary global lower bound only; no new kappa" +} diff --git a/research/sharp-finite-gaussian-outward-slack/review/extension/R9-RESULT.json b/research/sharp-finite-gaussian-outward-slack/review/extension/R9-RESULT.json new file mode 100644 index 0000000000..e9180e512f --- /dev/null +++ b/research/sharp-finite-gaussian-outward-slack/review/extension/R9-RESULT.json @@ -0,0 +1,5401 @@ +{ + "marker": "PASS_INDEPENDENT_FULL_RADIUS_NINE_OPTIMUM", + "radius": 9, + "threshold_pair": [ + 78, + 73 + ], + "inputs": 32633, + "complete_error_one_edges": 410569, + "strict_edges": 267721, + "inclusive_edges": 268489, + "strict_matching": 32569, + "strict_cut_inputs": 23057, + "strict_cut_outputs": 22993, + "deficiency": 64, + "inclusive_matching": 32633, + "attaining_edges": 178, + "augmenting_rounds": [ + 14, + 25 + ], + "cut_input_sha256": "31862fa4e7998b02b908c9472cd55e39b3017599f4fd1c0bc89edffdeaf9640c", + "cut_output_sha256": "9d2502872967c3567274e0b33c4516458622118c10e39f8de5d951996edb4506", + "matching_sha256": "fc6de182094b5b6eb66a233062b4a0fa7154db804463ebabe9f2ac2952d40997", + "orbit_counts": [ + { + "side": "input_cut", + "orbits": [ + { + "absolute_coordinates": [ + 0, + 0, + 0, + 0 + ], + "negative_product": 0, + "size": 1 + }, + { + "absolute_coordinates": [ + 0, + 0, + 0, + 1 + ], + "negative_product": 0, + "size": 8 + }, + { + "absolute_coordinates": [ + 0, + 0, + 0, + 2 + ], + "negative_product": 0, + "size": 8 + }, + { + "absolute_coordinates": [ + 0, + 0, + 0, + 3 + ], + "negative_product": 0, + "size": 8 + }, + { + "absolute_coordinates": [ + 0, + 0, + 0, + 4 + ], + "negative_product": 0, + "size": 8 + }, + { + "absolute_coordinates": [ + 0, + 0, + 0, + 5 + ], + "negative_product": 0, + "size": 8 + }, + { + "absolute_coordinates": [ + 0, + 0, + 0, + 6 + ], + "negative_product": 0, + "size": 8 + }, + { + "absolute_coordinates": [ + 0, + 0, + 0, + 7 + ], + "negative_product": 0, + "size": 8 + }, + { + "absolute_coordinates": [ + 0, + 0, + 0, + 8 + ], + "negative_product": 0, + "size": 8 + }, + { + "absolute_coordinates": [ + 0, + 0, + 1, + 1 + ], + "negative_product": 0, + "size": 24 + }, + { + "absolute_coordinates": [ + 0, + 0, + 1, + 2 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 0, + 0, + 1, + 3 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 0, + 0, + 1, + 4 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 0, + 0, + 1, + 5 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 0, + 0, + 1, + 6 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 0, + 0, + 1, + 7 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 0, + 0, + 1, + 8 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 0, + 0, + 2, + 2 + ], + "negative_product": 0, + "size": 24 + }, + { + "absolute_coordinates": [ + 0, + 0, + 2, + 3 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 0, + 0, + 2, + 4 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 0, + 0, + 2, + 5 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 0, + 0, + 2, + 6 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 0, + 0, + 2, + 7 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 0, + 0, + 2, + 8 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 0, + 0, + 3, + 3 + ], + "negative_product": 0, + "size": 24 + }, + { + "absolute_coordinates": [ + 0, + 0, + 3, + 4 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 0, + 0, + 3, + 5 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 0, + 0, + 3, + 6 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 0, + 0, + 3, + 7 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 0, + 0, + 4, + 4 + ], + "negative_product": 0, + "size": 24 + }, + { + "absolute_coordinates": [ + 0, + 0, + 4, + 5 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 0, + 0, + 4, + 6 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 0, + 0, + 5, + 5 + ], + "negative_product": 0, + "size": 24 + }, + { + "absolute_coordinates": [ + 0, + 1, + 1, + 1 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 0, + 1, + 1, + 2 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 1, + 1, + 3 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 1, + 1, + 4 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 1, + 1, + 5 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 1, + 1, + 6 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 1, + 1, + 7 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 1, + 1, + 8 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 1, + 2, + 2 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 1, + 2, + 3 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 0, + 1, + 2, + 4 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 0, + 1, + 2, + 5 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 0, + 1, + 2, + 6 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 0, + 1, + 2, + 7 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 0, + 1, + 2, + 8 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 0, + 1, + 3, + 3 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 1, + 3, + 4 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 0, + 1, + 3, + 5 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 0, + 1, + 3, + 6 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 0, + 1, + 3, + 7 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 0, + 1, + 4, + 4 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 1, + 4, + 5 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 0, + 1, + 4, + 6 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 0, + 1, + 5, + 5 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 2, + 2, + 2 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 0, + 2, + 2, + 3 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 2, + 2, + 4 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 2, + 2, + 5 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 2, + 2, + 6 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 2, + 2, + 7 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 2, + 2, + 8 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 2, + 3, + 3 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 2, + 3, + 4 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 0, + 2, + 3, + 5 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 0, + 2, + 3, + 6 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 0, + 2, + 3, + 7 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 0, + 2, + 4, + 4 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 2, + 4, + 5 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 0, + 2, + 4, + 6 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 0, + 2, + 5, + 5 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 3, + 3, + 3 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 0, + 3, + 3, + 4 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 3, + 3, + 5 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 3, + 3, + 6 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 3, + 3, + 7 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 3, + 4, + 4 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 3, + 4, + 5 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 0, + 3, + 4, + 6 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 0, + 3, + 5, + 5 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 4, + 4, + 4 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 0, + 4, + 4, + 5 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 4, + 4, + 6 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 4, + 5, + 5 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 1, + 1, + 1 + ], + "negative_product": 0, + "size": 8 + }, + { + "absolute_coordinates": [ + 1, + 1, + 1, + 1 + ], + "negative_product": 1, + "size": 8 + }, + { + "absolute_coordinates": [ + 1, + 1, + 1, + 2 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 1, + 1, + 2 + ], + "negative_product": 1, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 1, + 1, + 3 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 1, + 1, + 3 + ], + "negative_product": 1, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 1, + 1, + 4 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 1, + 1, + 4 + ], + "negative_product": 1, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 1, + 1, + 5 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 1, + 1, + 5 + ], + "negative_product": 1, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 1, + 1, + 6 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 1, + 1, + 6 + ], + "negative_product": 1, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 1, + 1, + 7 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 1, + 1, + 7 + ], + "negative_product": 1, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 1, + 1, + 8 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 1, + 1, + 8 + ], + "negative_product": 1, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 1, + 2, + 2 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 1, + 1, + 2, + 2 + ], + "negative_product": 1, + "size": 48 + }, + { + "absolute_coordinates": [ + 1, + 1, + 2, + 3 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 1, + 2, + 3 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 1, + 2, + 4 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 1, + 2, + 4 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 1, + 2, + 5 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 1, + 2, + 5 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 1, + 2, + 6 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 1, + 2, + 6 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 1, + 2, + 7 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 1, + 2, + 7 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 1, + 2, + 8 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 1, + 2, + 8 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 1, + 3, + 3 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 1, + 1, + 3, + 3 + ], + "negative_product": 1, + "size": 48 + }, + { + "absolute_coordinates": [ + 1, + 1, + 3, + 4 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 1, + 3, + 4 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 1, + 3, + 5 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 1, + 3, + 5 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 1, + 3, + 6 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 1, + 3, + 6 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 1, + 3, + 7 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 1, + 3, + 7 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 1, + 4, + 4 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 1, + 1, + 4, + 4 + ], + "negative_product": 1, + "size": 48 + }, + { + "absolute_coordinates": [ + 1, + 1, + 4, + 5 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 1, + 4, + 5 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 1, + 4, + 6 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 1, + 4, + 6 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 1, + 5, + 5 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 1, + 1, + 5, + 5 + ], + "negative_product": 1, + "size": 48 + }, + { + "absolute_coordinates": [ + 1, + 2, + 2, + 2 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 2, + 2, + 2 + ], + "negative_product": 1, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 2, + 2, + 3 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 2, + 2, + 3 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 2, + 2, + 4 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 2, + 2, + 4 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 2, + 2, + 5 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 2, + 2, + 5 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 2, + 2, + 6 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 2, + 2, + 6 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 2, + 2, + 7 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 2, + 2, + 7 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 2, + 2, + 8 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 2, + 3, + 3 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 2, + 3, + 3 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 2, + 3, + 4 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 1, + 2, + 3, + 4 + ], + "negative_product": 1, + "size": 192 + }, + { + "absolute_coordinates": [ + 1, + 2, + 3, + 5 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 1, + 2, + 3, + 5 + ], + "negative_product": 1, + "size": 192 + }, + { + "absolute_coordinates": [ + 1, + 2, + 3, + 6 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 1, + 2, + 3, + 6 + ], + "negative_product": 1, + "size": 192 + }, + { + "absolute_coordinates": [ + 1, + 2, + 3, + 7 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 1, + 2, + 3, + 7 + ], + "negative_product": 1, + "size": 192 + }, + { + "absolute_coordinates": [ + 1, + 2, + 4, + 4 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 2, + 4, + 4 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 2, + 4, + 5 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 1, + 2, + 4, + 5 + ], + "negative_product": 1, + "size": 192 + }, + { + "absolute_coordinates": [ + 1, + 2, + 4, + 6 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 1, + 2, + 4, + 6 + ], + "negative_product": 1, + "size": 192 + }, + { + "absolute_coordinates": [ + 1, + 2, + 5, + 5 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 2, + 5, + 5 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 3, + 3, + 3 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 3, + 3, + 3 + ], + "negative_product": 1, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 3, + 3, + 4 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 3, + 3, + 4 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 3, + 3, + 5 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 3, + 3, + 5 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 3, + 3, + 6 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 3, + 3, + 6 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 3, + 3, + 7 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 3, + 3, + 7 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 3, + 4, + 4 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 3, + 4, + 4 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 3, + 4, + 5 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 1, + 3, + 4, + 5 + ], + "negative_product": 1, + "size": 192 + }, + { + "absolute_coordinates": [ + 1, + 3, + 4, + 6 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 1, + 3, + 4, + 6 + ], + "negative_product": 1, + "size": 192 + }, + { + "absolute_coordinates": [ + 1, + 3, + 5, + 5 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 3, + 5, + 5 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 4, + 4, + 4 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 4, + 4, + 4 + ], + "negative_product": 1, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 4, + 4, + 5 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 4, + 4, + 5 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 4, + 4, + 6 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 4, + 4, + 6 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 4, + 5, + 5 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 4, + 5, + 5 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 2, + 2, + 2 + ], + "negative_product": 0, + "size": 8 + }, + { + "absolute_coordinates": [ + 2, + 2, + 2, + 2 + ], + "negative_product": 1, + "size": 8 + }, + { + "absolute_coordinates": [ + 2, + 2, + 2, + 3 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 2, + 2, + 2, + 3 + ], + "negative_product": 1, + "size": 32 + }, + { + "absolute_coordinates": [ + 2, + 2, + 2, + 4 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 2, + 2, + 2, + 4 + ], + "negative_product": 1, + "size": 32 + }, + { + "absolute_coordinates": [ + 2, + 2, + 2, + 5 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 2, + 2, + 2, + 5 + ], + "negative_product": 1, + "size": 32 + }, + { + "absolute_coordinates": [ + 2, + 2, + 2, + 6 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 2, + 2, + 2, + 6 + ], + "negative_product": 1, + "size": 32 + }, + { + "absolute_coordinates": [ + 2, + 2, + 2, + 7 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 2, + 2, + 2, + 7 + ], + "negative_product": 1, + "size": 32 + }, + { + "absolute_coordinates": [ + 2, + 2, + 3, + 3 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 2, + 2, + 3, + 3 + ], + "negative_product": 1, + "size": 48 + }, + { + "absolute_coordinates": [ + 2, + 2, + 3, + 4 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 2, + 3, + 4 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 2, + 3, + 5 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 2, + 3, + 5 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 2, + 3, + 6 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 2, + 3, + 6 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 2, + 3, + 7 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 2, + 3, + 7 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 2, + 4, + 4 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 2, + 2, + 4, + 4 + ], + "negative_product": 1, + "size": 48 + }, + { + "absolute_coordinates": [ + 2, + 2, + 4, + 5 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 2, + 4, + 5 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 2, + 4, + 6 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 2, + 4, + 6 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 2, + 5, + 5 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 2, + 2, + 5, + 5 + ], + "negative_product": 1, + "size": 48 + }, + { + "absolute_coordinates": [ + 2, + 3, + 3, + 3 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 2, + 3, + 3, + 3 + ], + "negative_product": 1, + "size": 32 + }, + { + "absolute_coordinates": [ + 2, + 3, + 3, + 4 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 3, + 3, + 4 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 3, + 3, + 5 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 3, + 3, + 5 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 3, + 3, + 6 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 3, + 3, + 6 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 3, + 3, + 7 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 3, + 3, + 7 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 3, + 4, + 4 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 3, + 4, + 4 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 3, + 4, + 5 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 2, + 3, + 4, + 5 + ], + "negative_product": 1, + "size": 192 + }, + { + "absolute_coordinates": [ + 2, + 3, + 4, + 6 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 2, + 3, + 4, + 6 + ], + "negative_product": 1, + "size": 192 + }, + { + "absolute_coordinates": [ + 2, + 3, + 5, + 5 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 3, + 5, + 5 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 4, + 4, + 4 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 2, + 4, + 4, + 4 + ], + "negative_product": 1, + "size": 32 + }, + { + "absolute_coordinates": [ + 2, + 4, + 4, + 5 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 4, + 4, + 5 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 4, + 4, + 6 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 4, + 4, + 6 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 4, + 5, + 5 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 4, + 5, + 5 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 3, + 3, + 3, + 3 + ], + "negative_product": 0, + "size": 8 + }, + { + "absolute_coordinates": [ + 3, + 3, + 3, + 3 + ], + "negative_product": 1, + "size": 8 + }, + { + "absolute_coordinates": [ + 3, + 3, + 3, + 4 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 3, + 3, + 3, + 4 + ], + "negative_product": 1, + "size": 32 + }, + { + "absolute_coordinates": [ + 3, + 3, + 3, + 5 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 3, + 3, + 3, + 5 + ], + "negative_product": 1, + "size": 32 + }, + { + "absolute_coordinates": [ + 3, + 3, + 3, + 6 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 3, + 3, + 3, + 6 + ], + "negative_product": 1, + "size": 32 + }, + { + "absolute_coordinates": [ + 3, + 3, + 4, + 4 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 3, + 3, + 4, + 4 + ], + "negative_product": 1, + "size": 48 + }, + { + "absolute_coordinates": [ + 3, + 3, + 4, + 5 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 3, + 3, + 4, + 5 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 3, + 3, + 4, + 6 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 3, + 3, + 5, + 5 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 3, + 4, + 4, + 4 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 3, + 4, + 4, + 4 + ], + "negative_product": 1, + "size": 32 + }, + { + "absolute_coordinates": [ + 3, + 4, + 4, + 5 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 3, + 4, + 4, + 6 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 3, + 4, + 5, + 5 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 4, + 4, + 4, + 4 + ], + "negative_product": 0, + "size": 8 + }, + { + "absolute_coordinates": [ + 4, + 4, + 4, + 5 + ], + "negative_product": 0, + "size": 32 + } + ] + }, + { + "side": "output_cut", + "orbits": [ + { + "absolute_coordinates": [ + 0, + 0, + 0, + 0 + ], + "negative_product": 0, + "size": 1 + }, + { + "absolute_coordinates": [ + 0, + 0, + 0, + 1 + ], + "negative_product": 0, + "size": 8 + }, + { + "absolute_coordinates": [ + 0, + 0, + 0, + 2 + ], + "negative_product": 0, + "size": 8 + }, + { + "absolute_coordinates": [ + 0, + 0, + 0, + 3 + ], + "negative_product": 0, + "size": 8 + }, + { + "absolute_coordinates": [ + 0, + 0, + 0, + 4 + ], + "negative_product": 0, + "size": 8 + }, + { + "absolute_coordinates": [ + 0, + 0, + 0, + 5 + ], + "negative_product": 0, + "size": 8 + }, + { + "absolute_coordinates": [ + 0, + 0, + 0, + 6 + ], + "negative_product": 0, + "size": 8 + }, + { + "absolute_coordinates": [ + 0, + 0, + 0, + 7 + ], + "negative_product": 0, + "size": 8 + }, + { + "absolute_coordinates": [ + 0, + 0, + 0, + 8 + ], + "negative_product": 0, + "size": 8 + }, + { + "absolute_coordinates": [ + 0, + 0, + 1, + 1 + ], + "negative_product": 0, + "size": 24 + }, + { + "absolute_coordinates": [ + 0, + 0, + 1, + 2 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 0, + 0, + 1, + 3 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 0, + 0, + 1, + 4 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 0, + 0, + 1, + 5 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 0, + 0, + 1, + 6 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 0, + 0, + 1, + 7 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 0, + 0, + 1, + 8 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 0, + 0, + 2, + 2 + ], + "negative_product": 0, + "size": 24 + }, + { + "absolute_coordinates": [ + 0, + 0, + 2, + 3 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 0, + 0, + 2, + 4 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 0, + 0, + 2, + 5 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 0, + 0, + 2, + 6 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 0, + 0, + 2, + 7 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 0, + 0, + 2, + 8 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 0, + 0, + 3, + 3 + ], + "negative_product": 0, + "size": 24 + }, + { + "absolute_coordinates": [ + 0, + 0, + 3, + 4 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 0, + 0, + 3, + 5 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 0, + 0, + 3, + 6 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 0, + 0, + 3, + 7 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 0, + 0, + 4, + 4 + ], + "negative_product": 0, + "size": 24 + }, + { + "absolute_coordinates": [ + 0, + 0, + 4, + 5 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 0, + 0, + 4, + 6 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 0, + 0, + 5, + 5 + ], + "negative_product": 0, + "size": 24 + }, + { + "absolute_coordinates": [ + 0, + 1, + 1, + 1 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 0, + 1, + 1, + 2 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 1, + 1, + 3 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 1, + 1, + 4 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 1, + 1, + 5 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 1, + 1, + 6 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 1, + 1, + 7 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 1, + 1, + 8 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 1, + 2, + 2 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 1, + 2, + 3 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 0, + 1, + 2, + 4 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 0, + 1, + 2, + 5 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 0, + 1, + 2, + 6 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 0, + 1, + 2, + 7 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 0, + 1, + 2, + 8 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 0, + 1, + 3, + 3 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 1, + 3, + 4 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 0, + 1, + 3, + 5 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 0, + 1, + 3, + 6 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 0, + 1, + 3, + 7 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 0, + 1, + 4, + 4 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 1, + 4, + 5 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 0, + 1, + 4, + 6 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 0, + 1, + 5, + 5 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 2, + 2, + 2 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 0, + 2, + 2, + 3 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 2, + 2, + 4 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 2, + 2, + 5 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 2, + 2, + 6 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 2, + 2, + 7 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 2, + 2, + 8 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 2, + 3, + 3 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 2, + 3, + 4 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 0, + 2, + 3, + 5 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 0, + 2, + 3, + 6 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 0, + 2, + 3, + 7 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 0, + 2, + 4, + 4 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 2, + 4, + 5 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 0, + 2, + 4, + 6 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 0, + 2, + 5, + 5 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 3, + 3, + 3 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 0, + 3, + 3, + 4 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 3, + 3, + 5 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 3, + 3, + 6 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 3, + 3, + 7 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 3, + 4, + 4 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 3, + 4, + 5 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 0, + 3, + 4, + 6 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 0, + 3, + 5, + 5 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 4, + 4, + 4 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 0, + 4, + 4, + 5 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 4, + 4, + 6 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 4, + 5, + 5 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 0, + 5, + 5, + 5 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 1, + 1, + 1 + ], + "negative_product": 0, + "size": 8 + }, + { + "absolute_coordinates": [ + 1, + 1, + 1, + 1 + ], + "negative_product": 1, + "size": 8 + }, + { + "absolute_coordinates": [ + 1, + 1, + 1, + 2 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 1, + 1, + 2 + ], + "negative_product": 1, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 1, + 1, + 3 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 1, + 1, + 3 + ], + "negative_product": 1, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 1, + 1, + 4 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 1, + 1, + 4 + ], + "negative_product": 1, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 1, + 1, + 5 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 1, + 1, + 5 + ], + "negative_product": 1, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 1, + 1, + 6 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 1, + 1, + 6 + ], + "negative_product": 1, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 1, + 1, + 7 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 1, + 1, + 7 + ], + "negative_product": 1, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 1, + 1, + 8 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 1, + 1, + 8 + ], + "negative_product": 1, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 1, + 2, + 2 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 1, + 1, + 2, + 2 + ], + "negative_product": 1, + "size": 48 + }, + { + "absolute_coordinates": [ + 1, + 1, + 2, + 3 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 1, + 2, + 3 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 1, + 2, + 4 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 1, + 2, + 4 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 1, + 2, + 5 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 1, + 2, + 5 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 1, + 2, + 6 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 1, + 2, + 6 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 1, + 2, + 7 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 1, + 2, + 7 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 1, + 2, + 8 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 1, + 2, + 8 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 1, + 3, + 3 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 1, + 1, + 3, + 3 + ], + "negative_product": 1, + "size": 48 + }, + { + "absolute_coordinates": [ + 1, + 1, + 3, + 4 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 1, + 3, + 4 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 1, + 3, + 5 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 1, + 3, + 5 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 1, + 3, + 6 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 1, + 3, + 6 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 1, + 3, + 7 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 1, + 3, + 7 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 1, + 4, + 4 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 1, + 1, + 4, + 4 + ], + "negative_product": 1, + "size": 48 + }, + { + "absolute_coordinates": [ + 1, + 1, + 4, + 5 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 1, + 4, + 5 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 1, + 4, + 6 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 1, + 4, + 6 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 1, + 5, + 5 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 1, + 1, + 5, + 5 + ], + "negative_product": 1, + "size": 48 + }, + { + "absolute_coordinates": [ + 1, + 2, + 2, + 2 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 2, + 2, + 2 + ], + "negative_product": 1, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 2, + 2, + 3 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 2, + 2, + 3 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 2, + 2, + 4 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 2, + 2, + 4 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 2, + 2, + 5 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 2, + 2, + 5 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 2, + 2, + 6 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 2, + 2, + 6 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 2, + 2, + 7 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 2, + 2, + 7 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 2, + 2, + 8 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 2, + 2, + 8 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 2, + 3, + 3 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 2, + 3, + 3 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 2, + 3, + 4 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 1, + 2, + 3, + 4 + ], + "negative_product": 1, + "size": 192 + }, + { + "absolute_coordinates": [ + 1, + 2, + 3, + 5 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 1, + 2, + 3, + 5 + ], + "negative_product": 1, + "size": 192 + }, + { + "absolute_coordinates": [ + 1, + 2, + 3, + 6 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 1, + 2, + 3, + 6 + ], + "negative_product": 1, + "size": 192 + }, + { + "absolute_coordinates": [ + 1, + 2, + 3, + 7 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 1, + 2, + 3, + 7 + ], + "negative_product": 1, + "size": 192 + }, + { + "absolute_coordinates": [ + 1, + 2, + 4, + 4 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 2, + 4, + 4 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 2, + 4, + 5 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 1, + 2, + 4, + 5 + ], + "negative_product": 1, + "size": 192 + }, + { + "absolute_coordinates": [ + 1, + 2, + 4, + 6 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 1, + 2, + 4, + 6 + ], + "negative_product": 1, + "size": 192 + }, + { + "absolute_coordinates": [ + 1, + 2, + 5, + 5 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 2, + 5, + 5 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 3, + 3, + 3 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 3, + 3, + 3 + ], + "negative_product": 1, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 3, + 3, + 4 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 3, + 3, + 4 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 3, + 3, + 5 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 3, + 3, + 5 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 3, + 3, + 6 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 3, + 3, + 6 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 3, + 3, + 7 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 3, + 3, + 7 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 3, + 4, + 4 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 3, + 4, + 4 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 3, + 4, + 5 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 1, + 3, + 4, + 5 + ], + "negative_product": 1, + "size": 192 + }, + { + "absolute_coordinates": [ + 1, + 3, + 4, + 6 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 1, + 3, + 4, + 6 + ], + "negative_product": 1, + "size": 192 + }, + { + "absolute_coordinates": [ + 1, + 3, + 5, + 5 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 3, + 5, + 5 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 4, + 4, + 4 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 4, + 4, + 4 + ], + "negative_product": 1, + "size": 32 + }, + { + "absolute_coordinates": [ + 1, + 4, + 4, + 5 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 4, + 4, + 5 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 4, + 4, + 6 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 4, + 4, + 6 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 4, + 5, + 5 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 4, + 5, + 5 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 1, + 5, + 5, + 5 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 2, + 2, + 2, + 2 + ], + "negative_product": 0, + "size": 8 + }, + { + "absolute_coordinates": [ + 2, + 2, + 2, + 2 + ], + "negative_product": 1, + "size": 8 + }, + { + "absolute_coordinates": [ + 2, + 2, + 2, + 3 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 2, + 2, + 2, + 3 + ], + "negative_product": 1, + "size": 32 + }, + { + "absolute_coordinates": [ + 2, + 2, + 2, + 4 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 2, + 2, + 2, + 4 + ], + "negative_product": 1, + "size": 32 + }, + { + "absolute_coordinates": [ + 2, + 2, + 2, + 5 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 2, + 2, + 2, + 5 + ], + "negative_product": 1, + "size": 32 + }, + { + "absolute_coordinates": [ + 2, + 2, + 2, + 6 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 2, + 2, + 2, + 6 + ], + "negative_product": 1, + "size": 32 + }, + { + "absolute_coordinates": [ + 2, + 2, + 2, + 7 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 2, + 2, + 2, + 7 + ], + "negative_product": 1, + "size": 32 + }, + { + "absolute_coordinates": [ + 2, + 2, + 3, + 3 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 2, + 2, + 3, + 3 + ], + "negative_product": 1, + "size": 48 + }, + { + "absolute_coordinates": [ + 2, + 2, + 3, + 4 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 2, + 3, + 4 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 2, + 3, + 5 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 2, + 3, + 5 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 2, + 3, + 6 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 2, + 3, + 6 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 2, + 3, + 7 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 2, + 3, + 7 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 2, + 4, + 4 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 2, + 2, + 4, + 4 + ], + "negative_product": 1, + "size": 48 + }, + { + "absolute_coordinates": [ + 2, + 2, + 4, + 5 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 2, + 4, + 5 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 2, + 4, + 6 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 2, + 4, + 6 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 2, + 5, + 5 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 2, + 2, + 5, + 5 + ], + "negative_product": 1, + "size": 48 + }, + { + "absolute_coordinates": [ + 2, + 3, + 3, + 3 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 2, + 3, + 3, + 3 + ], + "negative_product": 1, + "size": 32 + }, + { + "absolute_coordinates": [ + 2, + 3, + 3, + 4 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 3, + 3, + 4 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 3, + 3, + 5 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 3, + 3, + 5 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 3, + 3, + 6 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 3, + 3, + 6 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 3, + 3, + 7 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 3, + 3, + 7 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 3, + 4, + 4 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 3, + 4, + 4 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 3, + 4, + 5 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 2, + 3, + 4, + 5 + ], + "negative_product": 1, + "size": 192 + }, + { + "absolute_coordinates": [ + 2, + 3, + 4, + 6 + ], + "negative_product": 0, + "size": 192 + }, + { + "absolute_coordinates": [ + 2, + 3, + 4, + 6 + ], + "negative_product": 1, + "size": 192 + }, + { + "absolute_coordinates": [ + 2, + 3, + 5, + 5 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 3, + 5, + 5 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 4, + 4, + 4 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 2, + 4, + 4, + 4 + ], + "negative_product": 1, + "size": 32 + }, + { + "absolute_coordinates": [ + 2, + 4, + 4, + 5 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 4, + 4, + 5 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 4, + 4, + 6 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 4, + 4, + 6 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 2, + 4, + 5, + 5 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 3, + 3, + 3, + 3 + ], + "negative_product": 0, + "size": 8 + }, + { + "absolute_coordinates": [ + 3, + 3, + 3, + 3 + ], + "negative_product": 1, + "size": 8 + }, + { + "absolute_coordinates": [ + 3, + 3, + 3, + 4 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 3, + 3, + 3, + 4 + ], + "negative_product": 1, + "size": 32 + }, + { + "absolute_coordinates": [ + 3, + 3, + 3, + 5 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 3, + 3, + 3, + 5 + ], + "negative_product": 1, + "size": 32 + }, + { + "absolute_coordinates": [ + 3, + 3, + 3, + 6 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 3, + 3, + 3, + 6 + ], + "negative_product": 1, + "size": 32 + }, + { + "absolute_coordinates": [ + 3, + 3, + 4, + 4 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 3, + 3, + 4, + 4 + ], + "negative_product": 1, + "size": 48 + }, + { + "absolute_coordinates": [ + 3, + 3, + 4, + 5 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 3, + 3, + 4, + 5 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 3, + 3, + 4, + 6 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 3, + 3, + 4, + 6 + ], + "negative_product": 1, + "size": 96 + }, + { + "absolute_coordinates": [ + 3, + 3, + 5, + 5 + ], + "negative_product": 0, + "size": 48 + }, + { + "absolute_coordinates": [ + 3, + 4, + 4, + 4 + ], + "negative_product": 0, + "size": 32 + }, + { + "absolute_coordinates": [ + 3, + 4, + 4, + 4 + ], + "negative_product": 1, + "size": 32 + }, + { + "absolute_coordinates": [ + 3, + 4, + 4, + 5 + ], + "negative_product": 0, + "size": 96 + }, + { + "absolute_coordinates": [ + 4, + 4, + 4, + 4 + ], + "negative_product": 0, + "size": 8 + } + ] + } + ], + "library_sha256": "114e3bf3197c618aa17faf8d2d232a3d52ba8d973cf7514f6edd55c1f973f0af", + "independence": "full individual-vertex matching and rational radical intervals; imports no author orbit-flow code, receipts or certificates", + "negative_control": "strict predecessor graph has deficit64; equality edges restore a full injection", + "scope": "finite radius-nine optimum and global necessary lower bound only; no global sufficiency" +} diff --git a/research/sharp-finite-gaussian-outward-slack/review/extension/ROOT-REVIEW.md b/research/sharp-finite-gaussian-outward-slack/review/extension/ROOT-REVIEW.md new file mode 100644 index 0000000000..589bfd8060 --- /dev/null +++ b/research/sharp-finite-gaussian-outward-slack/review/extension/ROOT-REVIEW.md @@ -0,0 +1,51 @@ +# Independent review of the finite orbit-flow extension + +Verdict: approve the stated exact finite optima and global necessary lower +bound. No global sufficiency, physical tariff, selected caller or kappa claim. +The original radius-five package remains at commit +9c75d0b4b6e1cfe74694edf52f2f238a741bbaf5; this extension retains its code, +compressed certificate and compact proof. + +## Mathematical review + +The paired W(D4) action preserves input/output norms and error. A pair of +orbits need not induce a complete bipartite graph. Transitivity at each end +instead makes it biregular. If orbit flow f(I,J) is spread uniformly over +its actual edges, every input vertex has fractional degree1 and every +output degree at most1. Summing over any input subset proves Hall's +inequality, yielding an integral finite injection. Conversely a finite +matching aggregates to a feasible quotient flow. This is a classical +symmetry/fractional-matching argument, applied to this explicit graph. + +Every strict Hall cut is the complete union of its listed input orbits; +its output list equals the complete allowed neighborhood. A positive +strict deficiency and a saturated inclusive flow prove the exact optimum +without trusting binary-search coverage. The strict-lower receipts need +only the Hall cut; maximality of every strict cut is not assumed from an +unchecked flow value. At radius9, maximal deficiency64 is separately proved +by full-vertex matching. Radius10 follows by restricting the radius11 upper +injection and including the radius9 lower obstruction. + +## Independent evidence and controls + +check_full_certificates.py enumerates individual integer points and every +error-one neighbor at all four radii. It counts capacities from actual point +sets, verifies all flow entries and complete cut neighborhoods, and compares +radical gaps with certified 128-bit integer enclosures. A comparison that is +not separated would fail rather than guess. No author code is imported. +All twelve mutation/tie controls reject. It verifies the frozen receipt +SHA256 f6b3c5be0fd3e619dbbc44496ebef11d0f06ff5f5c1364e854020505baac85ef. + +check_full_r9.py uses a separately written full-vertex Hopcroft-Karp matcher +and alternating Hall search. On32,633 inputs and410,569 error-one edges it +finds strict matching32,569, a23,057/22,993 Hall cut, and inclusive matching +32,633 with178 equality edges. This method imports no author certificates, +orbit optimizer or comparator. Its local library is pinned in the manifest. + +Final isolated normal/optimized checks and exact source-byte inventory are +recorded in PUBLICATION-REPLAY.json. The author's freeze files are retained +unchanged in orbit-extension; their earlier local paths describe provenance, +while portable review scripts are here. No full global lattice was searched. + +Prepared for @CubeJerry with substantial OpenAI assistance; this review +is independent code/reasoning, not an independent human or formal proof. diff --git a/research/sharp-finite-gaussian-outward-slack/review/extension/check_full_certificates.py b/research/sharp-finite-gaussian-outward-slack/review/extension/check_full_certificates.py new file mode 100644 index 0000000000..1812ae267b --- /dev/null +++ b/research/sharp-finite-gaussian-outward-slack/review/extension/check_full_certificates.py @@ -0,0 +1,133 @@ +"""Independent full-point capacity/flow/cut checker; no orbit author code imports.""" +from collections import Counter +from itertools import product +from math import isqrt, prod +from pathlib import Path +from functools import lru_cache +import argparse, copy, hashlib, json + +H=((1,1,1,1),(1,-1,1,-1),(1,1,-1,-1),(1,-1,-1,1)) +Q=1<<128 + +def need(ok,why): + if not ok: raise ValueError(why) + +def key(v): + return tuple(sorted(map(abs,v))), (None if 0 in v else (1 if prod(v)>0 else -1)) +def decode(k):return tuple(k[0]),k[1] +def n2(v):return sum(a*a for a in v) +def ball(r): + pairs=[(a,b) for a in range(-r,r+1) for b in range(-r,r+1) if a*a+b*b<=r*r] + return [(a,b,c,d) for a,b in pairs for c,d in pairs if a*a+b*b+c*c+d*d<=r*r] +def neighbors(x): + hx=tuple(sum(a*b for a,b in zip(row,x)) for row in H) + need(len({t%2 for t in hx})==1,'common image parity') + if hx[0]%2: + for bits in product((0,1),repeat=4):yield tuple(t//2+b for t,b in zip(hx,bits)) + else: + y=tuple(t//2 for t in hx);yield y + for i in range(4): + for s in (-1,1): + z=list(y);z[i]+=s;yield tuple(z) +@lru_cache(None) +def interval(n): + lo=isqrt(n*Q*Q);return lo,lo+(lo*lo!=n*Q*Q) +@lru_cache(None) +def gap(a,b): + la,ua=interval(a);lb,ub=interval(b);return la-ub,ua-lb +@lru_cache(None) +def compare(edge,threshold): + if edge==threshold:return 0 + lo,hi=gap(*edge);tl,th=gap(*threshold) + if hith:return 1 + raise ValueError(('unseparated radicals',edge,threshold)) +def verify_tables(record,xs,ys): + maps=[] + for side,points in [('inputs',xs),('candidate_outputs',ys)]: + actual=Counter(key(v) for v in points) + saved=record['orbit_capacity_tables'][side] + need(len(saved)==len(actual),'exact number of orbit classes') + klist=[decode(row['key']) for row in saved] + need(len(set(klist))==len(klist),'duplicate orbit key') + need(set(klist)==set(actual),'complete orbit class coverage') + for row,k in zip(saved,klist): + need(row['capacity']==actual[k],'orbit capacity by actual point count') + need(row['norm_squared']==n2(k[0]),'orbit squared norm') + if 'representative' in row:need(key(row['representative'])==k,'representative class') + maps.append({k:i for i,k in enumerate(klist)}) + return maps + +def active_edges(pairs,threshold,inclusive): + return {(i,j) for (i,j),ab in pairs.items() if compare(ab,threshold)<0 or (inclusive and compare(ab,threshold)==0)} +def check_flow(record,receipt,active): + rows=[0]*len(record['orbit_capacity_tables']['inputs']);cols=[0]*len(record['orbit_capacity_tables']['candidate_outputs']);seen=set() + f=receipt['flow_certificate'] + for i,j,v in f['positive_orbit_pair_flows']: + need(type(v)is int and v>0 and (i,j) in active,'positive active orbit flow') + need((i,j) not in seen,'unique flow edge');seen.add((i,j));rows[i]+=v;cols[j]+=v + need(rows==f['input_supplies'] and cols==f['output_loads'],'flow conservation') + need(all(0<=v<=a['capacity'] for v,a in zip(rows,record['orbit_capacity_tables']['inputs'])),'input capacities') + need(all(0<=v<=a['capacity'] for v,a in zip(cols,record['orbit_capacity_tables']['candidate_outputs'])),'output capacities') + need(sum(rows)==sum(cols)==receipt['flow'],'flow value') + if receipt['feasible']:need(rows==[a['capacity'] for a in record['orbit_capacity_tables']['inputs']],'all inputs saturated') + return sum(rows) +def check_cut(record,receipt,active,im,om): + cut=receipt['maximal_hall_cut'] + li=[decode(a['key']) for a in cut['input_orbits']];lo=[decode(a['key']) for a in cut['output_orbits']] + need(len(set(li))==len(li) and len(set(lo))==len(lo),'cut key uniqueness') + ii={im[k] for k in li};oo={om[k] for k in lo} + need({j for i,j in active if i in ii}==oo,'complete cut neighborhood') + tables=record['orbit_capacity_tables'];ni=sum(tables['inputs'][i]['capacity'] for i in ii);no=sum(tables['candidate_outputs'][j]['capacity'] for j in oo) + need((ni,no,ni-no)==(cut['input_count'],cut['neighbor_count'],cut['deficiency']),'exact cut cardinalities') + need(record['domain_and_graph']['input_count']-ni+no==receipt['flow'],'reported cut capacity') + return ni,no + +def rejection(fn,label): + try:fn() + except (ValueError,KeyError,IndexError):return + raise ValueError('negative control accepted: '+label) + +def verify(record): + r=record['radius'];xs=ball(r);ys=set();raw=[];edge_total=0 + # Count every point and every candidate edge; no orbit capacity formula or representative generator. + input_counts=Counter(key(x) for x in xs) + for x in xs: + kx=key(x);n=n2(x) + for y in neighbors(x): + ys.add(y);raw.append((kx,key(y),n2(y),n));edge_total+=1 + im,om=verify_tables(record,xs,ys) + pairs={};pair_count=Counter() + for ki,kj,a,b in raw: + ij=(im[ki],om[kj]);need(ij not in pairs or pairs[ij]==(a,b),'constant norm gap within orbit pair');pairs[ij]=(a,b);pair_count[ij]+=1 + del raw + domain=record['domain_and_graph'];need((len(xs),len(ys),edge_total)==(domain['input_count'],domain['error_one_candidate_output_count'],domain['error_one_edge_count']),'complete graph size') + need(len(pairs)==domain['all_quotient_adjacencies'],'complete quotient adjacency') + # Biregularity follows from the paired group action proved in the manuscript. + # Exact edge counts must agree with integer degrees at both ends. + for (i,j),c in pair_count.items(): + need(c%record['orbit_capacity_tables']['inputs'][i]['capacity']==0,'integral left degree') + need(c%record['orbit_capacity_tables']['candidate_outputs'][j]['capacity']==0,'integral right degree') + target=tuple(record['target_pair']) + for name,inc in [('inclusive',True),('strict',False)]: + receipt=record['target_threshold_tests'][name];act=active_edges(pairs,target,inc) + check_flow(record,receipt,act);check_cut(record,receipt,act,im,om) + opt=record['exact_finite_optimum'];delta=tuple(opt['optimum_pair']);upper=active_edges(pairs,delta,True);lower=active_edges(pairs,delta,False) + need(opt['upper_flow']['feasible'],'saturating upper witness');check_flow(record,opt['upper_flow'],upper) + ni,no=check_cut(record,opt['strict_lower_cut'],lower,im,om);need(ni>no,'strict Hall failure') + # Deliberate corruptions exercise independent acceptance and complete-neighbor detection. + bad=copy.deepcopy(opt['upper_flow']);bad['flow_certificate']['positive_orbit_pair_flows'][0][2]+=1 + rejection(lambda:check_flow(record,bad,upper),'changed positive flow') + bad=copy.deepcopy(opt['strict_lower_cut']);bad['maximal_hall_cut']['output_orbits'].pop() + rejection(lambda:check_cut(record,bad,lower,im,om),'missing neighbor orbit') + # Treating the strict obstruction as inclusive must fail; this detects a wrong boundary convention. + rejection(lambda:check_cut(record,opt['strict_lower_cut'],upper,im,om),'strict cut used at inclusive threshold') + return {'radius':r,'inputs':len(xs),'candidate_outputs':len(ys),'error_one_edges':edge_total,'orbit_adjacencies':len(pairs),'optimum_pair':delta,'strict_cut':[ni,no],'strict_deficiency':ni-no,'negative_controls':3} + +def main(): + ap=argparse.ArgumentParser();ap.add_argument('receipt',type=Path,nargs='?',default=Path(__file__).resolve().parents[2]/'orbit-extension/RESULT.json');args=ap.parse_args();b=args.receipt.read_bytes();receipt=json.loads(b) + need(receipt['operator']==[list(row) for row in H],'operator') + rows=[verify(r) for r in receipt['completed_radii']] + need([r['radius'] for r in rows]==[6,7,9,11],'bounded scope') + print(json.dumps({'status':'PASS_INDEPENDENT_FULL_POINT_CERTIFICATES','receipt_sha256':hashlib.sha256(b).hexdigest(),'verified':rows,'method':'full individual-point and edge enumeration, actual class counts, 128-bit rational radical intervals, direct certificate conservation and complete Hall neighborhoods; imports no author code'},indent=2)) +if __name__=='__main__':main() diff --git a/research/sharp-finite-gaussian-outward-slack/review/extension/check_full_r9.py b/research/sharp-finite-gaussian-outward-slack/review/extension/check_full_r9.py new file mode 100644 index 0000000000..6fe6b373dc --- /dev/null +++ b/research/sharp-finite-gaussian-outward-slack/review/extension/check_full_r9.py @@ -0,0 +1,55 @@ +"""Independent dense-vertex verification of the radius-nine optimum.""" +from pathlib import Path +from types import ModuleType +from itertools import product +import hashlib,json,sys + +SOURCE=Path(__file__).with_name('full_graph_library.py') +M=ModuleType('independent_full_graph_library');M.__file__=str(SOURCE) +exec(compile(SOURCE.read_bytes(),str(SOURCE),'exec'),M.__dict__) +PAIR=(78,73);RADIUS=9 +LO,HI=M.gap_interval(*PAIR) +def strict(a,b): + if a<=b:return True + if (a,b)==PAIR:return False + lo,hi=M.gap_interval(a,b) + if hiHI:return False + raise ValueError(('unseparated exact radical gaps',a,b)) +def signature(points): + h=hashlib.sha256() + for point in sorted(points):h.update((','.join(map(str,point))+'\n').encode()) + return h.hexdigest() +def main(): + r=RADIUS;r2=r*r + pairs=[(a,b) for a in range(-r,r+1) for b in range(-r,r+1) if a*a+b*b<=r2] + xs=sorted((a,b,c,d) for a,b in pairs for c,d in pairs if a*a+b*b+c*c+d*d<=r2) + all_edges=[tuple(M.candidates(x)) for x in xs] + graph=[tuple(y for y in ys if strict(M.n2(y),M.n2(x))) for x,ys in zip(xs,all_edges)] + matching,left,right,rounds=M.maximum_matching(graph) + T={xs[i] for i in left} + M.need(len(T)-len(right)==64,'strict radius-nine Hall deficiency') + M.need(right=={y for x in T for y in M.candidates(x) if strict(M.n2(y),M.n2(x))},'complete lifted Hall neighborhood') + inclusive=[tuple(y for y in ys if strict(M.n2(y),M.n2(x)) or (M.n2(y),M.n2(x))==PAIR) for x,ys in zip(xs,all_edges)] + plus,lp,rp,prounds=M.maximum_matching(inclusive) + M.need(all(y is not None for y in plus) and not lp and not rp,'attaining full injection') + equality=sum((M.n2(y),M.n2(x))==PAIR for x,y in zip(xs,plus)) + M.need(equality>0,'attaining threshold edge present') + rows=[] + from collections import Counter + for kind,points in [('input_cut',T),('output_cut',right)]: + counts=Counter(M.dtype(x) for x in points) + rows.append({'side':kind,'orbits':[{'absolute_coordinates':k[0],'negative_product':k[1],'size':n} for k,n in sorted(counts.items())]}) + result={'marker':'PASS_INDEPENDENT_FULL_RADIUS_NINE_OPTIMUM','radius':r,'threshold_pair':PAIR, + 'inputs':len(xs),'complete_error_one_edges':sum(map(len,all_edges)), + 'strict_edges':sum(map(len,graph)),'inclusive_edges':sum(map(len,inclusive)), + 'strict_matching':sum(y is not None for y in matching),'strict_cut_inputs':len(T),'strict_cut_outputs':len(right),'deficiency':len(T)-len(right), + 'inclusive_matching':len(plus),'attaining_edges':equality,'augmenting_rounds':[rounds,prounds], + 'cut_input_sha256':signature(T),'cut_output_sha256':signature(right), + 'matching_sha256':signature(tuple(x)+tuple(y) for x,y in zip(xs,plus)), + 'orbit_counts':rows,'library_sha256':hashlib.sha256(SOURCE.read_bytes()).hexdigest(), + 'independence':'full individual-vertex matching and rational radical intervals; imports no author orbit-flow code, receipts or certificates', + 'negative_control':'strict predecessor graph has deficit64; equality edges restore a full injection', + 'scope':'finite radius-nine optimum and global necessary lower bound only; no global sufficiency'} + print(json.dumps(result,indent=2)) +if __name__=='__main__':main() diff --git a/research/sharp-finite-gaussian-outward-slack/review/extension/full_graph_library.py b/research/sharp-finite-gaussian-outward-slack/review/extension/full_graph_library.py new file mode 100644 index 0000000000..8b104b6ce5 --- /dev/null +++ b/research/sharp-finite-gaussian-outward-slack/review/extension/full_graph_library.py @@ -0,0 +1,115 @@ +"""Independent full-vertex matching and alternating Hall cut; no orbit optimizer.""" +from collections import Counter, deque +from itertools import product, permutations +from math import isqrt, prod +import json + +H = ((1,1,1,1),(1,-1,1,-1),(1,1,-1,-1),(1,-1,-1,1)) +Q = 1 << 128 +def need(ok, why): + if not ok: raise ValueError(why) +def n2(v): return sum(t*t for t in v) +def root_interval(n): + a=isqrt(n*Q*Q) + return a,a+int(a*a!=n*Q*Q) +def gap_interval(a,b): + la,ua=root_interval(a);lb,ub=root_interval(b) + return la-ub,ua-lb +BLO,BHI=gap_interval(21,19) +def strict(a,b): + if a<=b:return True + if (a,b)==(21,19):return False + lo,hi=gap_interval(a,b) + if hiBHI:return False + raise ValueError(('unseparated exact radical gaps',a,b)) +def candidates(x): + hx=tuple(sum(a*b for a,b in zip(row,x)) for row in H) + need(len({z%2 for z in hx})==1,'common Hadamard parity') + if hx[0]%2: + for bits in product((0,1),repeat=4): + yield tuple(z//2+t for z,t in zip(hx,bits)) + else: + c=tuple(z//2 for z in hx);yield c + for i in range(4): + for sign in (-1,1): + y=list(c);y[i]+=sign;yield tuple(y) +def maximum_matching(adj): + left=[None]*len(adj);right={};rounds=0 + while True: + dist=[-1]*len(adj);todo=deque() + for x,y in enumerate(left): + if y is None:dist[x]=0;todo.append(x) + end=False + while todo: + x=todo.popleft() + for y in adj[x]: + z=right.get(y) + if z is None:end=True + elif dist[z]<0:dist[z]=dist[x]+1;todo.append(z) + if not end:break + def augment(x): + for y in adj[x]: + z=right.get(y) + if z is None or (dist[z]==dist[x]+1 and augment(z)): + left[x]=y;right[y]=x;return True + dist[x]=-1;return False + gained=sum(augment(x) for x,y in enumerate(left) if y is None) + need(gained>0,'augmenting BFS progress');rounds+=1 + need(len(right)==sum(y is not None for y in left),'matching cardinality') + need(all(left[x]==y and y in adj[x] for y,x in right.items()),'matching edges') + lseen={x for x,y in enumerate(left) if y is None};rseen=set();todo=deque(lseen) + while todo: + x=todo.popleft() + for y in adj[x]: + if y in rseen:continue + rseen.add(y);need(y in right,'augmenting path remains') + z=right[y] + if z not in lseen:lseen.add(z);todo.append(z) + need(rseen=={y for x in lseen for y in adj[x]},'complete Hall neighborhood') + need(len(lseen)-len(rseen)==len(adj)-len(right),'maximal Hall deficiency') + return left,lseen,rseen,rounds +def dtype(x): + return tuple(sorted(map(abs,x))), (0 if 0 in x else int(prod(x)<0)) +def main(): + pairs=[(a,b) for a in range(-5,6) for b in range(-5,6) if a*a+b*b<=25] + xs=sorted((a,b,c,d) for a,b in pairs for c,d in pairs if a*a+b*b+c*c+d*d<=25) + need(len(xs)==3121,'complete ball count') + all_edges=[tuple(candidates(x)) for x in xs] + need(sum(map(len,all_edges))==39681,'complete error-one edge count') + for x,ys in zip(xs,all_edges): + hx=[sum(a*b for a,b in zip(row,x)) for row in H] + need(all(sum((2*a-b)**2 for a,b in zip(y,hx))<=4 for y in ys),'exact edge error') + adj=[tuple(y for y in ys if strict(n2(y),n2(x))) for x,ys in zip(xs,all_edges)] + matching,ls,ns,rounds=maximum_matching(adj);ts={xs[i] for i in ls} + group=[] + for perm in permutations(range(4)): + for signs in product((-1,1),repeat=4): + A=[[signs[i]*int(j==perm[i]) for j in range(4)] for i in range(4)] + num=[[sum(H[i][a]*A[a][b]*H[j][b] for a in range(4) for b in range(4)) for j in range(4)] for i in range(4)] + if any(z%4 for row in num for z in row):continue + B=[[z//4 for z in row] for row in num] + if not (all(sum(map(abs,row))==1 for row in B) and all(sum(abs(B[i][j]) for i in range(4))==1 for j in range(4))):continue + group.append((perm,signs,B)) + need({tuple(signs[i]*x[perm[i]] for i in range(4)) for x in ts}==ts,'input cut symmetry') + need({tuple(sum(B[i][j]*y[j] for j in range(4)) for i in range(4)) for y in ns}==ns,'output cut symmetry') + need(len(group)==192,'paired graph group count') + need(all(prod(s)==1 for _,s,_ in group),'group is even sign changes') + counts=Counter(dtype(x) for x in xs);tc=Counter(dtype(x) for x in ts) + need(all(v==counts[k] for k,v in tc.items()),'complete W(D4) input orbits') + output_universe={y for ys in all_edges for y in ys};oc=Counter(dtype(y) for y in output_universe);nc=Counter(dtype(y) for y in ns) + need(all(v==oc[k] for k,v in nc.items()),'complete W(D4) output orbits') + inclusive=[tuple(y for y in ys if strict(n2(y),n2(x)) or (n2(y),n2(x))==(21,19)) for x,ys in zip(xs,all_edges)] + im,il,ir,_=maximum_matching(inclusive) + need(all(y is not None for y in im) and not il and not ir,'inclusive threshold permits full matching') + out={'marker':'PASS_FULL_GRAPH_ALTERNATING_HALL_CUT','inputs':len(xs),'error_one_edges':sum(map(len,all_edges)), + 'strict_edges':sum(map(len,adj)),'strict_maximum_matching':sum(y is not None for y in matching), + 'strict_cut_inputs':len(ts),'strict_cut_outputs':len(ns),'strict_cut_deficiency':len(ts)-len(ns), + 'matching_rounds':rounds,'group_order':len(group),'group':'all coordinate permutations with an even number of sign changes', + 'input_orbits':[{'absolute_coordinates':k[0],'negative_product':k[1],'size':v} for k,v in sorted(tc.items())], + 'output_orbits':[{'absolute_coordinates':k[0],'negative_product':k[1],'size':v} for k,v in sorted(nc.items())], + 'strict_cut_input_points':sorted(ts),'strict_cut_output_points':sorted(ns), + 'negative_control':'including the 19-to-21 beta edges restores a complete matching', + 'method':'full vertex Hopcroft-Karp and alternating reachability; independent of compressed orbit min-cut'} + print(json.dumps(out,indent=2)) +if __name__=='__main__':main() From 3c7c3e8000f592fd9adecb44008ff6d5ae5d453d Mon Sep 17 00:00:00 2001 From: Jerry Jiaheng Chen <80299683+CubeJerry@users.noreply.github.com> Date: Fri, 13 Nov 2026 23:37:41 +1100 Subject: [PATCH 3/3] Clarify standalone archive replay and remove accidental malformed hook registration --- .../CHECKSUMS.sha256 | 4 ++-- .../PUBLICATION-MANIFEST.json | 16 ++++++++-------- .../README.md | 2 ++ .../{VERIFY.json => REPRODUCTION.json} | 0 4 files changed, 12 insertions(+), 10 deletions(-) rename research/sharp-finite-gaussian-outward-slack/{VERIFY.json => REPRODUCTION.json} (100%) diff --git a/research/sharp-finite-gaussian-outward-slack/CHECKSUMS.sha256 b/research/sharp-finite-gaussian-outward-slack/CHECKSUMS.sha256 index 367230cb3a..eab6b275ca 100644 --- a/research/sharp-finite-gaussian-outward-slack/CHECKSUMS.sha256 +++ b/research/sharp-finite-gaussian-outward-slack/CHECKSUMS.sha256 @@ -4,11 +4,11 @@ ba7a1125ae2c502e5f90de0214b37eefe03762818621f63891434b80d1250ef3 PR-DESCRIPTION 9650647a4713b7c35e9a61834578ca0d83ec960a5d5eb666f37b906a91a7f1e6 PR-DRAFT.md d00460ebf9579c49ae711079e3a21865571d82e7e42f8fc6bc11a08cf062f09b PROOF.md d26f615aacff4b082c316e491aa1730aabc9cb6ceb377d33fb9a279b2d7f5f16 R5-OPTIMUM.json.gz -6ca5638f4beed6b70a2d10b201bde9bbf66d49923608b753791f9fcb5fc5ed26 README.md +5e9c83e394d36a50a5cbec65acdf8a033df8c6c9a8752b19f02d34dbc057bb8b README.md 87ee11560e99e440fa47d0fb5f6799e8e85a100b8467b284605e58ef306fd1ce RESULT.json 58359532905649cd8c57f9400ae8e6858174a882e3be81824e063a714a1cd9e2 SEARCH-PROVENANCE.md e010d96e3b44bb10a0dddbbff66fb00dcd316e620b8feebd0e8477a84e0b1d51 SOURCES.json -f1ea9f91bf0f6517b30e278e2ae32bb8b23d4a451901eaae5a0ed652d1d5689c VERIFY.json +f1ea9f91bf0f6517b30e278e2ae32bb8b23d4a451901eaae5a0ed652d1d5689c REPRODUCTION.json a9e2c39ce39cfbc0327eed29bd249d1e7f02fe71c7847e9eeefac4e2b232de79 VERIFY.md 4c4647f16eb79881c324025c4e3a94d98b10750c12d345f730fed46c7569573c compact-hall/ORBIT-FLOW-RESULT.json c0a9ee164d3a466a4b3996e1075ef7443123ac5e99b0e4e9e05585411352ad21 compact-hall/PROOF.md diff --git a/research/sharp-finite-gaussian-outward-slack/PUBLICATION-MANIFEST.json b/research/sharp-finite-gaussian-outward-slack/PUBLICATION-MANIFEST.json index 262fc5e9eb..08fb8d62b6 100644 --- a/research/sharp-finite-gaussian-outward-slack/PUBLICATION-MANIFEST.json +++ b/research/sharp-finite-gaussian-outward-slack/PUBLICATION-MANIFEST.json @@ -9,7 +9,7 @@ "R5-OPTIMUM.json.gz", "RESULT.json", "SOURCES.json", - "VERIFY.json", + "REPRODUCTION.json", "VERIFY.md", "compact-hall/ORBIT-FLOW-RESULT.json", "compact-hall/PROOF.md", @@ -30,9 +30,9 @@ "files": [ { "path": "CHECKSUMS.sha256", - "bytes": 3989, - "sha256": "cf6e51d7d3ed42dc9ee9c4164c5e794e1ba54262e707036c48efbac962210e34", - "git_blob": "367230cb3ad309a972e5b93447c924e55307a124" + "bytes": 3995, + "sha256": "4aa7d1f4ddb13bd04091132f47329ee9e4a5bfb23af540ae4e2b134fcdfd6085", + "git_blob": "eab6b275ca4380d23a411956839ab059e7580ddd" }, { "path": "NOTICE.md", @@ -72,9 +72,9 @@ }, { "path": "README.md", - "bytes": 3026, - "sha256": "6ca5638f4beed6b70a2d10b201bde9bbf66d49923608b753791f9fcb5fc5ed26", - "git_blob": "927111d98f0b2ff7423b9660e470ea439b0bd46a" + "bytes": 3303, + "sha256": "5e9c83e394d36a50a5cbec65acdf8a033df8c6c9a8752b19f02d34dbc057bb8b", + "git_blob": "51b2a3180071a9bc53e66d357cf19ff21e379f67" }, { "path": "RESULT.json", @@ -95,7 +95,7 @@ "git_blob": "12b14ee4d31596420435206c19eb1ec319309274" }, { - "path": "VERIFY.json", + "path": "REPRODUCTION.json", "bytes": 462, "sha256": "f1ea9f91bf0f6517b30e278e2ae32bb8b23d4a451901eaae5a0ed652d1d5689c", "git_blob": "883e443f80b1fa34cf86af0d9bda593a5278b988" diff --git a/research/sharp-finite-gaussian-outward-slack/README.md b/research/sharp-finite-gaussian-outward-slack/README.md index 927111d98f..51b2a31800 100644 --- a/research/sharp-finite-gaussian-outward-slack/README.md +++ b/research/sharp-finite-gaussian-outward-slack/README.md @@ -43,6 +43,8 @@ radius-five compact check does not read the original matching certificate. ## Read-only reproduction +This archive uses [REPRODUCTION.json](REPRODUCTION.json) as a standalone replay guide, not a registered `research//VERIFY.json` manifest. The commands below are direct, read-only replays; the generic research-package hook does not validate or run this archive manifest. + Python 3.10+ and the standard library suffice. From this directory: ```sh diff --git a/research/sharp-finite-gaussian-outward-slack/VERIFY.json b/research/sharp-finite-gaussian-outward-slack/REPRODUCTION.json similarity index 100% rename from research/sharp-finite-gaussian-outward-slack/VERIFY.json rename to research/sharp-finite-gaussian-outward-slack/REPRODUCTION.json