From c9852bdac40c21c2d64c8d94aff260b484e28c4c Mon Sep 17 00:00:00 2001 From: Ali Romman <226877337+aliromman@users.noreply.github.com> Date: Wed, 18 Nov 2026 06:55:39 -0500 Subject: [PATCH 1/2] Classify sharp-radial Gaussian orders and prove the fourth-power optimum --- .../CREDITS.md | 36 + .../PROOF.md | 214 +++ .../README.md | 83 ++ .../RESULT.json | 1149 +++++++++++++++++ .../SOURCES.json | 18 + .../TASK.json | 99 ++ .../VERIFY.json | 34 + .../verify.py | 176 +++ 8 files changed, 1809 insertions(+) create mode 100644 research/gaussian-radial-order-classification/CREDITS.md create mode 100644 research/gaussian-radial-order-classification/PROOF.md create mode 100644 research/gaussian-radial-order-classification/README.md create mode 100644 research/gaussian-radial-order-classification/RESULT.json create mode 100644 research/gaussian-radial-order-classification/SOURCES.json create mode 100644 research/gaussian-radial-order-classification/TASK.json create mode 100644 research/gaussian-radial-order-classification/VERIFY.json create mode 100644 research/gaussian-radial-order-classification/verify.py diff --git a/research/gaussian-radial-order-classification/CREDITS.md b/research/gaussian-radial-order-classification/CREDITS.md new file mode 100644 index 0000000000..13113154f7 --- /dev/null +++ b/research/gaussian-radial-order-classification/CREDITS.md @@ -0,0 +1,36 @@ +# Sources and credit + +Prepared by Ali Romman with substantial OpenAI Codex assistance. +New work is Apache-2.0. Independent human and formal-kernel review are +unclaimed. The verifier follows the earlier half-grid conventions and +integer comparison method; it is not a blind review of those sources. + +- CubeJerry / Jerry Chen's [PR #7570](https://github.com/CrocSwap/integer-mult-bounds/pull/7570), + [exact proof](https://github.com/CubeJerry/integer-mult-bounds/blob/053c42c68165cf24fd4e8bc33c2b20d6ac3d399b/research/sharp-order-four-gaussian-rounding/proof/PROOF.md), + supplies the half-grid reduction and the sharp square-to-swap theorem. + Its global annular construction and attaining four-cycle supply the + upper bound for the weaker fourth-power class here. They are not new. + The full proof was read; its full package replay was not run. +- Ali Romman's [PR #7696](https://github.com/CrocSwap/integer-mult-bounds/pull/7696), + [exact proof](https://github.com/aliromman/integer-mult-bounds/blob/d7be8d9131a948ea1d25833e96906ea3da979764/research/gaussian-exact-sum-global-optimum/PROOF.md), + supplies the sharp unconstrained exact-sum value, the individual-ring + matching, square boundary costs and sharpness geometry. The new proof + forces every optimal map into those ring choices. The code adapts its + coordinate conventions and integer radical comparisons; the exhaustive + matching and orbit classifier are new. +- Ali Romman's [PR #7698](https://github.com/CrocSwap/integer-mult-bounds/pull/7698), + [exact proof](https://github.com/aliromman/integer-mult-bounds/blob/f821eb5ea909e5c56118c5042f7740d87f0355b2/research/phase-covariant-radial-ports/PROOF.md), + motivates the question through its failed fourth-power identity at the + optimum. Its phase/port construction is not replayed or changed here. + +The new lower proof assumes neither square-to-swap nor quarter-turn +symmetry. Its finite-capacity and cycle classification yield the general +finite-order gap and the exact weaker fourth-power lower bound. +The sources retain Nick Petalas's forward exact-sum question and first +finite witness, Ali Romman's next witness and ideal pair, and the earlier +Gaussian/native/compiler credit. No prior finite witness, generic matching +method, half-grid transform or upper construction is claimed as new. + +[PR #7572](https://github.com/CrocSwap/integer-mult-bounds/pull/7572) concerns +affine translation periods. That is a different condition from F^m=id; +it was checked for overlap and is not a mathematical dependency here. diff --git a/research/gaussian-radial-order-classification/PROOF.md b/research/gaussian-radial-order-classification/PROOF.md new file mode 100644 index 0000000000..1c0c15282a --- /dev/null +++ b/research/gaussian-radial-order-classification/PROOF.md @@ -0,0 +1,214 @@ +# Finite order has a strict radial cost for exact-sum Gaussian rounding + +Let `C_+(x,y)=((s+i*d)/2,(s-i*d)/2)`, with s=x+y and d=x-y. +Use the Euclidean norm on Gaussian-integer pairs. A map is admissible if +it is injective, preserves s exactly and has error at most one from C_+ +at every input. Write Delta for its forward outward norm supremum. + +**Theorem.** Put `rho=1/sqrt(2)`. Every admissible map with Delta<=rho +has the following exact classification on the sum-one fiber. On each +shell `|Re(d)|+|Im(d)|=R`, for odd R>=1, it is one of two permutations. +One has two cycles of length R, and the other has one cycle of length 2R. +Consequently, no such map has any finite global order. + +More quantitatively, if `F^m=id` for a positive integer m, then 4 divides +m and + +```text +Delta >= sqrt(2m^2+4m+3)-sqrt(2m^2+2m+1) > rho. +``` + +This bound is not claimed sharp for general m. For the fourth-power class +the exact optimum is + +```text +beta=sqrt(19)-sqrt(13). +``` + +The fourth-power lower bound does not assume `F^2=swap`, phase covariance, +wire-swap covariance, a translation period or quarter-turn symmetry. +The global upper construction is prior work from +[CubeJerry's PR #7570](https://github.com/CrocSwap/integer-mult-bounds/pull/7570), +[pinned all-input proof](https://github.com/CubeJerry/integer-mult-bounds/blob/053c42c68165cf24fd4e8bc33c2b20d6ac3d399b/research/sharp-order-four-gaussian-rounding/proof/PROOF.md). +It has the stronger square-to-swap property and hence fourth power one. +The sharp fourth-power conclusion uses that source's upper theorem. + +## 1. The exact graph and square boundary + +Use real two-vectors and set + +```text +J(a,b)=(-b,a), B(a,b)=(a+b,a-b), T=B/2, Q=-J. +``` + +For fixed s the output difference f(d) has the component parities of s. +The pair error squared is `|f(d)-Jd|^2/2`. In the sum-one fiber, both +components of this difference are odd integers. Error at most one is +therefore equivalent to both components being ±1. + +Set `t=T Jd` and `u=T f(d)`. The input t ranges over color A, the even +coordinate-sum points in `L=(Z+1/2)^2`. The output u ranges over the odd +color B. The legal outputs are exactly the four unit neighbors of t. +Both changes of coordinates are bijections on their respective cosets. +The pair squared norms are `1/2+|t|^2` and `1/2+|u|^2`. Thus F gives an +injection M_A from A to B along unit edges. Its action on the input +coordinate space A is + +```text +g=Q M_A, +``` + +because `T J B=Q`. This is a conjugate of F on this sum fiber, so their +cycle lengths agree. This half-grid framework is credited to PR #7570; +it does not impose that source's quarter-turn condition. + +Let D_r be the square of half-grid points with maximum coordinate +magnitude at most `r=k+1/2`, for k>=0. Each color has `2(k+1)^2` points. +An edge from D_r to its exterior changes one boundary coordinate from +absolute value r to r+1. For a fixed squared-radius increment the radial +gap decreases as the other coordinate's magnitude increases. Hence every +such edge costs at least + +```text +b(r)=sqrt(2r^2+2r+3/2)-sqrt(2r^2+1/2). +``` + +This exceeds rho for every r>=1/2. Positive squaring reduces the claim +to `(2r+1/2)^2>2(2r^2+1/2)`, or `2r>3/4`. + +If Delta=1, is the cycle graph with 4R +vertices. Its unit edges within the ring are exactly consecutive edges +of this cycle. A perfect matching of an even cycle has only two choices: +choose either edge at one vertex, then every remaining edge is forced. +Thus the complete matching is one of the two alternating edge sets. +This classifies all possible maps; no matching ansatz was imposed on F. + +Index the ring from its top right corner, through the top, left, bottom +and right sides. Each side includes its first corner and excludes its +last. The top right corner has color B, so A occupies the odd indices. +A matching sends these indices j to j+1 for all j, or to j-1 for all j, +modulo 4R. The clockwise quarter-turn Q subtracts R. Consequently g +acts on odd indices by + +```text +j -> j-R+1, or j -> j-R-1 (mod 4R). +``` + +On the 2R source points this is a cyclic translation by `(1-R)/2` or +`(-1-R)/2`. Each step is relatively prime to R, and the two steps have +opposite parity. Their orders are exactly 2R and R. A translation with +order R has two cycles; one with order 2R has one cycle. The same formula +covers R=1, where the choices are identity and transposition. + +Finally, `2 max(|t_1|,|t_2|)=|Re(d)|+|Im(d)|`, which identifies the +shell in the theorem. Both matchings use only tangential ring edges. For an edge with fixed +coordinate magnitude r and changing magnitudes u,u+1, one has r>=u+1. +With A=1/2+r^2+u^2, the inequality `(2u+1/2)^2<2A` gives radial gap +strictly below rho; a central sign toggle has zero gap. Arbitrary independent choices on +the rings therefore give exactly the stated sum-one possibilities. +They can be extended to other fibers with the existing global rounder +from [PR #7696](https://github.com/CrocSwap/integer-mult-bounds/pull/7696), +[pinned proof](https://github.com/aliromman/integer-mult-bounds/blob/d7be8d9131a948ea1d25833e96906ea3da979764/research/gaussian-exact-sum-global-optimum/PROOF.md). +No uniform finite m is a multiple of all these unbounded ring periods. + +## 3. A positive gap for every prescribed finite order + +On the zero-sum fiber the ideal Gaussian output is integral. Exact sum +and error at most one force exactness: its two Gaussian errors are e and +-e, and `2|e|^2<=1` implies e=0. Thus the nonzero difference rotates by +i at each step. If `F^m=id`, necessarily 4 divides m, so m>=4. + +The function b(r) is strictly decreasing for r>=3/2. Differentiating its +two positive square roots and comparing the positive terms shows that +the derivative has the sign of `-2r^2+2r+1/2`, which is negative there. + +Take `r=m+1/2` and `R=2m+1`. If Deltab(r)`. Their intervening ring therefore +has one of the two perfect matchings. Its periods R and 2R both exceed +m, so neither can occur under `F^m=id`. This contradiction gives +Delta>=b(m+1/2), the displayed quantitative bound. The strict inequality +above rho follows from Section 1. The result gives a necessary gap for +each fixed m; it is not an optimality theorem for every order. + +## 4. Sharp fourth-power lower bound + +Now assume only `F^4=id` in addition to the stated sum and error contract. +This identity itself implies injectivity. Put beta=`sqrt(19)-sqrt(13)`. +The two relevant square boundaries have costs + +```text +b(3/2)=3-sqrt(5) > beta, +b(5/2)=sqrt(19)-sqrt(13)=beta. +``` + +For an exact rational separation, the first is greater than 763/1000, +while beta is less than 754/1000. These follow from +`2237^2>5*1000^2`, `4359^2>19*1000^2` and `3605^2<13*1000^2`. +All square-root comparisons use positive quantities. + +If Delta=beta. No square-to-swap or symmetry premise +has entered this lower argument. + +The pinned global construction in PR #7570 preserves exact sum, has +error at most one, satisfies `F^2=swap` and has Delta=beta. Therefore it +also has `F^4=id` and attains the lower bound in this weaker class. Its +attaining cycle, retained here with credit, is + +```text +(3,-2) -> (3i,1-3i) -> (-2,3) -> (1-3i,3i) -> (3,-2). +``` + +The pair squared norms alternate 13 and 19. The cycle crosses the +critical ring at equality, so the proof must use a strict lower-threshold +hypothesis. The finite cycle is not, by itself, evidence for a global +upper map; that conclusion uses the pinned all-input construction. + +## 5. Evidence and limits + +The verifier enumerates every perfect matching in each of 33 complete +rings, for odd R from 1 through 65. It finds exactly two in each ring. +A direct orbit traversal and a separate gcd calculation agree on all +66 induced maps. All 2244 exterior edges from the corresponding squares +have radial cost strictly above rho and the exact Gaussian error one. +The two critical squares retain every exterior edge and exact comparison +with beta. Both ten-point maps are explicit in RESULT.json. + +Sixteen prescribed orders from 4 through 64 check the quantitative gap +and the incompatible large-ring orders. The source's attaining four-cycle +has direct sum, error and radial checks. Collision, forbidden central +outward-edge and strict-boundary controls pass. All arithmetic is integral. +These finite checks corroborate the all-ring argument, not a search-based +claim about arbitrary maps. + +The optimal-bound classification is stated on the sum-one fiber. It does +not classify every sum fiber or all maps above rho. The general finite-order +gap is not claimed sharp except for the separately proved fourth-power +case. A larger-block representation, extra state, relaxed exact sum or +a different error allowance is outside this theorem. The conjugate-inverse +condition is not an upper-construction promise for the fourth-power class. + +No physical provider, native tariff, full caller, multiplier invoice, +new kappa or selected-assumption discharge is supplied. The selected +frontier and all five assumptions remain unchanged. Full predecessor +package replays, selected cold replay, Lean and Docker were not run. +Independent human and formal-kernel review are unclaimed. + +Prepared by Ali Romman with substantial OpenAI Codex assistance. +[CREDITS.md](CREDITS.md) gives the precise new and retained source roles. +Apache-2.0. diff --git a/research/gaussian-radial-order-classification/README.md b/research/gaussian-radial-order-classification/README.md new file mode 100644 index 0000000000..58dd6b597e --- /dev/null +++ b/research/gaussian-radial-order-classification/README.md @@ -0,0 +1,83 @@ +# The radial cost of finite-order Gaussian rounding + +Every injective exact-sum Gaussian-pair rounder with error at most one +and optimal forward radial slack **1/sqrt(2)** has unbounded cycle lengths. +On the sum-one shell of odd difference taxicab radius R, it must have two +cycles of length R or one cycle of length 2R. No finite global order is +possible at this optimum. + +For the class with **F^4=id**, the sharp radial optimum is +**sqrt(19)-sqrt(13)**, even without F^2=swap, phase covariance or a +quarter-turn matching premise. The new lower bound combines with +CubeJerry's retained global upper construction from +[PR #7570](https://github.com/CrocSwap/integer-mult-bounds/pull/7570). +The upper construction and its attaining cycle remain prior work. + +[PROOF.md](PROOF.md) gives the classification, a positive necessary gap +for every prescribed finite order, and the fourth-power argument. +[RESULT.json](RESULT.json) retains both complete ten-point maps at the +critical ring, all critical exterior edges and the exact cycle checks. +The general finite-order bound is not claimed sharp for other orders. +No new kappa or selected-assumption discharge is claimed. + +## Evidence and reproduction + +Use CPython 3.12 and its standard library from the repository root: + +```sh +python3.12 -I -W error -B research/gaussian-radial-order-classification/verify.py +python3.12 -I -W error -B -O research/gaussian-radial-order-classification/verify.py +python3.12 -B scripts/research_package.py --package research/gaussian-radial-order-classification +python3.12 -B scripts/check_research_commit.py --package research/gaussian-radial-order-classification --check-source-history --check-modes +``` + +Expected markers are PASS_GAUSSIAN_RADIAL_ORDER_CLASSIFICATION, +PASS_REGISTERED_RESEARCH_PACKAGE and PASS_RESEARCH_COMMIT_BYTES. +The checker enumerates all matchings in 33 complete rings, with exactly +two per ring. Direct orbit traversal and a separate gcd calculation agree +on all 66 maps. All 2244 exterior edges have cost strictly above the +optimal threshold and direct Gaussian error one. The two critical squares +retain their complete boundary costs. Sixteen finite-order gaps and the +source's attaining four-cycle pass exact integer checks. Collision, +forbidden outward-edge and strict-threshold controls pass. + +The all-ring result follows from the written proof. The finite cycle is +not a standalone global upper construction; that conclusion uses the +pinned all-input source proof. Full predecessor package replays, selected +cold replay, Lean and Docker were not run. Independent human and +formal-kernel review are unclaimed. + +## Scope and source + +The classification is on the sum-one fiber. The no-finite-order conclusion +applies to every global map in the stated optimum class. The fourth-power +lower bound uses no additional symmetry; its upper map is not promised to +have conjugation as inverse. Larger blocks, extra state, changed error +allowances and relaxed sum constraints remain outside this theorem. +No physical provider, native tariff, full caller or complete multiplication +invoice is supplied. The selected frontier and all five assumptions remain. + +Base: canonical main e54523517d0f03e58352e647c403a5af3e525a57, priority +revision 8. The uniform-transfer card changes scope to the local precision +and functional-order implication. [TASK.json](TASK.json) records the family +decision and remaining obligations. The [advance claim](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19707892) follows +the exact-sum handoff. Live handoffs, source-reference intake, refreshed +PR/Discussion overlap and the complete closed snapshot with an updated-order +delta show no competing claim. Sparse local and unpublished work remain +coverage limits. Affine translation periods are a different model. + +## Open next questions + +For a specified finite order other than four, what global construction +attains the best possible radial budget? First fix the order, conserved +observables and error allowance. A necessary gap alone does not establish +its optimum. A larger-block or stateful caller needs a separate contract. + +## Credit + +Prepared by Ali Romman with substantial OpenAI Codex assistance. +Credit CubeJerry/Jerry Chen for the half-grid and prior upper construction, +Ali Romman for the global optimum and ring map, and Nick Petalas for the +forward-only exact-sum question. [CREDITS.md](CREDITS.md) links the exact +proofs and distinguishes the new classification/lower bound from prior +constructions. New work is Apache-2.0. diff --git a/research/gaussian-radial-order-classification/RESULT.json b/research/gaussian-radial-order-classification/RESULT.json new file mode 100644 index 0000000000..6f2ce090cc --- /dev/null +++ b/research/gaussian-radial-order-classification/RESULT.json @@ -0,0 +1,1149 @@ +{ + "status": "PASS_GAUSSIAN_RADIAL_ORDER_CLASSIFICATION", + "claim": "Every optimal sum-one map has ring orders R or 2R; no finite global order; sharp fourth-power slack sqrt(19)-sqrt(13)", + "complete_ring_domains": [ + { + "r_doubled": 1, + "source_points": 2, + "matching_count": 2, + "orders": [ + 1, + 2 + ] + }, + { + "r_doubled": 3, + "source_points": 6, + "matching_count": 2, + "orders": [ + 3, + 6 + ] + }, + { + "r_doubled": 5, + "source_points": 10, + "matching_count": 2, + "orders": [ + 5, + 10 + ] + }, + { + "r_doubled": 7, + "source_points": 14, + "matching_count": 2, + "orders": [ + 7, + 14 + ] + }, + { + "r_doubled": 9, + "source_points": 18, + "matching_count": 2, + "orders": [ + 9, + 18 + ] + }, + { + "r_doubled": 11, + "source_points": 22, + "matching_count": 2, + "orders": [ + 11, + 22 + ] + }, + { + "r_doubled": 13, + "source_points": 26, + "matching_count": 2, + "orders": [ + 13, + 26 + ] + }, + { + "r_doubled": 15, + "source_points": 30, + "matching_count": 2, + "orders": [ + 15, + 30 + ] + }, + { + "r_doubled": 17, + "source_points": 34, + "matching_count": 2, + "orders": [ + 17, + 34 + ] + }, + { + "r_doubled": 19, + "source_points": 38, + "matching_count": 2, + "orders": [ + 19, + 38 + ] + }, + { + "r_doubled": 21, + "source_points": 42, + "matching_count": 2, + "orders": [ + 21, + 42 + ] + }, + { + "r_doubled": 23, + "source_points": 46, + "matching_count": 2, + "orders": [ + 23, + 46 + ] + }, + { + "r_doubled": 25, + "source_points": 50, + "matching_count": 2, + "orders": [ + 25, + 50 + ] + }, + { + "r_doubled": 27, + "source_points": 54, + "matching_count": 2, + "orders": [ + 27, + 54 + ] + }, + { + "r_doubled": 29, + "source_points": 58, + "matching_count": 2, + "orders": [ + 29, + 58 + ] + }, + { + "r_doubled": 31, + "source_points": 62, + "matching_count": 2, + "orders": [ + 31, + 62 + ] + }, + { + "r_doubled": 33, + "source_points": 66, + "matching_count": 2, + "orders": [ + 33, + 66 + ] + }, + { + "r_doubled": 35, + "source_points": 70, + "matching_count": 2, + "orders": [ + 35, + 70 + ] + }, + { + "r_doubled": 37, + "source_points": 74, + "matching_count": 2, + "orders": [ + 37, + 74 + ] + }, + { + "r_doubled": 39, + "source_points": 78, + "matching_count": 2, + "orders": [ + 39, + 78 + ] + }, + { + "r_doubled": 41, + "source_points": 82, + "matching_count": 2, + "orders": [ + 41, + 82 + ] + }, + { + "r_doubled": 43, + "source_points": 86, + "matching_count": 2, + "orders": [ + 43, + 86 + ] + }, + { + "r_doubled": 45, + "source_points": 90, + "matching_count": 2, + "orders": [ + 45, + 90 + ] + }, + { + "r_doubled": 47, + "source_points": 94, + "matching_count": 2, + "orders": [ + 47, + 94 + ] + }, + { + "r_doubled": 49, + "source_points": 98, + "matching_count": 2, + "orders": [ + 49, + 98 + ] + }, + { + "r_doubled": 51, + "source_points": 102, + "matching_count": 2, + "orders": [ + 51, + 102 + ] + }, + { + "r_doubled": 53, + "source_points": 106, + "matching_count": 2, + "orders": [ + 53, + 106 + ] + }, + { + "r_doubled": 55, + "source_points": 110, + "matching_count": 2, + "orders": [ + 55, + 110 + ] + }, + { + "r_doubled": 57, + "source_points": 114, + "matching_count": 2, + "orders": [ + 57, + 114 + ] + }, + { + "r_doubled": 59, + "source_points": 118, + "matching_count": 2, + "orders": [ + 59, + 118 + ] + }, + { + "r_doubled": 61, + "source_points": 122, + "matching_count": 2, + "orders": [ + 61, + 122 + ] + }, + { + "r_doubled": 63, + "source_points": 126, + "matching_count": 2, + "orders": [ + 63, + 126 + ] + }, + { + "r_doubled": 65, + "source_points": 130, + "matching_count": 2, + "orders": [ + 65, + 130 + ] + } + ], + "ring_classifications": 33, + "ring_matchings": 66, + "exterior_edges": 2244, + "ring_maps_sha256": "f396ac04b49f3124b16d9bff7b5752143886c74b66c0e3ee7f722e434348d37a", + "critical_ring_maps": [ + { + "cycles": [ + 5, + 5 + ], + "map": [ + [ + [ + 0, + 2, + 1, + -2 + ], + [ + -2, + 0, + 3, + 0 + ] + ], + [ + [ + -1, + 1, + 2, + -1 + ], + [ + -1, + -1, + 2, + 1 + ] + ], + [ + [ + -2, + 0, + 3, + 0 + ], + [ + 0, + -2, + 1, + 2 + ] + ], + [ + [ + 1, + 2, + 0, + -2 + ], + [ + -1, + 1, + 2, + -1 + ] + ], + [ + [ + -1, + -1, + 2, + 1 + ], + [ + 1, + -2, + 0, + 2 + ] + ], + [ + [ + 2, + 1, + -1, + -1 + ], + [ + 0, + 2, + 1, + -2 + ] + ], + [ + [ + 0, + -2, + 1, + 2 + ], + [ + 2, + -1, + -1, + 1 + ] + ], + [ + [ + 3, + 0, + -2, + 0 + ], + [ + 1, + 2, + 0, + -2 + ] + ], + [ + [ + 2, + -1, + -1, + 1 + ], + [ + 2, + 1, + -1, + -1 + ] + ], + [ + [ + 1, + -2, + 0, + 2 + ], + [ + 3, + 0, + -2, + 0 + ] + ] + ] + }, + { + "cycles": [ + 10 + ], + "map": [ + [ + [ + 0, + 2, + 1, + -2 + ], + [ + -1, + -1, + 2, + 1 + ] + ], + [ + [ + -1, + 1, + 2, + -1 + ], + [ + 0, + -2, + 1, + 2 + ] + ], + [ + [ + -2, + 0, + 3, + 0 + ], + [ + 1, + -2, + 0, + 2 + ] + ], + [ + [ + 1, + 2, + 0, + -2 + ], + [ + -2, + 0, + 3, + 0 + ] + ], + [ + [ + -1, + -1, + 2, + 1 + ], + [ + 2, + -1, + -1, + 1 + ] + ], + [ + [ + 2, + 1, + -1, + -1 + ], + [ + -1, + 1, + 2, + -1 + ] + ], + [ + [ + 0, + -2, + 1, + 2 + ], + [ + 3, + 0, + -2, + 0 + ] + ], + [ + [ + 3, + 0, + -2, + 0 + ], + [ + 0, + 2, + 1, + -2 + ] + ], + [ + [ + 2, + -1, + -1, + 1 + ], + [ + 1, + 2, + 0, + -2 + ] + ], + [ + [ + 1, + -2, + 0, + 2 + ], + [ + 2, + 1, + -1, + -1 + ] + ] + ] + } + ], + "critical_square_boundaries": [ + { + "r_doubled": 3, + "source_points": 8, + "exterior_edges": [ + { + "source": [ + -3, + -1 + ], + "target": [ + -5, + -1 + ], + "squared_norms": [ + 3, + 7 + ], + "beta_category": 1 + }, + { + "source": [ + -3, + 3 + ], + "target": [ + -5, + 3 + ], + "squared_norms": [ + 5, + 9 + ], + "beta_category": 1 + }, + { + "source": [ + -3, + 3 + ], + "target": [ + -3, + 5 + ], + "squared_norms": [ + 5, + 9 + ], + "beta_category": 1 + }, + { + "source": [ + -1, + -3 + ], + "target": [ + -1, + -5 + ], + "squared_norms": [ + 3, + 7 + ], + "beta_category": 1 + }, + { + "source": [ + 1, + 3 + ], + "target": [ + 1, + 5 + ], + "squared_norms": [ + 3, + 7 + ], + "beta_category": 1 + }, + { + "source": [ + 3, + -3 + ], + "target": [ + 3, + -5 + ], + "squared_norms": [ + 5, + 9 + ], + "beta_category": 1 + }, + { + "source": [ + 3, + -3 + ], + "target": [ + 5, + -3 + ], + "squared_norms": [ + 5, + 9 + ], + "beta_category": 1 + }, + { + "source": [ + 3, + 1 + ], + "target": [ + 5, + 1 + ], + "squared_norms": [ + 3, + 7 + ], + "beta_category": 1 + } + ] + }, + { + "r_doubled": 5, + "source_points": 18, + "exterior_edges": [ + { + "source": [ + -5, + -3 + ], + "target": [ + -7, + -3 + ], + "squared_norms": [ + 9, + 15 + ], + "beta_category": 1 + }, + { + "source": [ + -5, + 1 + ], + "target": [ + -7, + 1 + ], + "squared_norms": [ + 7, + 13 + ], + "beta_category": 1 + }, + { + "source": [ + -5, + 5 + ], + "target": [ + -7, + 5 + ], + "squared_norms": [ + 13, + 19 + ], + "beta_category": 0 + }, + { + "source": [ + -5, + 5 + ], + "target": [ + -5, + 7 + ], + "squared_norms": [ + 13, + 19 + ], + "beta_category": 0 + }, + { + "source": [ + -3, + -5 + ], + "target": [ + -3, + -7 + ], + "squared_norms": [ + 9, + 15 + ], + "beta_category": 1 + }, + { + "source": [ + -1, + 5 + ], + "target": [ + -1, + 7 + ], + "squared_norms": [ + 7, + 13 + ], + "beta_category": 1 + }, + { + "source": [ + 1, + -5 + ], + "target": [ + 1, + -7 + ], + "squared_norms": [ + 7, + 13 + ], + "beta_category": 1 + }, + { + "source": [ + 3, + 5 + ], + "target": [ + 3, + 7 + ], + "squared_norms": [ + 9, + 15 + ], + "beta_category": 1 + }, + { + "source": [ + 5, + -5 + ], + "target": [ + 5, + -7 + ], + "squared_norms": [ + 13, + 19 + ], + "beta_category": 0 + }, + { + "source": [ + 5, + -5 + ], + "target": [ + 7, + -5 + ], + "squared_norms": [ + 13, + 19 + ], + "beta_category": 0 + }, + { + "source": [ + 5, + -1 + ], + "target": [ + 7, + -1 + ], + "squared_norms": [ + 7, + 13 + ], + "beta_category": 1 + }, + { + "source": [ + 5, + 3 + ], + "target": [ + 7, + 3 + ], + "squared_norms": [ + 9, + 15 + ], + "beta_category": 1 + } + ] + } + ], + "finite_order_gap_checks": [ + { + "order": 4, + "r_doubled": 9, + "gap_squared_norms": [ + 41, + 51 + ], + "ring_orders": [ + 9, + 18 + ] + }, + { + "order": 8, + "r_doubled": 17, + "gap_squared_norms": [ + 145, + 163 + ], + "ring_orders": [ + 17, + 34 + ] + }, + { + "order": 12, + "r_doubled": 25, + "gap_squared_norms": [ + 313, + 339 + ], + "ring_orders": [ + 25, + 50 + ] + }, + { + "order": 16, + "r_doubled": 33, + "gap_squared_norms": [ + 545, + 579 + ], + "ring_orders": [ + 33, + 66 + ] + }, + { + "order": 20, + "r_doubled": 41, + "gap_squared_norms": [ + 841, + 883 + ], + "ring_orders": [ + 41, + 82 + ] + }, + { + "order": 24, + "r_doubled": 49, + "gap_squared_norms": [ + 1201, + 1251 + ], + "ring_orders": [ + 49, + 98 + ] + }, + { + "order": 28, + "r_doubled": 57, + "gap_squared_norms": [ + 1625, + 1683 + ], + "ring_orders": [ + 57, + 114 + ] + }, + { + "order": 32, + "r_doubled": 65, + "gap_squared_norms": [ + 2113, + 2179 + ], + "ring_orders": [ + 65, + 130 + ] + }, + { + "order": 36, + "r_doubled": 73, + "gap_squared_norms": [ + 2665, + 2739 + ], + "ring_orders": [ + 73, + 146 + ] + }, + { + "order": 40, + "r_doubled": 81, + "gap_squared_norms": [ + 3281, + 3363 + ], + "ring_orders": [ + 81, + 162 + ] + }, + { + "order": 44, + "r_doubled": 89, + "gap_squared_norms": [ + 3961, + 4051 + ], + "ring_orders": [ + 89, + 178 + ] + }, + { + "order": 48, + "r_doubled": 97, + "gap_squared_norms": [ + 4705, + 4803 + ], + "ring_orders": [ + 97, + 194 + ] + }, + { + "order": 52, + "r_doubled": 105, + "gap_squared_norms": [ + 5513, + 5619 + ], + "ring_orders": [ + 105, + 210 + ] + }, + { + "order": 56, + "r_doubled": 113, + "gap_squared_norms": [ + 6385, + 6499 + ], + "ring_orders": [ + 113, + 226 + ] + }, + { + "order": 60, + "r_doubled": 121, + "gap_squared_norms": [ + 7321, + 7443 + ], + "ring_orders": [ + 121, + 242 + ] + }, + { + "order": 64, + "r_doubled": 129, + "gap_squared_norms": [ + 8321, + 8451 + ], + "ring_orders": [ + 129, + 258 + ] + } + ], + "beta_bracket": [ + 753347668076684259117759, + 753347668076684259117762, + 1000000000000000000000000 + ], + "retained_attaining_four_cycle": [ + [ + 3, + 0, + -2, + 0 + ], + [ + 0, + 3, + 1, + -3 + ], + [ + -2, + 0, + 3, + 0 + ], + [ + 1, + -3, + 0, + 3 + ] + ], + "upper_proof_source": "CubeJerry PR7570@053c42c68165cf24fd4e8bc33c2b20d6ac3d399b:proof/PROOF.md; full predecessor replay not run", + "controls": [ + "colliding target map", + "forbidden outward edge at rho", + "strict beta boundary; equality is allowed" + ] +} diff --git a/research/gaussian-radial-order-classification/SOURCES.json b/research/gaussian-radial-order-classification/SOURCES.json new file mode 100644 index 0000000000..5335fa97d9 --- /dev/null +++ b/research/gaussian-radial-order-classification/SOURCES.json @@ -0,0 +1,18 @@ +{ + "schema_version": 1, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "75d77b328ea02ded535e7f23aee5b1e55d0bb1a8", + "sha256": "154c3d30455d778fd3343b6b4851f0fa4665f0f7625b0adb3675e2bafbbf6bf1" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81" + } + ] +} diff --git a/research/gaussian-radial-order-classification/TASK.json b/research/gaussian-radial-order-classification/TASK.json new file mode 100644 index 0000000000..b42a8cb05d --- /dev/null +++ b/research/gaussian-radial-order-classification/TASK.json @@ -0,0 +1,99 @@ +{ + "schema_version": 1, + "task_id": "uniform-transfer-audit", + "priority_revision": 8, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "original_card": { + "id": "uniform-transfer-audit", + "question": "Can one of the selected record's five inherited assumptions be proved at its actual caller?", + "starting_points": [ + "docs/research/current-priorities.md", + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md" + ], + "methods": [ + "Construct and independently check one source-bound instance of the stated first experiment.", + "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change." + ], + "acceptance_gate": "Identify the proposition and what would change downstream; do not equate a finite replay with a universal proof.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.", + "scope": "Source-bound orientation only, not a supplier replay or theorem proof." + }, + "first_experiment": "Choose one assumption ID (native_all_columns, owned_erasure, compiler, precision_tape, analytic_recovery), one quantified implication and exact dependency closure. Check current handoffs, including #5625 row reentry and #5707 root-prefix lowering, without treating their partial scope as the whole theorem. Prove or falsify that implication with a caller-bound argument; stop at the chosen obligation. Finite tests or root digits do not discharge an all-size statement.", + "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.", + "allowed_variations": [ + "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes." + ], + "scope_change_triggers": [ + "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.", + "Treating an archived proposal or local numerical pass as complete supplier admission." + ], + "overlap_terms": [ + "native_all_columns", + "owned_erasure", + "compiler", + "precision_tape", + "analytic_recovery" + ], + "existing_checks": [ + { + "scope": "PR #4100: proposed unconditional construction and finite checks, without independent acceptance.", + "evidence": "research/unconditional-batched-crt/README.md", + "remaining": "Independent proof audit of one caller-bound all-size implication; all other premises remain explicit.", + "status": "author-checked", + "source_commit": "337d04939571a637aeab54a0f58f54fde811663a", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.", + "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.", + "status": "reviewed", + "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137", + "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + } + ] + }, + "scope_status": "changed", + "actual_scope": "Classify every optimal sum-one exact-sum error-one rounder; prove unbounded periods, a finite-order gap and the sharp fourth-power radial budget without square-to-swap.", + "scope_change_reason": "Determine whether the finite-order failure of the sharp radial provider is unavoidable, and remove the square-to-swap premise from the known order-four lower bound.", + "bottleneck_link": "A caller cannot require a finite provider order at the optimal radial budget. The exact fourth-power budget is higher even without additional symmetry requirements.", + "budget_minutes": 60, + "stop_rule": "Stop at this numerical/algebraic boundary. Larger blocks, extra state, physical implementation and other finite-order optima remain separate.", + "outcome": "completed", + "evidence": "PROOF.md; RESULT.json; 33 complete rings, 66 exhaustive matchings, 2244 exterior edges, exact critical-square records, source four-cycle and sixteen finite-order gap checks.", + "author": "Ali Romman", + "ai_assistance": "Substantial OpenAI Codex assistance; no independent human or formal-kernel review claimed.", + "open_questions": [ + { + "question": "What is the sharp radial budget for a specified finite order other than four, or for an explicit larger-block contract?", + "why_it_matters": "The quantitative order bound is necessary but not claimed optimal for general m.", + "first_step": "Fix the order, conserved observables and error allowance; prove both a global construction and a matching lower obstruction.", + "blocked_by": "Only the fourth-power class has an exact optimum here." + } + ], + "family_decision": { + "decision": "Resolve the finite-order implication left by the optimum provider, then stop at the classification and fourth-power boundary.", + "sources": "7696@d7be8d9131a948ea1d25833e96906ea3da979764; 7570@053c42c68165cf24fd4e8bc33c2b20d6ac3d399b; motivation 7698@f821eb5ea909e5c56118c5042f7740d87f0355b2", + "evidence_status": "Author-checked lower/classification proof and exact finite corroboration; fourth-power upper uses the pinned all-input predecessor construction.", + "boundary": "Gaussian pairs, exact conserved sum, injectivity and Euclidean error at most one; the finite-order and fourth-power results add only the stated iterate identity.", + "obligations": { + "optimal_sum_one_classification": "proved", + "finite_order_exclusion_and_gap": "proved", + "fourth_power_lower": "proved without square-to-swap or symmetry", + "fourth_power_upper": "retained global construction from PR7570; full source replay unrun", + "general_order_sharpness": "open", + "physical_and_selected_caller": "not supplied" + }, + "alternative": "A local search for an optimum finite-order map cannot escape this necessary ring classification.", + "construction_gate": "No physical implementation is proposed. A different contract must state which hypothesis changes and price the full consumer." + } +} diff --git a/research/gaussian-radial-order-classification/VERIFY.json b/research/gaussian-radial-order-classification/VERIFY.json new file mode 100644 index 0000000000..3d6b3fe137 --- /dev/null +++ b/research/gaussian-radial-order-classification/VERIFY.json @@ -0,0 +1,34 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Complete ring matching enumeration, direct cycle and gcd orders, exact square-boundary costs, Gaussian edge errors, fourth-power obstruction and retained attaining cycle." + }, + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "-O", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Complete ring matching enumeration, direct cycle and gcd orders, exact square-boundary costs, Gaussian edge errors, fourth-power obstruction and retained attaining cycle." + } + ] +} diff --git a/research/gaussian-radial-order-classification/verify.py b/research/gaussian-radial-order-classification/verify.py new file mode 100644 index 0000000000..9f5da9e5f5 --- /dev/null +++ b/research/gaussian-radial-order-classification/verify.py @@ -0,0 +1,176 @@ +#!/usr/bin/env python3 +"""Check exact ring classifications and the fourth-power obstruction. + +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +""" +from itertools import product +from math import gcd,isqrt +from pathlib import Path +import hashlib +import json + +ROOT=Path(__file__).resolve().parent +SCALE=10**24 +LOW=isqrt(19*SCALE*SCALE)-isqrt(13*SCALE*SCALE)-1 +HIGH=LOW+3 + + +def need(value,message): + if not value:raise ValueError(message) + + +def color(point):return ((point[0]+point[1])//2)%2 + +def neighbors(point): + x,y=point + return {(x-2,y),(x+2,y),(x,y-2),(x,y+2)} + + +def norm(point):return (point[0]*point[0]+point[1]*point[1]+2)//4 + +def at_most_rho(a,b): + difference=b-a + return difference<=0 or (2*difference-1)**2<=8*a + + +def gap_le(a,b,p,q): + remainder=(b-a)*q*q-p*p + return remainder<=0 or remainder*remainder<=4*a*p*p*q*q + + +def beta_category(a,b): + if (a,b)==(13,19):return 0 + if gap_le(a,b,LOW,SCALE):return -1 + need(not gap_le(a,b,HIGH,SCALE),'Unresolved beta comparison') + return 1 + + +def cycle(r): + points=[];x=y=r + for dx,dy in [(-2,0),(0,-2),(2,0),(0,2)]: + for _ in range(r):points.append((x,y));x+=dx;y+=dy + need((x,y)==(r,r) and len(set(points))==4*r,'Complete ring walk') + return points + + +def matchings(points): + target={z for z in points if color(z)==1} + source=[z for z in points if color(z)==0] + edges={z:sorted(neighbors(z)&target) for z in source} + need(all(len(v)==2 for v in edges.values()),'Ring degree two') + found=[] + def visit(index,used,mapping): + if index==len(source): + found.append(dict(mapping));return + u=source[index] + for v in edges[u]: + if v not in used: + used.add(v);mapping[u]=v;visit(index+1,used,mapping);used.remove(v);del mapping[u] + visit(0,set(),{}) + return found + + +def cycles(mapping): + need(set(mapping)==set(mapping.values()) and len(mapping)==len(set(mapping.values())),'Permutation coverage') + seen=set();sizes=[] + for u in sorted(mapping): + if u in seen:continue + current=u;length=0 + while current not in seen: + seen.add(current);length+=1;current=mapping[current] + need(current==u,'Closed orbit');sizes.append(length) + return sorted(sizes) + + +def source_pair(t): + x,y=t + return ((2+x-y)//4,-(x+y)//4,(2-x+y)//4,(x+y)//4) + + +def target_pair(u): + x,y=u + return ((2+x+y)//4,(x-y)//4,(2-x-y)//4,(-x+y)//4) + + +def direct_error(source,target): + a,b,c,d=source;sx,sy=a+c,b+d;dx,dy=a-c,b-d + ideal2=(sx-dy,sy+dx,sx+dy,sy-dx) + need((target[0]+target[2],target[1]+target[3])==(sx,sy)==(1,0),'Exact sum') + return sum((2*a-b)**2 for a,b in zip(target,ideal2)) + + +def verify(): + ring_rows=[];boundary_edges=0;digest=hashlib.sha256();critical=None + for r in range(1,66,2): + points=cycle(r);index={z:j for j,z in enumerate(points)} + square={(x,y) for x in range(-r,r+1,2) for y in range(-r,r+1,2)} + a={z for z in square if color(z)==0};b=square-a + need(len(a)==len(b)==(r+1)**2//2,'Equal square capacities') + for u in a: + for v in neighbors(u)-square: + need(norm(v)>norm(u) and not at_most_rho(norm(u),norm(v)),'Every exterior edge costs more than rho') + need(direct_error(source_pair(u),target_pair(v))==4,'Direct exterior Gaussian error') + boundary_edges+=1 + ms=matchings(points);need(len(ms)==2,'Exactly two complete ring matchings') + periods=[];records=[] + for matching in ms: + g={u:(v[1],-v[0]) for u,v in matching.items()} + lengths=cycles(g);periods.append(lengths[0]) + need(len(set(lengths))==1,'Uniform ring periods') + shifts={(index[g[u]]-index[u])%(4*r) for u in g} + need(len(shifts)==1 and shifts <= {(1-r)%(4*r),(-1-r)%(4*r)},'Forced Gaussian shift') + step=next(iter(shifts))//2;expected=2*r//gcd(2*r,step) + need(lengths[0]==expected,'Independent cycle and gcd orders') + rows=[] + for u,v in sorted(matching.items()): + source,target=source_pair(u),target_pair(v) + need(direct_error(source,target)==4,'Direct ring Gaussian error') + need(at_most_rho(norm(u),norm(v)),'Ring radial bound') + rows.append([source,target]);digest.update(f'{u}:{v};'.encode()) + records.append({'cycles':lengths,'map':rows}) + need(sorted(periods)==[r,2*r],'Both possible exact orders') + ring_rows.append({'r_doubled':r,'source_points':2*r,'matching_count':2,'orders':sorted(periods)}) + if r==5:critical=records + need(critical is not None,'Critical ring') + critical_boundaries=[] + for r in [3,5]: + square={(x,y) for x in range(-r,r+1,2) for y in range(-r,r+1,2)} + edges=[] + for u in sorted(z for z in square if color(z)==0): + for v in sorted(neighbors(u)-square): + category=beta_category(norm(u),norm(v)) + need(category>=0,'Square is closed below beta') + edges.append({'source':u,'target':v,'squared_norms':[norm(u),norm(v)],'beta_category':category}) + critical_boundaries.append({'r_doubled':r,'source_points':(r+1)**2//2,'exterior_edges':edges}) + need(all(row['orders']==[5,10] for row in ring_rows if row['r_doubled']==5),'No fourth-power matching') + need(2237**2>5*1000**2 and 4359**2>19*1000**2 and 3605**2<13*1000**2,'Exact strict boundary separation') + finite_order=[] + for m in range(4,65,4): + r=2*m+1;a=(r*r+1)//2;b=(r*r+2*r+3)//2 + need(not at_most_rho(a,b),'Positive finite-order gap') + orders=sorted(2*r//gcd(2*r,(sign-r)//2) for sign in [-1,1]) + need(orders==[r,2*r] and all(m%order for order in orders),'Large ring defeats prescribed finite order') + finite_order.append({'order':m,'r_doubled':r,'gap_squared_norms':[a,b],'ring_orders':orders}) + # The known source four-cycle attains beta and crosses the critical ring. + upper_cycle=[(3,0,-2,0),(0,3,1,-3),(-2,0,3,0),(1,-3,0,3)] + for a,b in zip(upper_cycle,upper_cycle[1:]+upper_cycle[:1]): + need(direct_error(a,b)==4,'Retained attaining cycle error') + need(beta_category(sum(x*x for x in a),sum(x*x for x in b))<=0,'Retained attaining cycle radial cost') + need([sum(x*x for x in z) for z in upper_cycle]==[13,19,13,19],'Attaining squared norms') + bad={z:(0,0) for z in [(1,-1),(-1,1)]} + try:cycles(bad) + except ValueError:pass + else:raise ValueError('Collision control accepted') + need(not at_most_rho(1,3),'Outward central edge is not rho-admissible') + need(beta_category(13,19)==0,'Strict-boundary control') + result={'status':'PASS_GAUSSIAN_RADIAL_ORDER_CLASSIFICATION','claim':'Every optimal sum-one map has ring orders R or 2R; no finite global order; sharp fourth-power slack sqrt(19)-sqrt(13)', + 'complete_ring_domains':ring_rows,'ring_classifications':len(ring_rows),'ring_matchings':2*len(ring_rows),'exterior_edges':boundary_edges,'ring_maps_sha256':digest.hexdigest(), + 'critical_ring_maps':critical,'critical_square_boundaries':critical_boundaries,'finite_order_gap_checks':finite_order,'beta_bracket':[LOW,HIGH,SCALE], + 'retained_attaining_four_cycle':upper_cycle,'upper_proof_source':'CubeJerry PR7570@053c42c68165cf24fd4e8bc33c2b20d6ac3d399b:proof/PROOF.md; full predecessor replay not run', + 'controls':['colliding target map','forbidden outward edge at rho','strict beta boundary; equality is allowed']} + return json.loads(json.dumps(result)) + + +if __name__=='__main__': + result=verify();need(result==json.loads((ROOT/'RESULT.json').read_text()),'Retained receipt') + print(json.dumps(result,indent=2,sort_keys=True)) From 2a5dcb314ccdfeed24bd86ec1f56f519eead56c1 Mon Sep 17 00:00:00 2001 From: Ali Romman <226877337+aliromman@users.noreply.github.com> Date: Wed, 18 Nov 2026 06:59:14 -0500 Subject: [PATCH 2/2] Verify that the fourth-power class strictly exceeds square-to-swap --- .../CREDITS.md | 6 +++++ .../PROOF.md | 15 ++++++++++++- .../README.md | 4 +++- .../RESULT.json | 10 ++++++++- .../verify.py | 22 +++++++++++++++++-- 5 files changed, 52 insertions(+), 5 deletions(-) diff --git a/research/gaussian-radial-order-classification/CREDITS.md b/research/gaussian-radial-order-classification/CREDITS.md index 13113154f7..1ee698d986 100644 --- a/research/gaussian-radial-order-classification/CREDITS.md +++ b/research/gaussian-radial-order-classification/CREDITS.md @@ -34,3 +34,9 @@ method, half-grid transform or upper construction is claimed as new. [PR #7572](https://github.com/CrocSwap/integer-mult-bounds/pull/7572) concerns affine translation periods. That is a different condition from F^m=id; it was checked for overlap and is not a mathematical dependency here. + +The proper-weakening control uses the minimum-error affine center family +in Ali Romman's [PR #6509](https://github.com/CrocSwap/integer-mult-bounds/pull/6509), +[pinned proof](https://github.com/aliromman/integer-mult-bounds/blob/a4173e810c4d34a1d13b9745af123ad0ec6cfed5/research/conservative-gaussian-rounding/PROOF.md). +The particular parity-only center is used only to show that F^4=id does +not imply F^2=swap. No first affine rounding construction is claimed. diff --git a/research/gaussian-radial-order-classification/PROOF.md b/research/gaussian-radial-order-classification/PROOF.md index 1c0c15282a..4effb00649 100644 --- a/research/gaussian-radial-order-classification/PROOF.md +++ b/research/gaussian-radial-order-classification/PROOF.md @@ -179,6 +179,18 @@ critical ring at equality, so the proof must use a strict lower-threshold hypothesis. The finite cycle is not, by itself, evidence for a global upper map; that conclusion uses the pinned all-input construction. +The weaker class is strictly larger. As a control, put c(s)=0 for +equal-parity sums and c(s)=1 for mixed sums, then set +`f(d)=i*(d-c(s))+c(s)`. This is the minimum-error affine family from +[PR #6509](https://github.com/CrocSwap/integer-mult-bounds/pull/6509), +[pinned center proof](https://github.com/aliromman/integer-mult-bounds/blob/a4173e810c4d34a1d13b9745af123ad0ec6cfed5/research/conservative-gaussian-rounding/PROOF.md). +The parity rule gives integral outputs; the error is |c(s)|<=1. +The sum and center stay fixed, so four iterations give identity, with +the negative rotation as inverse. But (1,0) is fixed, whereas wire swap +sends it to (0,1). Thus fourth power does not force square-to-swap even +within the exact-sum, error-one class. This prior affine family is a +proper-weakening control, not the new attaining upper construction. + ## 5. Evidence and limits The verifier enumerates every perfect matching in each of 33 complete @@ -192,7 +204,8 @@ with beta. Both ten-point maps are explicit in RESULT.json. Sixteen prescribed orders from 4 through 64 check the quantitative gap and the incompatible large-ring orders. The source's attaining four-cycle has direct sum, error and radial checks. Collision, forbidden central -outward-edge and strict-boundary controls pass. All arithmetic is integral. +outward-edge and strict-boundary controls pass. The affine control checks +625 inputs through four steps and retains its square-to-swap failure. All arithmetic is integral. These finite checks corroborate the all-ring argument, not a search-based claim about arbitrary maps. diff --git a/research/gaussian-radial-order-classification/README.md b/research/gaussian-radial-order-classification/README.md index 58dd6b597e..968d6b9237 100644 --- a/research/gaussian-radial-order-classification/README.md +++ b/research/gaussian-radial-order-classification/README.md @@ -39,7 +39,9 @@ on all 66 maps. All 2244 exterior edges have cost strictly above the optimal threshold and direct Gaussian error one. The two critical squares retain their complete boundary costs. Sixteen finite-order gaps and the source's attaining four-cycle pass exact integer checks. Collision, -forbidden outward-edge and strict-threshold controls pass. +forbidden outward-edge and strict-threshold controls pass. A credited +affine control checks 625 inputs and shows that the fourth-power class +is strictly larger than the square-to-swap class. The all-ring result follows from the written proof. The finite cycle is not a standalone global upper construction; that conclusion uses the diff --git a/research/gaussian-radial-order-classification/RESULT.json b/research/gaussian-radial-order-classification/RESULT.json index 6f2ce090cc..3b11bae9fa 100644 --- a/research/gaussian-radial-order-classification/RESULT.json +++ b/research/gaussian-radial-order-classification/RESULT.json @@ -1140,10 +1140,18 @@ 3 ] ], + "proper_weakening_affine_cases": 625, + "affine_fixed_witness": [ + 1, + 0, + 0, + 0 + ], "upper_proof_source": "CubeJerry PR7570@053c42c68165cf24fd4e8bc33c2b20d6ac3d399b:proof/PROOF.md; full predecessor replay not run", "controls": [ "colliding target map", "forbidden outward edge at rho", - "strict beta boundary; equality is allowed" + "strict beta boundary; equality is allowed", + "fourth power does not force square-to-swap" ] } diff --git a/research/gaussian-radial-order-classification/verify.py b/research/gaussian-radial-order-classification/verify.py index 9f5da9e5f5..dd4468fc48 100644 --- a/research/gaussian-radial-order-classification/verify.py +++ b/research/gaussian-radial-order-classification/verify.py @@ -157,6 +157,24 @@ def verify(): need(direct_error(a,b)==4,'Retained attaining cycle error') need(beta_category(sum(x*x for x in a),sum(x*x for x in b))<=0,'Retained attaining cycle radial cost') need([sum(x*x for x in z) for z in upper_cycle]==[13,19,13,19],'Attaining squared norms') + def affine(value): + a,b,c,d=value;sx,sy=a+c,b+d;dx,dy=a-c,b-d + center=(sx+sy)%2;ex,ey=-dy+center,dx-center + numerators=(sx+ex,sy+ey,sx-ex,sy-ey) + need(all(v%2==0 for v in numerators),'Affine integer halves') + out=tuple(v//2 for v in numerators) + ideal2=(sx-dy,sy+dx,sx+dy,sy-dx) + need(sum((2*u-v)**2 for u,v in zip(out,ideal2))==4*center,'Affine control exact error') + need((out[0]+out[2],out[1]+out[3])==(sx,sy),'Affine control exact sum') + return out + affine_cases=0 + for value in product(range(-2,3),repeat=4): + after=value + for _ in range(4):after=affine(after) + need(after==value,'Affine fourth power') + affine_cases+=1 + witness=(1,0,0,0) + need(affine(affine(witness))==witness and witness!=witness[2:]+witness[:2],'Proper weakening of square-to-swap') bad={z:(0,0) for z in [(1,-1),(-1,1)]} try:cycles(bad) except ValueError:pass @@ -166,8 +184,8 @@ def verify(): result={'status':'PASS_GAUSSIAN_RADIAL_ORDER_CLASSIFICATION','claim':'Every optimal sum-one map has ring orders R or 2R; no finite global order; sharp fourth-power slack sqrt(19)-sqrt(13)', 'complete_ring_domains':ring_rows,'ring_classifications':len(ring_rows),'ring_matchings':2*len(ring_rows),'exterior_edges':boundary_edges,'ring_maps_sha256':digest.hexdigest(), 'critical_ring_maps':critical,'critical_square_boundaries':critical_boundaries,'finite_order_gap_checks':finite_order,'beta_bracket':[LOW,HIGH,SCALE], - 'retained_attaining_four_cycle':upper_cycle,'upper_proof_source':'CubeJerry PR7570@053c42c68165cf24fd4e8bc33c2b20d6ac3d399b:proof/PROOF.md; full predecessor replay not run', - 'controls':['colliding target map','forbidden outward edge at rho','strict beta boundary; equality is allowed']} + 'retained_attaining_four_cycle':upper_cycle,'proper_weakening_affine_cases':affine_cases,'affine_fixed_witness':witness,'upper_proof_source':'CubeJerry PR7570@053c42c68165cf24fd4e8bc33c2b20d6ac3d399b:proof/PROOF.md; full predecessor replay not run', + 'controls':['colliding target map','forbidden outward edge at rho','strict beta boundary; equality is allowed','fourth power does not force square-to-swap']} return json.loads(json.dumps(result))