diff --git a/research/global-bilateral-half-gaussian-rounding/KERNEL-ORIGIN.json b/research/global-bilateral-half-gaussian-rounding/KERNEL-ORIGIN.json new file mode 100644 index 0000000000..6a07200e9c --- /dev/null +++ b/research/global-bilateral-half-gaussian-rounding/KERNEL-ORIGIN.json @@ -0,0 +1,8 @@ +{ + "source": "review/independent/mechanism_check.py", + "source_sha256": "fba858f2b464ad94ca1b4907647858be657e056fe1be12bdbb80fb2e023de716", + "copied_prefix_bytes": 4302, + "copied_prefix_sha256": "ea7cfd322ebf2c56b1aa0e4d2460c0266a63fea5d900b1eef240ad2e7418d747", + "changes": "No arithmetic edits to source functions through full_inverse; added input validation and exact signed-permutation wrappers. Root independent implementation remains separate.", + "scope": "Integer arithmetic reference implementation, not a literal selected tape graph" +} diff --git a/research/global-bilateral-half-gaussian-rounding/PR-DESCRIPTION.md b/research/global-bilateral-half-gaussian-rounding/PR-DESCRIPTION.md new file mode 100644 index 0000000000..a638501d89 --- /dev/null +++ b/research/global-bilateral-half-gaussian-rounding/PR-DESCRIPTION.md @@ -0,0 +1,46 @@ +## Result and why it matters + +This establishes an explicit **global** integer bijection for `H4/2`, and by signed permutations for the ideal Gaussian pair `C+`, with error at most one and optimal **bilateral** radial slack `1/2`. Every input has strict radial change below `1/2`, while explicit forward and inverse sequences approach that value. The all-input lower bound applies to every total error-one integer map, without injectivity or a periodicity premise. + +This is progress on the norm-rounding obligation behind an alternative precision/native interface. It is not a finite-search extrapolation, a completed selected supplier, or an unconditional multiplication theorem. + +## What changed + +- An explicit staggered matching of the half-integer grid, complete coset bijections, exact inverse and universal norm proof. +- A 16-corner unrestricted lower-bound sequence establishing optimal bilateral slack. +- A reusable exact integer kernel for the Hadamard and Gaussian forward/inverse maps. +- Separately written proof and implementation checks, a root implementation comparison, exact negative controls and a registered bounded replay manifest. +- Explicit counterexamples showing that this construction does not inherit conserved complex sum, global `i` covariance, inverse-by-conjugation or fourth-power identity. + +The actual Gaussian inverse is `S F_H^-1 L`. It must not be replaced by conjugating the positive rounded operation. + +## Novelty relative to prior work + +Ali Romman's #6509 provides the earlier reversible conservative Gaussian rounding and stronger-invariant contract. Nick Petalas's #6619, building on ywz65's #2589, proves the zero-slack obstruction and asks for the least outward allowance. The earlier affine-period/conserved-center result restricts its lower bound to its stated family; this construction uses a different global matching. + +The separate finite Hall package proves necessary forward lower bounds, most strongly `sqrt(78)-sqrt(73)`. This package supplies a constructive forward upper bound `1/2` and solves the **bilateral** problem. It does not prove a universal forward-only lower bound `1/2`. The exact predecessor heads, paths and hashes are retained in the package. + +## Base and reproduction + +Canonical base: `e54523517d0f03e58352e647c403a5af3e525a57`. All runtime code and evidence are in `research/global-bilateral-half-gaussian-rounding/`; Python 3.12 standard library, no solver or network dependency. + +```sh +python3 -B scripts/research_package.py --package research/global-bilateral-half-gaussian-rounding --check-only +python3 -B scripts/research_package.py --package research/global-bilateral-half-gaussian-rounding +``` + +Standalone commands are listed in the README. The public verifier reports `PASS_GLOBAL_HALF_KERNEL`; the proof-role verifier reports `PASS_STAGGERED_BIJECTION_PROOF_IDENTITIES`. Exact independent checks cover half-grid involutions, complete finite balls, all sixteen lower corners, both inverse compositions, large integers, attaining sequences and deliberate failed designs. Normal and optimized executions are recorded. These checks corroborate the universal written proof; finite coverage is not offered as a substitute for it. + +## Limitations and open obligations + +The exact forward-only optimum remains between the finite Hall lower bound and `1/2`. No selected caller, tensor-stage commutation, dirty-port wrapper, fixed-width overflow bound, fixed-tape tariff, recursive precision budget or all-size compiler transfer is admitted. The arithmetic kernel has unbounded integer inputs; a machine-model implementation must pay its complete costs. The stronger native identities fail for this construction and require separate work. + +## Kappa status + +**No new kappa.** The pinned selected `kappa = 363005817/100000000000` and all five framework assumptions remain unchanged. The full multiplication bound remains conditional. + +## Credit and assistance + +Prepared for **@CubeJerry** with substantial OpenAI ChatGPT/Codex assistance. The root supplied the construction, a separate proof role developed and challenged the all-input proof, a separate implementation role tested the mechanism, and the root checked an independently written implementation and the actual Gaussian interfaces. Shared proposed formulas are disclosed; no blind, human or formal-kernel review is claimed. + +Credit Ali Romman (#6509), Nick Petalas (#6619), ywz65 (#2589), and the earlier finite Hall and affine-period packages. The preserved notices and exact source pins identify predecessor contributions. Apache-2.0. diff --git a/research/global-bilateral-half-gaussian-rounding/PUBLICATION-CHECKS.json b/research/global-bilateral-half-gaussian-rounding/PUBLICATION-CHECKS.json new file mode 100644 index 0000000000..cc7a4c9b5d --- /dev/null +++ b/research/global-bilateral-half-gaussian-rounding/PUBLICATION-CHECKS.json @@ -0,0 +1,66 @@ +{ + "base": "e54523517d0f03e58352e647c403a5af3e525a57", + "runtime": "Python 3.12.14", + "registered_replay": [ + { + "label": "metadata", + "exit": 0, + "seconds": 0.405, + "stdout_sha256": "5873404cb4424dca918a00d503569f3c29a3190fd029a007e1afb2006399f647", + "stdout_bytes": 69, + "stderr": "" + }, + { + "label": "registered", + "exit": 0, + "seconds": 4.339, + "stdout_sha256": "de4f878a60b0eca52e23329720ba600d615f52cc9305b91b8f19c53bededc6d0", + "stdout_bytes": 18035, + "stderr": "" + } + ], + "checks": [ + { + "check": "frozen checksums proof", + "exit": 0 + }, + { + "check": "frozen checksums review/independent", + "exit": 0 + }, + { + "check": "verify.py", + "optimized": true, + "exit": 0, + "matches_retained_result": true, + "seconds": 0.694, + "stdout_sha256": "c81a97941aec4ef10f0ced9d2ab227e493a01fe2bdc6dfaef2546cd27ed47f9f" + }, + { + "check": "proof/check_identities.py", + "optimized": true, + "exit": 0, + "matches_retained_result": true, + "seconds": 0.183, + "stdout_sha256": "71d84b58c80a8c1ccad17d0b1ba56ced0a54ce403993878bd79e486437143659" + }, + { + "check": "review/independent/mechanism_check.py", + "optimized": true, + "exit": 0, + "matches_retained_result": true, + "seconds": 2.026, + "stdout_sha256": "70798b1ff53df317b2dce6c00c4cf86b78f1c716542477354a04b3c745452fc5" + }, + { + "check": "review/root/check_global_candidate.py", + "optimized": true, + "exit": 0, + "matches_retained_result": true, + "seconds": 1.111, + "stdout_sha256": "32cfe148be7b22ccbd065702d940428ccbac5ed87eaf388dca842960bc876101" + } + ], + "package_unchanged_during_replay": true, + "note": "Registered four normal commands and separate optimized commands passed. Proof-role command checks its retained JSON internally and prints a marker. Added receipt/manifest do not change scientific bytes. Final tree is checked to contain additions only." +} diff --git a/research/global-bilateral-half-gaussian-rounding/PUBLICATION-MANIFEST.json b/research/global-bilateral-half-gaussian-rounding/PUBLICATION-MANIFEST.json new file mode 100644 index 0000000000..39aa0362a7 --- /dev/null +++ b/research/global-bilateral-half-gaussian-rounding/PUBLICATION-MANIFEST.json @@ -0,0 +1,221 @@ +{ + "files": [ + { + "path": "KERNEL-ORIGIN.json", + "bytes": 551, + "sha256": "10d46bad67b13eac743b7d13c31792e0cfe4942dee4cf48cfd01bea941b8b0e3", + "git_blob": "6a07200e9c57c6889b0c9a586f389920a62e7743" + }, + { + "path": "PR-DESCRIPTION.md", + "bytes": 4562, + "sha256": "fd0671ea9f19fe8a705fb1090368d6f82f446f4ec06a75dc0862272cc234507f", + "git_blob": "a638501d8962bcdd2c176e017a4764caa8dfd11c" + }, + { + "path": "PUBLICATION-CHECKS.json", + "bytes": 2051, + "sha256": "dce62af2155445d2dba4928ae721c8c2582cd56a232a41892199a762ff340d66", + "git_blob": "cc7a4c9b5deea6adcf2a085648e2e724a44519f1" + }, + { + "path": "README.md", + "bytes": 7484, + "sha256": "724180d8095f118eeffc0807a167cb75e860b4ae6d5453e93ce975d293394da0", + "git_blob": "bd375556ecf3eacb4aeef58e144ad9e1f22c8728" + }, + { + "path": "RESULT.json", + "bytes": 1825, + "sha256": "c81a97941aec4ef10f0ced9d2ab227e493a01fe2bdc6dfaef2546cd27ed47f9f", + "git_blob": "a9897a8adef613d547354063e443d7b5e228df0a" + }, + { + "path": "ROOT-REVIEW.md", + "bytes": 4737, + "sha256": "a472211d97fb3dd5dada8b1e5fcd9488355c0aa9e26416713e7047b113626d0b", + "git_blob": "058834aeb3cceb14ed5527643ffc205fa7b99ea1" + }, + { + "path": "SOURCES.json", + "bytes": 1208, + "sha256": "b7e4569b92d77e3c729dafcfe79745923c6caad0c7178bd34e8285f53e9461d1", + "git_blob": "84507252934c70e9722af5ca32b6e9bc93d36be5" + }, + { + "path": "TASK.json", + "bytes": 6821, + "sha256": "fca8b8cef68e56f78996acbb345b6068873aaa73ee31b152d1f4c1c8415207eb", + "git_blob": "e89b75435eecc069a285864fc677f3c8a260cf2b" + }, + { + "path": "VERIFY.json", + "bytes": 1526, + "sha256": "67dd5d790b5f24f22d2993bb1121ede2569c770cf7af05e4d8040cf539b407db", + "git_blob": "e78142a08d74781ef3c1308277d7fa4a4a9dc861" + }, + { + "path": "kernel.py", + "bytes": 5411, + "sha256": "dfcb9c7ff816e3f73b597a76caeed7ed519d9c677c5a64a581468f3a05903521", + "git_blob": "eab50ec34f148cbc4d6e8dbfac9b029faa87f145" + }, + { + "path": "proof/CHECKPOINT.json", + "bytes": 1692, + "sha256": "0553ee9c34afc74dac56913f8357ac3be2b8ea7035a9dfc611e747565f7d2ebe", + "git_blob": "3db528fc141d6e43513f91f30e09ec9f24c2a1a9" + }, + { + "path": "proof/CHECKSUMS.sha256", + "bytes": 992, + "sha256": "dd71509a3c8bc6f7ed687d2dc98074b33f189c2cee0c2a9b628697898edf8103", + "git_blob": "aa7a406ba739ba41aad4ec1155082804b3a8d5d1" + }, + { + "path": "proof/CLAIM.json", + "bytes": 1322, + "sha256": "7fbe3db67f6dea22980f23f5ebc155c77c07e306aa2a623955f175575b91133e", + "git_blob": "87e53bbb2fe1bb6c60121502fe07ea035f4ffb40" + }, + { + "path": "proof/NOTICE.md", + "bytes": 1346, + "sha256": "d61b8166f8c18175638b7519dd8b48a418bdac9875a75540be6dbcbc97a9d186", + "git_blob": "f81ea7ef303156cc32da9a8708a10b9d5a1730dc" + }, + { + "path": "proof/OVERLAP.json", + "bytes": 18902, + "sha256": "48d78b77566a0b725159f242583a6acfdee918ca04877e28be718c983f8b19f1", + "git_blob": "ee994b0a8aaa3eddf432823b8979d96849d8f1da" + }, + { + "path": "proof/PR-DRAFT.md", + "bytes": 1507, + "sha256": "19e224d184e914e6d4e6e8bfe2163733db2d3b6173cd67244a00ac921f7e96d9", + "git_blob": "67b7778da10a12ac096f0b7b28d17eadf61a4ae7" + }, + { + "path": "proof/PROOF.md", + "bytes": 8652, + "sha256": "1b7bf1e00a3b9dc44ff603222423c94bba15cc9450df6483601f328993cfdf42", + "git_blob": "469fe11c43281e369d4aea172fe7780ca7115983" + }, + { + "path": "proof/README.md", + "bytes": 2231, + "sha256": "bf874d7dee57f1ef99e1ed80bd4537a795a250bce338963670e00f2684960285", + "git_blob": "d2b83bd0fce477926f03272a282480b79dd8445b" + }, + { + "path": "proof/RESULT.json", + "bytes": 2705, + "sha256": "2698bf88eb75c332b8e08ba074c1748f0ab73041d89deafda41f2aa0c35f672b", + "git_blob": "8032dcdce70b73fa02f634dcf1cab7effd249b10" + }, + { + "path": "proof/SOURCES.json", + "bytes": 4525, + "sha256": "f11913d498093940383dba0d876bca48ccd10fe7e6725197ee9fc7759c145dd0", + "git_blob": "01c9d601d9b467f066a7180d9ace92a99abbab80" + }, + { + "path": "proof/check_identities.py", + "bytes": 4212, + "sha256": "556e9ca46b8956afac0ea99dff7d6daf2bd387f11740633785b58bed3b7346d1", + "git_blob": "851b081aea0e2ad5e8087f860bd606c763101080" + }, + { + "path": "proof/references/ROOT-NONINHERITANCE.json", + "bytes": 492, + "sha256": "2c747c7b88f540d2ea3bbbee91ecbc4387cda3bef57153ad8ded6e03f98e719d", + "git_blob": "d95954c04f4c51ac438d6d37b89b9b70d5c4ff7b" + }, + { + "path": "proof/references/ROOT-REPORTED-INVERSE.json", + "bytes": 258, + "sha256": "95a73e92baec11de19aecc4207c2404e048d8e037308c396010a57ab3f581b02", + "git_blob": "da2255bf3de2748f094c167c7d2a9377ea6e12af" + }, + { + "path": "review/independent/CHECKSUMS.sha256", + "bytes": 487, + "sha256": "8ad22dcc153dd089c398be3067269258cab7bf094dda09e45b08f233e64eedd3", + "git_blob": "c0e6caf488ca8704bf98d52c307f5d521136f75e" + }, + { + "path": "review/independent/PROOF-CHALLENGE.md", + "bytes": 5844, + "sha256": "fdaecf910f1172e304d53bd5a74bfa4b512841c0800cc240f76a7fbede0d2829", + "git_blob": "509d0acf0fd8c0ca73231ef63becb7018b7f6cad" + }, + { + "path": "review/independent/README.md", + "bytes": 1552, + "sha256": "0c432aedd1387cff37971db3d95365f332f68e11f716b3a0ee67b3a147268df9", + "git_blob": "1801cd2440aa3a3a5481b27a71d1678729e78a7e" + }, + { + "path": "review/independent/RESULT.json", + "bytes": 14753, + "sha256": "70798b1ff53df317b2dce6c00c4cf86b78f1c716542477354a04b3c745452fc5", + "git_blob": "311ef0045c69189f63b7bb6ed48deccd599b034e" + }, + { + "path": "review/independent/REVIEW-RECEIPT.md", + "bytes": 694, + "sha256": "b5ea4a0a6206f83374f38a1ef2934a7940542d51a2021f36d8fdbb6f64e3a1da", + "git_blob": "a180750f29676f19f4accae9f75cceae2c5ea351" + }, + { + "path": "review/independent/SOURCES.json", + "bytes": 1111, + "sha256": "bbca8bc8d0dccfaeee1d748b24210b70e66cd76bcb2ebd2080c9ed2035a60010", + "git_blob": "be03b17a6f3e7e360443f5732953c2cb552fc623" + }, + { + "path": "review/independent/mechanism_check.py", + "bytes": 11642, + "sha256": "fba858f2b464ad94ca1b4907647858be657e056fe1be12bdbb80fb2e023de716", + "git_blob": "87b01262d6f03b5bf520ed850a66cbfd1e990569" + }, + { + "path": "review/root/GAUSSIAN-INTERFACE-RESULT.json", + "bytes": 1106, + "sha256": "ffc6097ed9d0a7adde3695441c95d57f41e619a24ae7815c28cf7fc0d8e99c84", + "git_blob": "123ef80318d79c213f4ebeea09f17e991a76a7d7" + }, + { + "path": "review/root/OVERLAP-METADATA.json", + "bytes": 23150, + "sha256": "9be890a22b61efff4996d2285b4fb13aacfc5c55ae40d22de255e1ae697210e6", + "git_blob": "48204c0fe4df63fead97d00ac99802687848e9ae" + }, + { + "path": "review/root/RESULT.json", + "bytes": 687, + "sha256": "32cfe148be7b22ccbd065702d940428ccbac5ed87eaf388dca842960bc876101", + "git_blob": "b3cc9c81d612947bff851cf1cc427297c81ec66a" + }, + { + "path": "review/root/check_gaussian_interfaces.py", + "bytes": 2271, + "sha256": "285ff90d09dfcdcfd412bb627771b11f8ad159980ed61d739a88cd9ca195b250", + "git_blob": "eba26791c84db2bfa1e3215d1b048f7ecd93ea5a" + }, + { + "path": "review/root/check_global_candidate.py", + "bytes": 3977, + "sha256": "3f1349d2e88e90aea9e133bd91421e91ccbab9bcb078253ab0faed8a9581982b", + "git_blob": "911e5c5a02d7ec07d492d0be84292f98fb66a9e0" + }, + { + "path": "verify.py", + "bytes": 3589, + "sha256": "4f04675e9a93d6bdca27bb75199a5604a0cf2d6ed053038d069c19d9dec1589f", + "git_blob": "4d580ec45b0d4e3b9522e30cb550dd8c7f7a7cd0" + } + ], + "scope": "All package files except this manifest; scientific source and result bytes were replayed before publication." +} diff --git a/research/global-bilateral-half-gaussian-rounding/README.md b/research/global-bilateral-half-gaussian-rounding/README.md new file mode 100644 index 0000000000..bd375556ec --- /dev/null +++ b/research/global-bilateral-half-gaussian-rounding/README.md @@ -0,0 +1,61 @@ +# A global Gaussian lattice bijection with optimal bilateral radial slack 1/2 + +This package proves an all-input rounding theorem. For the normalized four-dimensional Hadamard map `U=H4/2`, an explicit bijection `F:Z^4 -> Z^4` has Euclidean error at most one and + +\[ +\left|\|F(x)\|_2-\|x\|_2\right|<\tfrac12 +\quad\text{for every }x\in\mathbb Z^4. +\] + +The supremum is exactly `1/2`. Every total integer-output map with error at most one has bilateral radial supremum at least `1/2`, without an injectivity, parity, periodicity, conserved-sum or equivariance premise. Therefore the construction attains the optimal **bilateral** constant among bijections. Its forward and inverse outward suprema both equal `1/2`. + +The signed-permutation transfer gives the same result for the ideal Gaussian pair `C+` used in [CrocSwap/integer-mult-bounds#6509](https://github.com/CrocSwap/integer-mult-bounds/pull/6509). The actual negative provider is the explicit inverse. It is **not** obtained by conjugating the positive rounded map. + +## What is new + +The [complete proof](proof/PROOF.md) supplies an explicit global matching, its inverse, a uniform radial inequality, and an unrestricted lower-bound sequence. This answers the bilateral optimization problem and improves the constructive forward outward upper bound to `1/2`. It does not settle the forward-only optimum: the separately certified finite Hall lower bound `sqrt(78)-sqrt(73)` remains below `1/2`. + +The distinction matters. [#6619](https://github.com/CrocSwap/integer-mult-bounds/pull/6619) proves a zero-slack norm obstruction and asks about the least positive outward slack. The [affine-period package](https://github.com/CubeJerry/integer-mult-bounds/tree/26ea0e01b09b12759a17f006c9066d9e5fcd84e0/research/affine-period-outward-slack) proves results for globally affine-periodic maps and the conserved-center family. Its lower bound `1` for that family does not exclude the new matching. The [finite Hall package](https://github.com/CubeJerry/integer-mult-bounds/tree/58a8facd7fbae9212774925349fbb617f114f040/research/sharp-finite-gaussian-outward-slack) supplies finite/global-necessary lower bounds; it does not construct this infinite bijection. + +## Construction and computational contract + +Write `J=diag(1,1,1,-1)`, `E=JU`, `R=UJU`. The even-sum integer coset uses `Ux` exactly. On the odd-sum coset, `R` maps to one color of the half-integer grid. A staggered coordinate pairing `M` toggles the coordinate of least partner-invariant score. This is an involution between the two colors. The odd branch is `E M R`; its inverse is `R M E^T`. + +Two coordinates use magnitude pairs `(1/2,3/2), (5/2,7/2), ...`; the other two use a central pair `(-1/2,1/2)` and pairs `(3/2,5/2), ...`. For a selected noncentral lower magnitude `a`, the lower endpoint radius satisfies `r^2 >= (2a+1)^2+1`. The one-coordinate toggle changes squared radius by `2a+1`, proving the strict half-unit bound. All signs, ties and cosets are covered by the written proof. + +`kernel.py` exports `hadamard_forward`, `hadamard_inverse`, `gaussian_forward` and `gaussian_inverse`. Each takes exactly four Python integers, excluding Booleans. Its arithmetic is extracted byte-for-byte from the independently written checker, with input-validation wrappers; `KERNEL-ORIGIN.json` records the boundary and hashes. It uses a fixed number of integer additions, exact divisions, residue tests, absolute values and comparisons. No search, floating-point square root or finite-ball lookup is used by the kernel. + +This is an unbounded-integer arithmetic contract. It is not a fixed-word implementation or a fixed-tape tariff. On grid spacing `h`, homogeneity transfers error `1` and radial slack `1/2` to error `h` and slack `h/2`. + +## Reproduction and independent checks + +From the repository root, using Python 3.12 and its standard library: + +```sh +python3 -I -B -W error research/global-bilateral-half-gaussian-rounding/verify.py +python3 -I -B -W error research/global-bilateral-half-gaussian-rounding/proof/check_identities.py +python3 -I -B -W error research/global-bilateral-half-gaussian-rounding/review/independent/mechanism_check.py +python3 -I -B -W error research/global-bilateral-half-gaussian-rounding/review/root/check_global_candidate.py +python3 -B scripts/research_package.py --package research/global-bilateral-half-gaussian-rounding --check-only +python3 -B scripts/research_package.py --package research/global-bilateral-half-gaussian-rounding +``` + +The first command prints `PASS_GLOBAL_HALF_KERNEL`. The proof-role checker prints `PASS_STAGGERED_BIJECTION_PROOF_IDENTITIES`. The remaining checks report their exact counts and scopes in JSON. All commands are read-only. `VERIFY.json` is an explicit opt-in to the repository replay hook, with bounded command arrays and no external runtime inputs. Source provenance is pinned at canonical main `e54523517d0f03e58352e647c403a5af3e525a57`. + +The proof role derived the all-size argument separately from the implementation role. The implementation and root checkers use separate arithmetic implementations, but all roles knew the proposed mathematical formulas; this is not a blind or human review. Finite cases corroborate the proof and test failure modes. They do not establish universality by exhaustion. See [ROOT-REVIEW.md](ROOT-REVIEW.md), [the independent proof challenge](review/independent/PROOF-CHALLENGE.md) and their retained results. + +## Limitations and kappa status + +The public verifier records exact failures of complex-sum preservation, global `i` covariance, inverse-by-conjugation and fourth-power identity for this construction. These are limitations of this particular rounder, not impossibility theorems for other rounders. The Gaussian negative operation must use `gaussian_inverse`. + +No tensor-stage commutation, arbitrary native-word admission, dirty-port wrapper, fixed-width overflow envelope, all-column precision propagation, recursive physical tariff or complete multiplication argument is supplied. All five selected framework assumptions remain. **No new kappa**: the pinned selected value remains `363005817/100000000000`, and the full bound remains conditional. + +## Open next questions + +The structured questions in [TASK.json](TASK.json) identify three remaining obligations: close the forward-only gap; meet one actual caller's additional algebraic identities; and implement a complete physical precision/storage budget. Each gives a first step, its relevance and its blocker. The present package completes the stated rounding subproblem, not those interfaces. + +## Credit and assistance + +Prepared for **@CubeJerry**, with substantial OpenAI ChatGPT/Codex assistance. The root supplied the staggered-matching construction; a separate proof role established and challenged the all-size proof and unrestricted lower bound; a separate implementation role checked the mechanism; the root independently checked the implementation and Gaussian interface. Exact role boundaries and source hashes are retained. + +Credit Ali Romman for [#6509](https://github.com/CrocSwap/integer-mult-bounds/pull/6509), Nick Petalas for [#6619](https://github.com/CrocSwap/integer-mult-bounds/pull/6619), and ywz65 for [#2589](https://github.com/CrocSwap/integer-mult-bounds/pull/2589). Credit the earlier finite Hall and affine-period packages for the distinct lower-bound and scope questions. No priority claim is inferred from the bounded overlap search. Apache-2.0; retained notices remain effective. diff --git a/research/global-bilateral-half-gaussian-rounding/RESULT.json b/research/global-bilateral-half-gaussian-rounding/RESULT.json new file mode 100644 index 0000000000..a9897a8ade --- /dev/null +++ b/research/global-bilateral-half-gaussian-rounding/RESULT.json @@ -0,0 +1,88 @@ +{ + "status": "PASS_GLOBAL_HALF_KERNEL", + "cube_cases": 6561, + "large_cases": 60, + "max_bits": 4096, + "seed": 20261113, + "invalid_inputs_rejected": 28, + "interface_check": { + "status": "PASS_ROOT_GAUSSIAN_TRANSFER_AND_NONINHERITANCE", + "input_cases": 2401, + "source_sha256": "3f1349d2e88e90aea9e133bd91421e91ccbab9bcb078253ab0faed8a9581982b", + "controls": { + "complex_sum": { + "x": [ + 0, + 0, + 2, + 1 + ], + "output": [ + 2, + -1, + 1, + 1 + ] + }, + "global_i_phase": { + "x": [ + -2, + -2, + -2, + -1 + ], + "F(ix)": [ + 2, + -1, + 2, + -2 + ], + "iF(x)": [ + 1, + -2, + 2, + -2 + ] + }, + "conjugated_positive_not_inverse": { + "x": [ + -2, + -2, + -2, + -1 + ], + "conjugate": [ + -2, + -2, + -1, + -2 + ], + "inverse": [ + -2, + -1, + -2, + -2 + ] + }, + "fourth_power": { + "x": [ + -2, + -1, + -2, + 2 + ], + "output": [ + -3, + 1, + -1, + 0 + ] + } + }, + "negative_provider": "S F_H_inverse L, not conjugated positive map" + }, + "sharp_sequence_parameters": 8, + "kernel_sha256": "dfcb9c7ff816e3f73b597a76caeed7ed519d9c677c5a64a581468f3a05903521", + "independence": "public arithmetic extracted from C reviewer; compared with separately written root arithmetic and Gaussian transfer; shared proposed formulas disclosed", + "scope": "finite cross-implementation checks; all-input theorem rests on the written proof" +} diff --git a/research/global-bilateral-half-gaussian-rounding/ROOT-REVIEW.md b/research/global-bilateral-half-gaussian-rounding/ROOT-REVIEW.md new file mode 100644 index 0000000000..058834aeb3 --- /dev/null +++ b/research/global-bilateral-half-gaussian-rounding/ROOT-REVIEW.md @@ -0,0 +1,32 @@ +# Root review of the global half-unit rounding theorem + +## Exact scope and proof review + +Base: `e54523517d0f03e58352e647c403a5af3e525a57`. This review concerns a global arithmetic bijection on `Z^4`, not admission to a selected physical caller. + +The root checked the proof's complete coset maps, their surjectivity, the partner-score involution and tie rule, both staggered phases, signs and the central pair. The lower endpoint inequality uses two coordinates in each phase; a one-versus-three split cannot be substituted. The root separately checked the unrestricted 16-corner lower bound and both directional attaining sequences. No unproved infinite Hall matching theorem is needed for the construction: the matching is given explicitly. + +The Gaussian transfer is `F_C=L^-1 F_H S`, with inverse `S F_H^-1 L`. The root rejected the stronger interpretation that complex conjugation of `F_C` is its inverse, and retained a concrete counterexample. The final proof states the actual inverse. Four failed native identities remain visible in the main verifier. + +## Independent evidence and limits + +- Proof role: universal argument plus independent matrix, exact-corner and attaining-family checks, without importing the root or implementation-role arithmetic. Its final proof SHA256 is `1b7bf1e00a3b9dc44ff603222423c94bba15cc9450df6483601f328993cfdf42`. +- Implementation role: 65,536 half-grid inputs, including 27,136 ties and 15,360 central cases; complete odd subsets of balls of squared radii 25, 81 and 121; large-integer round trips and exact radial checks. Its source is `review/independent/mechanism_check.py`. +- Root arithmetic: 38,416 half-grid box cases, 28,561 integer cube inputs with distinct images, 120 seeded cases through 400 decimal digits, and exact directional sequences. Three negative designs are detected: unstaggered pairing, unequal phase counts, and selection by current magnitude rather than invariant score. +- Public kernel: compared to the separately written root arithmetic on 6,561 cube inputs and 60 seeded inputs through 4,096 bits. Both inverses, exact errors, parity and the radial allowance are checked. Twenty-eight malformed public inputs are rejected. Gaussian interface tests cover 2,401 inputs and four exact failed-identity controls. + +The root and implementation roles shared the proposed mathematical formulas, but did not share their arithmetic code when writing their first checks. The public kernel is subsequently extracted from the implementation role, so its comparison to that same role is provenance/regression, not independent implementation evidence. Independence is supplied by the root arithmetic and the separate written proof. No human review or formal-kernel certification is claimed. + +Normal and optimized Python executions have been used to ensure that required checks are not silently lost under `-O`. Final package replay and integrity receipts record the exact publication bytes. The main proof, rather than any finite test count, establishes the universal theorem. + +## Full-system relevance and remaining cost gate + +The kernel needs only a fixed amount of integer arithmetic on one Gaussian pair. A direct tensor application would still require its complete number of scalar fields, bit widths, head movement, copying, inverse/restoration work and error propagation to be charged. The run's separate selected-tariff audit shows that a serial `f V` monomial implementation cannot simply inherit the selected nonleaf sublinear-in-`f` tariff. This package makes no claim to solve that problem. + +The current result is an alternative rounding sub-lemma relevant to `precision_tape` and `native_all_columns`. It neither discharges an entire selected assumption nor improves the assembled multiplication exponent. In particular, the optimal **bilateral** constant does not prove the optimal **forward-only** constant, and lack of the stronger identities is not silently repaired by treating a nonlinear rounder as a tensor-linear map. + +## Novelty and sources + +The bounded overlap search inspected the exact #6509 and #6619 proofs, the earlier norm/finite-ball obstruction family, current PR metadata and terms concerning half-unit, radial, nonperiodic and bijective rounding. It found no identical global construction within that inspected scope. `review/root/OVERLAP-METADATA.json` and `proof/OVERLAP.json` preserve coverage and uncertainty. This is a recorded search boundary, not a proof of priority. + +The separate finite Hall package at commit `58a8facd7fbae9212774925349fbb617f114f040` supplies the optional comparison lower bound `sqrt(78)-sqrt(73)`. The present global construction, its inverse and its bilateral optimum do not execute or depend on that finite certificate. diff --git a/research/global-bilateral-half-gaussian-rounding/SOURCES.json b/research/global-bilateral-half-gaussian-rounding/SOURCES.json new file mode 100644 index 0000000000..8450725293 --- /dev/null +++ b/research/global-bilateral-half-gaussian-rounding/SOURCES.json @@ -0,0 +1,26 @@ +{ + "schema_version": 1, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "files": [ + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81" + }, + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "75d77b328ea02ded535e7f23aee5b1e55d0bb1a8", + "sha256": "154c3d30455d778fd3343b6b4851f0fa4665f0f7625b0adb3675e2bafbbf6bf1" + }, + { + "path": "docs/research/pr-intake-evidence/pr7000-application/PROOF-REVIEW.md", + "usage": "provenance", + "git_blob": "3dd1af2285e597676725e85ad4f65e7ad326d695", + "sha256": "4501502c2ceb9759b20372435fe4beb51082c5a5e2910c1fd5dbe6edca415055" + } + ], + "external_primary_provenance": "Exact upstream PR heads, paths, byte hashes and credits are recorded in proof/SOURCES.json. They are mathematical provenance, not runtime imports or Git-history requirements.", + "local_inputs": "All executable proof-relevant bytes are committed inside this package; no external runtime input or dependency is used." +} diff --git a/research/global-bilateral-half-gaussian-rounding/TASK.json b/research/global-bilateral-half-gaussian-rounding/TASK.json new file mode 100644 index 0000000000..e89b75435e --- /dev/null +++ b/research/global-bilateral-half-gaussian-rounding/TASK.json @@ -0,0 +1,93 @@ +{ + "schema_version": 1, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "task_id": "uniform-transfer-audit", + "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", + "scope_change_reason": "The user directed foundational-assumption research. Bounded source audits led to the open norm-rounding question in #6619 and an alternative universal primitive contract. The catalogue card is recorded as a classification at packaging time; this is not a claim that the full selected caller obligation was completed.", + "actual_scope": "Prove an explicit global error-one integer bijection for H4/2 and the Gaussian pair, with sharp optimal bilateral radial distortion 1/2, exact inverse and explicit non-inherited native identities.", + "bottleneck_link": "Alternative rounding sub-lemma relevant to precision_tape and native_all_columns; caller and physical admission remain open.", + "stop_rule": "Stop at the all-input rounding theorem, independent implementations and explicit interface counterexamples; do not infer a complete supplier, kappa change or assumption discharge.", + "evidence": "proof/PROOF.md; review/independent/PROOF-CHALLENGE.md; ROOT-REVIEW.md; exact checkers and retained results.", + "author": "@CubeJerry", + "ai_assistance": "Substantial OpenAI ChatGPT/Codex assistance; root construction and arithmetic, separate proof role and independent implementation role; shared proposed formulas disclosed.", + "outcome": "completed", + "open_questions": [ + { + "question": "What is the optimal forward-only outward slack for an unrestricted global error-one Gaussian bijection?", + "why_it_matters": "The constructed upper bound is 1/2 while the separately certified finite Hall lower bound is sqrt(78)-sqrt(73); bilateral optimality does not select one direction.", + "first_step": "Change the global matching rule or prove a new Hall obstruction beyond the retained finite balls; keep error at most one and global bijectivity.", + "blocked_by": "No universal forward-only lower bound of 1/2 and no construction below 1/2 are supplied." + }, + { + "question": "Can an explicit rounding pair meet the additional native identities required by a selected caller?", + "why_it_matters": "This map fails complex-sum preservation, global i covariance, inverse-by-conjugation and fourth-power identity, so it cannot be substituted without checking the real interface.", + "first_step": "Pin one actual C+/C- call and list the identities it uses; compare a sum-preserving construction with the true inverse contract.", + "blocked_by": "No tensor commutation or source-native word admission is supplied." + }, + { + "question": "Can the rounding kernel be implemented under a complete physical precision and storage budget?", + "why_it_matters": "An arithmetic bijection alone does not discharge precision_tape or native_all_columns.", + "first_step": "Choose a signed fixed-point width and one literal caller, account for width growth, copying, restoration and all recursive children.", + "blocked_by": "No fixed-tape transition table, selected nonleaf tariff or complete rounding-error recurrence is proved here." + } + ] +} diff --git a/research/global-bilateral-half-gaussian-rounding/VERIFY.json b/research/global-bilateral-half-gaussian-rounding/VERIFY.json new file mode 100644 index 0000000000..e78142a08d --- /dev/null +++ b/research/global-bilateral-half-gaussian-rounding/VERIFY.json @@ -0,0 +1,57 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "-W", + "error", + "{package}/verify.py" + ], + "timeout_seconds": 180, + "checks": "Public kernel versus separately written root oracle; both inverses, exact errors and radial inequalities, sharp families, malformed inputs and four non-inheritance controls." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "-W", + "error", + "{package}/proof/check_identities.py" + ], + "timeout_seconds": 60, + "checks": "Independent proof-role matrix identities, all sixteen lower-bound corners, exact directional families and limit inequalities." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "-W", + "error", + "{package}/review/independent/mechanism_check.py" + ], + "timeout_seconds": 240, + "checks": "Independent implementation, half-grid involution, complete finite balls, inverse formulas, exact norm bounds and large integers." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "-W", + "error", + "{package}/review/root/check_global_candidate.py" + ], + "timeout_seconds": 180, + "checks": "Separate root implementation; box, integer cube, large integers, attaining families and three design rejection controls." + } + ] +} diff --git a/research/global-bilateral-half-gaussian-rounding/kernel.py b/research/global-bilateral-half-gaussian-rounding/kernel.py new file mode 100644 index 0000000000..eab50ec34f --- /dev/null +++ b/research/global-bilateral-half-gaussian-rounding/kernel.py @@ -0,0 +1,167 @@ +# Reference kernel extracted without arithmetic edits from the independent reviewer. +# Complete source: review/independent/mechanism_check.py +# Source SHA256: fba858f2b464ad94ca1b4907647858be657e056fe1be12bdbb80fb2e023de716 +#!/usr/bin/env python3 +"""Independent exact challenge of the proposed R/M/E odd-coset map.""" + +from __future__ import annotations + +import itertools +import json + + +H = ( + (1, 1, 1, 1), + (1, -1, 1, -1), + (1, 1, -1, -1), + (1, -1, -1, 1), +) +J = (1, 1, 1, -1) +S = (1, -1, -1, 1) + + +def require(condition, message): + if not condition: + raise RuntimeError(message) + + +def matvec(matrix, vector): + return tuple(sum(matrix[i][j] * vector[j] for j in range(4)) + for i in range(4)) + + +def norm_squared(vector): + return sum(value * value for value in vector) + + +def parity(vector): + return sum(vector) & 1 + + +def score2(twice_t, axis): + """Twice the invariant lower-magnitude score of this coordinate pair.""" + magnitude = abs(twice_t[axis]) + require(magnitude % 2 == 1, "coordinate is not half-integral") + if axis < 2: + return 4 * ((magnitude - 1) // 4) + 1 + if magnitude == 1: + return 0 + return 4 * ((magnitude - 3) // 4) + 3 + + +def toggle_pair(twice_t): + """The coordinate-magnitude involution M, in doubled coordinates.""" + require(len(twice_t) == 4 and all(value % 2 for value in twice_t), + "M requires four half-integer coordinates") + axis = min(range(4), key=lambda i: (score2(twice_t, i), i)) + result = list(twice_t) + magnitude = abs(result[axis]) + if axis >= 2 and magnitude == 1: + result[axis] = -result[axis] + else: + low = score2(twice_t, axis) + high = low + 2 + require(magnitude in (low, high), "coordinate is outside its pair") + sign = 1 if result[axis] > 0 else -1 + result[axis] = sign * (high if magnitude == low else low) + return tuple(result) + + +def odd_map(x): + """F(x)=E M R x for odd x; all arithmetic is integer exact.""" + require(parity(x) == 1, "odd map requires odd-total-parity input") + dot = sum(S[i] * x[i] for i in range(4)) + require(dot % 2 == 1, "s dot x must be odd") + twice_t = tuple(2 * x[i] - dot * S[i] for i in range(4)) + require(all(value % 2 for value in twice_t), + "R must produce four half-integer coordinates") + require((sum(twice_t) // 2) % 2 == 1, + "R must produce odd coordinate sum") + twice_m = toggle_pair(twice_t) + require((sum(twice_m) // 2) % 2 == 0, + "M must flip odd coordinate sum to even") + hjm = matvec(H, twice_m) + require(all(value % 4 == 0 for value in hjm), + "E must produce an integer output") + y = tuple(J[i] * (hjm[i] // 4) for i in range(4)) + require(parity(y) == 1, "E must produce odd-total-parity output") + return y + + +def odd_inverse(y): + """F^{-1}(y)=R M E^{-1} y for odd y.""" + require(parity(y) == 1, "odd inverse requires odd output") + jy = tuple(J[i] * y[i] for i in range(4)) + twice_t = matvec(H, jy) # t=UJy, represented as 2t. + require(all(value % 2 for value in twice_t), + "E inverse must produce half-integers") + require((sum(twice_t) // 2) % 2 == 0, + "E inverse must produce even-sum half-integers") + twice_m = toggle_pair(twice_t) + require((sum(twice_m) // 2) % 2 == 1, + "M inverse step must return to odd-sum half-integers") + dot = sum(S[i] * twice_m[i] for i in range(4)) + numerator = tuple(2 * twice_m[i] - dot * S[i] for i in range(4)) + require(all(value % 4 == 0 for value in numerator), + "R must return integer coordinates") + x = tuple(value // 4 for value in numerator) + require(parity(x) == 1, "odd inverse must return odd input") + return x + + +def even_map(x): + require(parity(x) == 0, "even map requires even-total-parity input") + hx = matvec(H, x) + require(all(value % 2 == 0 for value in hx), + "even input must have integral U image") + y = tuple(value // 2 for value in hx) + require(parity(y) == 0, "exact U must preserve even total parity") + return y + + +def even_inverse(y): + require(parity(y) == 0, "even inverse requires even output") + hy = matvec(H, y) + require(all(value % 2 == 0 for value in hy), + "even output must have integral U inverse") + return tuple(value // 2 for value in hy) + + +def full_map(x): + return even_map(x) if parity(x) == 0 else odd_map(x) + + +def full_inverse(y): + return even_inverse(y) if parity(y) == 0 else odd_inverse(y) + + + +def _int4(values): + result = tuple(values) + if len(result) != 4 or any(type(value) is not int for value in result): + raise ValueError("expected exactly four integers") + return result + + +def hadamard_forward(values): + """Global bijection approximating H4/2; unbounded integer coordinates.""" + return full_map(_int4(values)) + + +def hadamard_inverse(values): + """Exact inverse, also within unit error of H4/2.""" + return full_inverse(_int4(values)) + + +def gaussian_forward(values): + """Approximate C+ on (Re u, Im u, Re v, Im v); not sum preserving.""" + a, b, c, d = _int4(values) + y = full_map((a, -b, c, d)) + return y[0], y[3], y[1], -y[2] + + +def gaussian_inverse(values): + """Exact inverse of gaussian_forward; approximates C- explicitly.""" + a, b, c, d = _int4(values) + y = full_inverse((a, c, -d, b)) + return y[0], -y[1], y[2], y[3] diff --git a/research/global-bilateral-half-gaussian-rounding/proof/CHECKPOINT.json b/research/global-bilateral-half-gaussian-rounding/proof/CHECKPOINT.json new file mode 100644 index 0000000000..3db528fc14 --- /dev/null +++ b/research/global-bilateral-half-gaussian-rounding/proof/CHECKPOINT.json @@ -0,0 +1,38 @@ +{ + "canonical_main": "e54523517d0f03e58352e647c403a5af3e525a57", + "claim": "Explicit error-one bijection with sharp absolute/bilateral radial supremum1/2; both constructed directional outward suprema1/2; universal forward-only necessity remains unproved.", + "completed_at_utc": "2026-11-13 12:19:56 UTC", + "noninheritance": [ + "Complex pair sum fails", + "Gaussian phase covariance fails", + "Fourth-power identity fails", + "Conjugated positive approximation is not actual inverse" + ], + "own_checks": [ + { + "command": "python3 -I -W error -B check_identities.py", + "exit_code": 0 + }, + { + "command": "python3 -I -O -W error -B check_identities.py", + "exit_code": 0 + } + ], + "prior_artifacts": "Parity package and ball-core gate remain frozen; Q explanatory checkpoint is retained but not separately proposed for publication.", + "proof_scope": [ + "Complete unrestricted16-corner lower for all total maps", + "Global partner-invariant involution on all half-grid points", + "Exact R/E half-grid coset bijections and explicit inverse", + "Uniform radial<1/2 for central and both staggered phases", + "Unbounded integer attaining families for both directions", + "Exact Gaussian transfer with actual inverse distinct from conjugation" + ], + "separate_checks": "C/root global implementations and numerical tests have separate pins; no implementation imported or executed by this role.", + "status": "FROZEN_PROOF_ROLE_READY_FOR_ROOT_PUBLICATION", + "unclaimed": [ + "Universal forward-only lower1/2", + "Tensor/native/caller admission", + "Physical fixed-tape tariff", + "New kappa or discharge of retained assumptions" + ] +} diff --git a/research/global-bilateral-half-gaussian-rounding/proof/CHECKSUMS.sha256 b/research/global-bilateral-half-gaussian-rounding/proof/CHECKSUMS.sha256 new file mode 100644 index 0000000000..aa7a406ba7 --- /dev/null +++ b/research/global-bilateral-half-gaussian-rounding/proof/CHECKSUMS.sha256 @@ -0,0 +1,12 @@ +0553ee9c34afc74dac56913f8357ac3be2b8ea7035a9dfc611e747565f7d2ebe CHECKPOINT.json +7fbe3db67f6dea22980f23f5ebc155c77c07e306aa2a623955f175575b91133e CLAIM.json +d61b8166f8c18175638b7519dd8b48a418bdac9875a75540be6dbcbc97a9d186 NOTICE.md +48d78b77566a0b725159f242583a6acfdee918ca04877e28be718c983f8b19f1 OVERLAP.json +19e224d184e914e6d4e6e8bfe2163733db2d3b6173cd67244a00ac921f7e96d9 PR-DRAFT.md +1b7bf1e00a3b9dc44ff603222423c94bba15cc9450df6483601f328993cfdf42 PROOF.md +bf874d7dee57f1ef99e1ed80bd4537a795a250bce338963670e00f2684960285 README.md +2698bf88eb75c332b8e08ba074c1748f0ab73041d89deafda41f2aa0c35f672b RESULT.json +f11913d498093940383dba0d876bca48ccd10fe7e6725197ee9fc7759c145dd0 SOURCES.json +556e9ca46b8956afac0ea99dff7d6daf2bd387f11740633785b58bed3b7346d1 check_identities.py +2c747c7b88f540d2ea3bbbee91ecbc4387cda3bef57153ad8ded6e03f98e719d references/ROOT-NONINHERITANCE.json +95a73e92baec11de19aecc4207c2404e048d8e037308c396010a57ab3f581b02 references/ROOT-REPORTED-INVERSE.json diff --git a/research/global-bilateral-half-gaussian-rounding/proof/CLAIM.json b/research/global-bilateral-half-gaussian-rounding/proof/CLAIM.json new file mode 100644 index 0000000000..87e53bbb2f --- /dev/null +++ b/research/global-bilateral-half-gaussian-rounding/proof/CLAIM.json @@ -0,0 +1,34 @@ +{ + "Gaussian_negative_provider": "S F_H^-1 L; conjugated positive map is different", + "construction": "F even=U; odd=E M R; inverse even=U; odd=R M E^T.", + "error": "0 for even-sum input,1 for odd-sum input", + "five_assumptions_retained": [ + "native_all_columns", + "owned_erasure", + "compiler", + "precision_tape", + "analytic_recovery" + ], + "ideal": "H4/2; exact signed-permutation transfer to C_+", + "noninheritance": [ + "Exact complex sum", + "Gaussian phase covariance", + "Fourth-power identity", + "Conjugation equals actual inverse" + ], + "optimality": "Bilateral optimum1/2 among all error-one bijections; universal forward-only lower1/2 is unproved.", + "pointwise_radial": "Strictly less than1/2 at every input", + "scope": "Unrestricted same-grid error-one Gaussian lattice bijection;4 real coordinates", + "sharp_suprema": [ + "absolute radial1/2", + "forward outward1/2 for this F", + "inverse outward1/2 for this F" + ], + "unclaimed": [ + "Selected native/tensor/caller admission", + "Physical fixed-tape tariff", + "Universal forward-only1/2 lower bound", + "New kappa or assumption discharge" + ], + "universal_lower": "Every total integer-output error-one map has supremum absolute radial change>=1/2; no injectivity/parity/period/sum/equivariance premise." +} diff --git a/research/global-bilateral-half-gaussian-rounding/proof/NOTICE.md b/research/global-bilateral-half-gaussian-rounding/proof/NOTICE.md new file mode 100644 index 0000000000..f81ea7ef30 --- /dev/null +++ b/research/global-bilateral-half-gaussian-rounding/proof/NOTICE.md @@ -0,0 +1,22 @@ +# Attribution and evidence roles + +Apache-2.0. The current CubeJerry workstream supplied the staggered pairing +candidate and constructive question. This role supplied the complementary +universal proof, source/novelty audit and lower-corner/algebra checks. +Separate C/root roles checked implementations and non-inheritance controls; +those checks were not imported as this role's oracle or relabeled as its own. + +Ali Romman/#6509 supplies the ideal Gaussian pair and earlier exact-sum +reversible rounding. Nick Petalas/#6619 supplies rational norm-rounding +and credits ywz65/#2589's finite-ball argument. The current workstream's +frozen R5/compact Hall result supplies the separate forward lower and +signed-permutation transfer. #6304's fixed rational-phase radial allowance, +#6755/#6574's certificate/kernel work and #6761's periodic exact-square +obstruction retain their different contracts and full original credit. + +Coordinate pairings, coset linear algebra, lattice nearest-point geometry, +reverse triangle inequality and radical comparisons are classical methods. +This is a scoped sharp4d rounding contract, not priority for a general +rounding method. Substantial OpenAI Codex assistance; no independent human +or formal-kernel acceptance. All prior Gaussian/native/compiler notices, +selected assumptions and frontier records remain effective. diff --git a/research/global-bilateral-half-gaussian-rounding/proof/OVERLAP.json b/research/global-bilateral-half-gaussian-rounding/proof/OVERLAP.json new file mode 100644 index 0000000000..ee994b0a8a --- /dev/null +++ b/research/global-bilateral-half-gaussian-rounding/proof/OVERLAP.json @@ -0,0 +1,236 @@ +{ + "scope": "Bounded project-source audit; no universal novelty or method-priority claim.", + "queries": [ + { + "query": "repo:CrocSwap/integer-mult-bounds is:pr rounding radial", + "total_count": 1, + "incomplete_results": false, + "returned": [ + { + "number": 6304, + "title": "Sharpen reversible phase squared error from 1 to 4/5 (no κ)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/6304" + } + ] + }, + { + "query": "repo:CrocSwap/integer-mult-bounds is:pr rounding bilateral", + "total_count": 2, + "incomplete_results": false, + "returned": [ + { + "number": 4408, + "title": "Answer #4356's open question: the broad forward bound stays polynomial at theta = 1/(4p^2); actual blocks sit 1e-5..1e-6 below it and scale like theta^(-1/2) (no new κ)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/4408" + }, + { + "number": 6126, + "title": "Prove production Gaussian inverse bound 2 + 2p/u² (no new κ)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/6126" + } + ] + }, + { + "query": "repo:CrocSwap/integer-mult-bounds is:pr rounding outward", + "total_count": 33, + "incomplete_results": false, + "returned": [ + { + "number": 1724, + "title": "Conditional κ = 0.0016769381110224387711...: stacked pivot 566 + 554 kernels with 600-digit grid and 600-digit endpoints over PR1692", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1724" + }, + { + "number": 1692, + "title": "Conditional κ = 0.0016769381110224387711...: stacked pivot 566 + 554 kernels with 470-digit grid and 450-digit endpoints over PR1672", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1692" + }, + { + "number": 605, + "title": "[Lean] Prove the pinned PR588 native Real moment bound", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/605" + }, + { + "number": 6619, + "title": "Classify reversible inward rounding of rational orthogonal maps (no κ)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/6619" + }, + { + "number": 6438, + "title": "Construct optimal unbiased reversible phase rounding (no κ)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/6438" + }, + { + "number": 585, + "title": "[Lean] Verify selected rational certificate arithmetic", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/585" + }, + { + "number": 5056, + "title": "Audit actual Tensor expansion's signed internal contraction", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/5056" + }, + { + "number": 1677, + "title": "Conditional κ = 0.0016768966690212993077...159193: pivot-566 kernel with 470-digit grid and 450-digit endpoints over PR1661", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1677" + }, + { + "number": 6977, + "title": "Research: Production Reference gap", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/6977" + }, + { + "number": 6304, + "title": "Sharpen reversible phase squared error from 1 to 4/5 (no κ)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/6304" + }, + { + "number": 1661, + "title": "Conditional κ = 0.0016768966690212993077...99432: pivot-566 kernel with 400-digit grid refinement over PR1644", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1661" + }, + { + "number": 4756, + "title": "Audit uniform raw Gaussian common-reference admission", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/4756" + }, + { + "number": 892, + "title": "Research: rank-eight coded-helper endpoint and complete mixed-cost obstruction (no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/892" + }, + { + "number": 672, + "title": "Tooling: exact integer exponential intervals with pinned replay evidence", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/672" + }, + { + "number": 2552, + "title": "Speed exact ceiling replay with integer Taylor arithmetic", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2552" + }, + { + "number": 6413, + "title": "Eliminate 11,470 Gaussian setup exponential calls (no κ)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/6413" + }, + { + "number": 5295, + "title": "Audit five-stage Tensor expansion accuracy at computed inputs", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/5295" + }, + { + "number": 1485, + "title": "Conditional κ 0.00167685522907132188620645677227459261951244873951047526280336519105115665521200964951578469164138454299292754381039421745513966674764384056: verified outer140 witness refinement, unchanged construction", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1485" + }, + { + "number": 1337, + "title": "Scoped negative result: no further helper-donor kernels or exact read re-timings on the #1297/#1305/#1324 words (no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1337" + }, + { + "number": 960, + "title": "Independent verification: PR890 T21 moment brackets via binomial enclosures", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/960" + }, + { + "number": 5992, + "title": "Certify the pooled R437 carrier moment ceiling: 0.00173678297, unreachable 17/5000 below width 28571 (no new κ)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/5992" + }, + { + "number": 2917, + "title": "Conditional κ ≈ 0.001721588647: nine additional paired helper extractions", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2917" + }, + { + "number": 5396, + "title": "Independently validate joint relations and conditional κ = 0.003026674765", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/5396" + }, + { + "number": 3804, + "title": "Independent direct certification of the two batched moment bounds, with sharp thresholds (no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3804" + }, + { + "number": 1519, + "title": "Audit: PR1479/PR1485 fine Mercator engine returns false lower log bounds (no kappa change)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1519" + }, + { + "number": 1069, + "title": "Independent verification: code-disjoint pricing of all 16 pending kappa claims; every one has deficit W - 64N (no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1069" + }, + { + "number": 1186, + "title": "Tooling: exact frame solver and delivery-rewrite search for gauge44/k8 local words (no new κ)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1186" + }, + { + "number": 5513, + "title": "Research: independently audit PR #4091's pooled duals with rational binomial bounds", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/5513" + }, + { + "number": 3948, + "title": "Negative result: +10% centre sharing at c* ≈ 0.0018433 needs 511 net complex rank-1 units (3.55/call, not 1.33); no admitted bit lever nets any of the 649 needed (no κ)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3948" + }, + { + "number": 3724, + "title": "Independent verification (no κ): arithmetic layer of PR3562's ordinary-rate theorem holds; line-158 exposition gap, 4283584 stands", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3724" + }, + { + "number": 1052, + "title": "Independent verification: T37 positive-binomial moments, all-T lemma, and 1024-bit reduction (seed 78, no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1052" + }, + { + "number": 5428, + "title": "Observation, state, and geometry: building complete suppliers for larger κ", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/5428" + }, + { + "number": 3954, + "title": "research: derive P104 two-axis endpoint intertwiners and cost gate", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3954" + } + ] + } + ], + "primary_proofs_read": [ + 6509, + 6619 + ], + "additional_full_bodies_read": [ + { + "pr": 6755, + "head": "4475dc90bbe6037981bfc8ce0dd55efb6bdbc6a0", + "repository": "ToikY/integer-mult-bounds", + "title": "Review four-axis certificate and inverse kernel", + "body": "## Change and mathematical scope\r\n\r\nAdds an external written review of [Nick Petalas #6574](https://github.com/CrocSwap/integer-mult-bounds/pull/6574), pinned to `48e312ff18d5b66b0969148f615fdf5ce0f92edd`. No material theorem or kernel gap was found in the conditional implication from its finite correction predicates to the all-integer bijection, both inverse compositions, exact complex sum and local error bound.\r\n\r\nThe review binds complete Walsh quotient coverage, offset congruences, the complete target permutation, target-indexed inverse partners, weighted sums and norm/zero conditions to the actual kernel. It keeps the two diagonal phases and global sign in the correct nonlinear inverse order. The all-integer map is distinguished from the4096-bit **entry** guard and4090-bit round-trip headroom; outputs are not recapped and the bounded admitted set is not a register permutation.\r\n\r\nA minor prose clarification follows from the fixture expression: a shift parameter B in(128,1024,4090) constructs some B+1-bit components, so the last fixture reaches4091 bits. No fixture ran; this is not a theorem, API or headroom failure. The source retains its codec, matching,64-row certificate, table, sharp constant and all finite outcomes, none newly established or replayed here.\r\n\r\n## Task and overlap\r\n\r\n[Advance claim and handoff](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19430769). Canonical main `7c49fe32c55de02c2c873655c804b16e4c3fef0a`, eight guidance pins, revision8 and selected6030 were refreshed for the round and before publication. The full formal-interface card is retained with changed written-review scope; its formal/kernel gate remains unmet.\r\n\r\nChecked the live Hub/index,704 complete open/draft bodies and heads across eight pages, targeted all-state searches and the source's empty timeline. Final refresh: no metadata/head/body changes, source unchanged. #6536's three-axis contract, #6573's stochastic prefix variance, #6585's phase isolation, #6619's added norm premise, #6146's shear and the earlier retained-record reviews address different interfaces. Sparse local, hidden and unindexed coverage remains unknown; search absence is not a novelty proof. Prior results are excluded.\r\n\r\n## Validation\r\n\r\n[Exact review, inert source texts and sealed roles](https://github.com/ToikY/integer-mult-bounds/tree/4475dc90bbe6037981bfc8ce0dd55efb6bdbc6a0/research/four-axis-certificate-kernel-review). REVIEW13,882bytes, SHA256 `d346f62f9f2d5d145682d1cb62ba53cc4420f9e3e072a13627ca4f0145fe24eb`. Target-known abstract and source-aware code drafts were sealed before peer reading, then source cross-binding and exact-version assessment passed. Historical source/preclaim exposure is disclosed; first drafts remain unchanged. Nine/nine overlapping written controls are **UNEXECUTED**, not18 experiments. Actual table existence and source finite outcomes remain conditional and unreplayed.\r\n\r\nAll25 files froze at02:03:11.278644UTC. Ten exact source objects total65,198bytes; actual foreign Git custody is separated from ten canonical provenance pins. The full original card, sole canonical parent, package-only change and unchanged selected record passed. All25 public files match frozen bytes/modes/sizes. A separate byte role passed31 checks, SHA2562f0b08f2c57a076d6535f2d57bb2401178d1811bd5c4b996a0074cb6ef9732ec, with prior abstract/cross involvement disclosed. The complete26-member194,560-byte manual export passed full readback, SHA256 `f3c3889ae73b4e5284a9bb9c614843b8e6a2d83a379dfad011be2dd245793fef`. Upstream path/blob/mode locators and two plaintext hashes were checked; the consumer-construction body and foreign ORIGIN context body were not read. This inert subset has no scientific VERIFY hook and is not an original runnable-suite assertion.\r\n\r\nOriginal [CI run42148118686](https://github.com/CrocSwap/integer-mult-bounds/actions/runs/42148118686), attempt1, passed711 helper tests/24 skips on Python3.12.16. Scientific replay was skipped with zero commands. Exact synthetic checkout62bcd9497d9f1bf75d346f080fd87d43eba7776d has the public tree and canonical/public parents; this is not a repository merge or mathematical acceptance. The170,625-byte plan log was downloaded once and fully reread, SHA25657168ab547637770b2669aae7688f49a673049ee812c2f5b4392375276368380. At least15 minutes of verification precede handoff. No source imports, constructor, matching, class enumeration, certificate, endpoint fixture, fault campaign, NumPy/native operator or proof kernel ran.\r\n\r\n## Credit\r\n\r\nNick Petalas #6574 retains the codec, matching, certificate, sharpness, table and original finite evidence. Credit Ali Romman #6536/#6534/#5821, David Ganz/Dugongue #5815, Brian/JoyboyBrian #5485, #4743 and every retained Gaussian/native/compiler/NOTICE contributor. Walsh orthogonality, quotient algebra and matching are classical. ToikY used substantial OpenAI Codex with separate abstract, code, metadata and byte roles. Attribution/license is retained; no blind, human, kernel acceptance or endorsement is claimed.\r\n\r\n## Open next questions\r\n\r\nFormalize the complete certificate-to-lattice/kernel implication; separately bind a literal caller's charts, adjoint/group order, dirty banks, precision and full transform/classification/table-access/restoration invoice. Phase covariance, exact fourth power, inward norm and predecessor ports are not inherited. Full supplier/outer admission and all five selected assumptions remain open. See TASK for first steps and blockers. No κ/frontier/adoption change or merge; maintainer edits and auto-merge disabled." + }, + { + "pr": 6761, + "head": "b78c8938b6d04b7c340c06d4e958947aeecd9270", + "repository": "CubeJerry/integer-mult-bounds", + "title": "Prove the four-axis exact-square period obstruction (no new κ)", + "body": "For A=W16/4, let S be the parity-sign diagonal and J complement the four coordinate bits. Prove that every full-rank affine period, with linear part A, of an odd integer map R commuting with K=SJ has index divisible by 4,096. No radius, sum or bijection premise is needed.\n\nIn the componentwise real native architecture F=-D R_C D, the exact square F^2=J implies the required commutation. Thus the 2,048-class phase-only period cannot support this additional identity. Existence at index 4,096 remains open. This does not exclude generic F^4=I.\n\nNew mechanism: close the declared period under K, then use two independent image classes against a rank-one quotient restriction. This proves divisibility without assuming a maximal or invariant declared period. It is a written obstruction, not a failed matching search.\n\nBase: 7c49fe32c55de02c2c873655c804b16e4c3fef0a.\n#6574 head: 48e312ff18d5b66b0969148f615fdf5ce0f92edd.\n#6561 head: e8a55a6edf91c5067b26cdfefbcc76517f86ab02.\nExact source/blob/hash pins are in SOURCES.json. The phase-only construction is discovery context, not a runtime dependency:\nhttps://github.com/CubeJerry/integer-mult-bounds/tree/362b20bc934500bc503e850059f0d34daa5dcae3/research/four-axis-phase-covariant-grid\n\nReproduce (CPython 3.12, stdlib):\n```sh\npython3 -B scripts/research_package.py --package research/four-axis-exact-square-period-obstruction\n```\nExpected: PASS_INDEX4096_OBSTRUCTION_WITNESSES, PASS_INDEPENDENT_PERIOD_WITNESSES and PASS_REGISTERED_RESEARCH_PACKAGE.\n\nExecuted normal/-O: complete matrix identities, all 31 nonzero parity combinations, two exact image witnesses and three controls rejecting a malformed preimage, false image and missing sign phase. A separate Walsh-divisibility implementation constructs the second preimage. Adversarial proof review, committed bytes/modes, export integrity and four Git-free replays pass. Complete remote tree matches.\n\nNo new κ. No bound for nonperiodic maps, arbitrary coupled complex architectures, memory or physical tariffs. A larger invariant period and compatible correction cycles remain unconstructed. All five selected assumptions remain. No human/formal acceptance, hosted CI, selected cold replay or full-history preflight.\n\nBy @CubeJerry with substantial OpenAI Codex assistance and separate construction, witness and proof-review roles. Credit Nick Petalas (#6574/#6561), Ali Romman, David Ganz/Dugongue and retained native lineage. Apache-2.0.\n\nProof, reviewed hashes and limits:\nhttps://github.com/CubeJerry/integer-mult-bounds/tree/b78c8938b6d04b7c340c06d4e958947aeecd9270/research/four-axis-exact-square-period-obstruction" + } + ], + "other_body_read": { + "pr": 6304, + "head_stated_in_body": "8053adb606c74353933457a0d0715028cab23e96", + "distinction": "Sharp radial allowance within four fixed lifting tie programs for phase(3+4i)/5, not arbitrary H4/2 lattice bijections." + }, + "decision": "No matching sharp unrestricted4d bilateral statement found in inspected coverage. #6619 supplies the outward-slack question; this gives forward upper1/2 and sharp bilateral optimum, not forward optimality. #6755/#6574 and #6761 have different finite-certificate/exact-square/period contracts. Root broader metadata is separately pinned.", + "limits": [ + "Sparse indexing, arbitrary diffs and unpublished work are outside coverage.", + "Prior methods are classical; no general rounding-method novelty asserted." + ] +} diff --git a/research/global-bilateral-half-gaussian-rounding/proof/PR-DRAFT.md b/research/global-bilateral-half-gaussian-rounding/proof/PR-DRAFT.md new file mode 100644 index 0000000000..67b7778da1 --- /dev/null +++ b/research/global-bilateral-half-gaussian-rounding/proof/PR-DRAFT.md @@ -0,0 +1,24 @@ +# Construct an error-one Gaussian lattice bijection with sharp bilateral radial1/2 + +The explicit half-grid matching yields a bijection approximating H4/2, and +by exact signed permutations the ideal Gaussian pair, with error0/1 and +radial change strictly below1/2 at every input. Both forward and inverse +outward suprema are1/2. A complete sixteen-corner input family proves that +no error-one total map can have smaller absolute radial supremum. The +bilateral optimum is therefore sharp. The forward-only optimum is not +established; this is a constructive forward upper1/2. + +The global proof uses two staggered coordinate-pair phases, an invariant +score and exact half-grid coset maps. The inverse is explicit. Separate +C/root global implementations and this proof-role algebra/lower-corner +check have distinct provenance and retained pins. This role imports none +of those implementations. Normal and optimized identity checks reproduce +the retained receipt; the universal statements rest on the written proof. + +The Gaussian transfer fails the earlier rounder's exact complex sum, +phase covariance and fourth-power identity. The actual inverse differs +from conjugating the positive rounded map. No tensor/native-caller, +physical tariff or complete supplier admission is asserted. No new kappa; +all five framework assumptions remain. Credit #6509/#6619/#2589, frozen +R5/compact work and related notices; coordinate matching and lattice +geometry are classical. Substantial OpenAI Codex assistance, Apache-2.0. diff --git a/research/global-bilateral-half-gaussian-rounding/proof/PROOF.md b/research/global-bilateral-half-gaussian-rounding/proof/PROOF.md new file mode 100644 index 0000000000..469fe11c43 --- /dev/null +++ b/research/global-bilateral-half-gaussian-rounding/proof/PROOF.md @@ -0,0 +1,176 @@ +# Sharp bilateral half-unit radial distortion for a Gaussian lattice bijection + +Let U=H/2 with H=((1,1,1,1),(1,-1,1,-1),(1,1,-1,-1),(1,-1,-1,1)). +Put R_abs(F)=sup_x | ||F(x)||-||x|| | and +Delta_+(F)=sup_x(||F(x)||-||x||). + +**Theorem.** Every total integer-output map with ||F(x)-Ux||<=1 has +R_abs(F)>=1/2. An explicit bijection F:Z^4→Z^4 has error0 on even-sum +inputs and error1 on odd-sum inputs, preserves total parity and satisfies +| ||F(x)||-||x|| |<1/2 at every input. Both Delta_+(F) and Delta_+(F^-1) +have supremum1/2. Thus the optimal bilateral bound among error-one +bijections is exactly1/2. No parity, period, sum or equivariance premise +is imposed on the competing maps in the lower bound. + +This does not prove a universal forward-only lower bound1/2. It gives a +constructive forward upper bound1/2. No selected physical tariff follows. + +## 1. Unrestricted lower bound from all sixteen corners + +U^T=U and U^2=I. Coordinates of Hx have parity sum_i x_i. An integral +image has nine error-one integer neighbors: its center and eight signed +unit translates. A half-integral image has exactly16: the nearest two +integers in each coordinate. Each corner has squared error1; every other +integer point has squared error at least3. + +For integer m>=2 take z_m=(m+1,m,m,m). Its image is +(2m+1/2,1/2,1/2,1/2), and A=||z_m||^2=4m^2+2m+1. Its16 outputs have +first coordinate2m or2m+1 and other coordinates0/1. The lower squared +norms4m^2+k,k=0..3 have multiplicities1,3,3,1; the upper norms +(2m+1)^2+k have the same multiplicities. Put B=4m^2+3 and C=(2m+1)^2. +Then B0, +B+C=4A-2(4m^2+2m), + +so sqrt(B)+sqrt(C)>2sqrt(A). The exact minimum absolute radial change +is beta_m=sqrt(A)-sqrt(B)=(2m-2)/(sqrt(A)+sqrt(B))→1/2. +Hence every total admissible map has R_abs>=sup beta_m=1/2, without any +injectivity, parity or matching premise. No finite beta_m equals1/2. + +## 2. Half-grid colors and exact coset maps + +Let Z_0={x∈Z^4:sum x_i even}, Z_1=Z^4\Z_0 and L_h=(Z+1/2)^4. +Split L_h into A={t:sum t_i odd} and B={t:sum t_i even}; its four +half-integers always have an integer sum. Define + +J=diag(1,1,1,-1), E=JU, s=(1,-1,-1,1), R=UJU=I-ss^T/2. + +These maps are orthogonal, R^2=I, and ER=U. U bijects Z_0 onto itself: +it is integral there, sum(Ux)=2x_0, and U^2=I. + +R bijects Z_1 onto A. For odd x, s dot x is odd, so Rx is half-integral +in all coordinates. Its sum equals that of x since sum s_i=0. Conversely, +for t∈A, s dot t is odd: writing t=h+z, h=(1/2,1/2,1/2,1/2), gives +s dot h=0 and s dot z≡sum z_i≡sum t_i modulo2. Thus Rt is integral +with odd sum; R^2=I supplies the inverse. + +E bijects B onto Z_1. For t=h+z∈B, z∈Z_0 and Ut=e_0+Uz is integral +with odd sum; J preserves integer parity. Conversely E^T y=UJy is +half-integral for odd y and has even sum2(Jy)_0. Orthogonality supplies +the inverse. These statements establish complete coset maps, not just +inclusions or finite counts. + +## 3. A global involution on the half-grid + +Use indices0,1,2,3. On axes0,1 pair, for k>=0 and sigma=±1, + +{sigma(2k+1/2),sigma(2k+3/2)}, score2k+1/2. + +On axes2,3 use{-1/2,1/2}, score0, and + +{sigma(2k+3/2),sigma(2k+5/2)}, score2k+3/2. + +Each coordinate rule partitions all half-integers into disjoint unit pairs. +At t select the coordinate with least(score,index), and toggle it to its +partner. Call the result M(t). Every score is unchanged, so the same +coordinate is chosen on return. The partner operation reverses itself: +M is a global involution. Its one signed unit step flips sum parity and +therefore restricts to inverse bijections A↔B. + +## 4. Uniform radial bound + +A central toggle preserves radius. For a noncentral chosen pair let a>0 +be its lower absolute magnitude. Every other score is at least a. The +two opposite-phase scores are at least a+1, because the positive score +lattices1/2+2Z_>=0 and3/2+2Z_>=0 interleave; score0 would have won. +Their magnitudes are at least a+1. The other same-phase magnitude is at +least a. At the lower-magnitude endpoint of the edge, its radius r obeys + +r^2>=a^2+a^2+2(a+1)^2=4a^2+4a+2=(2a+1)^2+1. + +The squared-radius change is2a+1, so the radial jump is +(2a+1)/(sqrt(r^2+2a+1)+r)<(2a+1)/(2r)<1/2. +This treats either traversal direction, all signs, both phases and ties. + +## 5. The lattice bijection, inverse and directional suprema + +Set F(x)=Ux on Z_0 and F(x)=E M(Rx) on Z_1. The even branch bijects +Z_0 onto itself. The odd branch composes Z_1 --R→A --M→B --E→Z_1. +There are no cross-parity collisions. Its inverse is Uy on Z_0 and +R M(E^T y) on Z_1. For odd x, ERx=Ux and M changes one coordinate unit, +so the error is exactly1 by orthogonality of E. It is a nearest integer +output. The even branch is exact. The orthogonal R/E factors transfer +the strict radial bound to F and to its inverse. + +For sharpness, let a=1/2+2k,k>=0. The point +t=(a,-a,a+1,a+1)∈A selects axis0 and toggles outward. In integer +coordinates this gives + +x_out=(0,0,4k+2,1), +F(x_out)=(2k+2,2k+1,-2k-1,-2k-1). + +Lower and upper squared radii are16k^2+16k+5 and16k^2+20k+7. +Their difference of square roots tends to1/2. For the reverse direction, +t=(a,a,a+1,a+1)∈B selects the same outward toggle. It yields + +x_in=(2k+1,2k+1,2k+2,2k+1), +F(x_in)=(4k+2,0,-1,0). + +This is inward by the same radial amount. Thus Delta_+(F)=Delta_+(F^-1) +=1/2 as suprema, with no individual input attaining a half-unit jump. + +For any bijection G, Delta_+(G^-1)=sup_x(||x||-||G(x)||). Hence +max(Delta_+(G),Delta_+(G^-1))=R_abs(G). Section1 proves bilateral +optimality among all error-one bijections. It does not select a direction +for every competing G. Forward-only optimality remains a separate question. + +## 6. Gaussian transfer and source-specific non-inheritance + +Use S=diag(1,-1,1,1) and L(a,b,c,d)=(a,c,-d,b). The frozen R5 proof +checks H=L(2C_+)S, so F_C=L^-1 F S is an error-one bijection for the ideal +Gaussian pair C_+. Its actual inverse is S F^-1 L, which approximates +C_+^-1=C_- with the same error and radial bounds. Conjugating F_C by +complex conjugation K gives a different admissible approximation to C_-; +it is not asserted to be the inverse. At x=(-2,-2,-2,-1), the separate +exact root control gives K F_C K(x)=(-2,-2,-1,-2), whereas +F_C^-1(x)=(-2,-1,-2,-2). Signed-permutation transfer does not preserve +arbitrary stronger invariants of another nonlinear rounder. + +For example F_C(0,0,2,1)=(2,-1,1,1), obtained directly from k=0 in the +outward family and L^-1. The exact complex pair sum changes from(2,1) +to(3,0). Thus this is not an automatic replacement for #6509's exact-sum +map. Separate exact root controls also show failure of Gaussian phase +covariance and fourth-power identity; their pinned receipts are evidence +about this construction, not premises of the universal radial proof. + +No tensor-stage commutation, nonlinear native-graph consistency, actual +selected caller, same dirty-port wrapper, all-width precision propagation, +fixed-tape tariff or compiler/outer admission is established. Exact inversion +uses the stated inverse, rather than repeated positive calls or an ideal +linear identity. All five framework assumptions and kappa are unchanged. + +## 7. Credit, relation to Q and evidence boundary + +The current CubeJerry workstream supplied the staggered matching candidate, +its application to U and the constructive question. Coordinate pairings, +coset linear algebra and radial estimates are elementary classical methods. +The exact unrestricted corner lower bound is the bilateral consequence of +the preceding parametric ball-core analysis. Ali Romman/#6509 supplies the +ideal Gaussian pair and earlier stronger-invariant reversible rounding; +Nick Petalas/#6619 supplies the rational norm-contraction obstruction, +crediting ywz65/#2589's finite-ball argument. Frozen R5/compact Hall work +supplies the distinct forward lower bound sqrt21-sqrt19 and transfer. +All full predecessor notices and method credits remain effective. + +The earlier minimum-coordinate contraction Q is not the bijection here: +Q(3,0,0,0)=Q(2,-1,-1,1)=(1,1,1,2). Its preserved checkpoint explains +why a local inward selector alone loses injectivity. The staggered M instead +uses partner-invariant scores, giving a genuine global involution. + +The universal theorem rests on the explicit proof above. Independent C/root +implementations and finite controls corroborate it; no human or formal-kernel +acceptance is claimed. This proof/source review does not import those +implementations or C's search. Prepared with substantial OpenAI Codex +assistance, Apache-2.0. Publication is left to the root review process. diff --git a/research/global-bilateral-half-gaussian-rounding/proof/README.md b/research/global-bilateral-half-gaussian-rounding/proof/README.md new file mode 100644 index 0000000000..d2b83bd0fc --- /dev/null +++ b/research/global-bilateral-half-gaussian-rounding/proof/README.md @@ -0,0 +1,40 @@ +# Sharp bilateral Gaussian lattice rounding: proof-role package + +An explicit bijection of Z^4 approximates H4/2 with error0 on even inputs +and error1 on odd inputs. It preserves parity and changes every radius by +strictly less than1/2. Forward and inverse outward suprema both equal1/2. +No error-one total integer-output map can have smaller absolute radial +supremum, so the bilateral optimum is sharp, without a parity, period, +conserved-sum or equivariance premise on competitors. + +The construction pairs half-integer coordinates in two staggered phases. +Toggling the coordinate with least partner-invariant(score,index) is a +global involution. Two exact orthogonal coset maps turn it into the lattice +bijection and its explicit inverse. PROOF.md proves all coset, radial, +nearest-corner and directional statements for unbounded integer inputs. + +This is a constructive forward upper1/2 and a universal bilateral lower1/2. +It does not prove universal forward-only optimality. The known R5 forward +lower sqrt21-sqrt19 remains a different bound. Gaussian-pair transfer does +not inherit exact complex sum, phase covariance or fourth-power identity. +Its actual inverse is S F_H^-1 L; conjugating the positive nonlinear map +is a different provider and is not its inverse. + +```sh +python3 -I -W error -B check_identities.py +python3 -I -O -W error -B check_identities.py +``` + +Expected marker: PASS_STAGGERED_BIJECTION_PROOF_IDENTITIES. `--write` +regenerates RESULT.json. These proof-role checks cover matrix/coset +congruences, exact attaining families, complete unrestricted lower corners +and premise controls. They do not implement the global matcher. The +separate C/root constructor and global checks were not imported or counted +as this role's executions; their exact reference pins are in SOURCES.json. + +The earlier noninjective Q draft is retained as provenance, not proposed +for separate publication. No physical tariff, full native/tensor/caller +admission or new kappa is claimed. All five framework assumptions remain. +Open questions include the forward-only optimum and compatibility with a +specific stronger-invariant native caller under a complete paid interface. +Prepared with substantial OpenAI Codex assistance, Apache-2.0. diff --git a/research/global-bilateral-half-gaussian-rounding/proof/RESULT.json b/research/global-bilateral-half-gaussian-rounding/proof/RESULT.json new file mode 100644 index 0000000000..8032dcdce7 --- /dev/null +++ b/research/global-bilateral-half-gaussian-rounding/proof/RESULT.json @@ -0,0 +1,96 @@ +{ + "attaining_family_cases": [ + { + "k": 0, + "lower_norm2": 5, + "upper_norm2": 7 + }, + { + "k": 1, + "lower_norm2": 37, + "upper_norm2": 43 + }, + { + "k": 2, + "lower_norm2": 101, + "upper_norm2": 111 + }, + { + "k": 7, + "lower_norm2": 901, + "upper_norm2": 931 + }, + { + "k": 100, + "lower_norm2": 161605, + "upper_norm2": 162007 + }, + { + "k": 100000000000000000000, + "lower_norm2": 160000000000000000001600000000000000000005, + "upper_norm2": 160000000000000000002000000000000000000007 + } + ], + "controls": [ + "unstaggered pairing violates radial half bound", + "current magnitude is not partner-invariant", + "exact local lower minimum is inward" + ], + "limits": [ + "No universal forward-only lower1/2", + "No stronger #6509 invariant inheritance", + "No physical/tensor/caller admission" + ], + "lower_corner_cases": [ + { + "comparison_bits": 32, + "input_norm2": 21, + "m": 2, + "minimum_norm2": 19 + }, + { + "comparison_bits": 32, + "input_norm2": 43, + "m": 3, + "minimum_norm2": 39 + }, + { + "comparison_bits": 32, + "input_norm2": 73, + "m": 4, + "minimum_norm2": 67 + }, + { + "comparison_bits": 32, + "input_norm2": 273, + "m": 8, + "minimum_norm2": 259 + }, + { + "comparison_bits": 32, + "input_norm2": 16513, + "m": 64, + "minimum_norm2": 16387 + }, + { + "comparison_bits": 32, + "input_norm2": 4000002000001, + "m": 1000000, + "minimum_norm2": 4000000000003 + }, + { + "comparison_bits": 128, + "input_norm2": 4000000000000000000000000000002000000000000000000000000000001, + "m": 1000000000000000000000000000000, + "minimum_norm2": 4000000000000000000000000000000000000000000000000000000000003 + }, + { + "comparison_bits": 512, + "input_norm2": 400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001, + "m": 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000, + "minimum_norm2": 400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003 + } + ], + "marker": "PASS_STAGGERED_BIJECTION_PROOF_IDENTITIES", + "scope": "Matrices, attaining families and complete unrestricted lower corners; global implementation separately checked by C/root, not imported here." +} diff --git a/research/global-bilateral-half-gaussian-rounding/proof/SOURCES.json b/research/global-bilateral-half-gaussian-rounding/proof/SOURCES.json new file mode 100644 index 0000000000..01c9d601d9 --- /dev/null +++ b/research/global-bilateral-half-gaussian-rounding/proof/SOURCES.json @@ -0,0 +1,97 @@ +{ + "canonical_main": "e54523517d0f03e58352e647c403a5af3e525a57", + "claim_provenance": "Current CubeJerry workstream supplied staggered pairing and exact construction; proof-role supplied complementary all-size proof and algebra/lower-corner checks.", + "frozen_R5_reference": [ + { + "bytes": 5812, + "origin": "worker-c/research/sharp-finite-gaussian-outward-slack/PROOF.md", + "sha256": "d00460ebf9579c49ae711079e3a21865571d82e7e42f8fc6bc11a08cf062f09b" + }, + { + "bytes": 2955, + "origin": "worker-c/research/sharp-finite-gaussian-outward-slack/SOURCES.json", + "sha256": "e010d96e3b44bb10a0dddbbff66fb00dcd316e620b8feebd0e8477a84e0b1d51" + }, + { + "bytes": 6065, + "origin": "worker-c/research/sharp-finite-gaussian-outward-slack/compact-hall/PROOF.md", + "sha256": "c0a9ee164d3a466a4b3996e1075ef7443123ac5e99b0e4e9e05585411352ad21" + }, + { + "bytes": 1905, + "origin": "worker-c/research/sharp-finite-gaussian-outward-slack/compact-hall/SOURCES.json", + "sha256": "5649af07ec67b10ca76b625250fe51e698fb2bb5ec25a82eaaaaaec5ca63dfdd" + }, + { + "bytes": 28950, + "origin": "worker-c/research/sharp-finite-gaussian-outward-slack/R5-OPTIMUM.json.gz", + "sha256": "d26f615aacff4b082c316e491aa1730aabc9cb6ceb377d33fb9a279b2d7f5f16" + } + ], + "primary_upstream_proofs": [ + { + "bytes": 11768, + "commit": "a4173e810c4d34a1d13b9745af123ad0ec6cfed5", + "git_blob": "b7047476aaa5e2bb149c92a8a40a9b2ab444ef73", + "path": "research/conservative-gaussian-rounding/PROOF.md", + "pr": 6509, + "repository": "aliromman/integer-mult-bounds", + "sha256": "122eff335674d8de1bcba47d28feb0c420be62b2b6d4e84f91c4292383753380" + }, + { + "bytes": 5884, + "commit": "eaa967e7e8aa12cc53ec246a5fc00c5f8873a50b", + "git_blob": "ffb873b2749b1590df9267e802aea5af2c2a6eb5", + "path": "research/rational-norm-rounding/PROOF.md", + "pr": 6619, + "repository": "petalas/integer-mult-bounds", + "sha256": "231b1b322b6be2a798d1807f5c0346ac4002323384b45cd4eff2a0ef7210bc00" + } + ], + "role_isolation": "Universal proof written without reading or importing C/root implementations/proof challenge; only hashes/reference receipts were read afterwards. No C current search code was read.", + "runtime_inputs": [], + "separate_roles": [ + { + "bytes": 5844, + "origin": "worker-c/research/odd-parity-global-map-review/PROOF-CHALLENGE.md", + "role": "Separate-role reference, hashed only; implementation/proof not imported or executed by this role.", + "sha256": "fdaecf910f1172e304d53bd5a74bfa4b512841c0800cc240f76a7fbede0d2829" + }, + { + "bytes": 11642, + "origin": "worker-c/research/odd-parity-global-map-review/mechanism_check.py", + "role": "Separate-role reference, hashed only; implementation/proof not imported or executed by this role.", + "sha256": "fba858f2b464ad94ca1b4907647858be657e056fe1be12bdbb80fb2e023de716" + }, + { + "bytes": 14753, + "origin": "worker-c/research/odd-parity-global-map-review/RESULT.json", + "role": "Separate-role reference, hashed only; implementation/proof not imported or executed by this role.", + "sha256": "70798b1ff53df317b2dce6c00c4cf86b78f1c716542477354a04b3c745452fc5" + }, + { + "bytes": 487, + "origin": "worker-c/research/odd-parity-global-map-review/CHECKSUMS.sha256", + "role": "Separate-role reference, hashed only; implementation/proof not imported or executed by this role.", + "sha256": "8ad22dcc153dd089c398be3067269258cab7bf094dda09e45b08f233e64eedd3" + }, + { + "bytes": 3977, + "origin": "root-work/half-grid-matching/check_global_candidate.py", + "role": "Separate-role reference, hashed only; implementation/proof not imported or executed by this role.", + "sha256": "3f1349d2e88e90aea9e133bd91421e91ccbab9bcb078253ab0faed8a9581982b" + }, + { + "bytes": 492, + "origin": "root-work/half-grid-matching/NONINHERITANCE.json", + "role": "Separate-role reference, hashed only; implementation/proof not imported or executed by this role.", + "sha256": "2c747c7b88f540d2ea3bbbee91ecbc4387cda3bef57153ad8ded6e03f98e719d" + }, + { + "bytes": 23150, + "origin": "root-work/half-grid-matching/OVERLAP-METADATA.json", + "role": "Separate-role reference, hashed only; implementation/proof not imported or executed by this role.", + "sha256": "9be890a22b61efff4996d2285b4fb13aacfc5c55ae40d22de255e1ae697210e6" + } + ] +} diff --git a/research/global-bilateral-half-gaussian-rounding/proof/check_identities.py b/research/global-bilateral-half-gaussian-rounding/proof/check_identities.py new file mode 100644 index 0000000000..851b081aea --- /dev/null +++ b/research/global-bilateral-half-gaussian-rounding/proof/check_identities.py @@ -0,0 +1,67 @@ +"""Proof-role identities and lower-corner oracle, not a global constructor. +No C/root implementation imported. Apache-2.0; substantial OpenAI assistance. +""" +from itertools import product +from math import isqrt +from pathlib import Path +import json,argparse +H=((1,1,1,1),(1,-1,1,-1),(1,1,-1,-1),(1,-1,-1,1));s=(1,-1,-1,1) +R2=tuple(tuple(2*(i==j)-s[i]*s[j] for j in range(4)) for i in range(4)) +E2=tuple(tuple((1 if i<3 else -1)*H[i][j] for j in range(4)) for i in range(4)) +def need(ok,m): + if not ok:raise ValueError(m) +def mm(A,B):return tuple(tuple(sum(A[i][k]*B[k][j] for k in range(4)) for j in range(4)) for i in range(4)) +def mv(A,v):return tuple(sum(a*b for a,b in zip(row,v)) for row in A) +def n2(v):return sum(t*t for t in v) +def interval(m,n,bits): + a=isqrt(max(m,n)<<(2*bits));b=isqrt(min(m,n)<<(2*bits));return(max(0,a-b-1),a-b+1) +def check(): + I4=tuple(tuple(4*(i==j) for j in range(4)) for i in range(4)) + need(mm(H,H)==I4 and mm(R2,R2)==I4,'orthogonal involutions') + need(mm(E2,R2)==tuple(tuple(2*t for t in row) for row in H),'ER=U') + need(mm(tuple(zip(*E2)),E2)==I4,'E orthogonality') + for x in product((0,1),repeat=4): + if sum(x)%2: + t=mv(R2,x);q=mv(tuple(zip(*E2)),x) + need(all(z%2 for z in t) and sum(t)%4==2,'R odd-to-A congruence') + need(all(z%2 for z in q) and sum(q)%4==0,'E transpose odd-to-B congruence') + for t in product((1,3),repeat=4): + A=R2 if sum(t)%4==2 else E2 + need(all(z%4==0 for z in mv(A,t)),'half-coset integrality') + records=[] + for k in (0,1,2,7,100,10**20): + a2=4*k+1;to=(a2,-a2,a2+2,a2+2);qo=(a2+2,-a2,a2+2,a2+2) + tb=(a2,a2,a2+2,a2+2);qa=(a2+2,a2,a2+2,a2+2) + outs=[mv(A,t) for A,t in ((R2,to),(E2,qo),(R2,qa),(E2,tb))] + need(all(z%4==0 for v in outs for z in v),'integer attaining families') + xo,yo,xi,yi=[tuple(z//4 for z in v) for v in outs] + need(xo==(0,0,4*k+2,1) and yo==(2*k+2,2*k+1,-2*k-1,-2*k-1),'outward family') + need(xi==(2*k+1,2*k+1,2*k+2,2*k+1) and yi==(4*k+2,0,-1,0),'inverse family') + need(n2(xo)==n2(yi)==16*k*k+16*k+5 and n2(yo)==n2(xi)==16*k*k+20*k+7,'norm polynomials') + records.append({'k':k,'lower_norm2':n2(xo),'upper_norm2':n2(yo)}) + lower=[] + for m in (2,3,4,8,64,10**6,10**30,10**100): + z=(m+1,m,m,m);h=mv(H,z);cs=list(product(*[(t//2,t//2+1) for t in h]));n=n2(z);best=4*m*m+3 + need(len(cs)==16 and all(sum((2*y[i]-h[i])**2 for i in range(4))==4 for y in cs),'complete error-one corners') + norms=set(map(n2,cs));ok=False + for bits in (32,64,128,256,512,1024): + spans={v:interval(v,n,bits) for v in norms} + if all(spans[best][1]16,'unstaggered a=.5 radius1-to-sqrt3 exceeds half') + t=(1,1,3,3);i=min(range(4),key=lambda j:(abs(t[j]),j));u=list(t);u[i]+=2 + need(i==0 and min(range(4),key=lambda j:(abs(u[j]),j))==1,'current magnitude is not invariant pairing score') + S=((1,0,0,0),(0,-1,0,0),(0,0,1,0),(0,0,0,1));L=((1,0,0,0),(0,0,1,0),(0,0,0,-1),(0,1,0,0)) + Cp=((1,-1,1,1),(1,1,-1,1),(1,1,1,-1),(-1,1,1,1)) + need(mm(mm(L,Cp),S)==H,'Gaussian signed transfer') + return {'marker':'PASS_STAGGERED_BIJECTION_PROOF_IDENTITIES','scope':'Matrices, attaining families and complete unrestricted lower corners; global implementation separately checked by C/root, not imported here.', + 'attaining_family_cases':records,'lower_corner_cases':lower, + 'controls':['unstaggered pairing violates radial half bound','current magnitude is not partner-invariant','exact local lower minimum is inward'], + 'limits':['No universal forward-only lower1/2','No stronger #6509 invariant inheritance','No physical/tensor/caller admission']} +if __name__=='__main__': + p=argparse.ArgumentParser();p.add_argument('--write',action='store_true');a=p.parse_args();r=check();dest=Path(__file__).with_name('RESULT.json') + if a.write:dest.write_text(json.dumps(r,indent=2,sort_keys=True)+'\n') + else:need(json.loads(dest.read_text())==r,'receipt drift') + print('PASS_STAGGERED_BIJECTION_PROOF_IDENTITIES: matrices, families and complete lower corners agree.') diff --git a/research/global-bilateral-half-gaussian-rounding/proof/references/ROOT-NONINHERITANCE.json b/research/global-bilateral-half-gaussian-rounding/proof/references/ROOT-NONINHERITANCE.json new file mode 100644 index 0000000000..d95954c04f --- /dev/null +++ b/research/global-bilateral-half-gaussian-rounding/proof/references/ROOT-NONINHERITANCE.json @@ -0,0 +1,50 @@ +{ + "phase_covariance": { + "x": [ + -2, + -2, + -2, + -1 + ], + "F_C(ix)": [ + 2, + -1, + 2, + -2 + ], + "iF_C(x)": [ + 1, + -2, + 2, + -2 + ] + }, + "complex_sum": { + "x": [ + -2, + -2, + -2, + 1 + ], + "F_C(x)": [ + 0, + -1, + -3, + -1 + ] + }, + "fourth_power": { + "x": [ + -2, + -1, + -2, + 2 + ], + "F_C^4(x)": [ + -3, + 1, + -1, + 0 + ] + } +} diff --git a/research/global-bilateral-half-gaussian-rounding/proof/references/ROOT-REPORTED-INVERSE.json b/research/global-bilateral-half-gaussian-rounding/proof/references/ROOT-REPORTED-INVERSE.json new file mode 100644 index 0000000000..da2255bf3d --- /dev/null +++ b/research/global-bilateral-half-gaussian-rounding/proof/references/ROOT-REPORTED-INVERSE.json @@ -0,0 +1,21 @@ +{ + "origin": "Exact root evaluation reported in task thread; not an additional execution by this role.", + "x": [ + -2, + -2, + -2, + -1 + ], + "K_F_C_K": [ + -2, + -2, + -1, + -2 + ], + "F_C_inverse": [ + -2, + -1, + -2, + -2 + ] +} diff --git a/research/global-bilateral-half-gaussian-rounding/review/independent/CHECKSUMS.sha256 b/research/global-bilateral-half-gaussian-rounding/review/independent/CHECKSUMS.sha256 new file mode 100644 index 0000000000..c0e6caf488 --- /dev/null +++ b/research/global-bilateral-half-gaussian-rounding/review/independent/CHECKSUMS.sha256 @@ -0,0 +1,6 @@ +fdaecf910f1172e304d53bd5a74bfa4b512841c0800cc240f76a7fbede0d2829 PROOF-CHALLENGE.md +0c432aedd1387cff37971db3d95365f332f68e11f716b3a0ee67b3a147268df9 README.md +70798b1ff53df317b2dce6c00c4cf86b78f1c716542477354a04b3c745452fc5 RESULT.json +b5ea4a0a6206f83374f38a1ef2934a7940542d51a2021f36d8fdbb6f64e3a1da REVIEW-RECEIPT.md +bbca8bc8d0dccfaeee1d748b24210b70e66cd76bcb2ebd2080c9ed2035a60010 SOURCES.json +fba858f2b464ad94ca1b4907647858be657e056fe1be12bdbb80fb2e023de716 mechanism_check.py diff --git a/research/global-bilateral-half-gaussian-rounding/review/independent/PROOF-CHALLENGE.md b/research/global-bilateral-half-gaussian-rounding/review/independent/PROOF-CHALLENGE.md new file mode 100644 index 0000000000..509d0acf0f --- /dev/null +++ b/research/global-bilateral-half-gaussian-rounding/review/independent/PROOF-CHALLENGE.md @@ -0,0 +1,172 @@ +# Independent challenge of the proposed global map + +## Review result + +I found no counterexample. The proposed map passes the exact boundary, +parity, inverse, unit-error, and half-unit radial checks below. The +coordinate-pair involution together with the R/M/E factorization gives a +direct all-input proof; the finite-point checks in RESULT.json are +cross-checks, not substitutes for that proof. + +## Exact matrices and cosets + +Let \(U=H_4/2\), \(J=\operatorname{diag}(1,1,1,-1)\), and +\(s=(1,-1,-1,1)^T\). Direct integer multiplication gives + +\[ +U^2=I,\qquad U^T=U,\qquad R:=UJU=I-\frac{ss^T}{2}. +\] + +Since \(s^Ts=4\), \(R^2=I\) and \(R\) is orthogonal. Put +\(E=JU\); it is also orthogonal. + +For odd-sum integer \(x\), \(s^Tx\) is odd, and + +\[ +Rx=x-\frac{s^Tx}{2}s. +\] + +Every coordinate of \(Rx\) is half-integral; because \(\sum_i s_i=0\), +its coordinate sum remains odd. Conversely, if \(t\) is half-integral with +odd coordinate sum, then \(s^Tt\) is an odd integer and the same formula +shows \(Rt\in\mathbb Z^4\) with odd sum. Thus \(R\) is a bijection from +odd-sum integer vectors to + +\[ +A=\{t\in(\mathbb Z+\tfrac12)^4:\sum_i t_i\text{ is odd}\}. +\] + +Define + +\[ +B=\{t\in(\mathbb Z+\tfrac12)^4:\sum_i t_i\text{ is even}\}. +\] + +If \(t\in B\), write \(t=z+\tfrac12(1,1,1,1)\). Then \(z\in\mathbb Z^4\) +has even sum. Since every entry of \(H_4\) is odd, \(U z\) is integral, +and \(U(\tfrac12\mathbf1)=(1,0,0,0)\). Hence \(Ut\) is integral. +Also \(\sum_i(Ut)_i=2t_1\) is odd; flipping its fourth coordinate with +\(J\) preserves parity. Therefore \(E(B)\) consists of odd-sum integer +vectors. Conversely, for odd integer \(y\), \(E^{-1}y=UJy\) is +half-integral and has sum \(2y_1\), which is even. Thus \(E:B\to X_{\rm odd}\) +is a bijection, with inverse \(UJ\). + +## The half-lattice pairing + +Every half-integer magnitude belongs to exactly one pair: + +- Axes 0 and 1: for each sign and \(k\ge0\), pair + \(a=\tfrac12+2k\) with \(a+1=\tfrac32+2k\). +- Axes 2 and 3: pair \(-\tfrac12\) with \(+\tfrac12\) as the central pair; + for each sign and \(k\ge0\), pair + \(a=\tfrac32+2k\) with \(a+1=\tfrac52+2k\). + +Give a coordinate the score equal to the lower absolute magnitude of its +pair, except that the central pair has score zero. Choose the coordinate +with least (score, index), and toggle its pair. This is exactly M. + +The toggle leaves that coordinate's score unchanged. All other scores are +unchanged, including the central score. Thus the same coordinate remains +selected after the toggle and M is an involution. Every toggle changes +one coordinate by \(+1\) or \(-1\), so it flips the parity of the integer +coordinate sum. Consequently \(M\) exchanges A and B bijectively. This +also covers ties: the selected index is fixed by the unchanged score +vector. + +## Map, inverse, and rounding error + +Define the full map on integer vectors by + +\[ +F(x)= +\begin{cases} +Ux,&\sum_i x_i\text{ even},\\ +EMRx,&\sum_i x_i\text{ odd}. +\end{cases} +\] + +The even branch is a bijection of the even-sum integer lattice because U +is an involution and maps even-sum integers to even-sum integers. +For the odd branch, R maps the odd integer coset bijectively to A, M maps +A bijectively to B, and E maps B bijectively to odd integers. Hence F is +a bijection of \(\mathbb Z^4\) preserving total-sum parity. + +The explicit inverse is + +\[ +F^{-1}(y)= +\begin{cases} +Uy,&\sum_i y_i\text{ even},\\ +RMUJ\,y,&\sum_i y_i\text{ odd}. +\end{cases} +\] + +For odd x put \(t=Rx\). Since \(ER=JU\,UJU=U\) and \(M(t)-t\) is a +signed coordinate unit vector \(\delta\), + +\[ +F(x)-Ux=E\delta=JU\delta. +\] + +The matrix \(JU\) is orthogonal, so this error has norm exactly one. +Because x and F(x) are both odd-sum integers while Ux is +half-integral, F(x) is one of the 16 nearest corners, and parity selects +the required eight-corner subfamily. The even branch has zero error. + +## Bilateral radial bound + +For odd x, orthogonality of R and E gives + +\[ +\|x\|_2=\|t\|_2,\qquad \|F(x)\|_2=\|M(t)\|_2. +\] + +If M selects the central pair, it only changes \(-1/2\) to \(+1/2\) or +vice versa, so the norm is unchanged. + +Otherwise let \(a>0\) be the selected lower magnitude and +\(q=2a+1\). The two phase classes of lower scores are +\(\tfrac12+2\mathbb Z_{\ge0}\) on axes 0,1 and +\(\tfrac32+2\mathbb Z_{\ge0}\) on axes 2,3. Since a is globally minimal, +the other same-phase axis has lower score at least a, and each of the two +opposite-phase axes has lower score at least \(a+1\). No central +coordinate is present in this case because its score zero would have +been selected. Therefore the endpoint with lower norm r satisfies + +\[ +r^2\ge a^2+a^2+2(a+1)^2 +=4a^2+4a+2 +=(2a+1)^2+1=q^2+1. +\] + +Toggling changes the squared norm by exactly +\((a+1)^2-a^2=q\). If \(r'\) is the larger endpoint radius, then +\(r>q\) and \(r'>r>q\), so + +\[ +|r'-r|=\frac{q}{r'+r}<\frac{q}{2q}=\frac12. +\] + +Thus the bilateral radial bound holds strictly on every noncentral pair +and with equality zero on the central pair. There are no omitted +boundary or tie cases. + +## Exact challenge checks + +The separate integer implementation in mechanism_check.py: + +- verifies \(H_4^2=4I\) and the reflection identity after clearing + denominators; +- applies M twice on 65,536 half-lattice vectors, including 27,136 score + ties and 15,360 central-pair cases; +- checks the explicit inverse, parity, unit-error corner condition, and + exact integer half-slack inequality on all odd input points in precisely + the named balls \(R=5,9,11\), with no collisions; +- checks 28 explicit odd round trips with coordinate magnitudes up to + \(2^{1024}\), plus large even exact-U round trips; +- checks the radial lower-bound identity for 1,000 positive half-integer + scores. + +The exact checks corroborate the algebra. They do not extend the finite +flow search to other radii. This challenge did not read or compare against +any other current proof package. diff --git a/research/global-bilateral-half-gaussian-rounding/review/independent/README.md b/research/global-bilateral-half-gaussian-rounding/review/independent/README.md new file mode 100644 index 0000000000..1801cd2440 --- /dev/null +++ b/research/global-bilateral-half-gaussian-rounding/review/independent/README.md @@ -0,0 +1,37 @@ +# Independent review of the odd-parity global map + +This directory records an independent exact challenge of the proposed +global \(H_4/2\) parity-preserving rounder with bilateral radial slack at +most \(1/2\). The complete derivation is in PROOF-CHALLENGE.md. The exact +checker uses integer matrices and doubled half-integer coordinates; it +imports no finite-sweep generator. + +The review found no counterexample. The factorization +\(F=E M R\) on odd total parity, exact \(U\) on even total parity, and the +inverse below give a global bijection: + +- odd output inverse: \(R M U J\); +- even output inverse: \(U\). + +For odd inputs the error norm is exactly one. For noncentral pair moves the +radial difference is strictly below \(1/2\); central moves and even inputs +preserve norm. See the proof for the score-phase and tie argument. + +## Checks + +~~~~sh +python3 -I -B mechanism_check.py > /tmp/odd-map-result.json +cmp /tmp/odd-map-result.json RESULT.json +python3 -I -O -B mechanism_check.py +~~~~ + +The checker verifies the matrix identities, all 65,536 half-lattice vectors +with doubled coordinates in \([-15,15]^4\), every odd point in precisely +the assigned balls \(R=5,9,11\), 28 explicit odd round trips up to scale +\(2^{1024}\), and large even exact-\(U\) round trips. These finite checks +corroborate the all-input algebra; they are not an extrapolation to further +radii. + +This is a review artifact for the proposed mechanism, not a separate PR. +The previous finite quotient receipts remain frozen in the sibling +odd-parity-bilateral-half-sweep package. diff --git a/research/global-bilateral-half-gaussian-rounding/review/independent/RESULT.json b/research/global-bilateral-half-gaussian-rounding/review/independent/RESULT.json new file mode 100644 index 0000000000..311ef0045c --- /dev/null +++ b/research/global-bilateral-half-gaussian-rounding/review/independent/RESULT.json @@ -0,0 +1 @@ +{"even_exact_round_trip_examples":[{"exponent":0,"input":["1","-1","0","0"],"output":["0","1","0","1"]},{"exponent":0,"input":["1","1","0","0"],"output":["1","0","1","0"]},{"exponent":1,"input":["2","-2","0","0"],"output":["0","2","0","2"]},{"exponent":1,"input":["2","2","0","0"],"output":["2","0","2","0"]},{"exponent":64,"input":["18446744073709551616","-18446744073709551616","0","0"],"output":["0","18446744073709551616","0","18446744073709551616"]},{"exponent":64,"input":["18446744073709551616","18446744073709551616","0","0"],"output":["18446744073709551616","0","18446744073709551616","0"]},{"exponent":1024,"input":["179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216","-179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216","0","0"],"output":["0","179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216","0","179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216"]},{"exponent":1024,"input":["179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216","179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216","0","0"],"output":["179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216","0","179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216","0"]}],"large_exponents":[0,1,2,10,64,256,1024],"large_round_trip_examples":[{"exponent":0,"input":["1","1","-1","0"],"input_norm_squared_digits":1,"output":["1","0","1","1"],"output_norm_squared_digits":1},{"exponent":0,"input":["-1","0","0","0"],"input_norm_squared_digits":1,"output":["0","0","-1","0"],"output_norm_squared_digits":1},{"exponent":0,"input":["1","0","2","0"],"input_norm_squared_digits":1,"output":["1","2","0","0"],"output_norm_squared_digits":1},{"exponent":0,"input":["0","1","-1","-1"],"input_norm_squared_digits":1,"output":["0","-1","1","-1"],"output_norm_squared_digits":1},{"exponent":1,"input":["2","1","-2","0"],"input_norm_squared_digits":1,"output":["1","0","2","2"],"output_norm_squared_digits":1},{"exponent":1,"input":["-2","0","0","1"],"input_norm_squared_digits":1,"output":["0","-1","-2","0"],"output_norm_squared_digits":1},{"exponent":1,"input":["2","-1","2","0"],"input_norm_squared_digits":1,"output":["2","2","-1","0"],"output_norm_squared_digits":1},{"exponent":1,"input":["0","2","-1","-2"],"input_norm_squared_digits":1,"output":["0","-1","2","-2"],"output_norm_squared_digits":1},{"exponent":2,"input":["4","1","-4","0"],"input_norm_squared_digits":2,"output":["1","0","4","4"],"output_norm_squared_digits":2},{"exponent":2,"input":["-4","0","0","1"],"input_norm_squared_digits":2,"output":["-1","-3","-2","-1"],"output_norm_squared_digits":2},{"exponent":2,"input":["4","-3","2","0"],"input_norm_squared_digits":2,"output":["1","4","-1","3"],"output_norm_squared_digits":2},{"exponent":2,"input":["0","4","-1","-4"],"input_norm_squared_digits":2,"output":["0","-1","4","-4"],"output_norm_squared_digits":2},{"exponent":10,"input":["1024","1","-1024","0"],"input_norm_squared_digits":7,"output":["1","0","1024","1024"],"output_norm_squared_digits":7},{"exponent":10,"input":["-1024","0","0","1"],"input_norm_squared_digits":7,"output":["-511","-513","-512","-511"],"output_norm_squared_digits":7},{"exponent":10,"input":["1024","-1023","2","0"],"input_norm_squared_digits":7,"output":["1","1024","-1","1023"],"output_norm_squared_digits":7},{"exponent":10,"input":["0","1024","-1","-1024"],"input_norm_squared_digits":7,"output":["0","-1","1024","-1024"],"output_norm_squared_digits":7},{"exponent":64,"input":["18446744073709551616","1","-18446744073709551616","0"],"input_norm_squared_digits":39,"output":["1","0","18446744073709551616","18446744073709551616"],"output_norm_squared_digits":39},{"exponent":64,"input":["-18446744073709551616","0","0","1"],"input_norm_squared_digits":39,"output":["-9223372036854775807","-9223372036854775809","-9223372036854775808","-9223372036854775807"],"output_norm_squared_digits":39},{"exponent":64,"input":["18446744073709551616","-18446744073709551615","2","0"],"input_norm_squared_digits":39,"output":["1","18446744073709551616","-1","18446744073709551615"],"output_norm_squared_digits":39},{"exponent":64,"input":["0","18446744073709551616","-1","-18446744073709551616"],"input_norm_squared_digits":39,"output":["0","-1","18446744073709551616","-18446744073709551616"],"output_norm_squared_digits":39},{"exponent":256,"input":["115792089237316195423570985008687907853269984665640564039457584007913129639936","1","-115792089237316195423570985008687907853269984665640564039457584007913129639936","0"],"input_norm_squared_digits":155,"output":["1","0","115792089237316195423570985008687907853269984665640564039457584007913129639936","115792089237316195423570985008687907853269984665640564039457584007913129639936"],"output_norm_squared_digits":155},{"exponent":256,"input":["-115792089237316195423570985008687907853269984665640564039457584007913129639936","0","0","1"],"input_norm_squared_digits":155,"output":["-57896044618658097711785492504343953926634992332820282019728792003956564819967","-57896044618658097711785492504343953926634992332820282019728792003956564819969","-57896044618658097711785492504343953926634992332820282019728792003956564819968","-57896044618658097711785492504343953926634992332820282019728792003956564819967"],"output_norm_squared_digits":155},{"exponent":256,"input":["115792089237316195423570985008687907853269984665640564039457584007913129639936","-115792089237316195423570985008687907853269984665640564039457584007913129639935","2","0"],"input_norm_squared_digits":155,"output":["1","115792089237316195423570985008687907853269984665640564039457584007913129639936","-1","115792089237316195423570985008687907853269984665640564039457584007913129639935"],"output_norm_squared_digits":155},{"exponent":256,"input":["0","115792089237316195423570985008687907853269984665640564039457584007913129639936","-1","-115792089237316195423570985008687907853269984665640564039457584007913129639936"],"input_norm_squared_digits":155,"output":["0","-1","115792089237316195423570985008687907853269984665640564039457584007913129639936","-115792089237316195423570985008687907853269984665640564039457584007913129639936"],"output_norm_squared_digits":155},{"exponent":1024,"input":["179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216","1","-179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216","0"],"input_norm_squared_digits":617,"output":["1","0","179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216","179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216"],"output_norm_squared_digits":617},{"exponent":1024,"input":["-179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216","0","0","1"],"input_norm_squared_digits":617,"output":["-89884656743115795386465259539451236680898848947115328636715040578866337902750481566354238661203768010560056939935696678829394884407208311246423715319737062188883946712432742638151109800623047059726541476042502884419075341171231440736956555270413618581675255342293149119973622969239858152417678164812112068607","-89884656743115795386465259539451236680898848947115328636715040578866337902750481566354238661203768010560056939935696678829394884407208311246423715319737062188883946712432742638151109800623047059726541476042502884419075341171231440736956555270413618581675255342293149119973622969239858152417678164812112068609","-89884656743115795386465259539451236680898848947115328636715040578866337902750481566354238661203768010560056939935696678829394884407208311246423715319737062188883946712432742638151109800623047059726541476042502884419075341171231440736956555270413618581675255342293149119973622969239858152417678164812112068608","-89884656743115795386465259539451236680898848947115328636715040578866337902750481566354238661203768010560056939935696678829394884407208311246423715319737062188883946712432742638151109800623047059726541476042502884419075341171231440736956555270413618581675255342293149119973622969239858152417678164812112068607"],"output_norm_squared_digits":617},{"exponent":1024,"input":["179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216","-179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137215","2","0"],"input_norm_squared_digits":617,"output":["1","179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216","-1","179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137215"],"output_norm_squared_digits":617},{"exponent":1024,"input":["0","179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216","-1","-179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216"],"input_norm_squared_digits":617,"output":["0","-1","179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216","-179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216"],"output_norm_squared_digits":617}],"limitations":["finite point checks are only R=5,9,11","the uniform radial proof is algebraic and uses the stated phase-score rules","no finite-period construction or global claim is inferred from the finite balls"],"matrix_identities":{"H_squared_equals_4I":true,"H_symmetric":true,"R_equals_I_minus_ssT_over_2":true},"method":"separate exact integer matrix/coordinate-pair implementation","named_odd_balls":[{"distinct_outputs":1656,"odd_inputs_checked":1656,"radius":5},{"distinct_outputs":16696,"odd_inputs_checked":16696,"radius":9},{"distinct_outputs":36704,"odd_inputs_checked":36704,"radius":11}],"pairing_check":{"central_pair_examples":15360,"half_integer_vectors_tested":65536,"tie_examples":27136},"radial_algebra_check":{"half_integer_lower_scores_checked":1000,"max_q_checked":2000},"status":"PASS"} diff --git a/research/global-bilateral-half-gaussian-rounding/review/independent/REVIEW-RECEIPT.md b/research/global-bilateral-half-gaussian-rounding/review/independent/REVIEW-RECEIPT.md new file mode 100644 index 0000000000..a180750f29 --- /dev/null +++ b/research/global-bilateral-half-gaussian-rounding/review/independent/REVIEW-RECEIPT.md @@ -0,0 +1,15 @@ +# Review receipt + +Independent review status: PASS, no counterexample found. + +The map and inverse in PROOF-CHALLENGE.md satisfy the stated odd/even +coset, parity, error, and bilateral radial conditions by the displayed +algebra. Direct integer checks additionally pass on all assigned finite +odd balls and on large explicit examples. Normal and optimized isolated +checkers emit the same receipt. + +Frozen result SHA-256: 70798b1ff53df317b2dce6c00c4cf86b78f1c716542477354a04b3c745452fc5. + +This challenge was kept separate from the finite quotient results and did +not read B's current proof. It is an independent mathematical review of +the supplied candidate, not a publication or authorship claim. diff --git a/research/global-bilateral-half-gaussian-rounding/review/independent/SOURCES.json b/research/global-bilateral-half-gaussian-rounding/review/independent/SOURCES.json new file mode 100644 index 0000000000..be03b17a6f --- /dev/null +++ b/research/global-bilateral-half-gaussian-rounding/review/independent/SOURCES.json @@ -0,0 +1,29 @@ +{ + "review_subject": { + "description": "R/M/E global parity-preserving H4/2 map supplied by the root workstream for independent challenge", + "author_credit": "Root workstream candidate; no publication claim" + }, + "mathematical_predecessors": [ + { + "pr": 6509, + "author": "Ali Romman", + "repository": "aliromman/integer-mult-bounds", + "commit": "a4173e810c4d34a1d13b9745af123ad0ec6cfed5", + "path": "research/conservative-gaussian-rounding/PROOF.md", + "git_blob": "b7047476aaa5e2bb149c92a8a40a9b2ab444ef73" + }, + { + "pr": 6619, + "author": "Nick Petalas", + "repository": "petalas/integer-mult-bounds", + "commit": "eaa967e7e8aa12cc53ec246a5fc00c5f8873a50b", + "path": "research/rational-norm-rounding/PROOF.md", + "git_blob": "ffb873b2749b1590df9267e802aea5af2c2a6eb5" + } + ], + "finite_quotient_context": { + "local_path": "../odd-parity-bilateral-half-sweep/PROOF.md", + "result_sha256": "497c020ddf7b24094e173e68cb899a313dcf5e1b8eb1deb506332296d0193432" + }, + "assistance": "Prepared with substantial OpenAI Codex assistance." +} diff --git a/research/global-bilateral-half-gaussian-rounding/review/independent/mechanism_check.py b/research/global-bilateral-half-gaussian-rounding/review/independent/mechanism_check.py new file mode 100644 index 0000000000..87b01262d6 --- /dev/null +++ b/research/global-bilateral-half-gaussian-rounding/review/independent/mechanism_check.py @@ -0,0 +1,327 @@ +#!/usr/bin/env python3 +"""Independent exact challenge of the proposed R/M/E odd-coset map.""" + +from __future__ import annotations + +import itertools +import json + + +H = ( + (1, 1, 1, 1), + (1, -1, 1, -1), + (1, 1, -1, -1), + (1, -1, -1, 1), +) +J = (1, 1, 1, -1) +S = (1, -1, -1, 1) + + +def require(condition, message): + if not condition: + raise RuntimeError(message) + + +def matvec(matrix, vector): + return tuple(sum(matrix[i][j] * vector[j] for j in range(4)) + for i in range(4)) + + +def norm_squared(vector): + return sum(value * value for value in vector) + + +def parity(vector): + return sum(vector) & 1 + + +def score2(twice_t, axis): + """Twice the invariant lower-magnitude score of this coordinate pair.""" + magnitude = abs(twice_t[axis]) + require(magnitude % 2 == 1, "coordinate is not half-integral") + if axis < 2: + return 4 * ((magnitude - 1) // 4) + 1 + if magnitude == 1: + return 0 + return 4 * ((magnitude - 3) // 4) + 3 + + +def toggle_pair(twice_t): + """The coordinate-magnitude involution M, in doubled coordinates.""" + require(len(twice_t) == 4 and all(value % 2 for value in twice_t), + "M requires four half-integer coordinates") + axis = min(range(4), key=lambda i: (score2(twice_t, i), i)) + result = list(twice_t) + magnitude = abs(result[axis]) + if axis >= 2 and magnitude == 1: + result[axis] = -result[axis] + else: + low = score2(twice_t, axis) + high = low + 2 + require(magnitude in (low, high), "coordinate is outside its pair") + sign = 1 if result[axis] > 0 else -1 + result[axis] = sign * (high if magnitude == low else low) + return tuple(result) + + +def odd_map(x): + """F(x)=E M R x for odd x; all arithmetic is integer exact.""" + require(parity(x) == 1, "odd map requires odd-total-parity input") + dot = sum(S[i] * x[i] for i in range(4)) + require(dot % 2 == 1, "s dot x must be odd") + twice_t = tuple(2 * x[i] - dot * S[i] for i in range(4)) + require(all(value % 2 for value in twice_t), + "R must produce four half-integer coordinates") + require((sum(twice_t) // 2) % 2 == 1, + "R must produce odd coordinate sum") + twice_m = toggle_pair(twice_t) + require((sum(twice_m) // 2) % 2 == 0, + "M must flip odd coordinate sum to even") + hjm = matvec(H, twice_m) + require(all(value % 4 == 0 for value in hjm), + "E must produce an integer output") + y = tuple(J[i] * (hjm[i] // 4) for i in range(4)) + require(parity(y) == 1, "E must produce odd-total-parity output") + return y + + +def odd_inverse(y): + """F^{-1}(y)=R M E^{-1} y for odd y.""" + require(parity(y) == 1, "odd inverse requires odd output") + jy = tuple(J[i] * y[i] for i in range(4)) + twice_t = matvec(H, jy) # t=UJy, represented as 2t. + require(all(value % 2 for value in twice_t), + "E inverse must produce half-integers") + require((sum(twice_t) // 2) % 2 == 0, + "E inverse must produce even-sum half-integers") + twice_m = toggle_pair(twice_t) + require((sum(twice_m) // 2) % 2 == 1, + "M inverse step must return to odd-sum half-integers") + dot = sum(S[i] * twice_m[i] for i in range(4)) + numerator = tuple(2 * twice_m[i] - dot * S[i] for i in range(4)) + require(all(value % 4 == 0 for value in numerator), + "R must return integer coordinates") + x = tuple(value // 4 for value in numerator) + require(parity(x) == 1, "odd inverse must return odd input") + return x + + +def even_map(x): + require(parity(x) == 0, "even map requires even-total-parity input") + hx = matvec(H, x) + require(all(value % 2 == 0 for value in hx), + "even input must have integral U image") + y = tuple(value // 2 for value in hx) + require(parity(y) == 0, "exact U must preserve even total parity") + return y + + +def even_inverse(y): + require(parity(y) == 0, "even inverse requires even output") + hy = matvec(H, y) + require(all(value % 2 == 0 for value in hy), + "even output must have integral U inverse") + return tuple(value // 2 for value in hy) + + +def full_map(x): + return even_map(x) if parity(x) == 0 else odd_map(x) + + +def full_inverse(y): + return even_inverse(y) if parity(y) == 0 else odd_inverse(y) + + +def half_slack_exact(m, n): + d = 4 * m + 4 * n - 1 + return d <= 0 or d * d <= 64 * m * n + + +def check_matrix_identities(): + h2 = tuple( + tuple(sum(H[i][k] * H[k][j] for k in range(4)) for j in range(4)) + for i in range(4) + ) + require(h2 == tuple(tuple(4 if i == j else 0 for j in range(4)) + for i in range(4)), "H^2 != 4I") + # Directly check U J U = I - ss^T/2 after clearing denominators. + for i in range(4): + for j in range(4): + numerator = sum(H[i][k] * J[k] * H[k][j] for k in range(4)) + expected = 4 * (1 if i == j else 0) - 2 * S[i] * S[j] + require(numerator == expected, "R=UJU reflection formula fails") + return { + "H_symmetric": all(H[i][j] == H[j][i] + for i in range(4) for j in range(4)), + "H_squared_equals_4I": True, + "R_equals_I_minus_ssT_over_2": True, + } + + +def check_pair_involution(): + values = tuple(range(-15, 16, 2)) + tested = 0 + tie_examples = 0 + central_examples = 0 + for point in itertools.product(values, repeat=4): + moved = toggle_pair(point) + require(toggle_pair(moved) == point, "M is not an involution") + differences = [moved[i] - point[i] for i in range(4)] + require(sum(value != 0 for value in differences) == 1 + and all(value == 0 or abs(value) == 2 for value in differences), + "M must toggle exactly one coordinate by one") + require(abs(sum(point) - sum(moved)) == 2, + "M must change coordinate sum by exactly one") + require((sum(point) // 2) % 2 != (sum(moved) // 2) % 2, + "M must flip integer sum parity") + scores = [score2(point, i) for i in range(4)] + selected = min(range(4), key=lambda i: (scores[i], i)) + after_scores = [score2(moved, i) for i in range(4)] + require(scores == after_scores, "pair scores changed under M") + require(selected == min(range(4), key=lambda i: (after_scores[i], i)), + "tie-broken selected coordinate changed") + tie_examples += len(set(scores)) < 4 + central_examples += scores[selected] == 0 + tested += 1 + return { + "half_integer_vectors_tested": tested, + "tie_examples": tie_examples, + "central_pair_examples": central_examples, + } + + +def check_point(x): + y = full_map(x) + back = full_inverse(y) + require(back == x, f"inverse fails for {x} -> {y} -> {back}") + require(parity(y) == parity(x), "full map fails parity preservation") + if parity(x) == 0: + hx = matvec(H, x) + error2_numerators = tuple(2 * y[i] - hx[i] for i in range(4)) + require(error2_numerators == (0, 0, 0, 0), + "even map is not exact U") + require(norm_squared(y) == norm_squared(x), + "even map changes norm") + return y + + hx = matvec(H, x) + error2_numerators = tuple(2 * y[i] - hx[i] for i in range(4)) + require(all(abs(value) == 1 for value in error2_numerators), + "odd map output is not one of the 16 nearest corners") + require(sum(value * value for value in error2_numerators) == 4, + "odd map error is not exactly one") + m = norm_squared(y) + n = norm_squared(x) + require(half_slack_exact(m, n), + f"bilateral radial half-slack fails for {x}: m={m}, n={n}") + return y + + +def odd_points_in_ball(radius): + for x in itertools.product(range(-radius, radius + 1), repeat=4): + if parity(x) == 1 and norm_squared(x) <= radius * radius: + yield x + + +def check_named_balls(): + results = [] + for radius in (5, 9, 11): + seen = set() + count = 0 + for x in odd_points_in_ball(radius): + y = check_point(x) + require(y not in seen, f"finite map collision at R={radius}: {y}") + seen.add(y) + count += 1 + results.append({"radius": radius, "odd_inputs_checked": count, + "distinct_outputs": len(seen)}) + return results + + +def check_large_inputs(): + cases = [] + for exponent in (0, 1, 2, 10, 64, 256, 1024): + n = 1 << exponent + second = (-n, 0, 0, 1) if exponent else (-1, 0, 0, 0) + for x in ( + (n, 1, -n, 0), + second, + (n, -n + 1, 2, 0), + (0, n, -1, -n), + ): + require(parity(x) == 1, "large test vector is not odd") + y = check_point(x) + require(full_inverse(y) == x, "large explicit inverse failed") + cases.append({ + "exponent": exponent, + "input": [str(value) for value in x], + "output": [str(value) for value in y], + "input_norm_squared_digits": len(str(norm_squared(x))), + "output_norm_squared_digits": len(str(norm_squared(y))), + }) + return cases + + +def check_even_examples(): + cases = [] + for exponent in (0, 1, 64, 1024): + n = 1 << exponent + for x in ((n, -n, 0, 0), (n, n, 0, 0)): + y = even_map(x) + require(even_inverse(y) == x, "even exact-U inverse failed") + require(norm_squared(y) == norm_squared(x), + "even exact-U map changed norm") + cases.append({ + "exponent": exponent, + "input": [str(value) for value in x], + "output": [str(value) for value in y], + }) + return cases + + +def check_exact_radial_bound_algebra(): + # The symbolic proof uses q=2a+1 and r^2 >= q^2+1. + checks = [] + for twice_a in range(1, 2001, 2): + # a is a positive half-integer; q=2a+1 is integer. + q = twice_a + 1 + lower_norm_squared = twice_a * twice_a + 2 * twice_a + 2 + # With a=twice_a/2, this is 4a^2+4a+2 = q^2+1. + require(lower_norm_squared == q * q + 1, + "radial lower endpoint identity fails") + high_norm_squared = lower_norm_squared + q + # Both endpoint radii exceed q, so q/(r+r') < 1/2 exactly. + require(lower_norm_squared > q * q and high_norm_squared > q * q, + "radial denominator is not strictly greater than 2q") + checks.append(q) + return {"half_integer_lower_scores_checked": len(checks), + "max_q_checked": max(checks)} + + +def main(): + matrix = check_matrix_identities() + pairing = check_pair_involution() + balls = check_named_balls() + large = check_large_inputs() + even = check_even_examples() + radial = check_exact_radial_bound_algebra() + print(json.dumps({ + "status": "PASS", + "method": "separate exact integer matrix/coordinate-pair implementation", + "matrix_identities": matrix, + "pairing_check": pairing, + "named_odd_balls": balls, + "large_round_trip_examples": large, + "even_exact_round_trip_examples": even, + "large_exponents": [0, 1, 2, 10, 64, 256, 1024], + "radial_algebra_check": radial, + "limitations": [ + "finite point checks are only R=5,9,11", + "the uniform radial proof is algebraic and uses the stated phase-score rules", + "no finite-period construction or global claim is inferred from the finite balls", + ], + }, sort_keys=True, separators=(",", ":"))) + + +if __name__ == "__main__": + main() diff --git a/research/global-bilateral-half-gaussian-rounding/review/root/GAUSSIAN-INTERFACE-RESULT.json b/research/global-bilateral-half-gaussian-rounding/review/root/GAUSSIAN-INTERFACE-RESULT.json new file mode 100644 index 0000000000..123ef80318 --- /dev/null +++ b/research/global-bilateral-half-gaussian-rounding/review/root/GAUSSIAN-INTERFACE-RESULT.json @@ -0,0 +1,76 @@ +{ + "status": "PASS_ROOT_GAUSSIAN_TRANSFER_AND_NONINHERITANCE", + "input_cases": 2401, + "source_sha256": "3f1349d2e88e90aea9e133bd91421e91ccbab9bcb078253ab0faed8a9581982b", + "controls": { + "complex_sum": { + "x": [ + 0, + 0, + 2, + 1 + ], + "output": [ + 2, + -1, + 1, + 1 + ] + }, + "global_i_phase": { + "x": [ + -2, + -2, + -2, + -1 + ], + "F(ix)": [ + 2, + -1, + 2, + -2 + ], + "iF(x)": [ + 1, + -2, + 2, + -2 + ] + }, + "conjugated_positive_not_inverse": { + "x": [ + -2, + -2, + -2, + -1 + ], + "conjugate": [ + -2, + -2, + -1, + -2 + ], + "inverse": [ + -2, + -1, + -2, + -2 + ] + }, + "fourth_power": { + "x": [ + -2, + -1, + -2, + 2 + ], + "output": [ + -3, + 1, + -1, + 0 + ] + } + }, + "negative_provider": "S F_H_inverse L, not conjugated positive map" +} diff --git a/research/global-bilateral-half-gaussian-rounding/review/root/OVERLAP-METADATA.json b/research/global-bilateral-half-gaussian-rounding/review/root/OVERLAP-METADATA.json new file mode 100644 index 0000000000..48204c0fe4 --- /dev/null +++ b/research/global-bilateral-half-gaussian-rounding/review/root/OVERLAP-METADATA.json @@ -0,0 +1 @@ +[{"query":"repo:CrocSwap/integer-mult-bounds is:pull-request \"rounding\" \"1/2\"","total":258,"returned":50,"items":[{"number":7471,"title":"Prove exact affine-lattice hulls of rounded-linear programs (no κ)","state":"open","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/7471","updated_at":"2026-11-12T19:33:27Z"},{"number":7268,"title":"Reduce compact rounded-ADD residue control to linear size (no κ)","state":"open","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/7268","updated_at":"2026-11-11T13:41:44Z"},{"number":7263,"title":"Attain exact factor-one Stein bounds with at most 2r terms (no κ)","state":"open","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/7263","updated_at":"2026-11-11T13:36:05Z"},{"number":7247,"title":"Prove the exact rounded tensor-image block minimum (no κ)","state":"open","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/7247","updated_at":"2026-11-11T12:55:32Z"},{"number":7211,"title":"Lower rounded-MOVE component width to h+2ceil(rf/2)+1 (no κ)","state":"open","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/7211","updated_at":"2026-11-11T11:43:35Z"},{"number":7199,"title":"Sharpen prime-power cyclotomic gap exponents (no κ)","state":"open","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/7199","updated_at":"2026-11-11T10:21:29Z"},{"number":7195,"title":"Sharpen the composite cyclotomic precision exponent (no κ)","state":"open","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/7195","updated_at":"2026-11-11T10:17:19Z"},{"number":7180,"title":"Prove the sharp half-shift Gaussian inverse lower envelope (no κ)","state":"open","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/7180","updated_at":"2026-11-11T09:14:52Z"},{"number":7135,"title":"Prove the best-quotient staircase of the sharp net splitting tax (no κ)","state":"open","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/7135","updated_at":"2026-11-11T07:58:21Z"},{"number":6996,"title":"Research: Rounded selected MOVE","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6996","updated_at":"2026-11-10T07:02:38Z"},{"number":6977,"title":"Research: Production Reference gap","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6977","updated_at":"2026-11-10T07:02:38Z"},{"number":6989,"title":"Research: Rounded positive leaf","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6989","updated_at":"2026-11-10T07:02:38Z"},{"number":6995,"title":"Research: Original-q field extraction","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6995","updated_at":"2026-11-10T07:02:38Z"},{"number":6988,"title":"Research: Rounded scalar tables","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6988","updated_at":"2026-11-10T07:02:38Z"},{"number":6969,"title":"Research: Core/halo source bridge","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6969","updated_at":"2026-11-10T07:02:38Z"},{"number":6992,"title":"Research: Rounded global Lambda","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6992","updated_at":"2026-11-10T07:02:38Z"},{"number":6895,"title":"Verify source-level numerical recovery of normalized products (no new κ)","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6895","updated_at":"2026-11-10T07:01:00Z"},{"number":6880,"title":"Prove a rounded finite-core and sparse-halo composition bound (no new κ)","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6880","updated_at":"2026-11-10T07:01:00Z"},{"number":6899,"title":"Connect actual Core interiors to the global physical caller (no new κ)","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6899","updated_at":"2026-11-10T07:01:00Z"},{"number":6930,"title":"Record that the #6030 primary stores a width-1 MOVE phase","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6930","updated_at":"2026-11-10T07:00:59Z"},{"number":6909,"title":"Execute source-bound banded forward matrix actions on fixed tapes (no new κ)","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6909","updated_at":"2026-11-10T07:00:59Z"},{"number":6790,"title":"Prove a sharp bounded-error cutoff for acyclic decoder rows (no κ)","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6790","updated_at":"2026-11-10T06:56:01Z"},{"number":6778,"title":"Prove a sharp all-axis obstruction to Gaussian rounding tensor consistency (no new κ)","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6778","updated_at":"2026-11-10T06:55:59Z"},{"number":6758,"title":"Restore phase covariance in sharp four-axis Gaussian rounding (no new κ)","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6758","updated_at":"2026-11-10T06:55:59Z"},{"number":6801,"title":"Compute positive signed halves in linear tape time without work cells","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6801","updated_at":"2026-11-10T06:55:59Z"},{"number":6796,"title":"Prove sharp dirty-word intervals at n=2^h+1 (no κ)","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6796","updated_at":"2026-11-10T06:55:59Z"},{"number":6788,"title":"Prove the sharp inverse envelope under a column cap (no κ)","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6788","updated_at":"2026-11-10T06:55:59Z"},{"number":6789,"title":"Optimize dyadic error cuts and prove a quantitative convergence rate (no κ)","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6789","updated_at":"2026-11-10T06:55:59Z"},{"number":6829,"title":"No facet or ridge shadow of the mode zonotope obstructs R = 1: 422,224 facets, 21,589 ridge flats (no κ)","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6829","updated_at":"2026-11-10T06:55:58Z"},{"number":6848,"title":"Refined recovery: max fiber = zero fiber under an ε₀ threshold; exact depth-27 optimum (1+12ρ₂²⁵+3ρ₂²⁶)·F²⁷, 696 bits (no κ)","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6848","updated_at":"2026-11-10T06:55:58Z"},{"number":6685,"title":"Prove exact coarse-output error for a refined dirty helper (no κ)","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6685","updated_at":"2026-11-10T06:53:52Z"},{"number":6700,"title":"Emit the exact conservative Gaussian pair as a clean bit circuit (no κ)","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6700","updated_at":"2026-11-10T06:53:52Z"},{"number":6675,"title":"Locate the recursive interchange crossover length at a stated constant ratio (no κ)","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6675","updated_at":"2026-11-10T06:53:52Z"},{"number":6668,"title":"Prove all-depth attainment of 4g-3 destination channels (no κ)","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6668","updated_at":"2026-11-10T06:53:52Z"},{"number":6564,"title":"Prove the sharp rounded dyadic connector carry (no κ)","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6564","updated_at":"2026-11-10T06:47:08Z"},{"number":6571,"title":"Raise the sparse P104 correction floor from 28 to 38 ADDs (no κ)","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6571","updated_at":"2026-11-10T06:47:08Z"},{"number":6560,"title":"Compile a nilpotent chain with optimal reflection calls (no κ)","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6560","updated_at":"2026-11-10T06:47:08Z"},{"number":6561,"title":"Prove exact rounding radii for signed-permutation frame groups (no κ)","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6561","updated_at":"2026-11-10T06:47:07Z"},{"number":6602,"title":"Prove linear-order optimality for rounded inverse oracles (no κ)","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6602","updated_at":"2026-11-10T06:47:07Z"},{"number":6614,"title":"Prove sharp dyadic two-wire approximation floors (no κ)","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6614","updated_at":"2026-11-10T06:47:07Z"},{"number":6575,"title":"Prove the exact shared atom-power crossover with 24 carry states","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6575","updated_at":"2026-11-10T06:47:07Z"},{"number":6613,"title":"Prove exact monomial-reflection tariffs with dirty workspace (no κ)","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6613","updated_at":"2026-11-10T06:47:07Z"},{"number":6585,"title":"Prove exact isolation capacity for shared phase charts (no κ)","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6585","updated_at":"2026-11-10T06:47:07Z"},{"number":6576,"title":"Prove sharp ADDRESS tariff margins for every odd kernel (no κ)","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6576","updated_at":"2026-11-10T06:47:07Z"},{"number":6581,"title":"Prove even local factor degrees for ternary kernels (no κ)","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6581","updated_at":"2026-11-10T06:47:07Z"},{"number":6622,"title":"Prove sharp uniform error from transient transfer leakage (no κ)","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6622","updated_at":"2026-11-10T06:47:06Z"},{"number":6446,"title":"Prove exact lattice closure for rational rounded shears (no κ)","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6446","updated_at":"2026-11-10T06:44:11Z"},{"number":6470,"title":"Prove sharp critical-tail parity-cut bound N (no κ)","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6470","updated_at":"2026-11-10T06:44:11Z"},{"number":6480,"title":"Construct exact zero-padding return for rounded spectator rows (no new κ)","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6480","updated_at":"2026-11-10T06:44:10Z"},{"number":6514,"title":"Prove the sharp paid-moment floor for independent four-cycles.","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6514","updated_at":"2026-11-10T06:44:10Z"}]},{"query":"repo:CrocSwap/integer-mult-bounds is:pull-request \"bilateral\"","total":4,"returned":4,"items":[{"number":6126,"title":"Prove production Gaussian inverse bound 2 + 2p/u² (no new κ)","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6126","updated_at":"2026-10-28T17:36:27Z"},{"number":5566,"title":"Prove faster periodic Gaussian inversion through Beatty-run blocks","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/5566","updated_at":"2026-10-25T22:13:04Z"},{"number":4408,"title":"Answer #4356's open question: the broad forward bound stays polynomial at theta = 1/(4p^2); actual blocks sit 1e-5..1e-6 below it and scale like theta^(-1/2) (no new κ)","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/4408","updated_at":"2026-10-21T19:27:52Z"},{"number":3048,"title":"P112: exclude cost 296 in the aligned six-mode factor family","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/3048","updated_at":"2026-10-16T23:51:02Z"}]},{"query":"repo:CrocSwap/integer-mult-bounds is:pull-request \"checkerboard\"","total":4,"returned":4,"items":[{"number":7180,"title":"Prove the sharp half-shift Gaussian inverse lower envelope (no κ)","state":"open","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/7180","updated_at":"2026-11-11T09:14:52Z"},{"number":6459,"title":"Sharpen a uniform finite-cap Gaussian inverse bound (no κ)","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6459","updated_at":"2026-11-10T06:44:11Z"},{"number":5183,"title":"Prove the two-edge half-line operator limit of broad Gaussian inverses","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/5183","updated_at":"2026-10-23T13:09:36Z"},{"number":5150,"title":"Prove sharp theta order for broad Gaussian edge inverses (no κ)","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/5150","updated_at":"2026-10-23T11:56:47Z"}]},{"query":"repo:CrocSwap/integer-mult-bounds is:pull-request \"radial\"","total":3,"returned":3,"items":[{"number":6816,"title":"Prove sharp dimension growth for column-capped Euclidean resolvents (no κ)","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6816","updated_at":"2026-11-10T06:55:58Z"},{"number":6304,"title":"Sharpen reversible phase squared error from 1 to 4/5 (no κ)","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6304","updated_at":"2026-10-31T04:04:55Z"},{"number":3655,"title":"Classify H6 dyadic Smith factors and sharp physical-row repair","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/3655","updated_at":"2026-10-20T05:06:39Z"}]},{"query":"repo:CrocSwap/integer-mult-bounds is:pull-request \"outward\" \"rounding\"","total":33,"returned":33,"items":[{"number":6977,"title":"Research: Production Reference gap","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6977","updated_at":"2026-11-10T07:02:38Z"},{"number":6619,"title":"Classify reversible inward rounding of rational orthogonal maps (no κ)","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6619","updated_at":"2026-11-10T06:47:07Z"},{"number":6413,"title":"Eliminate 11,470 Gaussian setup exponential calls (no κ)","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6413","updated_at":"2026-11-10T06:41:30Z"},{"number":6438,"title":"Construct optimal unbiased reversible phase rounding (no κ)","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6438","updated_at":"2026-11-10T06:41:29Z"},{"number":5992,"title":"Certify the pooled R437 carrier moment ceiling: 0.00173678297, unreachable 17/5000 below width 28571 (no new κ)","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/5992","updated_at":"2026-11-06T21:01:50Z"},{"number":6304,"title":"Sharpen reversible phase squared error from 1 to 4/5 (no κ)","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6304","updated_at":"2026-10-31T04:04:55Z"},{"number":5396,"title":"Independently validate joint relations and conditional κ = 0.003026674765","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/5396","updated_at":"2026-10-26T01:04:29Z"},{"number":3954,"title":"research: derive P104 two-axis endpoint intertwiners and cost gate","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/3954","updated_at":"2026-10-26T01:43:19Z"},{"number":5513,"title":"Research: independently audit PR #4091's pooled duals with rational binomial bounds","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/5513","updated_at":"2026-10-25T14:17:23Z"},{"number":5428,"title":"Observation, state, and geometry: building complete suppliers for larger κ","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/5428","updated_at":"2026-10-24T17:08:03Z"},{"number":5295,"title":"Audit five-stage Tensor expansion accuracy at computed inputs","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/5295","updated_at":"2026-10-23T18:37:53Z"},{"number":5056,"title":"Audit actual Tensor expansion's signed internal contraction","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/5056","updated_at":"2026-10-23T08:19:41Z"},{"number":4756,"title":"Audit uniform raw Gaussian common-reference admission","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/4756","updated_at":"2026-10-22T19:31:50Z"},{"number":3948,"title":"Negative result: +10% centre sharing at c* ≈ 0.0018433 needs 511 net complex rank-1 units (3.55/call, not 1.33); no admitted bit lever nets any of the 649 needed (no κ)","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/3948","updated_at":"2026-10-20T05:22:43Z"},{"number":3804,"title":"Independent direct certification of the two batched moment bounds, with sharp thresholds (no new kappa)","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/3804","updated_at":"2026-10-20T05:20:12Z"},{"number":3724,"title":"Independent verification (no κ): arithmetic layer of PR3562's ordinary-rate theorem holds; line-158 exposition gap, 4283584 stands","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/3724","updated_at":"2026-10-20T05:06:38Z"},{"number":1677,"title":"Conditional κ = 0.0016768966690212993077...159193: pivot-566 kernel with 470-digit grid and 450-digit endpoints over PR1661","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/1677","updated_at":"2026-10-16T14:06:50Z"},{"number":1661,"title":"Conditional κ = 0.0016768966690212993077...99432: pivot-566 kernel with 400-digit grid refinement over PR1644","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/1661","updated_at":"2026-10-16T14:06:50Z"},{"number":1485,"title":"Conditional κ 0.00167685522907132188620645677227459261951244873951047526280336519105115665521200964951578469164138454299292754381039421745513966674764384056: verified outer140 witness refinement, unchanged construction","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/1485","updated_at":"2026-10-16T13:45:38Z"},{"number":1186,"title":"Tooling: exact frame solver and delivery-rewrite search for gauge44/k8 local words (no new κ)","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/1186","updated_at":"2026-10-16T13:45:38Z"},{"number":1337,"title":"Scoped negative result: no further helper-donor kernels or exact read re-timings on the #1297/#1305/#1324 words (no new kappa)","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/1337","updated_at":"2026-10-16T13:35:39Z"},{"number":2917,"title":"Conditional κ ≈ 0.001721588647: nine additional paired helper extractions","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/2917","updated_at":"2026-10-16T13:35:38Z"},{"number":2552,"title":"Speed exact ceiling replay with integer Taylor arithmetic","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/2552","updated_at":"2026-10-16T01:14:47Z"},{"number":1724,"title":"Conditional κ = 0.0016769381110224387711...: stacked pivot 566 + 554 kernels with 600-digit grid and 600-digit endpoints over PR1692","state":"open","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/1724","updated_at":"2026-10-14T15:59:32Z"},{"number":1692,"title":"Conditional κ = 0.0016769381110224387711...: stacked pivot 566 + 554 kernels with 470-digit grid and 450-digit endpoints over PR1672","state":"open","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/1692","updated_at":"2026-10-14T15:58:23Z"},{"number":892,"title":"Research: rank-eight coded-helper endpoint and complete mixed-cost obstruction (no new kappa)","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/892","updated_at":"2026-10-14T05:04:33Z"},{"number":672,"title":"Tooling: exact integer exponential intervals with pinned replay evidence","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/672","updated_at":"2026-10-14T04:06:37Z"},{"number":1519,"title":"Audit: PR1479/PR1485 fine Mercator engine returns false lower log bounds (no kappa change)","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/1519","updated_at":"2026-10-14T02:17:35Z"},{"number":1069,"title":"Independent verification: code-disjoint pricing of all 16 pending kappa claims; every one has deficit W - 64N (no new kappa)","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/1069","updated_at":"2026-10-13T19:00:26Z"},{"number":1052,"title":"Independent verification: T37 positive-binomial moments, all-T lemma, and 1024-bit reduction (seed 78, no new kappa)","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/1052","updated_at":"2026-10-13T18:47:08Z"},{"number":960,"title":"Independent verification: PR890 T21 moment brackets via binomial enclosures","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/960","updated_at":"2026-10-13T15:39:43Z"},{"number":605,"title":"[Lean] Prove the pinned PR588 native Real moment bound","state":"open","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/605","updated_at":"2026-10-12T17:50:45Z"},{"number":585,"title":"[Lean] Verify selected rational certificate arithmetic","state":"open","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/585","updated_at":"2026-10-12T12:18:34Z"}]},{"query":"repo:CrocSwap/integer-mult-bounds is:pull-request \"norm\" \"bijection\"","total":6,"returned":6,"items":[{"number":6755,"title":"Review four-axis certificate and inverse kernel","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6755","updated_at":"2026-11-10T06:55:59Z"},{"number":6619,"title":"Classify reversible inward rounding of rational orthogonal maps (no κ)","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6619","updated_at":"2026-11-10T06:47:07Z"},{"number":6438,"title":"Construct optimal unbiased reversible phase rounding (no κ)","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6438","updated_at":"2026-11-10T06:41:29Z"},{"number":5912,"title":"Prove exact nearest-even shear history from binary code weight","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/5912","updated_at":"2026-10-27T13:41:52Z"},{"number":4113,"title":"Review the common-map tensor-pairing bound independently.","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/4113","updated_at":"2026-10-20T05:28:21Z"},{"number":496,"title":"Conditional κ = 0.001332077359286333: pooled whole-owner complex supply","state":"open","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/496","updated_at":"2026-10-11T20:57:04Z"}]},{"query":"repo:CrocSwap/integer-mult-bounds is:pull-request \"nonperiodic\"","total":2,"returned":2,"items":[{"number":6761,"title":"Prove the four-axis exact-square period obstruction (no new κ)","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/6761","updated_at":"2026-11-10T06:55:59Z"},{"number":5998,"title":"Prove a sharp obstruction for every two-grid precision selector (no κ)","state":"closed","url":"https://github.com/CrocSwap/integer-mult-bounds/pull/5998","updated_at":"2026-10-28T00:24:32Z"}]}] diff --git a/research/global-bilateral-half-gaussian-rounding/review/root/RESULT.json b/research/global-bilateral-half-gaussian-rounding/review/root/RESULT.json new file mode 100644 index 0000000000..b3cc9c81d6 --- /dev/null +++ b/research/global-bilateral-half-gaussian-rounding/review/root/RESULT.json @@ -0,0 +1,22 @@ +{ + "status": "PASS_ROOT_GLOBAL_HALF_GRID_CANDIDATE", + "half_grid_box_cases": 38416, + "integer_cube_cases": 28561, + "distinct_images": 28561, + "large_integer_cases": 120, + "max_decimal_digits": 400, + "seed": 20261113, + "directional_sequence_parameters": [ + "0", + "1", + "2", + "7", + "100", + "10000000000", + "100000000000000000000000000000000000000000000000000", + "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "exact_controls": 3, + "scope": "finite exact corroboration of separately stated universal pairing/coset/norm proof, not a proof by finite search", + "no_author_code_imported": true +} diff --git a/research/global-bilateral-half-gaussian-rounding/review/root/check_gaussian_interfaces.py b/research/global-bilateral-half-gaussian-rounding/review/root/check_gaussian_interfaces.py new file mode 100644 index 0000000000..eba26791c8 --- /dev/null +++ b/research/global-bilateral-half-gaussian-rounding/review/root/check_gaussian_interfaces.py @@ -0,0 +1,47 @@ +"""Independent transfer and explicit non-inheritance controls for the global map.""" +from pathlib import Path +from types import ModuleType +from itertools import product +import hashlib,json +SOURCE=Path(__file__).with_name('check_global_candidate.py') +M=ModuleType('root_global_matching');M.__file__=str(SOURCE) +exec(compile(SOURCE.read_bytes(),str(SOURCE),'exec'),M.__dict__) +C2=((1,-1,1,1),(1,1,-1,1),(1,1,1,-1),(-1,1,1,1)) +def S(x):return(x[0],-x[1],x[2],x[3]) +def L(x):return(x[0],x[2],-x[3],x[1]) +def Li(x):return(x[0],x[3],x[1],-x[2]) +def Fc(x):return Li(M.F(S(x))) +def Fc_inv(x):return S(M.inv(L(x))) +def phase(x):return(-x[1],x[0],-x[3],x[2]) +def K(x):return(x[0],-x[1],x[2],-x[3]) +def cminus2(x):return K(M.mul(C2,K(x))) +def fourth(x): + for _ in range(4):x=Fc(x) + return x + +def main(): + for i in range(4): + x=tuple(int(j==i) for j in range(4)) + M.need(L(M.mul(C2,S(x)))==M.mul(M.H,x),'exact signed transfer') + M.need(cminus2(M.mul(C2,x))==tuple(4*a for a in x),'ideal negative is inverse') + for x in product(range(-3,4),repeat=4): + y=Fc(x);z=Fc_inv(x) + M.need(Fc_inv(y)==x and Fc(z)==x,'Gaussian exact inverse') + for a,b in [(y,M.mul(C2,x)),(z,cminus2(x))]: + M.need(sum((2*c-d)**2 for c,d in zip(a,b))<=4,'both ideal errors') + M.need(M.radial_half(M.n2(a),M.n2(x)),'both radial allowances') + controls={} + x=(0,0,2,1);y=Fc(x) + M.need(y==(2,-1,1,1) and (y[0]+y[2],y[1]+y[3])!=(x[0]+x[2],x[1]+x[3]),'sum noninheritance') + controls['complex_sum']={'x':x,'output':y} + x=(-2,-2,-2,-1);a=Fc(phase(x));b=phase(Fc(x)) + M.need(a==(2,-1,2,-2) and b==(1,-2,2,-2) and a!=b,'phase noninheritance') + controls['global_i_phase']={'x':x,'F(ix)':a,'iF(x)':b} + a=K(Fc(K(x)));b=Fc_inv(x) + M.need(a==(-2,-2,-1,-2) and b==(-2,-1,-2,-2) and a!=b,'conjugation not inverse') + controls['conjugated_positive_not_inverse']={'x':x,'conjugate':a,'inverse':b} + x=(-2,-1,-2,2);a=fourth(x) + M.need(a==(-3,1,-1,0) and a!=x,'fourth power noninheritance') + controls['fourth_power']={'x':x,'output':a} + print(json.dumps({'status':'PASS_ROOT_GAUSSIAN_TRANSFER_AND_NONINHERITANCE','input_cases':7**4,'source_sha256':hashlib.sha256(SOURCE.read_bytes()).hexdigest(),'controls':controls,'negative_provider':'S F_H_inverse L, not conjugated positive map'},indent=2)) +if __name__=='__main__':main() diff --git a/research/global-bilateral-half-gaussian-rounding/review/root/check_global_candidate.py b/research/global-bilateral-half-gaussian-rounding/review/root/check_global_candidate.py new file mode 100644 index 0000000000..911e5c5a02 --- /dev/null +++ b/research/global-bilateral-half-gaussian-rounding/review/root/check_global_candidate.py @@ -0,0 +1,76 @@ +"""Root independent integer implementation of the alternating-pair radial matching.""" +from itertools import product +from functools import lru_cache +from collections import Counter +from math import isqrt +import json,random +H=((1,1,1,1),(1,-1,1,-1),(1,1,-1,-1),(1,-1,-1,1));s=(1,-1,-1,1) +def need(ok,msg): + if not ok:raise ValueError(msg) +def mul(A,x):return tuple(sum(a*b for a,b in zip(row,x)) for row in A) +def n2(x):return sum(a*a for a in x) +def paired(q,phase): + need(q%2==1,'odd doubled coordinate') + a=abs(q);sign=1 if q>0 else -1 + if phase==1 and a==1:return 0,-q + base=a-(0 if a%4==(1 if phase==0 else 3) else 2) + need(base>0,'positive noncentral base') + return base,sign*(base+2 if a==base else base) +def match(q,phases=(0,0,1,1),bad_choice=False): + ps=[paired(a,b) for a,b in zip(q,phases)] + i=min(range(4),key=lambda i:(abs(q[i]) if bad_choice else ps[i][0],i)) + y=list(q);y[i]=ps[i][1] + return tuple(y) +def F(x): + hx=mul(H,x) + if sum(x)%2==0: + need(all(a%2==0 for a in hx),'even exact integrality');return tuple(a//2 for a in hx) + dot=sum(a*b for a,b in zip(s,x));q=tuple(2*a-dot*b for a,b in zip(x,s)) + q=match(q);hq=mul(H,q) + need(all(a%4==0 for a in hq),'forward odd integrality') + return tuple((1 if i!=3 else -1)*a//4 for i,a in enumerate(hq)) +def inv(y): + if sum(y)%2==0:return tuple(a//2 for a in mul(H,y)) + jy=tuple((1 if i!=3 else -1)*a for i,a in enumerate(y));q=match(mul(H,jy));dot=sum(a*b for a,b in zip(s,q));num=tuple(2*a-dot*b for a,b in zip(q,s)) + need(all(a%4==0 for a in num),'inverse odd integrality');return tuple(a//4 for a in num) +def radial_half(m,n): + d=4*m+4*n-1;return d<=0 or d*d<=64*m*n +def check_point(x): + y=F(x);need(inv(y)==x and F(inv(x))==x,'two-sided inverse') + need(sum(x)%2==sum(y)%2,'parity') + hx=mul(H,x);err=sum((2*a-b)**2 for a,b in zip(y,hx)) + need(err==(4 if sum(x)%2 else 0),'sharp error') + need(radial_half(n2(y),n2(x)),'bilateral half radial bound') + return y + +def main(): + half_count=0 + for q in product(range(-13,14,2),repeat=4): + z=match(q);need(match(z)==q,'pair involution');need(sum((a-b)**2 for a,b in zip(q,z))==4,'one coordinate step') + need((sum(q)-sum(z))%4==2,'checkerboard swap') + # Scaling by two: norm difference<=1 is equivalent to |sqrt(n2q)-sqrt(n2z)|<=1. + a,b=n2(q),n2(z);d=a+b-1;need(d<=0 or d*d<=4*a*b,'half-grid radial bound') + half_count+=1 + count=0;images=set() + for x in product(range(-6,7),repeat=4): + images.add(check_point(x));count+=1 + need(len(images)==count,'finite collision control') + rng=random.Random(20261113);large=[] + for digits in [1,2,10,40,100,400]: + for j in range(20): + limit=10**digits; x=tuple(rng.randrange(-limit,limit+1) for _ in range(4));check_point(x);large.append(digits) + families=[] + for k in [0,1,2,7,100,10**10,10**50,10**100]: + xo=(0,0,4*k+2,1);yo=(2*k+2,2*k+1,-2*k-1,-2*k-1) + xi=(2*k+1,2*k+1,2*k+2,2*k+1);yi=(4*k+2,0,-1,0) + need(F(xo)==yo and F(xi)==yi,'attaining directional sequences') + lo=16*k*k+16*k+5;hi=16*k*k+20*k+7 + need((n2(xo),n2(yo),n2(xi),n2(yi))==(lo,hi,hi,lo),'sequence norm polynomials') + need(radial_half(lo,hi),'family half bound');families.append(str(k)) + # Meaningful design controls: one phase and an unbalanced phase split violate the bound. + for q,phases in [((1,1,1,1),(0,0,0,0)),((5,3,3,3),(0,1,1,1))]: + z=match(q,phases);a,b=n2(q),n2(z);d=a+b-1 + need(d>0 and d*d>4*a*b,'bad phase split must violate bound') + q=(1,1,3,3);need(match(match(q,bad_choice=True),bad_choice=True)!=q,'current magnitude tie rule must fail inversion') + print(json.dumps({'status':'PASS_ROOT_GLOBAL_HALF_GRID_CANDIDATE','half_grid_box_cases':half_count,'integer_cube_cases':count,'distinct_images':len(images),'large_integer_cases':len(large),'max_decimal_digits':400,'seed':20261113,'directional_sequence_parameters':families,'exact_controls':3,'scope':'finite exact corroboration of separately stated universal pairing/coset/norm proof, not a proof by finite search','no_author_code_imported':True},indent=2)) +if __name__=='__main__':main() diff --git a/research/global-bilateral-half-gaussian-rounding/verify.py b/research/global-bilateral-half-gaussian-rounding/verify.py new file mode 100644 index 0000000000..4d580ec45b --- /dev/null +++ b/research/global-bilateral-half-gaussian-rounding/verify.py @@ -0,0 +1,60 @@ +"""Check the public kernel against separately written code and exact obligations.""" +from pathlib import Path +from types import ModuleType +from itertools import product +import hashlib,json,random,io,contextlib +ROOT=Path(__file__).resolve().parent + +def load_source(name,path): + module=ModuleType(name);module.__file__=str(path) + exec(compile(path.read_bytes(),str(path),'exec'),module.__dict__) + return module +K=load_source('public_kernel',ROOT/'kernel.py') +O=load_source('independent_root_oracle',ROOT/'review/root/check_global_candidate.py') +G=load_source('independent_gaussian_oracle',ROOT/'review/root/check_gaussian_interfaces.py') + +def need(condition,message): + if not condition:raise ValueError(message) + +def one(x): + y=K.hadamard_forward(x);z=K.hadamard_inverse(x) + need(y==O.F(x) and z==O.inv(x),'Hadamard implementation agreement') + need(K.hadamard_inverse(y)==x and K.hadamard_forward(z)==x,'two inverse compositions') + need(sum(x)%2==sum(y)%2,'total parity') + target=O.mul(O.H,x) + need(sum((2*a-b)**2 for a,b in zip(y,target))==(4 if sum(x)%2 else 0),'unit/zero error') + need(O.radial_half(O.n2(y),O.n2(x)),'half radial allowance') + a=K.gaussian_forward(x);b=K.gaussian_inverse(x) + need(a==G.Fc(x) and b==G.Fc_inv(x),'Gaussian implementation agreement') + need(K.gaussian_inverse(a)==x and K.gaussian_forward(b)==x,'Gaussian exact inverse') + +def main(): + origin=json.loads((ROOT/'KERNEL-ORIGIN.json').read_text());source=(ROOT/origin['source']).read_bytes() + need(hashlib.sha256(source).hexdigest()==origin['source_sha256'],'reference source hash') + prefix=source[:origin['copied_prefix_bytes']] + need(hashlib.sha256(prefix).hexdigest()==origin['copied_prefix_sha256'],'copied prefix hash') + need(prefix in (ROOT/'kernel.py').read_bytes(),'exact reference arithmetic prefix') + count=0 + for x in product(range(-4,5),repeat=4):one(x);count+=1 + rng=random.Random(20261113);large=0 + for bits in [1,8,64,256,1024,4096]: + for _ in range(10): + x=tuple((1 if rng.randrange(2) else -1)*rng.getrandbits(bits) for _ in range(4)) + one(x);large+=1 + for k in [0,1,2,7,100,10**10,10**50,10**100]: + xo=(0,0,4*k+2,1);yo=(2*k+2,2*k+1,-2*k-1,-2*k-1) + xi=(2*k+1,2*k+1,2*k+2,2*k+1);yi=(4*k+2,0,-1,0) + need(K.hadamard_forward(xo)==yo and K.hadamard_forward(xi)==yi,'sharp directional families') + bad=[(),(1,2,3),(1,2,3,4,5),(True,0,0,0),(0.5,0,0,0),('1',0,0,0),None] + rejected=0 + for value in bad: + for fn in [K.hadamard_forward,K.hadamard_inverse,K.gaussian_forward,K.gaussian_inverse]: + try:fn(value) + except (TypeError,ValueError):rejected+=1 + else:raise ValueError('malformed public input accepted') + # These controls separately prove that four source-native identities are not inherited. + buffer=io.StringIO() + with contextlib.redirect_stdout(buffer):G.main() + interface_check=json.loads(buffer.getvalue()) + print(json.dumps({'status':'PASS_GLOBAL_HALF_KERNEL','cube_cases':count,'large_cases':large,'max_bits':4096,'seed':20261113,'invalid_inputs_rejected':rejected,'interface_check':interface_check,'sharp_sequence_parameters':8,'kernel_sha256':hashlib.sha256((ROOT/'kernel.py').read_bytes()).hexdigest(),'independence':'public arithmetic extracted from C reviewer; compared with separately written root arithmetic and Gaussian transfer; shared proposed formulas disclosed','scope':'finite cross-implementation checks; all-input theorem rests on the written proof'},indent=2)) +if __name__=='__main__':main()