From 26ea0e01b09b12759a17f006c9066d9e5fcd84e0 Mon Sep 17 00:00:00 2001 From: Jerry Jiaheng Chen <80299683+CubeJerry@users.noreply.github.com> Date: Fri, 13 Nov 2026 21:07:09 +1100 Subject: [PATCH 1/2] Prove exact outward norm slack for affine-period maps and the conserved-sum Gaussian family --- .../CHECKSUMS.sha256 | 20 ++ .../affine-period-outward-slack/NOTICE.md | 13 ++ .../affine-period-outward-slack/PR-DRAFT.md | 37 ++++ .../affine-period-outward-slack/PR-TITLE.txt | 1 + research/affine-period-outward-slack/PROOF.md | 202 ++++++++++++++++++ .../PUBLICATION-MANIFEST.json | 26 +++ .../affine-period-outward-slack/README.md | 80 +++++++ .../affine-period-outward-slack/RESULT.json | 106 +++++++++ .../SOURCE-NOTICE.md | 21 ++ .../affine-period-outward-slack/SOURCES.json | 84 ++++++++ .../affine-period-outward-slack/VERIFY.json | 19 ++ .../affine-period-outward-slack/kernel.py | 63 ++++++ .../affine-period-outward-slack/reproduce.py | 188 ++++++++++++++++ .../review/AUTHOR-OPTIMIZED-REPLAY.json | 1 + .../review/AUTHOR-REPLAY.json | 1 + .../review/PUBLICATION-ROOT-REPLAY.json | 27 +++ .../review/README.md | 14 ++ .../review/RESULT.json | 27 +++ .../review/ROOT-REVIEW.md | 91 ++++++++ .../review/SOURCE-BINDING.json | 77 +++++++ .../review/check_norm_slack_root.py | 146 +++++++++++++ 21 files changed, 1244 insertions(+) create mode 100644 research/affine-period-outward-slack/CHECKSUMS.sha256 create mode 100644 research/affine-period-outward-slack/NOTICE.md create mode 100644 research/affine-period-outward-slack/PR-DRAFT.md create mode 100644 research/affine-period-outward-slack/PR-TITLE.txt create mode 100644 research/affine-period-outward-slack/PROOF.md create mode 100644 research/affine-period-outward-slack/PUBLICATION-MANIFEST.json create mode 100644 research/affine-period-outward-slack/README.md create mode 100644 research/affine-period-outward-slack/RESULT.json create mode 100644 research/affine-period-outward-slack/SOURCE-NOTICE.md create mode 100644 research/affine-period-outward-slack/SOURCES.json create mode 100644 research/affine-period-outward-slack/VERIFY.json create mode 100644 research/affine-period-outward-slack/kernel.py create mode 100644 research/affine-period-outward-slack/reproduce.py create mode 100644 research/affine-period-outward-slack/review/AUTHOR-OPTIMIZED-REPLAY.json create mode 100644 research/affine-period-outward-slack/review/AUTHOR-REPLAY.json create mode 100644 research/affine-period-outward-slack/review/PUBLICATION-ROOT-REPLAY.json create mode 100644 research/affine-period-outward-slack/review/README.md create mode 100644 research/affine-period-outward-slack/review/RESULT.json create mode 100644 research/affine-period-outward-slack/review/ROOT-REVIEW.md create mode 100644 research/affine-period-outward-slack/review/SOURCE-BINDING.json create mode 100644 research/affine-period-outward-slack/review/check_norm_slack_root.py diff --git a/research/affine-period-outward-slack/CHECKSUMS.sha256 b/research/affine-period-outward-slack/CHECKSUMS.sha256 new file mode 100644 index 0000000000..9f4ecfa250 --- /dev/null +++ b/research/affine-period-outward-slack/CHECKSUMS.sha256 @@ -0,0 +1,20 @@ +cf2799f914127a3c6b74db62afeaa2482cf7b5ac159aac186d0d17ee6104a1f6 NOTICE.md +c069671740452e1276ae4d0bb33967e74fc52f043268ca0f97d6d1c6349e8766 PR-DRAFT.md +e96399c06b577e2e9308aef387c15944b88012b6e6835a87bd75e12a05f034e5 PR-TITLE.txt +7eae173d7223d473d574c87bbdae6fad4fb857559a8cc717304bdbdebaa1eb7d PROOF.md +0c07b799a1b9d0a31ae6b2fc06c8e1e8f10017f86acbfafb745e0ff54eac6689 PUBLICATION-MANIFEST.json +89d934319e688e7c9ffd686d00deb14b48d687152227dea383b1ba74b2c9689c README.md +0fc96cc4f7f04a5de9c224ab1e516c3d3d9b70700b41da7fb646e7a629102bf9 RESULT.json +ba3157cea93750cc40a060e06af11da25f8d1b0e51eeea56636c94ce2c8abe8e SOURCE-NOTICE.md +5316820f28df712e374365bb7aacf60e4a8de7a018911e68ba4fe915d952859b SOURCES.json +c392c163eb22f23dc7085b8bc1e81343031cafa1329b610a77133282a0fd97b7 VERIFY.json +fc3e2bf828fa547bee5710f9d5502b7c8c4dcb4cab7536ff73e3dbff54960f1b kernel.py +419a231716a7f8679deb9faba7f44a3233912bc7296a1521d4fb9b546dca38f7 reproduce.py +fb7725008661c5a3f788f9ca6428db77fa8fad620477d135250400fd3cae452b review/AUTHOR-OPTIMIZED-REPLAY.json +fb7725008661c5a3f788f9ca6428db77fa8fad620477d135250400fd3cae452b review/AUTHOR-REPLAY.json +6e0e2186fd1e684b353bc444303218bea24a9833dec7157e24ab7f14ad3ebbdc review/PUBLICATION-ROOT-REPLAY.json +c6e2a0e25bf481a2f77e5f3381fc6645406d1487440e025e5ecbcb7b8a9a73bd review/README.md +6e0e2186fd1e684b353bc444303218bea24a9833dec7157e24ab7f14ad3ebbdc review/RESULT.json +c9d738ae5d96f74cc17c552a53cb69560aa30e78cfae81cfb79a3011f4fbf97c review/ROOT-REVIEW.md +d06a6eced4cd0ce7e63a989e3f3d14f55bba31c3821a5a4fced7b0ce99618416 review/SOURCE-BINDING.json +ea2c2e0bbdc992adeeb4a5df35e7492d4144bfe067622d726494ebeacb3d9214 review/check_norm_slack_root.py diff --git a/research/affine-period-outward-slack/NOTICE.md b/research/affine-period-outward-slack/NOTICE.md new file mode 100644 index 0000000000..028091efba --- /dev/null +++ b/research/affine-period-outward-slack/NOTICE.md @@ -0,0 +1,13 @@ +The unchanged `kernel.py` is copied from Ali Romman's #6509 source snapshot, +with substantial OpenAI Codex assistance; its original notice is preserved in +`SOURCE-NOTICE.md`. It remains under the upstream Apache-2.0 notice. + +The new affine-period/fiber proof and this small replay were prepared with +substantial OpenAI Codex assistance. No implementation, table, or checker is +copied from #6534, #6536, #6438, or #6758; those source results retain their +original authorship and are used only as pinned mathematical premises for the +stated corollaries. + +Credit retained: Ali Romman (#6509, #6534, #6536); Nick Petalas (#6438, #6619); +CubeJerry (#6758); and the finite-sphere predecessor PR #2589, cited by #6619. +Apache-2.0. diff --git a/research/affine-period-outward-slack/PR-DRAFT.md b/research/affine-period-outward-slack/PR-DRAFT.md new file mode 100644 index 0000000000..f284726b08 --- /dev/null +++ b/research/affine-period-outward-slack/PR-DRAFT.md @@ -0,0 +1,37 @@ +# Draft PR title + +Prove exact outward norm slack from affine periods and classify the conserved-sum Gaussian pair family + +## Draft description + +This scoped research package proves an exact outward-slack identity for +rational orthogonal integer maps with a full-rank affine period. It also +proves the identity fiberwise for every legal bounded center rule in Ali +Romman's #6509 sum-preserving Gaussian pair family, even though the retained +sign-based rule is not globally affine-periodic. The minimum family slack is +one, and the `c(1)=1` ray has the explicit gap bounds in `PROOF.md`. + +The note applies the same lemma to inherited source results: #6534's sharp +two-axis error, #6536's sharp matched three-axis error, Nick Petalas's #6438 +five-seed rotation, and @CubeJerry's #6758 native forward/inverse theorem. +Those applications derive radial outward-slack values from pinned periods +and error bounds; they do not reverify source tables or certificates. + +Base: canonical main `e54523517d0f03e58352e647c403a5af3e525a57`. Exact proof +and kernel pins, including Git blob IDs and SHA-256 digests, are in +`SOURCES.json`. The unchanged #6509 kernel replay passes 72 signed ray inputs +through `t=2^256`, literal inverse checks, dyadic unit-ball witnesses for +`p=1..64`, and source/assumption negative controls. Run +`python3 -B reproduce.py`; the receipt is emitted to stdout. `RESULT.json` +changes only with explicit `--write-result`. + +Credit Ali Romman (#6509, #6534, #6536), Nick Petalas (#6438, #6619), @CubeJerry +(#6758), and the finite-sphere predecessor #2589. The new proof and replay +were prepared with substantial OpenAI Codex assistance; `SOURCE-NOTICE.md` +preserves the #6509 notice. + +This is not a new κ result or a change to the selected frontier. All five +global assumptions of the current conditional multiplication theorem remain +as stated. The unrestricted #6619 outward-slack question remains open; the +note establishes neither global optimality for arbitrary maps nor a physical +implementation or tariff. diff --git a/research/affine-period-outward-slack/PR-TITLE.txt b/research/affine-period-outward-slack/PR-TITLE.txt new file mode 100644 index 0000000000..e2822140ea --- /dev/null +++ b/research/affine-period-outward-slack/PR-TITLE.txt @@ -0,0 +1 @@ +Prove exact outward norm slack from affine periods and classify the conserved-sum Gaussian pair family diff --git a/research/affine-period-outward-slack/PROOF.md b/research/affine-period-outward-slack/PROOF.md new file mode 100644 index 0000000000..3d97a26044 --- /dev/null +++ b/research/affine-period-outward-slack/PROOF.md @@ -0,0 +1,202 @@ +# Exact outward slack from affine periods and sum fibers + +## Scope and notation + +All norms below are Euclidean. A supremum is over an unbounded integer lattice; +no finite input cutoff is implicit. The pair specialization uses +`G = Z[i]`, identifies `G^2` with `Z^4`, and uses the norm +`||(x,y)||^2 = |x|^2 + |y|^2`. + +## Full-rank affine-period theorem + +Let `U` be a rational orthogonal `d x d` matrix, `F: Z^d -> Z^d`, and +`Lambda <= Z^d` a full-rank sublattice. Suppose + +```text +F(x + lambda) = F(x) + U lambda for all x in Z^d, lambda in Lambda. +``` + +Then + +```text +sup_x (||F(x)|| - ||x||) + = max_[x] in Z^d/Lambda ||F(x) - Ux||. +``` + +Proof. Put `e(x)=F(x)-Ux`. The period law makes `e` constant on each +coset. The quotient is finite because `Lambda` has full rank. On a coset with +error `e`, orthogonality and the triangle inequality give + +```text +||F(x)|| - ||x|| = ||Ux+e|| - ||Ux|| <= ||e||. +``` + +If `e=0`, this bound is attained as equality. Otherwise `v=U^T e` is a +nonzero rational vector. Choose an integer `q>0` clearing its denominators and +an integer `m>0` with `m Z^d <= Lambda`; then `lambda=m q v` belongs to +`Lambda`. For a coset representative `x0`, set `xn=x0+n lambda`. Since +`U lambda=m q e`, + +```text +||F(xn)|| - ||xn|| + = ||Ux0 + (n m q + 1)e|| - ||Ux0 + n m q e|| -> ||e||. +``` + +Thus each coset supremum is its error norm, and the finite quotient turns the +supremum over all inputs into the stated maximum. No injectivity, inverse, +nonexpansion, or rounding rule is assumed. Full rank, orthogonality, an +unbounded domain, and the affine-period identity are substantive hypotheses. + +Rationality of `U` may be retained as a convenient hypothesis, but follows +from the others: for an integer basis matrix `B` of `Lambda`, the period law +implies `UB=F(x+B)-F(x)` has integer columns, so `U=(UB)B^-1` is rational. + +## The entire bounded-center pair family + +Fix `sigma` in `{+1,-1}` and any bounded center rule `c: G -> G` satisfying +the exact output-parity condition + +```text +Re(c(s)) + Im(c(s)) = Re(s) + Im(s) (mod 2). +``` + +This is the legal-center condition proved in #6509. For `s=x+y` and `d=x-y`, +define the ideal orthogonal pair operator and the rounded map by + +```text +C_sigma(x,y) = ((s + sigma*i*d)/2, (s - sigma*i*d)/2) +F_(c,sigma)(x,y) + = ((s + sigma*i*d + (1-sigma*i)c(s))/2, + (s - sigma*i*d - (1-sigma*i)c(s))/2). +``` + +`C_sigma` fixes the sum and multiplies the difference by `sigma*i`; its +adjoint is `C_-sigma`. On the fiber with sum `s`, the error is constant: + +```text +e_s = ((1-sigma*i)c(s)/2, -(1-sigma*i)c(s)/2), +||e_s|| = |c(s)|. +``` + +The fiber is an affine copy of the full-rank tangent lattice +`T={(z,-z): z in G}`. Define + +```text +lambda_s = 2 C_sigma^* e_s + = (-(1+sigma*i)c(s), (1+sigma*i)c(s)). +``` + +This is an integral Gaussian pair with sum zero, and `C_sigma lambda_s=2e_s`. +For every fixed `s`, the triangle inequality bounds the fiber's outward norm +increment by `|c(s)|`. If `c(s) != 0`, take any `X0` on the fiber and +`Xn=X0+n lambda_s`. Then + +```text +C_sigma Xn = C_sigma X0 + 2n e_s, +F_(c,sigma)(Xn) = C_sigma X0 + (2n+1)e_s, +``` + +so the fiber supremum is exactly `|c(s)|`. For `c(s)=0`, the map is +orthogonal on that fiber and the same value zero holds. Taking the supremum +over all sums gives the exact family formula + +```text +sup_(x,y) (||F_(c,sigma)(x,y)|| - ||(x,y)||) = sup_s |c(s)|. +``` + +This is a fiberwise argument; the center may depend on `s` and need not make +the full map affine-periodic on one global full-rank lattice. + +For every legal rule, an odd-parity sum such as `s=1` requires +`Re(c)+Im(c)` odd. Thus `c(s)` is nonzero there and `|c(s)| >= 1`; no legal +rule has uniform outward slack below one. #6509's rule has `c=0` on even +parity sums and chooses a Gaussian unit on odd parity sums, so it attains +`sup_s |c(s)|=1`. The minimum outward slack over the whole bounded-center +family is therefore exactly one, independent of the sign `sigma`. + +## Exact ray for the retained #6509 kernel + +For `sigma=+1`, `s=1`, and the source rule's `c(1)=1`, the base point +`X0=(1,0)` has the legal tangent increment `lambda_1=(-(1+i),1+i)`. At +integer `t>=0`, + +```text +Xt = (1-t-it, t+it), +F(Xt) = (1+t-it, -t+it), +||Xt||^2 = 4t^2 - 2t + 1, +||F(Xt)||^2 = 4t^2 + 2t + 1. +``` + +For `t>=1`, let `g_t=||F(Xt)||-||Xt||`. Then + +```text +g_t = 4t / (sqrt(4t^2+2t+1) + sqrt(4t^2-2t+1)), +(32t^2-2)/(32t^2+1) < g_t < 1. +``` + +For the lower bound, put `a=2t+1/2` and `b=2t-1/2`. For positive `z`, +`sqrt(z^2+3/4) < z+3/(8z)`. Hence the denominator above is strictly less +than `4t + 6t/(16t^2-1)`, which gives the displayed lower bound. For the +upper bound, `4(4t^2-2t+1) > (4t-1)^2`, so +`2 sqrt(4t^2-2t+1)+1 > 4t`, equivalent to `g_t<1`. + +There is also a closed-unit-ball witness at every dyadic scale. Put +`h=2^-p`, `t=2^(p-1)` for integer `p>=1`, and interpret the integer-grid +kernel inputs and outputs multiplied by `h`. The exact squared norms are + +```text +input: 1 - h + h^2 <= 1, +output: 1 + h + h^2 > 1. +``` + +The executable check below runs the unchanged integer-grid kernel on finite +members of both witness families. The all-size conclusions above follow from +the algebra, not from these runs. + +## Source-bound consequences and limits + +The exact #6534 two-axis map has a full-rank affine period relative to its +unitary ideal map and sharp uniform error `sqrt(2) h`; the theorem therefore +identifies its outward norm supremum as `sqrt(2) h`. The exact #6536 +three-axis matched-coset map has its full-rank source-class period and sharp +uniform error `2h`; its outward norm supremum is `2h`. These are corollaries +of the pinned source theorems, not fresh table or matching checks. + +The #6438 five-seed rotation has period `5 Z^2` relative to the rational +orthogonal matrix `[[3,-4],[4,3]]/5`. Its source proves error at most +`sqrt(4/5)` for every seed/input and states that this deterministic bound is +attained by the construction. The lemma therefore gives exact worst outward +slack `sqrt(4/5)` across the five maps; this does not assert that every +individual seed attains that value. The #6758 native theorem similarly gives +sharp forward and inverse error `sqrt(8)` and a full-rank forward period +`Gamma`. For the inverse, `U Gamma` is an integral full-rank lattice: the +forward period law and integer-valued F imply `U lambda` is integral, and +bijectivity gives `F^-1(y+U lambda)=F^-1(y)+lambda`. Applying the theorem to +F and to its inverse relative to `U^*` gives forward and inverse outward +slack `sqrt(8)`. These uses inherit the pinned source results; this package +does not recheck their tables, certificates, or full implementations. + +This does not answer #6619's unrestricted outward-slack optimization and +does not imply a positive minimum for every reversible integer-output map. +For a translation `lambda=(a,b)` with sum `u=a+b`, the pair formula gives +`F(X+lambda)-F(X)=C_sigma lambda + e_(s+u)-e_s`. Thus a global period +identity for this translation requires `c(s+u)=c(s)` for every `s`. The +actual #6509 sign-based center has no nonzero additive period: if the +real-plus-imaginary parity of `u` is odd, use `s=0`, where `c(s)=0` but +`c(s+u)` is a Gaussian unit; if both coordinates of `u` are odd, use +`s=1`, where the center changes from `1` to `i` or `-i`; if both are even +and `u != 0`, choose an odd real (respectively imaginary) coordinate `+1` +or `-1` whose sign is reversed by the nonzero real (respectively imaginary) +part of `u`, with the other coordinate zero. In that last case the center +changes from `+1` to `-1` or vice versa, or from `+i` to `-i` or vice versa. +For example, the equal-coordinate shift `(-1,-1)` changes the center from +`c(1)=1` to `c(-1)=-1` and fails the global affine-period identity. A full-rank +period lattice cannot lie wholly in the rank-two sum-zero subspace, so this +source map is not globally affine-periodic on a full-rank lattice. The +fixed-sum fiber argument is precisely why the #6509 result remains valid +without a global period premise. + +No new kernel, physical tariff, component guard, selected `kappa`, or +unrestricted optimality result is claimed. The finite kernel replay tests the +retained center rule only; the universal bounded-center theorem is proved by +the formulas above. diff --git a/research/affine-period-outward-slack/PUBLICATION-MANIFEST.json b/research/affine-period-outward-slack/PUBLICATION-MANIFEST.json new file mode 100644 index 0000000000..6e502407ef --- /dev/null +++ b/research/affine-period-outward-slack/PUBLICATION-MANIFEST.json @@ -0,0 +1,26 @@ +{ + "base": "e54523517d0f03e58352e647c403a5af3e525a57", + "claim_type": "scoped universal mathematical lemma and source corollaries; no new kappa", + "files": { + "NOTICE.md": "cf2799f914127a3c6b74db62afeaa2482cf7b5ac159aac186d0d17ee6104a1f6", + "PR-DRAFT.md": "c069671740452e1276ae4d0bb33967e74fc52f043268ca0f97d6d1c6349e8766", + "PR-TITLE.txt": "e96399c06b577e2e9308aef387c15944b88012b6e6835a87bd75e12a05f034e5", + "PROOF.md": "7eae173d7223d473d574c87bbdae6fad4fb857559a8cc717304bdbdebaa1eb7d", + "README.md": "89d934319e688e7c9ffd686d00deb14b48d687152227dea383b1ba74b2c9689c", + "RESULT.json": "0fc96cc4f7f04a5de9c224ab1e516c3d3d9b70700b41da7fb646e7a629102bf9", + "SOURCE-NOTICE.md": "ba3157cea93750cc40a060e06af11da25f8d1b0e51eeea56636c94ce2c8abe8e", + "SOURCES.json": "5316820f28df712e374365bb7aacf60e4a8de7a018911e68ba4fe915d952859b", + "VERIFY.json": "c392c163eb22f23dc7085b8bc1e81343031cafa1329b610a77133282a0fd97b7", + "kernel.py": "fc3e2bf828fa547bee5710f9d5502b7c8c4dcb4cab7536ff73e3dbff54960f1b", + "reproduce.py": "419a231716a7f8679deb9faba7f44a3233912bc7296a1521d4fb9b546dca38f7", + "review/AUTHOR-OPTIMIZED-REPLAY.json": "fb7725008661c5a3f788f9ca6428db77fa8fad620477d135250400fd3cae452b", + "review/AUTHOR-REPLAY.json": "fb7725008661c5a3f788f9ca6428db77fa8fad620477d135250400fd3cae452b", + "review/PUBLICATION-ROOT-REPLAY.json": "6e0e2186fd1e684b353bc444303218bea24a9833dec7157e24ab7f14ad3ebbdc", + "review/README.md": "c6e2a0e25bf481a2f77e5f3381fc6645406d1487440e025e5ecbcb7b8a9a73bd", + "review/RESULT.json": "6e0e2186fd1e684b353bc444303218bea24a9833dec7157e24ab7f14ad3ebbdc", + "review/ROOT-REVIEW.md": "c9d738ae5d96f74cc17c552a53cb69560aa30e78cfae81cfb79a3011f4fbf97c", + "review/SOURCE-BINDING.json": "d06a6eced4cd0ce7e63a989e3f3d14f55bba31c3821a5a4fced7b0ce99618416", + "review/check_norm_slack_root.py": "ea2c2e0bbdc992adeeb4a5df35e7492d4144bfe067622d726494ebeacb3d9214" + }, + "reviews": "written author and lead proofs; exact independent rational/source replay; all eight remote source pins checked" +} diff --git a/research/affine-period-outward-slack/README.md b/research/affine-period-outward-slack/README.md new file mode 100644 index 0000000000..626b48b10d --- /dev/null +++ b/research/affine-period-outward-slack/README.md @@ -0,0 +1,80 @@ +# Exact outward slack from affine periods and sum fibers + +**Result.** For a rational orthogonal map with a full-rank affine period, the +supremum of the outward norm increment equals the largest period-coset error. +Applying the same ray argument within each fixed-sum fiber proves, for every +legal bounded center rule in the #6509 pair family, that the global outward +slack is exactly `sup_s |c(s)|`. The least value among these center rules is +one, attained by #6509's source rule. + +This is an exact norm-slack classification for a scoped family. It gives no +physical tariff, selected `kappa`, or unrestricted optimality claim. The +#6509 sign-based center does not have a full-rank global affine period; its +proof uses integral ray shifts inside fixed-sum fibers. + +## Files and reproduction + +- [PROOF.md](PROOF.md) gives the period theorem, the complete legal-center + family proof, the ray inequalities, and the source-bound corollaries. +- [SOURCES.json](SOURCES.json) pins the canonical base, retained kernel, and + predecessor proofs by commit, Git blob, and SHA-256. +- [kernel.py](kernel.py) is a byte-identical copy of #6509's tiny kernel. +- [SOURCE-NOTICE.md](SOURCE-NOTICE.md) preserves its upstream notice; + [NOTICE.md](NOTICE.md) records this package's added work and credit. +- [VERIFY.json](VERIFY.json) records the exact replay command. + +Run from this directory with Python 3.10+ and the standard library: + +```sh +python3 -B reproduce.py +``` + +The default run prints the full receipt to stdout and leaves `RESULT.json` +untouched; the explicit checks also pass under `python3 -O -B reproduce.py`. +Use `python3 -B reproduce.py --write-result` to refresh the receipt file. + +The verifier authenticates the copied kernel bytes, runs the exact `c(1)=1` +ray and literal inverse on integer-grid witnesses, checks the dyadic +unit-ball crossing with `Fraction`, and requires both an illegal-center +mutation and a specific unsupported equal-coordinate global-period candidate +to fail. The finite run +corroborates the retained kernel on those witnesses; it does not prove the +all-center theorem, which follows from the written algebra. + +## Predecessors and limits + +Ali Romman's #6509 supplies the legal-center condition, exact inverse, and the +unchanged pair kernel. #6534 and #6536 do not state the radial outward-slack +equality proved here. Ali Romman's #6534 two-axis map already has sharp +uniform error `sqrt(2)h`; the period theorem converts that inherited error +result into exact outward slack `sqrt(2)h`. The #6536 matched three-axis map +has sharp uniform error `2h`, giving exact outward slack `2h`. These are +corollaries of pinned source claims; their tables and matchings are not +reverified here. + +Nick Petalas's #6438 five-seed rotation has an affine period, a per-seed error +bound `sqrt(4/5)`, and an attained maximum across the construction, so its +worst outward slack across the seeds is exactly `sqrt(4/5)`. CubeJerry's #6758 native map similarly has inherited sharp +forward and inverse error `sqrt(8)` and a full-rank period, so both outward +slacks are `sqrt(8)`. This package does not recheck either certificate. + +The prior finite-set argument #2589, cited by #6619, concerns exact norm +preservation on finite spheres; it is not the unbounded lattice ray proof +used here. #6619's unrestricted outward-slack optimization remains open in +this package. + +## Open next questions + +- **Question:** Is there a sharp outward-slack bound for injective + integer-output maps without an affine-period or fixed-fiber decomposition? + **Why it matters:** Such a result would connect this exact periodic/fiber + classification to the unrestricted problem left open by #6619. + **First step:** Prove a bound or construct a counterexample while checking + injectivity over complete integer spheres, not only a finite sample. + **Blocked by:** No period quotient or other finite classification is known + here for the unrestricted map class. + +## Assistance + +The new proof and reproduction package were prepared with substantial OpenAI +Codex assistance. No code from #6534, #6536, #6438, or #6758 is copied. diff --git a/research/affine-period-outward-slack/RESULT.json b/research/affine-period-outward-slack/RESULT.json new file mode 100644 index 0000000000..71882c9c06 --- /dev/null +++ b/research/affine-period-outward-slack/RESULT.json @@ -0,0 +1,106 @@ +{ + "controls": { + "candidate_global_equal_coordinate_period_rejected": true, + "illegal_center_mutation_rejected": true, + "one_step_adjoint_error_not_integral": true + }, + "dependencies": "Python standard library only", + "dyadic_case_count": 64, + "dyadic_endpoint_examples": [ + { + "input_norm_squared": "3/4", + "output_norm_squared": "7/4", + "p": 1 + }, + { + "input_norm_squared": "340282366920938463444927863358058659841/340282366920938463463374607431768211456", + "output_norm_squared": "340282366920938463481821351505477763073/340282366920938463463374607431768211456", + "p": 64 + } + ], + "dyadic_p_range": [ + 1, + 64 + ], + "kernel_git_blob": "b00bbbc7655121232a46101962c48e71cee98a39", + "kernel_sha256": "fc3e2bf828fa547bee5710f9d5502b7c8c4dcb4cab7536ff73e3dbff54960f1b", + "max_ray_t_bits": 257, + "python_version": "3.12.14", + "ray_case_count": 72, + "ray_t_values": [ + "0", + "1", + "2", + "3", + "4", + "5", + "6", + "7", + "8", + "16", + "32", + "64", + "128", + "256", + "512", + "1024", + "2048", + "4096", + "8192", + "16384", + "32768", + "65536", + "131072", + "262144", + "524288", + "1048576", + "2097152", + "4194304", + "8388608", + "16777216", + "33554432", + "67108864", + "134217728", + "268435456", + "536870912", + "1073741824", + "2147483648", + "4294967296", + "8589934592", + "17179869184", + "34359738368", + "68719476736", + "137438953472", + "274877906944", + "549755813888", + "1099511627776", + "2199023255552", + "4398046511104", + "8796093022208", + "17592186044416", + "35184372088832", + "70368744177664", + "140737488355328", + "281474976710656", + "562949953421312", + "1125899906842624", + "2251799813685248", + "4503599627370496", + "9007199254740992", + "18014398509481984", + "36028797018963968", + "72057594037927936", + "144115188075855872", + "288230376151711744", + "576460752303423488", + "1152921504606846976", + "2305843009213693952", + "4611686018427387904", + "9223372036854775808", + "18446744073709551616", + "340282366920938463463374607431768211456", + "115792089237316195423570985008687907853269984665640564039457584007913129639936" + ], + "scope": "finite exact execution of #6509 source ray and negative controls; all-size proof is PROOF.md", + "status": "PASS" +} diff --git a/research/affine-period-outward-slack/SOURCE-NOTICE.md b/research/affine-period-outward-slack/SOURCE-NOTICE.md new file mode 100644 index 0000000000..e5377e3e34 --- /dev/null +++ b/research/affine-period-outward-slack/SOURCE-NOTICE.md @@ -0,0 +1,21 @@ +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. + +JoyboyBrian / PR5485 supplies the retained literal nearest-even C0/C2 calls, +monomial/mixing implementation, complete port schedules, accuracy and width +bounds. PR4743 and its retained native-port/error-channel lineage supply the +underlying ports and external tolerance analysis. These are reused and credited, +not claimed as new constructions or independently re-established theorems. + +Tekalign supplies p104-reversible-lifting, including an earlier exact inverse, +nearest pair-error bound and complete collector cleanup. Arham Tahir supplies +the numerical collision and native-rounding context. Nick Petalas and the +retained precision authors supply unitary error-propagation context. The +native-rounded-loop-defect result is by JoyboyBrian; coherent-frame-additivity +is by Cinna Davis. They retain their separate graph-consistency obstructions. +All copied files keep their notices. + +The new contribution is the conserved-sum, Gaussian-phase-covariant rounding +choice, exact center classification and pointwise optimality proof, complete +port installation, exact fiber-observable contract, controls and direct cost. +Lattice parity, affine rotation and integer lifting are established mathematics. +No historical algorithm, generic reversibility or source port is claimed as new. diff --git a/research/affine-period-outward-slack/SOURCES.json b/research/affine-period-outward-slack/SOURCES.json new file mode 100644 index 0000000000..04e0260992 --- /dev/null +++ b/research/affine-period-outward-slack/SOURCES.json @@ -0,0 +1,84 @@ +{ + "package": "affine-period-outward-slack", + "canonical_base": { + "repository": "CrocSwap/integer-mult-bounds", + "commit": "e54523517d0f03e58352e647c403a5af3e525a57" + }, + "files": [ + { + "local_path": "kernel.py", + "usage": "input", + "source_repository": "aliromman/integer-mult-bounds", + "source_pr": 6509, + "source_commit": "a4173e810c4d34a1d13b9745af123ad0ec6cfed5", + "source_path": "research/conservative-gaussian-rounding/kernel.py", + "git_blob": "b00bbbc7655121232a46101962c48e71cee98a39", + "sha256": "fc3e2bf828fa547bee5710f9d5502b7c8c4dcb4cab7536ff73e3dbff54960f1b" + }, + { + "source_repository": "aliromman/integer-mult-bounds", + "source_pr": 6509, + "source_commit": "a4173e810c4d34a1d13b9745af123ad0ec6cfed5", + "source_path": "research/conservative-gaussian-rounding/PROOF.md", + "git_blob": "b7047476aaa5e2bb149c92a8a40a9b2ab444ef73", + "sha256": "122eff335674d8de1bcba47d28feb0c420be62b2b6d4e84f91c4292383753380", + "role": "legal center condition, source rule, inverse, and inherited kernel contract" + }, + { + "local_path": "SOURCE-NOTICE.md", + "usage": "provenance", + "source_repository": "aliromman/integer-mult-bounds", + "source_pr": 6509, + "source_commit": "a4173e810c4d34a1d13b9745af123ad0ec6cfed5", + "source_path": "research/conservative-gaussian-rounding/NOTICE", + "git_blob": "e5377e3e34c883d3bd8a829e1cb247f3aba28cc8", + "sha256": "ba3157cea93750cc40a060e06af11da25f8d1b0e51eeea56636c94ce2c8abe8e" + }, + { + "source_repository": "aliromman/integer-mult-bounds", + "source_pr": 6534, + "source_commit": "78a41d06645b2e53ec3708d5580920e7dd002776", + "source_path": "research/fused-gaussian-rounding/PROOF.md", + "git_blob": "58dc3d172883b3c688970c7f00f1ede85aec4a79", + "sha256": "8c1e873bc1aefcbf0a78ff1f22bd91bece06e126f82abc833a14cd456fde110b", + "role": "predecessor comparison and inherited sharp two-axis error" + }, + { + "source_repository": "aliromman/integer-mult-bounds", + "source_pr": 6536, + "source_commit": "83fee59d692b0764d716e8356a7d991e4d503868", + "source_path": "research/three-axis-coset-rounding/PROOF.md", + "git_blob": "0d97e005ee7afe989ad96dc040aea3b3f59e3011", + "sha256": "9d29cc4b7a640787bffe1e5475f0f5da0714928aa1739511020bb0946fb03ffa", + "role": "predecessor comparison and inherited sharp three-axis error" + }, + { + "source_repository": "CrocSwap/integer-mult-bounds", + "source_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "source_path": "research/unbiased-periodic-rotation/PROOF.md", + "git_blob": "d8d4038ccef682e3c52984076fcfb1d2783487aa", + "sha256": "fff6996afd0875a0d3a47c2cb4641a88aba38e7de8d44f23265bf39d9a918b18", + "role": "predecessor with affine periods and explicitly allowed outward motion" + }, + { + "source_repository": "CubeJerry/integer-mult-bounds", + "source_commit": "362b20bc934500bc503e850059f0d34daa5dcae3", + "source_path": "research/four-axis-phase-covariant-grid/PROOF.md", + "git_blob": "bd5fb90ec3f064388eda1c1bd8834c26b4464bab", + "sha256": "dc07dcdf9793b401053738ea7e88c69495967f48f234e8411b8aaaa9858e8632", + "role": "inherited sharp native error and full-rank period corollary" + }, + { + "source_repository": "petalas/integer-mult-bounds", + "source_commit": "eaa967e7e8aa12cc53ec246a5fc00c5f8873a50b", + "source_path": "research/rational-norm-rounding/PROOF.md", + "git_blob": "ffb873b2749b1590df9267e802aea5af2c2a6eb5", + "sha256": "231b1b322b6be2a798d1807f5c0346ac4002323384b45cd4eff2a0ef7210bc00", + "role": "unrestricted outward-slack limit and predecessor credit" + } + ], + "external_predecessor_credit": { + "pr": 2589, + "source_context": "Cited as a finite-sphere lemma by #6619; not used in this ray proof." + } +} diff --git a/research/affine-period-outward-slack/VERIFY.json b/research/affine-period-outward-slack/VERIFY.json new file mode 100644 index 0000000000..c649cbe999 --- /dev/null +++ b/research/affine-period-outward-slack/VERIFY.json @@ -0,0 +1,19 @@ +{ + "status": "ready", + "commands": [ + { + "argv": ["python3", "-B", "reproduce.py"], + "timeout_seconds": 30, + "inputs": ["kernel.py"], + "expected_stdout_contains": "\"status\": \"PASS\"" + }, + { + "argv": ["python3", "-O", "-B", "reproduce.py"], + "timeout_seconds": 30, + "inputs": ["kernel.py"], + "expected_stdout_contains": "\"status\": \"PASS\"" + } + ], + "runtime": "Python 3.10+ standard library", + "note": "Default replay emits a receipt on stdout and does not write RESULT.json. Add --write-result to update that file explicitly. The command authenticates and executes the unchanged #6509 kernel. It corroborates finite witnesses and controls; it does not execute the universal written proof." +} diff --git a/research/affine-period-outward-slack/kernel.py b/research/affine-period-outward-slack/kernel.py new file mode 100644 index 0000000000..b00bbbc765 --- /dev/null +++ b/research/affine-period-outward-slack/kernel.py @@ -0,0 +1,63 @@ +"""Conserve pair sums with a reversible nearest Gaussian grid map. + +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +""" + +def need(ok, why): + if not ok: + raise ValueError(why) + + +def center(real, imag): + """Choose a phase-covariant minimum-norm parity center.""" + if (real ^ imag) & 1 == 0: + return 0, 0 + if real & 1: + return (1 if real > 0 else -1), 0 + return 0, (1 if imag > 0 else -1) + + +def pair(x, y, width, sign=1, trace=None): + need(type(width) is int and width >= 2 and type(sign) is int and sign in (-1, 1), 'Pair format') + need(len(x) == len(y) == 2, 'Gaussian pair') + trace = trace if trace is not None else {} + def word(value): + need(type(value) is int and -(1 << (width-1)) <= value < (1 << (width-1)), 'Signed word overflow') + trace['checked_values'] = trace.get('checked_values', 0)+1 + trace['peak_integer'] = max(trace.get('peak_integer', 0), abs(value)) + return value + a,b=map(word,x);c,d=map(word,y) + sr,si=word(a+c),word(b+d) + dr,di=word(a-c),word(b-d) + cr,ci=center(sr,si) + tr,ti=cr+sign*ci,ci-sign*cr + nr=word(word(sr-sign*di)+tr) + ni=word(word(si+sign*dr)+ti) + need(nr & 1 == ni & 1 == 0, 'Exact pair halves') + first=word(nr >> 1),word(ni >> 1) + second=word(sr-first[0]),word(si-first[1]) + trace['butterflies']=trace.get('butterflies',0)+1 + trace['nonzero_roundings']=trace.get('nonzero_roundings',0)+int(bool(cr or ci)) + trace['data_additions']=trace.get('data_additions',0)+10 + trace['data_half_shifts']=trace.get('data_half_shifts',0)+2 + return first,second + + +def layer(values, bit, width, sign=1, trace=None): + need(type(bit) is int and bit >= 0 and len(values)>0 and len(values)&(len(values)-1)==0 + and (1 << bit)= 1 and type(axis) is int and axis in (0,2) + and len(values)==8**f and type(adjoint) is bool, 'Literal Gaussian call dimensions') + stages=range(f-1,-1,-1) if adjoint else range(f) + for stage in stages: + layer(values,3*stage+axis,width,-1 if adjoint else 1,trace) + return values diff --git a/research/affine-period-outward-slack/reproduce.py b/research/affine-period-outward-slack/reproduce.py new file mode 100644 index 0000000000..47032e85d4 --- /dev/null +++ b/research/affine-period-outward-slack/reproduce.py @@ -0,0 +1,188 @@ +#!/usr/bin/env python3 +"""Replay finite source-bound witnesses for PROOF.md (not its all-size proof).""" + +from __future__ import annotations + +import hashlib +import argparse +import json +from fractions import Fraction +from pathlib import Path +import sys +from types import ModuleType + + +ROOT = Path(__file__).resolve().parent +KERNEL_PATH = ROOT / "kernel.py" +RESULT_PATH = ROOT / "RESULT.json" +EXPECTED_GIT_BLOB = "b00bbbc7655121232a46101962c48e71cee98a39" +EXPECTED_SHA256 = "fc3e2bf828fa547bee5710f9d5502b7c8c4dcb4cab7536ff73e3dbff54960f1b" + + +def require(condition: bool, explanation: str) -> None: + if not condition: + raise RuntimeError(explanation) + + +def git_blob_id(data: bytes) -> str: + prefix = b"blob " + str(len(data)).encode("ascii") + b"\0" + return hashlib.sha1(prefix + data).hexdigest() + + +def load_kernel() -> tuple[ModuleType, bytes]: + data = KERNEL_PATH.read_bytes() + require(hashlib.sha256(data).hexdigest() == EXPECTED_SHA256, + "kernel.py SHA-256 differs from the pinned #6509 source") + require(git_blob_id(data) == EXPECTED_GIT_BLOB, + "kernel.py Git blob differs from the pinned #6509 source") + module = ModuleType("retained_6509_kernel") + exec(compile(data, str(KERNEL_PATH), "exec"), module.__dict__) + return module, data + + +def add(a: tuple[int, int], b: tuple[int, int]) -> tuple[int, int]: + return a[0] + b[0], a[1] + b[1] + + +def sub(a: tuple[int, int], b: tuple[int, int]) -> tuple[int, int]: + return a[0] - b[0], a[1] - b[1] + + +def ideal_pair(pair: tuple[tuple[int, int], tuple[int, int]], sigma: int): + x, y = pair + s = add(x, y) + d = sub(x, y) + rotated = (-sigma * d[1], sigma * d[0]) + numerators = (add(s, rotated), sub(s, rotated)) + require(all((coordinate % 2) == 0 for out in numerators for coordinate in out), + "the ideal image used in an integer identity was not integral") + return tuple((out[0] // 2, out[1] // 2) for out in numerators) + + +def expected_ray_input(t: int): + return ((1 - t, -t), (t, t)) + + +def expected_ray_output(t: int): + return ((1 + t, -t), (-t, t)) + + +def width_for(t: int) -> int: + # The #6509 proof bounds every pair intermediate by 4M+1; here M<=2t. + return max(3, (8 * t + 2).bit_length() + 1) + + +def source_mutation_control(source: bytes) -> None: + text = source.decode("utf-8") + needle = "return (1 if real > 0 else -1), 0" + require(text.count(needle) == 1, "could not locate the pinned odd-center branch") + mutant_text = text.replace(needle, "return 0, 0", 1) + mutant = ModuleType("illegal_center_mutant") + exec(compile(mutant_text, "", "exec"), mutant.__dict__) + try: + mutant.pair((1, 0), (0, 0), width=8, sign=1) + except ValueError as error: + require("Exact pair halves" in str(error), + "illegal-center mutant failed for an unexpected reason") + else: + raise RuntimeError("illegal odd-sum center was accepted by the source mutant") + + +def global_period_control(kernel: ModuleType) -> None: + # The translation (-1,-1) is fixed by C_sigma, but the sign-based source + # center changes from c(1)=1 to c(-1)=-1. + start = ((1, 0), (0, 0)) + shift = ((-1, 0), (-1, 0)) + translated = ((0, 0), (-1, 0)) + require(kernel.center(1, 0) == (1, 0), "unexpected source center at sum 1") + require(kernel.center(-1, 0) == (-1, 0), "unexpected source center at sum -1") + out0 = kernel.pair(start[0], start[1], width=8, sign=1) + out1 = kernel.pair(translated[0], translated[1], width=8, sign=1) + difference = (sub(out1[0], out0[0]), sub(out1[1], out0[1])) + require(difference != shift, + "a sign-dependent center unexpectedly obeyed this global period candidate") + + +def main() -> None: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--write-result", action="store_true", + help="write the verified receipt to RESULT.json") + args = parser.parse_args() + kernel, source = load_kernel() + + # The factor 2 in lambda=2 C_sigma^* e is essential: C_sigma^* e + # itself has half-integral coordinates for the c=1 witness. + half_adjoint_error = ( + (Fraction(-1, 2), Fraction(-1, 2)), + (Fraction(1, 2), Fraction(1, 2)), + ) + require(any(value.denominator != 1 for row in half_adjoint_error for value in row), + "the one-step adjoint error should not be a lattice vector") + integral_lambda = tuple(tuple(2 * value for value in row) for row in half_adjoint_error) + require(integral_lambda == ((-1, -1), (1, 1)), + "doubled adjoint error does not match the predicted integral ray") + twice_error = ((1, -1), (-1, 1)) + require(ideal_pair(integral_lambda, 1) == twice_error, + "C_sigma lambda != 2e on the retained c=1 ray") + + t_values = set(range(9)) + t_values.update(1 << exponent for exponent in (16, 32, 64, 128, 256)) + t_values.update(1 << (p - 1) for p in range(1, 65)) + ordered_t_values = sorted(t_values) + for t in ordered_t_values: + width = width_for(t) + incoming = expected_ray_input(t) + expected = expected_ray_output(t) + output = kernel.pair(incoming[0], incoming[1], width=width, sign=1) + require(output == expected, f"forward exact ray mismatch at t={t}") + returned = kernel.pair(output[0], output[1], width=width, sign=-1) + require(returned == incoming, f"literal inverse mismatch at t={t}") + + dyadic_cases = [] + for p in range(1, 65): + t = 1 << (p - 1) + h = Fraction(1, 1 << p) + input_norm2 = h * h * (4 * t * t - 2 * t + 1) + output_norm2 = h * h * (4 * t * t + 2 * t + 1) + require(input_norm2 == 1 - h + h * h, + f"dyadic input norm identity failed at p={p}") + require(output_norm2 == 1 + h + h * h, + f"dyadic output norm identity failed at p={p}") + require(input_norm2 < 1 and output_norm2 > 1, + f"dyadic unit-ball crossing failed at p={p}") + dyadic_cases.append({ + "p": p, + "input_norm_squared": str(input_norm2), + "output_norm_squared": str(output_norm2), + }) + + source_mutation_control(source) + global_period_control(kernel) + + result = { + "status": "PASS", + "scope": "finite exact execution of #6509 source ray and negative controls; all-size proof is PROOF.md", + "kernel_git_blob": EXPECTED_GIT_BLOB, + "kernel_sha256": EXPECTED_SHA256, + "ray_case_count": len(ordered_t_values), + "ray_t_values": [str(t) for t in ordered_t_values], + "max_ray_t_bits": max(ordered_t_values).bit_length(), + "dyadic_p_range": [1, 64], + "dyadic_case_count": len(dyadic_cases), + "dyadic_endpoint_examples": [dyadic_cases[0], dyadic_cases[-1]], + "controls": { + "illegal_center_mutation_rejected": True, + "one_step_adjoint_error_not_integral": True, + "candidate_global_equal_coordinate_period_rejected": True, + }, + "dependencies": "Python standard library only", + "python_version": sys.version.split()[0], + } + if args.write_result: + RESULT_PATH.write_text(json.dumps(result, indent=2, sort_keys=True) + "\n", + encoding="utf-8") + print(json.dumps(result, sort_keys=True)) + + +if __name__ == "__main__": + main() diff --git a/research/affine-period-outward-slack/review/AUTHOR-OPTIMIZED-REPLAY.json b/research/affine-period-outward-slack/review/AUTHOR-OPTIMIZED-REPLAY.json new file mode 100644 index 0000000000..4f9fdc28b7 --- /dev/null +++ b/research/affine-period-outward-slack/review/AUTHOR-OPTIMIZED-REPLAY.json @@ -0,0 +1 @@ +{"controls": {"candidate_global_equal_coordinate_period_rejected": true, "illegal_center_mutation_rejected": true, "one_step_adjoint_error_not_integral": true}, "dependencies": "Python standard library only", "dyadic_case_count": 64, "dyadic_endpoint_examples": [{"input_norm_squared": "3/4", "output_norm_squared": "7/4", "p": 1}, {"input_norm_squared": "340282366920938463444927863358058659841/340282366920938463463374607431768211456", "output_norm_squared": "340282366920938463481821351505477763073/340282366920938463463374607431768211456", "p": 64}], "dyadic_p_range": [1, 64], "kernel_git_blob": "b00bbbc7655121232a46101962c48e71cee98a39", "kernel_sha256": "fc3e2bf828fa547bee5710f9d5502b7c8c4dcb4cab7536ff73e3dbff54960f1b", "max_ray_t_bits": 257, "python_version": "3.12.14", "ray_case_count": 72, "ray_t_values": ["0", "1", "2", "3", "4", "5", "6", "7", "8", "16", "32", "64", "128", "256", "512", "1024", "2048", "4096", "8192", "16384", "32768", "65536", "131072", "262144", "524288", "1048576", "2097152", "4194304", "8388608", "16777216", "33554432", "67108864", "134217728", "268435456", "536870912", "1073741824", "2147483648", "4294967296", "8589934592", "17179869184", "34359738368", "68719476736", "137438953472", "274877906944", "549755813888", "1099511627776", "2199023255552", "4398046511104", "8796093022208", "17592186044416", "35184372088832", "70368744177664", "140737488355328", "281474976710656", "562949953421312", "1125899906842624", "2251799813685248", "4503599627370496", "9007199254740992", "18014398509481984", "36028797018963968", "72057594037927936", "144115188075855872", "288230376151711744", "576460752303423488", "1152921504606846976", "2305843009213693952", "4611686018427387904", "9223372036854775808", "18446744073709551616", "340282366920938463463374607431768211456", "115792089237316195423570985008687907853269984665640564039457584007913129639936"], "scope": "finite exact execution of #6509 source ray and negative controls; all-size proof is PROOF.md", "status": "PASS"} diff --git a/research/affine-period-outward-slack/review/AUTHOR-REPLAY.json b/research/affine-period-outward-slack/review/AUTHOR-REPLAY.json new file mode 100644 index 0000000000..4f9fdc28b7 --- /dev/null +++ b/research/affine-period-outward-slack/review/AUTHOR-REPLAY.json @@ -0,0 +1 @@ +{"controls": {"candidate_global_equal_coordinate_period_rejected": true, "illegal_center_mutation_rejected": true, "one_step_adjoint_error_not_integral": true}, "dependencies": "Python standard library only", "dyadic_case_count": 64, "dyadic_endpoint_examples": [{"input_norm_squared": "3/4", "output_norm_squared": "7/4", "p": 1}, {"input_norm_squared": "340282366920938463444927863358058659841/340282366920938463463374607431768211456", "output_norm_squared": "340282366920938463481821351505477763073/340282366920938463463374607431768211456", "p": 64}], "dyadic_p_range": [1, 64], "kernel_git_blob": "b00bbbc7655121232a46101962c48e71cee98a39", "kernel_sha256": "fc3e2bf828fa547bee5710f9d5502b7c8c4dcb4cab7536ff73e3dbff54960f1b", "max_ray_t_bits": 257, "python_version": "3.12.14", "ray_case_count": 72, "ray_t_values": ["0", "1", "2", "3", "4", "5", "6", "7", "8", "16", "32", "64", "128", "256", "512", "1024", "2048", "4096", "8192", "16384", "32768", "65536", "131072", "262144", "524288", "1048576", "2097152", "4194304", "8388608", "16777216", "33554432", "67108864", "134217728", "268435456", "536870912", "1073741824", "2147483648", "4294967296", "8589934592", "17179869184", "34359738368", "68719476736", "137438953472", "274877906944", "549755813888", "1099511627776", "2199023255552", "4398046511104", "8796093022208", "17592186044416", "35184372088832", "70368744177664", "140737488355328", "281474976710656", "562949953421312", "1125899906842624", "2251799813685248", "4503599627370496", "9007199254740992", "18014398509481984", "36028797018963968", "72057594037927936", "144115188075855872", "288230376151711744", "576460752303423488", "1152921504606846976", "2305843009213693952", "4611686018427387904", "9223372036854775808", "18446744073709551616", "340282366920938463463374607431768211456", "115792089237316195423570985008687907853269984665640564039457584007913129639936"], "scope": "finite exact execution of #6509 source ray and negative controls; all-size proof is PROOF.md", "status": "PASS"} diff --git a/research/affine-period-outward-slack/review/PUBLICATION-ROOT-REPLAY.json b/research/affine-period-outward-slack/review/PUBLICATION-ROOT-REPLAY.json new file mode 100644 index 0000000000..1c4b8acfeb --- /dev/null +++ b/research/affine-period-outward-slack/review/PUBLICATION-ROOT-REPLAY.json @@ -0,0 +1,27 @@ +{ + "status": "PASS_ROOT_AFFINE_PERIOD_SLACK_REVIEW", + "rotation": "[[3,-4],[4,3]]/5", + "quotient_representatives": 25, + "rotation_max_error_squared": "1/5", + "exact_ray_checks": 80, + "source_blob": "b00bbbc7655121232a46101962c48e71cee98a39", + "source_sha256": "fc3e2bf828fa547bee5710f9d5502b7c8c4dcb4cab7536ff73e3dbff54960f1b", + "unchanged_source_ray_and_inverse_cases": 20, + "source_t_exponents_through": 256, + "dyadic_unit_ball_p": [ + 1, + 2, + 3, + 7, + 31, + 128, + 257 + ], + "premise_controls": [ + "wrong period", + "nonorthogonal map", + "rank-deficient period", + "rectangular isometry" + ], + "scope": "Exact finite independent corroboration; universal equality and source-family optimum require written proofs. No full #6758 table replay." +} diff --git a/research/affine-period-outward-slack/review/README.md b/research/affine-period-outward-slack/review/README.md new file mode 100644 index 0000000000..7b528ab76b --- /dev/null +++ b/research/affine-period-outward-slack/review/README.md @@ -0,0 +1,14 @@ +# Independent lead review + +The final frozen proof, all eight source pins and normal/optimized replays were checked. ROOT-REVIEW.md gives an alternate lower-bound proof, the family proof audit and failed-premise examples. The root checker imports no author checker and authenticates the retained kernel before compiling its exact bytes. Its rational rotation is the classical 3/5,4/5 example, not a new construction. Source-bound corollaries inherit the original finite certificates; those tables were not rerun. + +From this package directory: + +```sh +python3 -I -W error -B reproduce.py +python3 -I -O -W error -B reproduce.py +python3 -I -W error -B review/check_norm_slack_root.py kernel.py +sha256sum --check CHECKSUMS.sha256 +``` + +Expected status values are PASS for the first two and PASS_ROOT_AFFINE_PERIOD_SLACK_REVIEW for the separate root replay. Direct runs write no package files. Prepared for @CubeJerry with substantial OpenAI assistance; this is AI-assisted independent reasoning and code, not human or proof-kernel approval. diff --git a/research/affine-period-outward-slack/review/RESULT.json b/research/affine-period-outward-slack/review/RESULT.json new file mode 100644 index 0000000000..1c4b8acfeb --- /dev/null +++ b/research/affine-period-outward-slack/review/RESULT.json @@ -0,0 +1,27 @@ +{ + "status": "PASS_ROOT_AFFINE_PERIOD_SLACK_REVIEW", + "rotation": "[[3,-4],[4,3]]/5", + "quotient_representatives": 25, + "rotation_max_error_squared": "1/5", + "exact_ray_checks": 80, + "source_blob": "b00bbbc7655121232a46101962c48e71cee98a39", + "source_sha256": "fc3e2bf828fa547bee5710f9d5502b7c8c4dcb4cab7536ff73e3dbff54960f1b", + "unchanged_source_ray_and_inverse_cases": 20, + "source_t_exponents_through": 256, + "dyadic_unit_ball_p": [ + 1, + 2, + 3, + 7, + 31, + 128, + 257 + ], + "premise_controls": [ + "wrong period", + "nonorthogonal map", + "rank-deficient period", + "rectangular isometry" + ], + "scope": "Exact finite independent corroboration; universal equality and source-family optimum require written proofs. No full #6758 table replay." +} diff --git a/research/affine-period-outward-slack/review/ROOT-REVIEW.md b/research/affine-period-outward-slack/review/ROOT-REVIEW.md new file mode 100644 index 0000000000..943809c182 --- /dev/null +++ b/research/affine-period-outward-slack/review/ROOT-REVIEW.md @@ -0,0 +1,91 @@ +# Independent lead review of affine-period outward slack + +Base: `e54523517d0f03e58352e647c403a5af3e525a57`. +The final author proof and code were reviewed in the publication snapshot. +All eight exact remote source pins match; normal/optimized author replay and +the separate root rational/source replay pass. The proof and implementation +hashes are recorded in PUBLICATION-MANIFEST.json. + +## Universal equality + +Let U be a square orthogonal matrix, F integer-valued, and Lambda a full-rank +integer lattice satisfying F(x+lambda)=F(x)+U lambda. Each error e=F(x)-Ux +is constant on its coset. The triangle inequality bounds every outward norm +increment by ||e||. For the reverse bound, choose a coset representative a. +The full-rank lattice has a bounded covering radius, so there are lambda_t in +Lambda with lambda_t=t U^T e+O(1). If e is nonzero, the vector U(a+lambda_t) +has length tending to infinity and unit direction tending to e/||e||. +Rationalizing the difference of its norm and the norm after adding e gives +the limit ||e||. If e=0 the difference is identically zero. The finite quotient +therefore gives the claimed maximum. This is a different proof of the lower +bound from the author's exact rational-ray argument. + +The source arithmetic is rational, so the author's stronger exact ray also +works: some positive integer multiple of U^T e belongs to Lambda. In fact +rationality of U follows from the other hypotheses: choose an integral basis +matrix B of Lambda; the columns of UB are integral differences of F values, +so U=(UB)B^-1 is rational. Bijectivity is not needed. If present, it makes +the inverse affine-periodic on U Lambda, with inverse error -U^T e at F(x), +and hence identical uniform error norm and identical outward-slack supremum. + +This is a statement on the unbounded lattice. It does not guarantee the same +supremum on an arbitrary fixed signed-width box, input ball, or selected caller +domain. Nonexpansion failure does not by itself give a new multiplication bound. + +## Fixed-sum conservative family + +For a Gaussian pair let s=x+y and d=x-y. The map fixes s and sends d to +sigma*i*(d-c(s))+c(s). Its error is (q,-q), where +q=(1-sigma*i)c(s)/2, of ambient pair norm |c(s)|. The orthogonal inverse image +of that error is also zero-sum. Twice that image is the Gaussian-integer tangent +vector (-(1+sigma*i)c(s),(1+sigma*i)c(s)); it preserves s and its image is +twice the error. Thus the exact-ray proof applies on each fixed-sum fiber, +even though the source's sign-dependent center is not globally periodic. + +Integer outputs require Re(c)+Im(c) congruent to Re(s)+Im(s) modulo two. +At mixed parity, every Gaussian integer center has magnitude at least one. +Consequently the least possible global outward slack among these legal +center-on-sum affine-difference rules is one. The source #6509 selects centers +of magnitude zero or one, so attains it. This does not classify arbitrary +nonperiodic bijective rounders in #6619. + +On the specific positive-sign ray (1-t-it,t+it), the unchanged source returns +(1+t-it,-t+it). Squared norms are 4t^2-2t+1 and 4t^2+2t+1. For integer t>=1, +the outward difference is strictly between (32t^2-2)/(32t^2+1) and one. +To prove the lower bound, write each radical as sqrt((2t +/- 1/2)^2+3/4) +and use sqrt(a^2+c)0 in their rationalized denominator. +The upper bound follows because each radical is greater than 2t +/- 1/2. +For h=2^-p and t=2^(p-1), the physical squared norms are 1-h+h^2 and +1+h+h^2. This is a pair Euclidean unit-ball obstruction, not an obstruction +to every selected component guard or every possible finite-width interface. + +## Independent executed evidence and controls + +`check_norm_slack_root.py` uses exact Fractions, a new rational rotation, +complete representatives modulo 5Z^2, and squared polynomial inequalities +instead of floating square roots. It reads and authenticates the unchanged +#6509 source blob before compiling those bytes directly; it does not import +the author's checker or any bytecode cache. The accompanying RESULT records +80 rotation-ray checks, 20 actual source ray/inverse checks through t=2^256, +and dyadic ball witnesses through p=257. These finite checks corroborate the +proof and source binding; they do not prove a universal theorem by enumeration. + +Failed-premise controls explain the limits. An incorrect proposed period +fails the affine identity. For U=2I and F=U the error is zero but outward +growth is unbounded, so orthogonality matters. With only the period along the +first coordinate, F(a,b)=(a,b-sign(b)) has error norm one and never increases +the norm, so full rank matters. For a rectangular isometry Ux=(x,0), +F(x)=(x,x mod 2) has period 2Z and error maximum one, but outward supremum +sqrt(2)-1; the error cannot be aligned using input directions. The square +orthogonal assumption avoids that problem. + +The pinned #6534, #6536 and #6758 proofs supply their kernel error/period +premises. This review read their relevant proofs but did not independently +regenerate the #6536 matching or #6758 large finite tables. Any applications +must retain that explicit source dependency. Source approximation optima are +predecessor results; the present contribution converts them to exact radial +slack statements within the stated family. No new kappa or native tariff. + +Prepared for @CubeJerry by the lead OpenAI research agent, with substantial +AI assistance. This is independent reasoning and implementation within the +same AI-assisted session, not human review or proof-kernel certification. diff --git a/research/affine-period-outward-slack/review/SOURCE-BINDING.json b/research/affine-period-outward-slack/review/SOURCE-BINDING.json new file mode 100644 index 0000000000..589ffb2f7f --- /dev/null +++ b/research/affine-period-outward-slack/review/SOURCE-BINDING.json @@ -0,0 +1,77 @@ +{ + "status": "PASS_REMOTE_SOURCE_PINS", + "files": [ + { + "source_repository": "aliromman/integer-mult-bounds", + "source_commit": "a4173e810c4d34a1d13b9745af123ad0ec6cfed5", + "source_path": "research/conservative-gaussian-rounding/kernel.py", + "git_blob": "b00bbbc7655121232a46101962c48e71cee98a39", + "sha256": "fc3e2bf828fa547bee5710f9d5502b7c8c4dcb4cab7536ff73e3dbff54960f1b", + "bytes": 2464, + "matches": true + }, + { + "source_repository": "aliromman/integer-mult-bounds", + "source_commit": "a4173e810c4d34a1d13b9745af123ad0ec6cfed5", + "source_path": "research/conservative-gaussian-rounding/PROOF.md", + "git_blob": "b7047476aaa5e2bb149c92a8a40a9b2ab444ef73", + "sha256": "122eff335674d8de1bcba47d28feb0c420be62b2b6d4e84f91c4292383753380", + "bytes": 11768, + "matches": true + }, + { + "source_repository": "aliromman/integer-mult-bounds", + "source_commit": "a4173e810c4d34a1d13b9745af123ad0ec6cfed5", + "source_path": "research/conservative-gaussian-rounding/NOTICE", + "git_blob": "e5377e3e34c883d3bd8a829e1cb247f3aba28cc8", + "sha256": "ba3157cea93750cc40a060e06af11da25f8d1b0e51eeea56636c94ce2c8abe8e", + "bytes": 1346, + "matches": true + }, + { + "source_repository": "aliromman/integer-mult-bounds", + "source_commit": "78a41d06645b2e53ec3708d5580920e7dd002776", + "source_path": "research/fused-gaussian-rounding/PROOF.md", + "git_blob": "58dc3d172883b3c688970c7f00f1ede85aec4a79", + "sha256": "8c1e873bc1aefcbf0a78ff1f22bd91bece06e126f82abc833a14cd456fde110b", + "bytes": 6745, + "matches": true + }, + { + "source_repository": "aliromman/integer-mult-bounds", + "source_commit": "83fee59d692b0764d716e8356a7d991e4d503868", + "source_path": "research/three-axis-coset-rounding/PROOF.md", + "git_blob": "0d97e005ee7afe989ad96dc040aea3b3f59e3011", + "sha256": "9d29cc4b7a640787bffe1e5475f0f5da0714928aa1739511020bb0946fb03ffa", + "bytes": 9097, + "matches": true + }, + { + "source_repository": "CrocSwap/integer-mult-bounds", + "source_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "source_path": "research/unbiased-periodic-rotation/PROOF.md", + "git_blob": "d8d4038ccef682e3c52984076fcfb1d2783487aa", + "sha256": "fff6996afd0875a0d3a47c2cb4641a88aba38e7de8d44f23265bf39d9a918b18", + "bytes": 6926, + "matches": true + }, + { + "source_repository": "CubeJerry/integer-mult-bounds", + "source_commit": "362b20bc934500bc503e850059f0d34daa5dcae3", + "source_path": "research/four-axis-phase-covariant-grid/PROOF.md", + "git_blob": "bd5fb90ec3f064388eda1c1bd8834c26b4464bab", + "sha256": "dc07dcdf9793b401053738ea7e88c69495967f48f234e8411b8aaaa9858e8632", + "bytes": 15396, + "matches": true + }, + { + "source_repository": "petalas/integer-mult-bounds", + "source_commit": "eaa967e7e8aa12cc53ec246a5fc00c5f8873a50b", + "source_path": "research/rational-norm-rounding/PROOF.md", + "git_blob": "ffb873b2749b1590df9267e802aea5af2c2a6eb5", + "sha256": "231b1b322b6be2a798d1807f5c0346ac4002323384b45cd4eff2a0ef7210bc00", + "bytes": 5884, + "matches": true + } + ] +} diff --git a/research/affine-period-outward-slack/review/check_norm_slack_root.py b/research/affine-period-outward-slack/review/check_norm_slack_root.py new file mode 100644 index 0000000000..87a927c0a2 --- /dev/null +++ b/research/affine-period-outward-slack/review/check_norm_slack_root.py @@ -0,0 +1,146 @@ +"""Independent exact-rational checks; finite evidence, not the universal proof.""" +from fractions import Fraction as Q +from pathlib import Path +import hashlib +import json +import sys + + +def need(ok, why): + if not ok: + raise ValueError(why) + + +def dot(x, y): + return sum(a * b for a, b in zip(x, y)) + + +def matvec(a, x): + return tuple(dot(r, x) for r in a) + + +def norm2(x): + return dot(x, x) + + +def plus(x, y): + return tuple(a + b for a, b in zip(x, y)) + + +def minus(x, y): + return tuple(a - b for a, b in zip(x, y)) + + +def times(t, x): + return tuple(t * a for a in x) + + +def nearest_up(x): + z = x + Q(1, 2) + return z.numerator // z.denominator + + +def gap_gt(a, b, c, s): + """Exactly certify sqrt(a)-sqrt(b) > c sqrt(s), for c,s positive.""" + h = a - b - c * c * s + return h > 0 and h * h > 4 * c * c * s * b + + +def gap_le(a, b, c, s): + h = a - b - c * c * s + return h <= 0 or h * h <= 4 * c * c * s * b + + +def main(): + u = ((Q(3, 5), Q(-4, 5)), (Q(4, 5), Q(3, 5))) + ut = tuple(zip(*u)) + need(all(dot(ut[i], ut[j]) == int(i == j) for i in range(2) for j in range(2)), + 'rational rotation is orthogonal') + + def f(x): + return tuple(nearest_up(z) for z in matvec(u, x)) + + errors = [] + rays = 0 + for a in range(5): + for b in range(5): + x = (Q(a), Q(b)) + e = minus(f(x), matvec(u, x)) + s = norm2(e) + errors.append(s) + for lam in ((5, 0), (0, 5), (-5, -10)): + need(f(plus(x, lam)) == plus(f(x), matvec(u, lam)), 'period law') + if not s: + continue + lam = times(125, matvec(ut, e)) + need(all(v.denominator == 1 and v % 5 == 0 for v in lam), 'ray in period') + need(matvec(u, lam) == times(125, e), 'exact positive error ray') + for t in (1, 2, 16, 256): + xt = plus(x, times(t, lam)) + ft = f(xt) + need(minus(ft, matvec(u, xt)) == e, 'error constant on ray') + aa, bb = norm2(ft), norm2(xt) + need(gap_le(aa, bb, Q(1), s), 'triangle upper bound') + c = 1 - Q(1, (t + 2) ** 2) + need(gap_gt(aa, bb, c, s), 'rational lower approach certificate') + rays += 1 + need(set(errors) == {Q(0), Q(1, 5)}, 'complete quotient error census') + + source = Path(sys.argv[1]).resolve() + raw = source.read_bytes() + blob = hashlib.sha1(b'blob ' + str(len(raw)).encode() + b'\0' + raw).hexdigest() + need(blob == 'b00bbbc7655121232a46101962c48e71cee98a39', 'unchanged #6509 kernel') + namespace = {'__name__': 'pinned_source_kernel'} + exec(compile(raw, str(source), 'exec'), namespace) + pair = namespace['pair'] + source_cases = 0 + for t in (0, 1, 2, 3, 8, 64, 1024, 1 << 32, 1 << 64, 1 << 256): + for sign in (-1, 1): + x, y = (1 - t, -sign * t), (t, sign * t) + expected = ((1 + t, -sign * t), (-t, sign * t)) + width = t.bit_length() + 5 + out = pair(x, y, width, sign) + need(out == expected, 'actual pinned source on exact ray') + need(pair(*out, width, -sign) == (x, y), 'actual opposite-sign inverse') + aa, bb = sum(norm2(z) for z in out), norm2(x) + norm2(y) + need((aa, bb) == (4*t*t + 2*t + 1, 4*t*t - 2*t + 1), 'ray norm polynomials') + if t: + c = Q(32*t*t - 2, 32*t*t + 1) + need(gap_gt(aa, bb, c, Q(1)), 'strict quantitative pair lower bound') + need(gap_le(aa, bb, Q(1), Q(1)), 'source pair upper bound') + need(not gap_gt(aa, bb, Q(1), Q(1)), 'source does not exceed its error') + source_cases += 1 + balls = [] + for p in (1, 2, 3, 7, 31, 128, 257): + h, t = Q(1, 1 << p), 1 << (p - 1) + before = h*h*(4*t*t - 2*t + 1) + after = h*h*(4*t*t + 2*t + 1) + need(before == 1-h+h*h and after == 1+h+h*h, 'dyadic polynomial identity') + need(before < 1 < after, 'closed pair Euclidean ball counterexample') + balls.append(p) + + # Premise controls are explicit counterexamples, not a heuristic search. + need(f((1, 0)) != plus(f((0, 0)), matvec(u, (1, 0))), 'wrong period rejected') + need(norm2((2, 0)) - norm2((1, 0)) > 0, '2I cannot replace orthogonality') + inward = lambda x: (x[0], x[1] - ((x[1] > 0) - (x[1] < 0))) + need(inward((7, 2)) == plus(inward((2, 2)), (5, 0)), 'rank-one period control') + need(norm2(minus(inward((0, 1)), (0, 1))) == 1, 'rank-one error is nonzero') + need(all(norm2(inward((a, b))) <= a*a+b*b for a in range(-3,4) for b in range(-3,4)), + 'rank-one example is inward on finite corroborating box') + # For U:x->(x,0), F(x)=(x, x mod 2), the exact supremum is sqrt(2)-1 < 1. + need(gap_le(Q(2), Q(1), Q(1), Q(1)), 'rectangular isometry counterexample') + need(norm2(minus((1,1),(1,0))) == 1, 'rectangular error magnitude') + print(json.dumps({ + 'status': 'PASS_ROOT_AFFINE_PERIOD_SLACK_REVIEW', + 'rotation': '[[3,-4],[4,3]]/5', 'quotient_representatives': 25, + 'rotation_max_error_squared': str(max(errors)), 'exact_ray_checks': rays, + 'source_blob': blob, 'source_sha256': hashlib.sha256(raw).hexdigest(), + 'unchanged_source_ray_and_inverse_cases': source_cases, + 'source_t_exponents_through': 256, 'dyadic_unit_ball_p': balls, + 'premise_controls': ['wrong period', 'nonorthogonal map', 'rank-deficient period', 'rectangular isometry'], + 'scope': 'Exact finite independent corroboration; universal equality and source-family optimum require written proofs. No full #6758 table replay.', + }, indent=2)) + + +if __name__ == '__main__': + main() From 76811d7c2621c2a186776a1a31cbe223a52b76bc Mon Sep 17 00:00:00 2001 From: Jerry Jiaheng Chen <80299683+CubeJerry@users.noreply.github.com> Date: Fri, 13 Nov 2026 23:37:38 +1100 Subject: [PATCH 2/2] Clarify standalone archive replay and remove accidental malformed hook registration --- research/affine-period-outward-slack/CHECKSUMS.sha256 | 6 +++--- .../affine-period-outward-slack/PUBLICATION-MANIFEST.json | 4 ++-- research/affine-period-outward-slack/README.md | 4 +++- .../{VERIFY.json => REPRODUCTION.json} | 0 4 files changed, 8 insertions(+), 6 deletions(-) rename research/affine-period-outward-slack/{VERIFY.json => REPRODUCTION.json} (100%) diff --git a/research/affine-period-outward-slack/CHECKSUMS.sha256 b/research/affine-period-outward-slack/CHECKSUMS.sha256 index 9f4ecfa250..40ca160ee6 100644 --- a/research/affine-period-outward-slack/CHECKSUMS.sha256 +++ b/research/affine-period-outward-slack/CHECKSUMS.sha256 @@ -2,12 +2,12 @@ cf2799f914127a3c6b74db62afeaa2482cf7b5ac159aac186d0d17ee6104a1f6 NOTICE.md c069671740452e1276ae4d0bb33967e74fc52f043268ca0f97d6d1c6349e8766 PR-DRAFT.md e96399c06b577e2e9308aef387c15944b88012b6e6835a87bd75e12a05f034e5 PR-TITLE.txt 7eae173d7223d473d574c87bbdae6fad4fb857559a8cc717304bdbdebaa1eb7d PROOF.md -0c07b799a1b9d0a31ae6b2fc06c8e1e8f10017f86acbfafb745e0ff54eac6689 PUBLICATION-MANIFEST.json -89d934319e688e7c9ffd686d00deb14b48d687152227dea383b1ba74b2c9689c README.md +2f3f3fcfd5e23165b4b8b7dc585f7c96903fe7eebc115033e394179626fa9469 PUBLICATION-MANIFEST.json +d411866b2e6f3feb28043d695a7aee96b30a6201ad675419f044cfb4943a0bfc README.md 0fc96cc4f7f04a5de9c224ab1e516c3d3d9b70700b41da7fb646e7a629102bf9 RESULT.json ba3157cea93750cc40a060e06af11da25f8d1b0e51eeea56636c94ce2c8abe8e SOURCE-NOTICE.md 5316820f28df712e374365bb7aacf60e4a8de7a018911e68ba4fe915d952859b SOURCES.json -c392c163eb22f23dc7085b8bc1e81343031cafa1329b610a77133282a0fd97b7 VERIFY.json +c392c163eb22f23dc7085b8bc1e81343031cafa1329b610a77133282a0fd97b7 REPRODUCTION.json fc3e2bf828fa547bee5710f9d5502b7c8c4dcb4cab7536ff73e3dbff54960f1b kernel.py 419a231716a7f8679deb9faba7f44a3233912bc7296a1521d4fb9b546dca38f7 reproduce.py fb7725008661c5a3f788f9ca6428db77fa8fad620477d135250400fd3cae452b review/AUTHOR-OPTIMIZED-REPLAY.json diff --git a/research/affine-period-outward-slack/PUBLICATION-MANIFEST.json b/research/affine-period-outward-slack/PUBLICATION-MANIFEST.json index 6e502407ef..189add372c 100644 --- a/research/affine-period-outward-slack/PUBLICATION-MANIFEST.json +++ b/research/affine-period-outward-slack/PUBLICATION-MANIFEST.json @@ -6,11 +6,11 @@ "PR-DRAFT.md": "c069671740452e1276ae4d0bb33967e74fc52f043268ca0f97d6d1c6349e8766", "PR-TITLE.txt": "e96399c06b577e2e9308aef387c15944b88012b6e6835a87bd75e12a05f034e5", "PROOF.md": "7eae173d7223d473d574c87bbdae6fad4fb857559a8cc717304bdbdebaa1eb7d", - "README.md": "89d934319e688e7c9ffd686d00deb14b48d687152227dea383b1ba74b2c9689c", + "README.md": "d411866b2e6f3feb28043d695a7aee96b30a6201ad675419f044cfb4943a0bfc", "RESULT.json": "0fc96cc4f7f04a5de9c224ab1e516c3d3d9b70700b41da7fb646e7a629102bf9", "SOURCE-NOTICE.md": "ba3157cea93750cc40a060e06af11da25f8d1b0e51eeea56636c94ce2c8abe8e", "SOURCES.json": "5316820f28df712e374365bb7aacf60e4a8de7a018911e68ba4fe915d952859b", - "VERIFY.json": "c392c163eb22f23dc7085b8bc1e81343031cafa1329b610a77133282a0fd97b7", + "REPRODUCTION.json": "c392c163eb22f23dc7085b8bc1e81343031cafa1329b610a77133282a0fd97b7", "kernel.py": "fc3e2bf828fa547bee5710f9d5502b7c8c4dcb4cab7536ff73e3dbff54960f1b", "reproduce.py": "419a231716a7f8679deb9faba7f44a3233912bc7296a1521d4fb9b546dca38f7", "review/AUTHOR-OPTIMIZED-REPLAY.json": "fb7725008661c5a3f788f9ca6428db77fa8fad620477d135250400fd3cae452b", diff --git a/research/affine-period-outward-slack/README.md b/research/affine-period-outward-slack/README.md index 626b48b10d..3034a355ef 100644 --- a/research/affine-period-outward-slack/README.md +++ b/research/affine-period-outward-slack/README.md @@ -14,6 +14,8 @@ proof uses integral ray shifts inside fixed-sum fibers. ## Files and reproduction +This archive uses [REPRODUCTION.json](REPRODUCTION.json) as a standalone replay guide, not a registered `research//VERIFY.json` manifest. The default direct replay is read-only; `--write-result` explicitly refreshes the receipt. The generic research-package hook does not validate or run this archive manifest. + - [PROOF.md](PROOF.md) gives the period theorem, the complete legal-center family proof, the ray inequalities, and the source-bound corollaries. - [SOURCES.json](SOURCES.json) pins the canonical base, retained kernel, and @@ -21,7 +23,7 @@ proof uses integral ray shifts inside fixed-sum fibers. - [kernel.py](kernel.py) is a byte-identical copy of #6509's tiny kernel. - [SOURCE-NOTICE.md](SOURCE-NOTICE.md) preserves its upstream notice; [NOTICE.md](NOTICE.md) records this package's added work and credit. -- [VERIFY.json](VERIFY.json) records the exact replay command. +- [REPRODUCTION.json](REPRODUCTION.json) records the standalone replay command. Run from this directory with Python 3.10+ and the standard library: diff --git a/research/affine-period-outward-slack/VERIFY.json b/research/affine-period-outward-slack/REPRODUCTION.json similarity index 100% rename from research/affine-period-outward-slack/VERIFY.json rename to research/affine-period-outward-slack/REPRODUCTION.json