From 8da45a76a26979d4ee4b0a204bc77036d3e74966 Mon Sep 17 00:00:00 2001 From: Ali Romman <226877337+aliromman@users.noreply.github.com> Date: Wed, 18 Nov 2026 10:30:25 -0500 Subject: [PATCH 1/2] Prove sharp Gaussian radial budgets for every finite iterate --- .../CREDITS.md | 43 + .../gaussian-finite-iterate-optimum/PROOF.md | 271 +++ .../gaussian-finite-iterate-optimum/README.md | 91 + .../RESULT.json | 1479 +++++++++++++++++ .../SOURCES.json | 18 + .../gaussian-finite-iterate-optimum/TASK.json | 98 ++ .../VERIFY.json | 34 + .../gaussian-finite-iterate-optimum/verify.py | 329 ++++ 8 files changed, 2363 insertions(+) create mode 100644 research/gaussian-finite-iterate-optimum/CREDITS.md create mode 100644 research/gaussian-finite-iterate-optimum/PROOF.md create mode 100644 research/gaussian-finite-iterate-optimum/README.md create mode 100644 research/gaussian-finite-iterate-optimum/RESULT.json create mode 100644 research/gaussian-finite-iterate-optimum/SOURCES.json create mode 100644 research/gaussian-finite-iterate-optimum/TASK.json create mode 100644 research/gaussian-finite-iterate-optimum/VERIFY.json create mode 100644 research/gaussian-finite-iterate-optimum/verify.py diff --git a/research/gaussian-finite-iterate-optimum/CREDITS.md b/research/gaussian-finite-iterate-optimum/CREDITS.md new file mode 100644 index 0000000000..fb085c9b3b --- /dev/null +++ b/research/gaussian-finite-iterate-optimum/CREDITS.md @@ -0,0 +1,43 @@ +# Attribution and exact source pins + +Ali Romman prepared the finite-iterate optimum, shifted annular assembly, +proof and checks with substantial OpenAI Codex assistance. New work is +Apache-2.0. It is author-checked, not independent review of its sources. + +Jerry Chen / CubeJerry's +[PR #7570](https://github.com/CrocSwap/integer-mult-bounds/pull/7570), head +`053c42c68165cf24fd4e8bc33c2b20d6ac3d399b`, supplies the +[half-grid framework, annular matching and sharp square-to-swap theorem](https://github.com/CubeJerry/integer-mult-bounds/blob/053c42c68165cf24fd4e8bc33c2b20d6ac3d399b/research/sharp-order-four-gaussian-rounding/proof/PROOF.md). +That full proof was read. The annular construction and connector cycle +are adapted here to arbitrary odd starting radii and prescribed iterate +identities. Its m=4 optimum is retained, not claimed as new. No CubeJerry +source code is copied; the local partner rule and separate arc generator +implement the cited mathematical construction. + +Ali Romman's [PR #7699](https://github.com/CrocSwap/integer-mult-bounds/pull/7699), +head `2a5dcb314ccdfeed24bd86ec1f56f519eead56c1`, supplies the +[forced ring classification and finite-order lower framework](https://github.com/aliromman/integer-mult-bounds/blob/2a5dcb314ccdfeed24bd86ec1f56f519eead56c1/research/gaussian-radial-order-classification/PROOF.md) +and [exact coordinate, cycle and radical-comparison routines](https://github.com/aliromman/integer-mult-bounds/blob/2a5dcb314ccdfeed24bd86ec1f56f519eead56c1/research/gaussian-radial-order-classification/verify.py) +adapted in this package. The proof is source-relative and the checker +is not blind to that source. No predecessor module is imported. +The new step selects the first incompatible odd radius, handles the +central exception, and assembles a total map that attains its lower bound. + +The [retained source credits](https://github.com/aliromman/integer-mult-bounds/blob/2a5dcb314ccdfeed24bd86ec1f56f519eead56c1/research/gaussian-radial-order-classification/CREDITS.md) +identify Ali Romman's global optimum and ring construction in +[PR #7696](https://github.com/CrocSwap/integer-mult-bounds/pull/7696), +the provider question in +[PR #7698](https://github.com/CrocSwap/integer-mult-bounds/pull/7698), +the earlier Gaussian contract in +[PR #6509](https://github.com/CrocSwap/integer-mult-bounds/pull/6509), +and Nick Petalas's exact-sum question in +[PR #7652](https://github.com/CrocSwap/integer-mult-bounds/pull/7652). +The present result does not count those prior bounds, contracts or +constructions as new. The source notices retain the earlier native and +tensor lineage, including its known limitations. + +Douglas Colkitt and the repository contributors supplied the research +framework, task catalogue and package tools. SOURCES.json pins the +main-branch provenance at `e54523517d0f03e58352e647c403a5af3e525a57`. +The consumed unmerged proof and code commits are pinned above and are +not represented as ancestors of main. Full predecessor suites were not run. diff --git a/research/gaussian-finite-iterate-optimum/PROOF.md b/research/gaussian-finite-iterate-optimum/PROOF.md new file mode 100644 index 0000000000..0b18ba82a3 --- /dev/null +++ b/research/gaussian-finite-iterate-optimum/PROOF.md @@ -0,0 +1,271 @@ +# Sharp radial budget for each finite Gaussian iterate identity + +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +This is an author-checked local precision theorem. No new kappa follows. + +## 1. Statement + +For Gaussian integers x,y, put `s=x+y`, `d=x-y`, and +`C_+(x,y)=((s+i*d)/2,(s-i*d)/2)`. Use the Euclidean norm of the pair. +For a positive integer m, consider total maps F on Gaussian pairs with +exact sum, error at most one from C_+, and `F^m=id`. Define + +```text +Delta(F) = sup_z max(0, ||F(z)||-||z||). +``` + +Such a map exists exactly when 4 divides m. In that case let R be the +least odd integer at least five that does not divide m. The exact minimum is + +```text +beta_R = sqrt((R^2+2R+3)/2) - sqrt((R^2+1)/2). (1) +``` + +The construction below attains this value on a full four-cycle. It has +an explicit inverse and global Gaussian-unit covariance. Its forward, +inverse outward and absolute radial suprema all equal beta_R. The lower +bound assumes none of these additional symmetry properties. + +The requirement is the iterate identity `F^m=id`. The theorem does not +require m to be the least positive global period. The constructed map's +least period divides m and can be smaller. An exact-least-period constraint +is a different optimization problem. + +Examples of (m,R,beta_R) are + +```text +(4, 5, sqrt(19)-sqrt(13)), +(20, 7, sqrt(33)-5), +(140, 9, sqrt(51)-sqrt(41)), +(1260, 11, sqrt(73)-sqrt(61)), +(13860,13, sqrt(99)-sqrt(85)). +``` + +The m=4 value and its annular construction are prior results of +[CubeJerry's PR #7570](https://github.com/CrocSwap/integer-mult-bounds/pull/7570), +[pinned proof](https://github.com/CubeJerry/integer-mult-bounds/blob/053c42c68165cf24fd4e8bc33c2b20d6ac3d399b/research/sharp-order-four-gaussian-rounding/proof/PROOF.md), +and the fourth-power-only lower bound in +[PR #7699](https://github.com/CrocSwap/integer-mult-bounds/pull/7699), +[pinned proof](https://github.com/aliromman/integer-mult-bounds/blob/2a5dcb314ccdfeed24bd86ec1f56f519eead56c1/research/gaussian-radial-order-classification/PROOF.md). +The present result supplies the optimum for every prescribed finite +iterate, using the first incompatible ring and a new global assembly. + +## 2. Half-grid reduction and lower bound + +Use real two-vectors, with `J(a,b)=(-b,a)`, `B(a,b)=(a+b,a-b)`, +`T=B/2`, and `Q=-J`. The output difference f(d) must have the same +component parities as s. The pair error squared is +`|f(d)-Jd|^2/2`. When the component parities of s agree, the ideal +output is integral. Exact sum makes its two Gaussian errors e and -e. +Error at most one then forces e=0. In particular, the nonzero zero-sum +fiber rotates exactly by i. Any global iterate identity requires 4 to +divide m. + +For mixed parities, set `t=T Jd` and `u=T f(d)`. Both coordinates lie +in `Z+1/2`. The error bound is equivalent to u being a unit neighbor +of t. Their colors, defined by coordinate-sum parity, are opposite. +At sum s=1 the source color A is even and the target color is odd. +The pair squared norms are `1/2+|t|^2` and `1/2+|u|^2`. The action on +the source coordinate space A is `g=Q M_A`, where M_A sends t to u. +It is conjugate to F on that sum fiber. These conventions and the +unit-edge reduction come from the cited PR #7570 proof. + +Let D_r be the square of half-grid points with maximum coordinate +magnitude at most r, for r a positive half-integer. Each color has +the same finite number of points. The minimum forward radial cost of +an edge from its A points to the exterior is + +```text +b(r) = sqrt(2r^2+2r+3/2)-sqrt(2r^2+1/2). (2) +``` + +Indeed the changing magnitude goes from r to r+1. The radial gap +decreases as the other coordinate magnitude increases, and that +magnitude is at most r. Corners of color A attain the minimum. +If `Delta(F)=3/2`. Comparing its two +positive derivative terms gives the sign of `-2r^2+2r+1/2`, which +is negative there. Also `b(r)>1/sqrt(2)` on this range, by positive +squaring. These boundary facts are retained from PR #7699. + +Take r=R/2. Since R>=5, both r and r-1 are in the decreasing range. +If `Delta(F)(a+2,a)` and its four quarter-turn rotations. +On the inner top side, pair consecutive entries of + +```text +(-a+2,a), (-a+4,a), ..., (a-2,a). +``` + +On the outer top side, pair consecutive entries of + +```text +(a+2,a+2), (a,a+2), ..., (-a+2,a+2). +``` + +Rotate those pairs through all four quarter-turns. The two lists have +a-1 and a+1 vertices, both even. After the connector endpoints are +removed, the four rotated arcs are disjoint and cover every remaining +vertex. At a=1 the inner list is empty. Thus this is a complete +involutive matching on the two rings, with M commuting with Q. +Consequently `(Q M)^2=Q^2` and `(Q M)^4=id` there. + +The annular edge formula is adapted from CubeJerry's construction. +The general starting radius and its assembly with directed single-ring +maps are the changed steps. M on the whole grid need not be involutive. + +## 4. Assemble the global permutation + +Fix m divisible by four and its first incompatible odd R>=5. + +If 3 divides m, use single-ring cyclic maps on every odd doubled +radius below R, including one and three. If 3 does not divide m, +pair the central radii one and three by the annular rule, and use +single-ring maps at every odd radius from five through R-2. + +In both cases, pair all remaining rings as + +```text +(R,R+2), (R+4,R+6), (R+8,R+10), ... . (3) +``` + +These pieces are disjoint and cover L. All are unit-neighbor bijections +between the colors and commute with Q. Every single-ring radius divides +m by the definition of R and the central case split. Every paired-ring +piece has fourth power one under g=Q M. Thus `g^m=id` on all of L. + +The formula is local and total: locate the ring, select its single-ring +or paired-ring case, and use its position on one of four sides. It needs +no growing matching table or search over input points. On single rings, +M inverse is the predecessor. On paired rings, it is the same partner. + +Return to Gaussian pairs. For equal-parity sums use f(d)=Jd. For mixed +sums use `f(d)=B M(T Jd)`, then `F(x,y)=((s+f(d))/2,(s-f(d))/2)`. +M exchanges colors, so these outputs are Gaussian integers. Their +sum is s and their error is one in the mixed case, zero otherwise. +In transformed coordinates the action is g=Q M, so `F^m=id` everywhere. + +For a mixed output difference d', the inverse difference is +`-J B M^-1(T d')`. For equal parities it is -Jd'. This proves both +inverse identities. The same M is used for all mixed sum fibers and +both colors. Its quarter-turn covariance gives global Gaussian-unit +covariance of F. No sum-dependent lookup table is used. + +## 5. Uniform sharp radial bound + +On any mixed-sum fiber, the squared pair norms are `c+|t|^2` and +`c+|M(t)|^2`, with `c=|s|^2/2>=1/2`. Increasing c decreases the absolute +radial jump of a fixed edge. Tangential edges have jump below +`1/sqrt(2)`. A connector with inner doubled radius a has jump at most +`b(a/2)`, attained at a corner on a sum of norm one. + +For the outer pairs (3), the inner a are R,R+4,... . Since R>=5 and b +decreases there, their largest possible jump is b(R/2)=beta_R. + +The only other connectors are the optional central pair, with cost +`b(1/2)=sqrt(3)-1`. If this pair is used, 3 does not divide m. Then 9 +does not divide m either, so R is 5, 7 or 9. All three beta values +exceed the central cost. It is enough to check + +```text +sqrt(3)-1 < 733/1000 < sqrt(51)-sqrt(41) = beta_9, +``` + +followed by the decreasing property of b. Both comparisons follow by +positive integer squaring and are checked exactly. This central case is +why the first incompatible radius starts at five, not at three. + +Thus every edge has absolute radial gap at most beta_R. Equal-parity +fibers have zero radial change. This proves a uniform all-input upper +bound for forward and inverse outward slack as well. + +Let `a=(R+1)/2`. The first outer connector gives the Gaussian four-cycle + +```text +(a,1-a) -> (a*i,1-a*i) -> (1-a,a) -> (1-a*i,a*i) -> (a,1-a). +``` + +Its squared norms alternate `(R^2+1)/2` and `(R^2+2R+3)/2`. It attains +beta_R in both directions, so all three radial suprema equal the lower +bound. This is the source's connector cycle with the new radius R; +the all-input argument above, not this cycle alone, supplies attainment. + +Finite iterate identities can approach the unrestricted optimum +`1/sqrt(2)` as closely as desired. Take m divisible by four and by all +odd integers through a growing cutoff. Its first incompatible R tends +to infinity, and (1) tends to `1/sqrt(2)` by rationalization. No finite +m attains that limit, in agreement with PR #7699. This is a radial +precision tradeoff, not a multiplication-exponent improvement. + +## 6. Verification and limits + +The checker evaluates the first-incompatible-radius rule for all 1024 +positive multiples of four through 4096. Twenty-three complete finite +grid fixtures cover 20 distinct cutoffs from five through 61, including both central choices +at R=5,7,9. They cover 41032 half-grid points. A separate arc generator +agrees with the local point rule. Direct orbit traversal agrees with +the algebraic cycle orders and checks divisibility into the prescribed m, +including large m without iterating m times. + +All 2424 exterior edges of the two critical squares across 20 cutoffs +meet the claimed lower threshold. The construction checks both colors, +every inverse, unit error, phase covariance, radial inequality and each +attaining cycle. An additional 19208 Gaussian inputs cover all component +parities, eight iterate choices and both inverse identities. + +Deleting the central annular case fails the identity for m=4,20,140. +Leaving the first incompatible ring as a single ring also fails. The +unchanged fourth-power construction exceeds the new m=20 radial budget. +The zero-sum control has exact period four. These checks use integer +arithmetic and certified square-root comparisons. The unbounded theorem +rests on the written proof, not the finite grid sizes. + +The result changes no selected caller or physical provider. It does not +claim inverse by conjugation, row/column tensor commutation, a native +tariff, restored scratch, a complete multiplier invoice or discharge +of a selected assumption. The known tensor limitations in the cited +source remain. Exact least period, extra state, larger blocks, changed +error bounds and relaxed sum constraints are outside the theorem. +Full predecessor suites, selected cold replay, native/physical replay, +Lean, Docker, independent human and formal-kernel review were not run. diff --git a/research/gaussian-finite-iterate-optimum/README.md b/research/gaussian-finite-iterate-optimum/README.md new file mode 100644 index 0000000000..ebdf7381cf --- /dev/null +++ b/research/gaussian-finite-iterate-optimum/README.md @@ -0,0 +1,91 @@ +# Sharp radial budgets for finite Gaussian iterate identities + +**Scoped all-input optimum; no new kappa.** Fix a positive integer m. +A total Gaussian-pair map can preserve exact sum, stay within Euclidean +error one of the positive half-transform, and satisfy `F^m=id` exactly +when four divides m. In that case, let R be the first odd integer at +least five that does not divide m. The sharp forward outward slack is + +```text +sqrt((R^2+2R+3)/2) - sqrt((R^2+1)/2). +``` + +The proof gives a global bijection with an explicit inverse. It attains +the same bound for absolute radial change and inverse outward slack. +The map has Gaussian-unit covariance; the lower bound assumes no symmetry. +The requirement is the iterate identity, not that m be the least period. + +Examples: m=4 retains the known `sqrt(19)-sqrt(13)` optimum. At m=20, +the optimum is `sqrt(33)-5`; at m=140, it is `sqrt(51)-sqrt(41)`. +Finite iterate budgets approach `1/sqrt(2)` as their compatible odd +ring periods increase. No finite iterate attains that limit. + +Read [PROOF.md](PROOF.md), [RESULT.json](RESULT.json), +[verify.py](verify.py) and [CREDITS.md](CREDITS.md). + +The lower bound isolates the first incompatible ring between two +invariant finite squares. The upper map uses directed cycles on allowed +single rings and shifted pairs of annuli outside that radius. If three +does not divide m, the two central rings need a separate paired case. +The code has a local point rule and does not store an unbounded table. + +## Reproduce + +Use CPython 3.12 and the standard library: + +```sh +python3 -B scripts/research_package.py --package research/gaussian-finite-iterate-optimum +``` + +Both registered normal and optimized commands print: + +```text +PASS_GAUSSIAN_FINITE_ITERATE_OPTIMUM +1024 iterate budgets; 23 complete grids; 41032 half-grid points +2424 lower-boundary edges; 19208 full Gaussian inputs; all controls pass +``` + +The complete grid checks compare the local map with a separate arc +generator, follow every cycle, verify the stated iterate identity, +check both colors and inverses, and attain each exact bound. Twenty +distinct critical cutoffs from five through 61 have complete lower- +boundary checks. The Gaussian inputs include every component parity +and eight iterate choices. All comparisons use integers and certified +square-root intervals. The proof establishes the all-input and all-m +claims; these finite domains corroborate them. + +Controls reject omission of the central paired case, a single map on +the first incompatible ring, and reuse of the old fourth-power budget +at m=20. The zero-sum fiber forces divisibility by four. No finite +attaining cycle is treated as a complete global construction on its own. + +## Scope and credit + +CubeJerry/Jerry Chen supplied the half-grid and annular map in +[PR #7570](https://github.com/CrocSwap/integer-mult-bounds/pull/7570). +Ali Romman's [PR #7699](https://github.com/CrocSwap/integer-mult-bounds/pull/7699) +supplied the forced ring classification, no-finite-order optimum and +fourth-power-only lower bound. Those results are prior work. This +package supplies the first-incompatible-ring formula and an attaining +global map for every prescribed iterate identity. The source roles, +exact pins, reused routines and retained geometric credit are in CREDITS.md. + +The selected kappa remains `0.00363005817`, with all five assumptions. +No native tariff, physical provider, tensor caller, scratch restoration +or complete recursive invoice is supplied. Inverse by conjugation and +row/column tensor commutation are not claimed. Full predecessor suites, +selected cold replay, native/physical replay, Lean, Docker, independent +human and formal-kernel review were not run. This is author-checked work; +the adapted checker is not an independent source review. + +## Open next questions + +The theorem specifies an iterate identity. If an actual caller needs +exact least period m, identify that caller and the period requirement +before further construction. The present map can have a smaller period. +Its local point rule also needs a complete physical cost and restoration +contract before native use. Exact local identities do not provide tensor +commutation or supplier admission. No follow-up is reserved. + +Prepared by Ali Romman with substantial OpenAI Codex assistance. +Apache-2.0. diff --git a/research/gaussian-finite-iterate-optimum/RESULT.json b/research/gaussian-finite-iterate-optimum/RESULT.json new file mode 100644 index 0000000000..d2e3d9ab23 --- /dev/null +++ b/research/gaussian-finite-iterate-optimum/RESULT.json @@ -0,0 +1,1479 @@ +{ + "controls": [ + { + "iterate": 4, + "omitted_central_pair_cycle_lengths": [ + 6, + 6 + ] + }, + { + "iterate": 20, + "omitted_central_pair_cycle_lengths": [ + 6, + 6 + ] + }, + { + "iterate": 140, + "omitted_central_pair_cycle_lengths": [ + 6, + 6 + ] + } + ], + "cutoff_distribution": { + "5": 820, + "7": 175, + "9": 26, + "11": 3 + }, + "fixtures": [ + { + "attaining_cycle": [ + [ + 3, + 0, + -2, + 0 + ], + [ + 0, + 3, + 1, + -3 + ], + [ + -2, + 0, + 3, + 0 + ], + [ + 1, + -3, + 0, + 3 + ] + ], + "central_pair": false, + "cutoff": 5, + "cycle_lengths": { + "1": 4, + "4": 60, + "6": 2 + }, + "iterate": 12, + "map_order": 12, + "map_sha256": "7b3eb4ff75dc41b391c6d65ff095f5d2c521950a49dcd262774f57684da6fe98", + "points": 256, + "threshold_squared_norms": [ + 13, + 19 + ] + }, + { + "attaining_cycle": [ + [ + 3, + 0, + -2, + 0 + ], + [ + 0, + 3, + 1, + -3 + ], + [ + -2, + 0, + 3, + 0 + ], + [ + 1, + -3, + 0, + 3 + ] + ], + "central_pair": true, + "cutoff": 5, + "cycle_lengths": { + "4": 64 + }, + "iterate": 4, + "map_order": 4, + "map_sha256": "0f148fe15578533344d6bbbe569edac4c50c714872c4930b67148b2978e21716", + "points": 256, + "threshold_squared_norms": [ + 13, + 19 + ] + }, + { + "attaining_cycle": [ + [ + 4, + 0, + -3, + 0 + ], + [ + 0, + 4, + 1, + -4 + ], + [ + -3, + 0, + 4, + 0 + ], + [ + 1, + -4, + 0, + 4 + ] + ], + "central_pair": false, + "cutoff": 7, + "cycle_lengths": { + "1": 4, + "4": 72, + "5": 4, + "6": 2 + }, + "iterate": 60, + "map_order": 60, + "map_sha256": "f0b2097c50f0afeed21899a6a3a0168b92ed3c5110ee24d15e687fe840fc6c5b", + "points": 324, + "threshold_squared_norms": [ + 25, + 33 + ] + }, + { + "attaining_cycle": [ + [ + 4, + 0, + -3, + 0 + ], + [ + 0, + 4, + 1, + -4 + ], + [ + -3, + 0, + 4, + 0 + ], + [ + 1, + -4, + 0, + 4 + ] + ], + "central_pair": true, + "cutoff": 7, + "cycle_lengths": { + "4": 76, + "5": 4 + }, + "iterate": 20, + "map_order": 20, + "map_sha256": "2ed96f62405bdfd5e338e46e116acbd84adb4412cdbb0165a037630a4d393337", + "points": 324, + "threshold_squared_norms": [ + 25, + 33 + ] + }, + { + "attaining_cycle": [ + [ + 5, + 0, + -4, + 0 + ], + [ + 0, + 5, + 1, + -5 + ], + [ + -4, + 0, + 5, + 0 + ], + [ + 1, + -5, + 0, + 5 + ] + ], + "central_pair": false, + "cutoff": 9, + "cycle_lengths": { + "1": 4, + "4": 84, + "5": 4, + "6": 2, + "14": 2 + }, + "iterate": 420, + "map_order": 420, + "map_sha256": "66dc115f7b0b8d8f75d42da64579a880e85187aa682b5ed3f75ff067a5ac5326", + "points": 400, + "threshold_squared_norms": [ + 41, + 51 + ] + }, + { + "attaining_cycle": [ + [ + 5, + 0, + -4, + 0 + ], + [ + 0, + 5, + 1, + -5 + ], + [ + -4, + 0, + 5, + 0 + ], + [ + 1, + -5, + 0, + 5 + ] + ], + "central_pair": true, + "cutoff": 9, + "cycle_lengths": { + "4": 88, + "5": 4, + "14": 2 + }, + "iterate": 140, + "map_order": 140, + "map_sha256": "46036b5921774f09c4188d5ab9df8eba1d5534710cae635c3f10fd025b9a9be9", + "points": 400, + "threshold_squared_norms": [ + 41, + 51 + ] + }, + { + "attaining_cycle": [ + [ + 6, + 0, + -5, + 0 + ], + [ + 0, + 6, + 1, + -6 + ], + [ + -5, + 0, + 6, + 0 + ], + [ + 1, + -6, + 0, + 6 + ] + ], + "central_pair": false, + "cutoff": 11, + "cycle_lengths": { + "1": 4, + "4": 96, + "5": 4, + "6": 2, + "9": 4, + "14": 2 + }, + "iterate": 1260, + "map_order": 1260, + "map_sha256": "1ea50d6c07233ad1eed198338899f6a4456710eef3084adb9763cff971e8678c", + "points": 484, + "threshold_squared_norms": [ + 61, + 73 + ] + }, + { + "attaining_cycle": [ + [ + 7, + 0, + -6, + 0 + ], + [ + 0, + 7, + 1, + -7 + ], + [ + -6, + 0, + 7, + 0 + ], + [ + 1, + -7, + 0, + 7 + ] + ], + "central_pair": false, + "cutoff": 13, + "cycle_lengths": { + "1": 4, + "4": 108, + "5": 4, + "6": 2, + "9": 4, + "14": 2, + "22": 2 + }, + "iterate": 13860, + "map_order": 13860, + "map_sha256": "f02c037130d0b9d94010d9681aad386b0bdf53fec2d6762ccade925b73865c0a", + "points": 576, + "threshold_squared_norms": [ + 85, + 99 + ] + }, + { + "attaining_cycle": [ + [ + 9, + 0, + -8, + 0 + ], + [ + 0, + 9, + 1, + -9 + ], + [ + -8, + 0, + 9, + 0 + ], + [ + 1, + -9, + 0, + 9 + ] + ], + "central_pair": false, + "cutoff": 17, + "cycle_lengths": { + "1": 4, + "4": 132, + "5": 4, + "6": 2, + "9": 4, + "13": 4, + "14": 2, + "22": 2, + "30": 2 + }, + "iterate": 180180, + "map_order": 180180, + "map_sha256": "3e08cfed87e43021468d36cb6bc4b7f3c07bf94c6a412ff5def78f615f4b4238", + "points": 784, + "threshold_squared_norms": [ + 145, + 163 + ] + }, + { + "attaining_cycle": [ + [ + 10, + 0, + -9, + 0 + ], + [ + 0, + 10, + 1, + -10 + ], + [ + -9, + 0, + 10, + 0 + ], + [ + 1, + -10, + 0, + 10 + ] + ], + "central_pair": false, + "cutoff": 19, + "cycle_lengths": { + "1": 4, + "4": 144, + "5": 4, + "6": 2, + "9": 4, + "13": 4, + "14": 2, + "17": 4, + "22": 2, + "30": 2 + }, + "iterate": 3063060, + "map_order": 3063060, + "map_sha256": "1cf314bdc58f84fb0f77270731211303f245411804aa3b2dfea8e8ca42b80276", + "points": 900, + "threshold_squared_norms": [ + 181, + 201 + ] + }, + { + "attaining_cycle": [ + [ + 12, + 0, + -11, + 0 + ], + [ + 0, + 12, + 1, + -12 + ], + [ + -11, + 0, + 12, + 0 + ], + [ + 1, + -12, + 0, + 12 + ] + ], + "central_pair": false, + "cutoff": 23, + "cycle_lengths": { + "1": 4, + "4": 168, + "5": 4, + "6": 2, + "9": 4, + "13": 4, + "14": 2, + "17": 4, + "21": 4, + "22": 2, + "30": 2, + "38": 2 + }, + "iterate": 58198140, + "map_order": 58198140, + "map_sha256": "2d1e302185364aac220f26b0e0ed30ee3010af17b0d11d4fd5b03adb4dedbbea", + "points": 1156, + "threshold_squared_norms": [ + 265, + 289 + ] + }, + { + "attaining_cycle": [ + [ + 13, + 0, + -12, + 0 + ], + [ + 0, + 13, + 1, + -13 + ], + [ + -12, + 0, + 13, + 0 + ], + [ + 1, + -13, + 0, + 13 + ] + ], + "central_pair": false, + "cutoff": 25, + "cycle_lengths": { + "1": 4, + "4": 180, + "5": 4, + "6": 2, + "9": 4, + "13": 4, + "14": 2, + "17": 4, + "21": 4, + "22": 2, + "30": 2, + "38": 2, + "46": 2 + }, + "iterate": 1338557220, + "map_order": 1338557220, + "map_sha256": "677f6fa086a90dc5546e68188de8c52543958de6fbf2f7851beb3a091dd2a532", + "points": 1296, + "threshold_squared_norms": [ + 313, + 339 + ] + }, + { + "attaining_cycle": [ + [ + 14, + 0, + -13, + 0 + ], + [ + 0, + 14, + 1, + -14 + ], + [ + -13, + 0, + 14, + 0 + ], + [ + 1, + -14, + 0, + 14 + ] + ], + "central_pair": false, + "cutoff": 27, + "cycle_lengths": { + "1": 4, + "4": 192, + "5": 4, + "6": 2, + "9": 4, + "13": 4, + "14": 2, + "17": 4, + "21": 4, + "22": 2, + "25": 4, + "30": 2, + "38": 2, + "46": 2 + }, + "iterate": 6692786100, + "map_order": 6692786100, + "map_sha256": "797d14ae5c0bb9af2dfe7c27554f062712c5d08d226e52287939d65fd4b428e1", + "points": 1444, + "threshold_squared_norms": [ + 365, + 393 + ] + }, + { + "attaining_cycle": [ + [ + 15, + 0, + -14, + 0 + ], + [ + 0, + 15, + 1, + -15 + ], + [ + -14, + 0, + 15, + 0 + ], + [ + 1, + -15, + 0, + 15 + ] + ], + "central_pair": false, + "cutoff": 29, + "cycle_lengths": { + "1": 4, + "4": 204, + "5": 4, + "6": 2, + "9": 4, + "13": 4, + "14": 2, + "17": 4, + "21": 4, + "22": 2, + "25": 4, + "30": 2, + "38": 2, + "46": 2, + "54": 2 + }, + "iterate": 20078358300, + "map_order": 20078358300, + "map_sha256": "96bf1a9ca4edebdac29f9f5a2b8606c472b51ca26b00d2380184e759329e57fb", + "points": 1600, + "threshold_squared_norms": [ + 421, + 451 + ] + }, + { + "attaining_cycle": [ + [ + 16, + 0, + -15, + 0 + ], + [ + 0, + 16, + 1, + -16 + ], + [ + -15, + 0, + 16, + 0 + ], + [ + 1, + -16, + 0, + 16 + ] + ], + "central_pair": false, + "cutoff": 31, + "cycle_lengths": { + "1": 4, + "4": 216, + "5": 4, + "6": 2, + "9": 4, + "13": 4, + "14": 2, + "17": 4, + "21": 4, + "22": 2, + "25": 4, + "29": 4, + "30": 2, + "38": 2, + "46": 2, + "54": 2 + }, + "iterate": 582272390700, + "map_order": 582272390700, + "map_sha256": "3fe80f0a0ff31ef2103b631e091b087330f25fba4b5973402bafc2aeb0839d28", + "points": 1764, + "threshold_squared_norms": [ + 481, + 513 + ] + }, + { + "attaining_cycle": [ + [ + 19, + 0, + -18, + 0 + ], + [ + 0, + 19, + 1, + -19 + ], + [ + -18, + 0, + 19, + 0 + ], + [ + 1, + -19, + 0, + 19 + ] + ], + "central_pair": false, + "cutoff": 37, + "cycle_lengths": { + "1": 4, + "4": 252, + "5": 4, + "6": 2, + "9": 4, + "13": 4, + "14": 2, + "17": 4, + "21": 4, + "22": 2, + "25": 4, + "29": 4, + "30": 2, + "33": 4, + "38": 2, + "46": 2, + "54": 2, + "62": 2, + "70": 2 + }, + "iterate": 18050444111700, + "map_order": 18050444111700, + "map_sha256": "44e0c71c0316ea6d40e6738ecb90a50c73dd91dd35b4796453441b5368bff450", + "points": 2304, + "threshold_squared_norms": [ + 685, + 723 + ] + }, + { + "attaining_cycle": [ + [ + 21, + 0, + -20, + 0 + ], + [ + 0, + 21, + 1, + -21 + ], + [ + -20, + 0, + 21, + 0 + ], + [ + 1, + -21, + 0, + 21 + ] + ], + "central_pair": false, + "cutoff": 41, + "cycle_lengths": { + "1": 4, + "4": 276, + "5": 4, + "6": 2, + "9": 4, + "13": 4, + "14": 2, + "17": 4, + "21": 4, + "22": 2, + "25": 4, + "29": 4, + "30": 2, + "33": 4, + "37": 4, + "38": 2, + "46": 2, + "54": 2, + "62": 2, + "70": 2, + "78": 2 + }, + "iterate": 667866432132900, + "map_order": 667866432132900, + "map_sha256": "a35274230e2b0f75f727fde91d5a152fc56ac94143ff31ac7b8f37b2f59b09f6", + "points": 2704, + "threshold_squared_norms": [ + 841, + 883 + ] + }, + { + "attaining_cycle": [ + [ + 22, + 0, + -21, + 0 + ], + [ + 0, + 22, + 1, + -22 + ], + [ + -21, + 0, + 22, + 0 + ], + [ + 1, + -22, + 0, + 22 + ] + ], + "central_pair": false, + "cutoff": 43, + "cycle_lengths": { + "1": 4, + "4": 288, + "5": 4, + "6": 2, + "9": 4, + "13": 4, + "14": 2, + "17": 4, + "21": 4, + "22": 2, + "25": 4, + "29": 4, + "30": 2, + "33": 4, + "37": 4, + "38": 2, + "41": 4, + "46": 2, + "54": 2, + "62": 2, + "70": 2, + "78": 2 + }, + "iterate": 27382523717448900, + "map_order": 27382523717448900, + "map_sha256": "25fa7681751257727091b774cb7e0d7e2226b930a50ff5d6b1a39eb9554a952b", + "points": 2916, + "threshold_squared_norms": [ + 925, + 969 + ] + }, + { + "attaining_cycle": [ + [ + 24, + 0, + -23, + 0 + ], + [ + 0, + 24, + 1, + -24 + ], + [ + -23, + 0, + 24, + 0 + ], + [ + 1, + -24, + 0, + 24 + ] + ], + "central_pair": false, + "cutoff": 47, + "cycle_lengths": { + "1": 4, + "4": 312, + "5": 4, + "6": 2, + "9": 4, + "13": 4, + "14": 2, + "17": 4, + "21": 4, + "22": 2, + "25": 4, + "29": 4, + "30": 2, + "33": 4, + "37": 4, + "38": 2, + "41": 4, + "45": 4, + "46": 2, + "54": 2, + "62": 2, + "70": 2, + "78": 2, + "86": 2 + }, + "iterate": 1177448519850302700, + "map_order": 1177448519850302700, + "map_sha256": "de9f1b221265956000cab7cac9985afc0feb4dace4fbc10c344be2b9c530f8ee", + "points": 3364, + "threshold_squared_norms": [ + 1105, + 1153 + ] + }, + { + "attaining_cycle": [ + [ + 25, + 0, + -24, + 0 + ], + [ + 0, + 25, + 1, + -25 + ], + [ + -24, + 0, + 25, + 0 + ], + [ + 1, + -25, + 0, + 25 + ] + ], + "central_pair": false, + "cutoff": 49, + "cycle_lengths": { + "1": 4, + "4": 324, + "5": 4, + "6": 2, + "9": 4, + "13": 4, + "14": 2, + "17": 4, + "21": 4, + "22": 2, + "25": 4, + "29": 4, + "30": 2, + "33": 4, + "37": 4, + "38": 2, + "41": 4, + "45": 4, + "46": 2, + "54": 2, + "62": 2, + "70": 2, + "78": 2, + "86": 2, + "94": 2 + }, + "iterate": 55340080432964226900, + "map_order": 55340080432964226900, + "map_sha256": "fe6bd52cbe8413c318838d547c6272ea24a5937b1a6a685675330e8260131f4c", + "points": 3600, + "threshold_squared_norms": [ + 1201, + 1251 + ] + }, + { + "attaining_cycle": [ + [ + 27, + 0, + -26, + 0 + ], + [ + 0, + 27, + 1, + -27 + ], + [ + -26, + 0, + 27, + 0 + ], + [ + 1, + -27, + 0, + 27 + ] + ], + "central_pair": false, + "cutoff": 53, + "cycle_lengths": { + "1": 4, + "4": 348, + "5": 4, + "6": 2, + "9": 4, + "13": 4, + "14": 2, + "17": 4, + "21": 4, + "22": 2, + "25": 4, + "29": 4, + "30": 2, + "33": 4, + "37": 4, + "38": 2, + "41": 4, + "45": 4, + "46": 2, + "49": 4, + "54": 2, + "62": 2, + "70": 2, + "78": 2, + "86": 2, + "94": 2, + "102": 2 + }, + "iterate": 387380563030749588300, + "map_order": 387380563030749588300, + "map_sha256": "3070c6d4e23d8b334d725a0a483a6764582e41c9226d1636e2f98ff8c91857cc", + "points": 4096, + "threshold_squared_norms": [ + 1405, + 1459 + ] + }, + { + "attaining_cycle": [ + [ + 30, + 0, + -29, + 0 + ], + [ + 0, + 30, + 1, + -30 + ], + [ + -29, + 0, + 30, + 0 + ], + [ + 1, + -30, + 0, + 30 + ] + ], + "central_pair": false, + "cutoff": 59, + "cycle_lengths": { + "1": 4, + "4": 384, + "5": 4, + "6": 2, + "9": 4, + "13": 4, + "14": 2, + "17": 4, + "21": 4, + "22": 2, + "25": 4, + "29": 4, + "30": 2, + "33": 4, + "37": 4, + "38": 2, + "41": 4, + "45": 4, + "46": 2, + "49": 4, + "53": 4, + "54": 2, + "57": 4, + "62": 2, + "70": 2, + "78": 2, + "86": 2, + "94": 2, + "102": 2, + "110": 2 + }, + "iterate": 20531169840629728179900, + "map_order": 20531169840629728179900, + "map_sha256": "8dfee84a0096c0186e7dd52d047a6a3d052a59eafd67e479287c1ed41563bba3", + "points": 4900, + "threshold_squared_norms": [ + 1741, + 1801 + ] + }, + { + "attaining_cycle": [ + [ + 31, + 0, + -30, + 0 + ], + [ + 0, + 31, + 1, + -31 + ], + [ + -30, + 0, + 31, + 0 + ], + [ + 1, + -31, + 0, + 31 + ] + ], + "central_pair": false, + "cutoff": 61, + "cycle_lengths": { + "1": 4, + "4": 396, + "5": 4, + "6": 2, + "9": 4, + "13": 4, + "14": 2, + "17": 4, + "21": 4, + "22": 2, + "25": 4, + "29": 4, + "30": 2, + "33": 4, + "37": 4, + "38": 2, + "41": 4, + "45": 4, + "46": 2, + "49": 4, + "53": 4, + "54": 2, + "57": 4, + "62": 2, + "70": 2, + "78": 2, + "86": 2, + "94": 2, + "102": 2, + "110": 2, + "118": 2 + }, + "iterate": 1211339020597153962614100, + "map_order": 1211339020597153962614100, + "map_sha256": "56203da5bfb764b27ca73022fc05d39a0d14f00c453dfb1d08c5544d2fc78f90", + "points": 5184, + "threshold_squared_norms": [ + 1861, + 1923 + ] + } + ], + "gaussian_input_cases": 19208, + "iterate_cutoff_sha256": "29d7c1e1e34381a2564b4c38b82ef74b4119fc1448edb224748789fe225d0c8f", + "lower_boundaries": { + "5": [ + { + "exterior_edges": 8, + "radius_doubled": 3 + }, + { + "exterior_edges": 12, + "radius_doubled": 5 + } + ], + "7": [ + { + "exterior_edges": 12, + "radius_doubled": 5 + }, + { + "exterior_edges": 16, + "radius_doubled": 7 + } + ], + "9": [ + { + "exterior_edges": 16, + "radius_doubled": 7 + }, + { + "exterior_edges": 20, + "radius_doubled": 9 + } + ], + "11": [ + { + "exterior_edges": 20, + "radius_doubled": 9 + }, + { + "exterior_edges": 24, + "radius_doubled": 11 + } + ], + "13": [ + { + "exterior_edges": 24, + "radius_doubled": 11 + }, + { + "exterior_edges": 28, + "radius_doubled": 13 + } + ], + "17": [ + { + "exterior_edges": 32, + "radius_doubled": 15 + }, + { + "exterior_edges": 36, + "radius_doubled": 17 + } + ], + "19": [ + { + "exterior_edges": 36, + "radius_doubled": 17 + }, + { + "exterior_edges": 40, + "radius_doubled": 19 + } + ], + "23": [ + { + "exterior_edges": 44, + "radius_doubled": 21 + }, + { + "exterior_edges": 48, + "radius_doubled": 23 + } + ], + "25": [ + { + "exterior_edges": 48, + "radius_doubled": 23 + }, + { + "exterior_edges": 52, + "radius_doubled": 25 + } + ], + "27": [ + { + "exterior_edges": 52, + "radius_doubled": 25 + }, + { + "exterior_edges": 56, + "radius_doubled": 27 + } + ], + "29": [ + { + "exterior_edges": 56, + "radius_doubled": 27 + }, + { + "exterior_edges": 60, + "radius_doubled": 29 + } + ], + "31": [ + { + "exterior_edges": 60, + "radius_doubled": 29 + }, + { + "exterior_edges": 64, + "radius_doubled": 31 + } + ], + "37": [ + { + "exterior_edges": 72, + "radius_doubled": 35 + }, + { + "exterior_edges": 76, + "radius_doubled": 37 + } + ], + "41": [ + { + "exterior_edges": 80, + "radius_doubled": 39 + }, + { + "exterior_edges": 84, + "radius_doubled": 41 + } + ], + "43": [ + { + "exterior_edges": 84, + "radius_doubled": 41 + }, + { + "exterior_edges": 88, + "radius_doubled": 43 + } + ], + "47": [ + { + "exterior_edges": 92, + "radius_doubled": 45 + }, + { + "exterior_edges": 96, + "radius_doubled": 47 + } + ], + "49": [ + { + "exterior_edges": 96, + "radius_doubled": 47 + }, + { + "exterior_edges": 100, + "radius_doubled": 49 + } + ], + "53": [ + { + "exterior_edges": 104, + "radius_doubled": 51 + }, + { + "exterior_edges": 108, + "radius_doubled": 53 + } + ], + "59": [ + { + "exterior_edges": 116, + "radius_doubled": 57 + }, + { + "exterior_edges": 120, + "radius_doubled": 59 + } + ], + "61": [ + { + "exterior_edges": 120, + "radius_doubled": 59 + }, + { + "exterior_edges": 124, + "radius_doubled": 61 + } + ] + }, + "small_iterates": 1024, + "status": "PASS_GAUSSIAN_FINITE_ITERATE_OPTIMUM", + "total_half_grid_points": 41032 +} diff --git a/research/gaussian-finite-iterate-optimum/SOURCES.json b/research/gaussian-finite-iterate-optimum/SOURCES.json new file mode 100644 index 0000000000..5335fa97d9 --- /dev/null +++ b/research/gaussian-finite-iterate-optimum/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-finite-iterate-optimum/TASK.json b/research/gaussian-finite-iterate-optimum/TASK.json new file mode 100644 index 0000000000..8c6c131de8 --- /dev/null +++ b/research/gaussian-finite-iterate-optimum/TASK.json @@ -0,0 +1,98 @@ +{ + "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": "Sharp forward radial optimum and global attaining construction for every finite iterate identity F^m=id in the exact-sum error-one Gaussian-pair class.", + "scope_change_reason": "PR7699 leaves non-fourth finite iterate optima open. The first incompatible ring and a shifted annular assembly give a common all-m solution.", + "bottleneck_link": "An exact finite iterate identity has a specific radial precision cost; this local result supplies no native tariff or caller admission.", + "budget_minutes": 60, + "stop_rule": "Stop at the all-m optimum with exact global map, inverse, attainment and bounded finite checks. Do not infer physical or tensor compatibility.", + "outcome": "completed", + "evidence": "PROOF.md; RESULT.json; 1024 iterate budgets, 23 complete grids, 41032 half-grid points, 2424 lower-boundary edges and 19208 Gaussian inputs.", + "author": "Ali Romman", + "ai_assistance": "Substantial OpenAI Codex assistance. CubeJerry annular geometry and Ali Romman ring/comparison routines are adapted and credited; not independent source review.", + "open_questions": [ + { + "question": "Does an actual caller require exact least period m or a physical implementation of this local map?", + "why_it_matters": "An iterate identity does not specify least period or a native cost.", + "first_step": "Name the caller and its exact period, ownership, storage and restoration contract.", + "blocked_by": "No physical tariff or tensor compatibility follows from this local optimum." + } + ], + "family_decision": { + "decision": "Resolve the open optimum for every finite iterate identity, then stop at this local precision theorem.", + "sources": "7699@2a5dcb314ccdfeed24bd86ec1f56f519eead56c1; 7570@053c42c68165cf24fd4e8bc33c2b20d6ac3d399b", + "evidence_status": "Author-checked all-input lower and upper proof, local constructive map and exact finite corroboration.", + "boundary": "Gaussian pairs, exact conserved sum, Euclidean error at most one and F^m=id; no exact least-period requirement.", + "obligations": { + "all_m_lower": "proved by first incompatible ring", + "all_m_attainment": "explicit global map, inverse and attaining cycle", + "finite_replay": "complete stated grids, exact periods and radical comparisons", + "exact_least_period_optimum": "not claimed", + "physical_and_selected_caller": "not supplied" + }, + "alternative": "A changed error, larger-block or stateful contract is outside this optimization and needs a caller-bound specification.", + "construction_gate": "No native implementation or downstream optimization is authorized by this local result alone." + } +} diff --git a/research/gaussian-finite-iterate-optimum/VERIFY.json b/research/gaussian-finite-iterate-optimum/VERIFY.json new file mode 100644 index 0000000000..3b56eb5f3d --- /dev/null +++ b/research/gaussian-finite-iterate-optimum/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": "Check complete grid maps, independent arc generation, exact cycle orders, inverses, radial bounds, attaining cycles and failure controls." + }, + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "-O", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Check complete grid maps, independent arc generation, exact cycle orders, inverses, radial bounds, attaining cycles and failure controls." + } + ] +} diff --git a/research/gaussian-finite-iterate-optimum/verify.py b/research/gaussian-finite-iterate-optimum/verify.py new file mode 100644 index 0000000000..e474e2fd16 --- /dev/null +++ b/research/gaussian-finite-iterate-optimum/verify.py @@ -0,0 +1,329 @@ +"""Exact finite-iterate Gaussian construction checks. + +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +The half-grid and annular construction adapt CubeJerry PR7570. +Ring, cycle and exact comparison routines adapt Ali Romman PR7699. +""" +from collections import Counter +from itertools import product +from math import gcd, isqrt, lcm +from pathlib import Path +import hashlib +import json + + +def need(value, message): + if not value: + raise ValueError(message) + + +def q(point): + return point[1], -point[0] + + +def rotate(point, turns): + for _ in range(turns % 4): + point = q(point) + return point + + +def color(point): + return ((point[0] + point[1]) // 2) % 2 + + +def norm(point): + return (point[0] ** 2 + point[1] ** 2 + 2) // 4 + + +def gap_le(a, b, p, denominator): + remainder = (b - a) * denominator ** 2 - p ** 2 + return remainder <= 0 or remainder ** 2 <= 4 * a * p ** 2 * denominator ** 2 + + +def at_most_rho(a, b): + difference = b - a + return difference <= 0 or (2 * difference - 1) ** 2 <= 8 * a + + +def threshold(r): + return (r * r + 1) // 2, (r * r + 2 * r + 3) // 2 + + +def gap_category(a, b, r): + if b <= a: + return -1 + lower, upper = threshold(r) + if (a, b) == (lower, upper): + return 0 + scale = 10 ** 30 + low = isqrt(upper * scale * scale) - isqrt(lower * scale * scale) - 1 + if gap_le(a, b, low, scale): + return -1 + need(not gap_le(a, b, low + 3, scale), 'resolved exact radical comparison') + return 1 + + +def first_bad(m): + need(m > 0 and m % 4 == 0, 'positive iterate divisible by four') + r = 5 + while m % r == 0: + r += 2 + return r + + +def ring(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') + return points + + +def ring_index(point): + x, y = point + r = max(abs(x), abs(y)) + if y == r and x > -r: + index = (r - x) // 2 + elif x == -r and y > -r: + index = r + (r - y) // 2 + elif y == -r and x < r: + index = 2 * r + (x + r) // 2 + else: + need(x == r and y < r, 'fourth ring side') + index = 3 * r + (y + r) // 2 + return r, index + + +def ring_point(r, index): + side, offset = divmod(index % (4 * r), r) + return [(r - 2 * offset, r), (-r, r - 2 * offset), + (-r + 2 * offset, -r), (r, -r + 2 * offset)][side] + + +def annulus_partner(point, r): + b = r + 2 + for turns in range(4): + x, y = rotate(point, turns) + if (x, y) == (r, r): + partner = (b, r) + elif (x, y) == (b, r): + partner = (r, r) + elif y == r and -r < x < r: + index = (x + r - 2) // 2 + partner = (x + (2 if index % 2 == 0 else -2), y) + elif y == b and -r + 2 <= x <= b: + index = (b - x) // 2 + partner = (x + (-2 if index % 2 == 0 else 2), y) + else: + continue + return rotate(partner, -turns) + raise ValueError('annulus coverage') + + +def annulus_edges(r): + mapping = {} + edges = [((r, r), (r + 2, r))] + inner = [(x, r) for x in range(-r + 2, r, 2)] + outer = [(x, r + 2) for x in range(r + 2, -r, -2)] + for arc in [inner, outer]: + need(len(arc) % 2 == 0, 'even arc length') + edges.extend(zip(arc[::2], arc[1::2])) + for a, b in edges: + for turns in range(4): + u, v = rotate(a, turns), rotate(b, turns) + need(u not in mapping and v not in mapping, 'disjoint annular edges') + mapping[u], mapping[v] = v, u + need(set(mapping) == set(ring(r) + ring(r + 2)), 'annular coverage') + return mapping + + +def local_map(point, m, inverse=False): + cutoff = first_bad(m) + r, index = ring_index(point) + if r < cutoff: + if m % 3 and r <= 3: + return annulus_partner(point, 1) + return ring_point(r, index + (-1 if inverse else 1)) + inner = cutoff + 4 * ((r - cutoff) // 4) + return annulus_partner(point, inner) + + +def gaussian(value, m, inverse=False): + need(m > 0 and m % 4 == 0, 'positive iterate divisible by four') + a, b, c, d = value + sx, sy, dx, dy = a + c, b + d, a - c, b - d + if (sx - sy) % 2 == 0: + ex, ey = (dy, -dx) if inverse else (-dy, dx) + elif inverse: + tx, ty = local_map((dx + dy, dx - dy), m, True) + ex, ey = (tx - ty) // 2, -(tx + ty) // 2 + else: + ux, uy = local_map((dx - dy, -dy - dx), m) + ex, ey = (ux + uy) // 2, (ux - uy) // 2 + numerators = (sx + ex, sy + ey, sx - ex, sy - ey) + need(all(x % 2 == 0 for x in numerators), 'Gaussian integral output') + return tuple(x // 2 for x in numerators) + + +def direct_contract(value, target): + a, b, c, d = value + sx, sy, dx, dy = a + c, b + d, a - c, b - d + ideal2 = (sx - dy, sy + dx, sx + dy, sy - dx) + need((target[0] + target[2], target[1] + target[3]) == (sx, sy), 'exact sum') + error4 = sum((2 * x - y) ** 2 for x, y in zip(target, ideal2)) + need(error4 == 4 * ((sx - sy) % 2), 'exact Gaussian error') + return error4 + + +def cycles(mapping): + need(set(mapping) == set(mapping.values()), 'permutation of the whole finite domain') + seen, lengths = set(), [] + for point in sorted(mapping): + if point in seen: + continue + current, length = point, 0 + while current not in seen: + seen.add(current) + length += 1 + current = mapping[current] + need(current == point, 'closed cycle') + lengths.append(length) + return lengths + + +def complete_fixture(m): + cutoff = first_bad(m) + outer = cutoff + 10 + points = [(x, y) for x in range(-outer, outer + 1, 2) + for y in range(-outer, outer + 1, 2)] + mapping = {p: local_map(p, m) for p in points} + need(set(mapping.values()) == set(points), 'complete finite local permutation') + oracle = {} + singles = [] + if m % 3: + oracle.update(annulus_edges(1)) + start = 5 + else: + start = 1 + for r in range(start, cutoff, 2): + arc = ring(r) + oracle.update(zip(arc, arc[1:] + arc[:1])) + singles.append(r) + for r in range(cutoff, outer, 4): + oracle.update(annulus_edges(r)) + need(mapping == oracle, 'pointwise rule equals separate arc generator') + digest = hashlib.sha256() + for p, out in sorted(mapping.items()): + need(abs(p[0] - out[0]) + abs(p[1] - out[1]) == 2, 'unit neighbor') + need(local_map(out, m, True) == p, 'explicit local inverse') + need(local_map(q(p), m) == q(out), 'quarter-turn covariance') + need(gap_category(min(norm(p), norm(out)), max(norm(p), norm(out)), cutoff) <= 0, + 'absolute radial bound on both colors') + sx, sy = ((1, 0) if color(p) == 0 else (0, 1)) + dx, dy = (p[0] - p[1]) // 2, -(p[0] + p[1]) // 2 + value = ((sx + dx) // 2, (sy + dy) // 2, (sx - dx) // 2, (sy - dy) // 2) + target = gaussian(value, m) + direct_contract(value, target) + need(gaussian(target, m, True) == value, 'Gaussian inverse on both colors') + need(sum(x*x for x in value) == norm(p) and sum(x*x for x in target) == norm(out), 'coordinate norm identity') + digest.update(f'{p}:{out};'.encode()) + g = {p: q(out) for p, out in mapping.items()} + lengths = cycles(g) + actual_order = lcm(*lengths) + predicted_order = lcm(4, *(2*r//gcd(2*r, (1-r)//2) for r in singles)) + need(actual_order == predicted_order and m % actual_order == 0, 'direct cycles and iterate identity') + a = (cutoff + 1) // 2 + attaining = [(a, 0, 1-a, 0), (0, a, 1, -a), (1-a, 0, a, 0), (1, -a, 0, a)] + for old, new in zip(attaining, attaining[1:] + attaining[:1]): + need(gaussian(old, m) == new, 'attaining four-cycle') + need([sum(x*x for x in z) for z in attaining] == list(threshold(cutoff))*2, 'exact attained threshold') + return {'iterate': m, 'cutoff': cutoff, 'central_pair': bool(m % 3), 'points': len(points), + 'cycle_lengths': dict(sorted(Counter(lengths).items())), 'map_order': actual_order, + 'map_sha256': digest.hexdigest(), 'attaining_cycle': attaining, + 'threshold_squared_norms': threshold(cutoff)} + + +def lower_boundaries(cutoff): + rows = [] + for r in [cutoff - 2, cutoff]: + count = 0 + for p in product(range(-r, r + 1, 2), repeat=2): + if color(p): + continue + x, y = p + for out in [(x-2, y), (x+2, y), (x, y-2), (x, y+2)]: + if max(abs(out[0]), abs(out[1])) > r: + need(gap_category(norm(p), norm(out), cutoff) >= 0, 'every exterior edge meets lower threshold') + count += 1 + rows.append({'radius_doubled': r, 'exterior_edges': count}) + need(sum(x['exterior_edges'] for x in rows) == 4 * cutoff, 'independent boundary count') + need(not at_most_rho(*threshold(cutoff)), 'strictly above unrestricted optimum') + return rows + + +def compute(): + order_digest = hashlib.sha256() + distribution = Counter() + for m in range(4, 4097, 4): + cutoff = first_bad(m) + need(all(m % r == 0 for r in range(5, cutoff, 2)) and m % cutoff, 'least incompatible odd ring') + need(m % 3 == 0 or cutoff <= 9, 'central exception has only three cutoffs') + distribution[cutoff] += 1 + order_digest.update(f'{m}:{cutoff};'.encode()) + representatives = {} + for candidate in range(5, 66, 2): + minimum = 4*lcm(*range(5, candidate, 2)) + for m in [minimum, 3*minimum]: + cutoff = first_bad(m) + if cutoff <= 65: + representatives.setdefault((cutoff, bool(m % 3)), m) + fixtures = [complete_fixture(m) for _, m in sorted(representatives.items())] + boundaries = {r: lower_boundaries(r) for r in sorted({r for r, _ in representatives})} + gaussian_cases = 0 + for m in [4, 12, 20, 60, 140, 420, 1260, 13860]: + cutoff = first_bad(m) + for value in product(range(-3, 4), repeat=4): + target = gaussian(value, m) + direct_contract(value, target) + need(gaussian(target, m, True) == value and gaussian(gaussian(value, m, True), m) == value, + 'both full Gaussian inverse identities') + need(gap_category(sum(x*x for x in value), sum(x*x for x in target), cutoff) <= 0, 'all-sum forward bound') + phase = (-value[1], value[0], -value[3], value[2]) + need(gaussian(phase, m) == (-target[1], target[0], -target[3], target[2]), 'Gaussian phase covariance') + gaussian_cases += 1 + need(gap_le(1, 3, 733, 1000) and not gap_le(41, 51, 733, 1000), 'central connector below the smallest exceptional threshold') + controls = [] + for m in [4, 20, 140]: + points = ring(3) + bad = {p: q(points[(i+1) % len(points)]) for i, p in enumerate(points)} + lengths = cycles(bad) + need(any(m % length for length in lengths), 'omitted central pairing breaks iterate identity') + controls.append({'iterate': m, 'omitted_central_pair_cycle_lengths': lengths}) + for row in fixtures: + r, m = row['cutoff'], row['iterate'] + orders = [r, 2*r] + need(all(m % order for order in orders), 'both isolated critical-ring maps fail') + need(gap_category(13, 19, 7) == 1, 'unchanged fourth-power map exceeds the order-twenty budget') + zero_sum = (1, 0, -1, 0) + after = zero_sum + for step in range(1, 65): + after = gaussian(after, 4) + need((after == zero_sum) == (step % 4 == 0), 'four divides every global iterate identity') + return {'status': 'PASS_GAUSSIAN_FINITE_ITERATE_OPTIMUM', + 'small_iterates': 1024, 'cutoff_distribution': dict(sorted(distribution.items())), + 'iterate_cutoff_sha256': order_digest.hexdigest(), 'fixtures': fixtures, + 'lower_boundaries': boundaries, 'gaussian_input_cases': gaussian_cases, + 'controls': controls, 'total_half_grid_points': sum(r['points'] for r in fixtures)} + + +if __name__ == '__main__': + actual = json.loads(json.dumps(compute())) + expected = json.loads(Path(__file__).with_name('RESULT.json').read_text()) + need(actual == expected, 'exact committed receipt') + print(actual['status']) + print('1024 iterate budgets; 23 complete grids; 41032 half-grid points') + print('2424 lower-boundary edges; 19208 full Gaussian inputs; all controls pass') From ba5e006ed70119b23d6ef9e2e8627e43a3f4f18b Mon Sep 17 00:00:00 2001 From: Ali Romman <226877337+aliromman@users.noreply.github.com> Date: Wed, 18 Nov 2026 10:32:35 -0500 Subject: [PATCH 2/2] Keep wrapped proof terms readable --- research/gaussian-finite-iterate-optimum/PROOF.md | 4 ++-- research/gaussian-finite-iterate-optimum/README.md | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/research/gaussian-finite-iterate-optimum/PROOF.md b/research/gaussian-finite-iterate-optimum/PROOF.md index 0b18ba82a3..04333af6e9 100644 --- a/research/gaussian-finite-iterate-optimum/PROOF.md +++ b/research/gaussian-finite-iterate-optimum/PROOF.md @@ -117,8 +117,8 @@ entire half-grid L, on both colors. Q preserves each square ring and exchanges colors. We will make M commute with Q. On a single ring of radius R0/2, use the cyclic successor in the same -index order as above, on every vertex of both colors. This is a unit- -neighbor permutation, and its inverse is the cyclic predecessor. +index order as above, on every vertex of both colors. This permutation +uses unit neighbors, and its inverse is the cyclic predecessor. It commutes with Q. On either source color, `g=Q M` has order R0 or 2R0. Therefore its order divides m whenever R0 divides m and 4 divides m. Every edge is tangential and its absolute radial gap is less than diff --git a/research/gaussian-finite-iterate-optimum/README.md b/research/gaussian-finite-iterate-optimum/README.md index ebdf7381cf..abff712bad 100644 --- a/research/gaussian-finite-iterate-optimum/README.md +++ b/research/gaussian-finite-iterate-optimum/README.md @@ -48,8 +48,8 @@ PASS_GAUSSIAN_FINITE_ITERATE_OPTIMUM The complete grid checks compare the local map with a separate arc generator, follow every cycle, verify the stated iterate identity, check both colors and inverses, and attain each exact bound. Twenty -distinct critical cutoffs from five through 61 have complete lower- -boundary checks. The Gaussian inputs include every component parity +distinct critical cutoffs from five through 61 have complete checks of +their lower boundaries. The Gaussian inputs include every component parity and eight iterate choices. All comparisons use integers and certified square-root intervals. The proof establishes the all-input and all-m claims; these finite domains corroborate them.