From 0f513f4681a56859957ce039d4e802c1305c8c1b Mon Sep 17 00:00:00 2001 From: Alan Grillo <290989452+bg-grillo-alan@users.noreply.github.com> Date: Tue, 13 Oct 2026 13:22:08 +0200 Subject: [PATCH 1/2] Research audit: tighten Gaussian correction endpoint potential --- .../CLAIM.md | 13 + .../README.md | 204 ++++++++++++++ .../RESULT.json | 61 +++++ .../SOURCES.json | 27 ++ .../VALIDATION.md | 63 +++++ .../test_verify.py | 122 +++++++++ .../verify.py | 253 ++++++++++++++++++ 7 files changed, 743 insertions(+) create mode 100644 research/gaussian-endpoint-potential-audit/CLAIM.md create mode 100644 research/gaussian-endpoint-potential-audit/README.md create mode 100644 research/gaussian-endpoint-potential-audit/RESULT.json create mode 100644 research/gaussian-endpoint-potential-audit/SOURCES.json create mode 100644 research/gaussian-endpoint-potential-audit/VALIDATION.md create mode 100644 research/gaussian-endpoint-potential-audit/test_verify.py create mode 100644 research/gaussian-endpoint-potential-audit/verify.py diff --git a/research/gaussian-endpoint-potential-audit/CLAIM.md b/research/gaussian-endpoint-potential-audit/CLAIM.md new file mode 100644 index 0000000000..9d7e6f005e --- /dev/null +++ b/research/gaussian-endpoint-potential-audit/CLAIM.md @@ -0,0 +1,13 @@ +# Local sprint claim + +- Track: adversarial mathematical audit; OS-random seed: 62 (cryptographic byte rejection at 200, then modulo 100). +- Base: f567884aeb8851b6e794af1184119a3bfbe1e631. +- Object: notes/fast-gaussian-resampling.tex, lem:correction-powers; retain the correlated endpoint squares in the existing potential argument. +- Hypothesis: combining the endpoint terms gives beta_end^2/theta - beta_start^2/theta, reducing the exponential prefactor; derive certified residual counts without confusing a power residual with the inverse tail. +- Method: written universal algebra; exact rational path enumeration, a separate integer-scaled oracle, rational constant bounds and adversarial sign/tie/carry controls. Seed 62 fixes supplemental path samples. +- Deliverable: one scoped proof/audit package with a deterministic certificate and offline verification command. No new kappa; no selected-frontier change. +- Expected finish: 2026-10-13 12:00 UTC (14:00 Europe/Paris). +- Three candidates considered: packed-bit exceptional repair (already addressed by #735/#763/#773); signed coefficient extraction (already addressed by #690/#693); Gaussian correction-power endpoint accounting (chosen). +- Overlap: current open PR titles through #898; targeted all-state searches for selected-bit, signed packing, resampling, Neumann and correction powers. #5 supplies the original potential; #684 audits chirp windows and explicitly excludes Neumann evaluation. No duplicate endpoint-power refinement found in these searches. This is a bounded metadata inspection, not an exhaustive review of every PR's source. +- Coordination: the open-issue query returned only #650, a request to enable Discussions, not a pinned sprint issue. Claim recorded locally; no reservation issue opened. +- Budget: scope now frozen; reserve the final quarter of implementation/verification effort for adversarial checks and handoff. diff --git a/research/gaussian-endpoint-potential-audit/README.md b/research/gaussian-endpoint-potential-audit/README.md new file mode 100644 index 0000000000..d6db18c054 --- /dev/null +++ b/research/gaussian-endpoint-potential-audit/README.md @@ -0,0 +1,204 @@ +# Gaussian correction powers: keep the endpoint squares together + +**Research audit / analytic refinement; no new kappa.** The existing +`lem:correction-powers` in `notes/fast-gaussian-resampling.tex` is valid but +separately bounds two correlated endpoint terms. Keeping them together gives + +\[ + \|E^n\|_\infty\le + \exp\left(\frac{\pi\alpha^2}{\theta} + \frac{\lfloor s/2\rfloor^2}{s^2}\right) + \left(\sum_{h\ne0}e^{-\pi\alpha^2\sigma h^2}\right)^n + <\exp\left(\frac{\pi\alpha^2}{\theta} + \frac{\lfloor s/2\rfloor^2}{s^2}\right) + (2.01e^{-\pi\alpha^2\sigma})^n. +\] + +Here `2 <= s < t` are coprime integers, `sigma=t/s`, `theta=sigma-1`, +`alpha >= 2`, and `n >= 1`. The old exponential prefactor uses +`1/(4 theta) + 1/2`; the new one uses at most `1/(4 theta)`, and less +when `s` is odd. This is a deduction from eumemic's existing potential, +not a new Gaussian algorithm. There is no contradiction to the old bound. +No optimality of the new prefactor or truncation count is claimed. + +## Precise object and proof + +Use the correction operator from the pinned note, on `s`-periodic vectors: + +\[ + (Eu)_j=\sum_{h\in\mathbb Z\setminus\{0\}} + e^{-A X_{j,h}}u_{j+h},\quad + A=\pi\alpha^2,\quad + X_{j,h}=(\sigma h+\beta_j)^2-\beta_{j+h}^2, +\] + +where `q_j=floor(tj/s+1/2)` and `beta_j=tj/s-q_j` for every integer `j`. +Thus `-1/2 <= beta_j < 1/2`; ties round upward. In particular **nonzero +multiples of s remain in the sum**, even though they address the same +coordinate. Periodicity is not a reason to discard them. + +Put `y=beta_j+theta h` and `w=q_(j+h)-q_j-h`. Then `w` is integral and +`beta_(j+h)=y-w`. Direct expansion gives the sharper one-step identity + +\[ + X_{j,h}=\sigma h^2+ + \frac{\beta_{j+h}^2-\beta_j^2}{\theta} + +\frac{\sigma}{\theta}w(2y-w). \tag{1} +\] + +The last term is nonnegative: writing `z=y-w` gives +`w(2y-w)=w^2+2wz >= w^2-|w| >= 0`. This uses only `theta>0`, +not `theta<1`. Equivalently, in the predecessor's proof combine +`Phi(end)-Phi(start)` with `beta_start^2-beta_end^2` **before** bounding +them: since `sigma/theta-1=1/theta`, their sum is exactly the middle +term in (1). + +For a path `j_i=j_(i-1)+h_i`, sum (1): + +\[ + \sum_i X_{j_{i-1},h_i}\ge + \sigma\sum_i h_i^2+ + (\beta_{j_n}^2-\beta_{j_0}^2)/\theta. \tag{2} +\] + +This holds for every finite path of nonzero integer increments, including +negative increments, repeated coordinates and arbitrary winding. Coprimality +implies the residues `tj mod s` visit every residue. Hence + +\[ + \min_j\beta_j^2=0,\qquad + \max_j\beta_j^2=\lfloor s/2\rfloor^2/s^2=:b_s^2. +\] + +Apply (2) to every term in the path expansion of `E^n`. The positive +Gaussian sums converge absolutely (quadratic decay in each increment), so +Tonelli permits summing the inequalities. The sum of the majorants factors +into the nth power of the one-dimensional Gaussian sum. Every row sum is +bounded by `exp(A beta_j^2/theta)` times that power; taking the maximum +proves the first displayed bound. Equivalently, conjugation by +`D_jj=exp(A beta_j^2/theta)` makes every row sum of `D^-1 E D` at most +the Gaussian sum. No diagonalization or eigenvalue assumption is used. + +For `a=A sigma>4 pi>12`, the inequality `h^2 >= 1+3(h-1)` for `h>=1` +gives + +\[ + \sum_{h\ne0}e^{-a h^2}\le 2e^{-a}/(1-e^{-3a})<2.01e^{-a}. +\] + +For the last strict comparison it suffices that `e>2` and `a>12`, so +`e^-3a < 4096^-3`; the remaining comparison is rational and checked. + +## Certified counts and what they do not mean + +Let `L=(333/106)/(6932/10000)` and `U=(355/113)/(693/1000)`. +Then `L < pi/log(2) < U`, and `log2(2.01)<101/100`. Define + +\[ + d=L\alpha^2\sigma-101/100>0,\qquad + B=U\alpha^2 b_s^2/\theta,\qquad + n_p=\left\lceil(p+B)/d\right\rceil. +\] + +The bound above implies **`||E^n_p|| < 2^-p`**. The verifier encloses +pi by Machin's identity with alternating rational arctangent sums and +log(2) by the positive series `2 atanh(1/3)`, including its tail. It +does not use floating-point evaluations of a logarithm or exponential. + +For the inverse partial sum `S_n=sum_{k=0}^{n-1}(-E)^k`, +`(I+E)S_n=I-(-E)^n`. Thus `n_p` certifies its **residual**, not by +itself the same absolute inverse error. If the separately established +`||E||<1/2` holds, then + +\[ + \|(I+E)^{-1}-S_n\|\le2\|E^n\|. +\] + +Use `n_(p+1)` to certify inverse error below `2^-p`. We retain this +extra bit explicitly. Neither bound prices rounded evaluations of `E`, +storage, setup, source access, restoration or tape movement. No modified +resampling implementation, end-to-end running time or multiplication +exponent is claimed. The algebraic operator bound holds for all `theta>0`; +it does **not** enlarge the implemented chirp domain. + +`RESULT.json` separates three counts: the original corollary's simplified +count, the old endpoint bound priced with the **same** rational decay `d`, +and the new endpoint bound. Only the last comparison isolates the gain +from this contribution. The original count is compared only within its +stated `alpha^2 theta>=1, theta<1` domain. + +Exact examples from the receipt: + +| p | alpha | s,t | Old endpoint, same decay | New residual | New inverse, if norm < 1/2 | +|---:|---:|---|---:|---:|---:| +| 128 | 4 | 15,16 | 6 | 5 | 5 | +| 1024 | 8 | 63,64 | 20 | 19 | 19 | +| 4096 | 16 | 255,256 | 68 | 67 | 67 | + +## Counterexamples and finite evidence + +The prefactor cannot simply be deleted. At `s=4,t=5,j=2,h=1`, (1) has +`X=1/2`, `sigma h^2=5/4`, endpoint contribution `-3/4`, and zero +remainder. At `alpha=2`, this one positive term in row 2 of E exceeds +`2.01 exp(-A sigma)`, because `exp(3A/4)>exp(9)>2.01`. +This also refutes the claimed prefactor-free operator bound, not merely +one intermediate inequality. The tuple has `theta=1/4` and +`alpha^2 theta=1`, inside the implemented Gaussian parameter restriction. + +The residual/inverse distinction has a separate scalar counterexample: +`E=-1/4`, `n=2`, gives residual `1/16` but inverse error `1/12`. +It refutes the general inference from residual alone; this signed scalar +is not asserted to be one of the positive Gaussian matrices. + +The finite audit enumerates all coprime `2<=s<=32, s= s) + expected = Fraction(t * j, s) - nearest + self.assertEqual(verify.phase(s, t, j), expected) + self.assertEqual(verify.phase(s, t, j + s), expected) + + def test_formal_matrix_powers_preserve_wrapped_steps(self): + # Represent truncated E entries as exact polynomials in z=exp(-A/s^2). + # Matrix multiplication groups paths by destination, unlike verify.py. + # Nonzero h = +/-s must contribute to diagonal entries. + for s, t in ((2, 3), (3, 4), (4, 5)): + moves = tuple(h for h in range(-s, s + 1) if h) + def beta_num(j): + return t * j - s * ((2 * t * j + s) // (2 * s)) + + matrix = [[Counter() for _ in range(s)] for _ in range(s)] + for j in range(s): + for h in moves: + exponent = (t * h + beta_num(j)) ** 2 - beta_num(j + h) ** 2 + matrix[j][(j + h) % s][exponent] += 1 + self.assertEqual(sum(matrix[j][j].values()), 2) + square = [[Counter() for _ in range(s)] for _ in range(s)] + for j, k, middle in product(range(s), repeat=3): + for a, na in matrix[j][middle].items(): + for b, nb in matrix[middle][k].items(): + square[j][k][a + b] += na * nb + for j in range(s): + direct = [Counter() for _ in range(s)] + for h1, h2 in product(moves, repeat=2): + x1 = verify.step(s, t, j, h1)[0] + x2 = verify.step(s, t, j + h1, h2)[0] + exponent = (x1 + x2) * s * s + self.assertEqual(exponent.denominator, 1) + direct[(j + h1 + h2) % s][int(exponent)] += 1 + self.assertEqual(square[j], direct) + self.assertEqual(sum(sum(entry.values()) for entry in square[j]), len(moves) ** 2) + + def test_counterexamples_and_domain_controls(self): + self.assertEqual(verify.rejection_controls(), 10) + # This admitted tuple isolates an actual integer count improvement. + example = verify.counts(128, 4, 15, 16) + self.assertEqual(example["residual_count"], 5) + self.assertEqual(example["old_endpoint_same_decay_count"], 6) + self.assertEqual(example["original_corollary_count"], 18) + + def test_constants_are_certified(self): + verify.constant_checks() + + def test_independent_oracle_detects_corruption(self): + original = verify.integer_path + def wrong_exponent(*args): + total, slack = original(*args) + return total + 1, slack + with patch.object(verify, "integer_path", wrong_exponent): + with self.assertRaisesRegex(ValueError, "independent exponent"): + verify.audit_path(4, 5, 2, (1, -1, 4)) + + def test_source_drift_and_missing_source(self): + rows = json.loads((verify.HERE / "SOURCES.json").read_text())["files"] + with tempfile.TemporaryDirectory(prefix="gaussian audit ") as folder: + root = Path(folder) + for row in rows: + target = root / row["path"] + target.parent.mkdir(parents=True, exist_ok=True) + target.write_bytes((verify.ROOT / row["path"]).read_bytes()) + self.assertEqual(verify.source_check(root), len(rows)) + target = root / rows[0]["path"] + original = target.read_bytes() + target.write_bytes(original + b"\n% control\n") + with self.assertRaisesRegex(ValueError, "source drift"): + verify.source_check(root) + target.unlink() + with self.assertRaises(FileNotFoundError): + verify.source_check(root) + + def test_receipt_corruption_including_numeric_types(self): + expected = json.loads((verify.HERE / "RESULT.json").read_text()) + verify.check_receipt(expected, deepcopy(expected)) + for field, replacement in (("assignment_seed", 63), ("controls", True), + ("controls", 10.0), ("exact_paths", 0)): + bad = deepcopy(expected) + bad[field] = replacement + with self.assertRaisesRegex(ValueError, "receipt mismatch"): + verify.check_receipt(expected, bad) + bad = deepcopy(expected) + del bad["examples"] + with self.assertRaisesRegex(ValueError, "receipt mismatch"): + verify.check_receipt(expected, bad) + + def test_existing_output_preserved(self): + # Check the CLI output policy without repeating the full enumeration. + with tempfile.TemporaryDirectory() as folder: + output = Path(folder) / "receipt.json" + output.write_bytes(b"retained\n") + with patch.object(verify, "certificate", return_value={}), \ + patch("sys.argv", ["verify.py", "--write", str(output)]): + with self.assertRaises(FileExistsError): + verify.main() + self.assertEqual(output.read_bytes(), b"retained\n") + + +if __name__ == "__main__": + unittest.main() diff --git a/research/gaussian-endpoint-potential-audit/verify.py b/research/gaussian-endpoint-potential-audit/verify.py new file mode 100644 index 0000000000..cf50e7df59 --- /dev/null +++ b/research/gaussian-endpoint-potential-audit/verify.py @@ -0,0 +1,253 @@ +#!/usr/bin/env python3 +"""Exact finite audit of a written Gaussian endpoint-potential argument. + +Standard library only. No predecessor arithmetic/checker is imported. +The finite checks are evidence, not a formal proof of the universal bound. +""" +from fractions import Fraction as Q +from hashlib import sha256 +from itertools import product +from math import gcd +from pathlib import Path +import argparse +import json +import random + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +LO = Q(333, 106) / Q(6932, 10000) +HI = Q(355, 113) / Q(693, 1000) +LOG_FACTOR = Q(101, 100) + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def ceil(value): + return -(-value.numerator // value.denominator) + + +def constant_checks(): + """Rational Taylor enclosures; Machin's identity and atanh(1/3).""" + def atan_interval(q): + terms = 12 + partial = sum((-1) ** k * q ** (2 * k + 1) / (2 * k + 1) + for k in range(terms)) + return partial, partial + q ** (2 * terms + 1) / (2 * terms + 1) + + a, b = atan_interval(Q(1, 5)), atan_interval(Q(1, 239)) + pi_lo, pi_hi = 16 * a[0] - 4 * b[1], 16 * a[1] - 4 * b[0] + log_lo = 2 * sum(Q(1, 3) ** (2 * k + 1) / (2 * k + 1) for k in range(12)) + log_hi = log_lo + 2 * Q(1, 3) ** 25 / (25 * (1 - Q(1, 9))) + require(Q(333, 106) < pi_lo < pi_hi < Q(355, 113), "pi enclosure") + require(Q(693, 1000) < log_lo < log_hi < Q(6932, 10000), "log(2) enclosure") + require(Q(201, 100) ** 100 < 2 ** 101, "log2(2.01) enclosure") + + +def phase(s, t, j): + """Exact nearest integer, ties upward, for positive or negative j.""" + x = Q(t * j, s) + return x - (x + Q(1, 2)).__floor__() + + +def step(s, t, j, h): + sigma, theta = Q(t, s), Q(t - s, s) + b, end = phase(s, t, j), phase(s, t, j + h) + y = b + theta * h + w = y - end + exponent = (sigma * h + b) ** 2 - end ** 2 + endpoint = (end ** 2 - b ** 2) / theta + gap = sigma / theta * w * (2 * y - w) + require(w.denominator == 1, "phase carry must be integral") + require(exponent == sigma * h * h + endpoint + gap, "step identity") + require(gap >= 0, "step remainder must be nonnegative") + return exponent, endpoint, gap + + +def integer_path(s, t, j, moves): + """Independent oracle: integer phase numerators, no Fraction step formula. + + All Gaussian exponents are multiplied by s^2; modulo arithmetic replaces + nearest-integer evaluation. The endpoint bound is cross-multiplied. + """ + def numerator(k): + return ((2 * t * k + s) % (2 * s) - s) // 2 + + start = numerator(j) + total = 0 + energy = 0 + for h in moves: + before, after = numerator(j), numerator(j + h) + total += (t * h + before) ** 2 - after ** 2 + energy += h * h + j += h + end = numerator(j) + slack = (t - s) * (total - t * s * energy) - s * (end * end - start * start) + require(slack >= 0, "integer path inequality") + return total, slack + + +def audit_path(s, t, j, moves): + initial = j + exponent = Q(0) + gaps = Q(0) + for h in moves: + x, _, gap = step(s, t, j, h) + exponent += x + gaps += gap + j += h + energy = Q(t, s) * sum(h * h for h in moves) + endpoint = (phase(s, t, j) ** 2 - phase(s, t, initial) ** 2) / Q(t - s, s) + require(exponent == energy + endpoint + gaps, "path telescope") + total, slack = integer_path(s, t, initial, moves) + require(exponent * s * s == total, "independent exponent disagreement") + require(gaps * s * s * (t - s) == slack, "independent slack disagreement") + require(exponent >= energy - Q((s // 2) ** 2, s * (t - s)), "phase range bound") + + +def counts(p, alpha, s, t): + require(type(p) is int and p > 0, "positive integral precision") + require(type(alpha) is int and alpha >= 2, "integral alpha >= 2") + require(type(s) is int and type(t) is int and 2 <= s < t and gcd(s, t) == 1, + "coprime 2 <= s < t") + a2, theta, sigma = alpha * alpha, Q(t - s, s), Q(t, s) + decay = LO * a2 * sigma - LOG_FACTOR + require(decay > 0, "positive decay") + burn = HI * a2 * Q((s // 2) ** 2, s * (t - s)) + old_burn = HI * a2 * (1 / (4 * theta) + Q(1, 2)) + n = ceil((p + burn) / decay) + inverse = ceil((p + 1 + burn) / decay) + require(n * decay - burn >= p, "residual precision") + require(inverse * decay - burn >= p + 1, "inverse-tail precision") + same_decay_old = ceil((p + old_burn) / decay) + require(n <= same_decay_old, "endpoint-only count must not increase") + result = dict(p=p, alpha=alpha, s=s, t=t, burn=str(burn), decay=str(decay), + residual_count=n, inverse_count_if_norm_below_half=inverse, + old_endpoint_same_decay_count=same_decay_old) + if a2 * theta >= 1 and theta < 1: + original = min(ceil(Q(p, 1) / (a2 * theta)), + ceil(Q(p + 1, 4 * a2) + 1 / theta)) + # This check concerns the stated integer domain, not arbitrary reals. + require(n <= original, "count exceeds predecessor in tested domain") + result["original_corollary_count"] = original + return result + + +def source_check(root): + manifest = json.loads((HERE / "SOURCES.json").read_text(encoding="utf-8")) + for row in manifest["files"]: + data = (root / row["path"]).read_bytes() + require(sha256(data).hexdigest() == row["sha256"], "source drift: " + row["path"]) + blob = b"blob " + str(len(data)).encode() + b"\0" + data + from hashlib import sha1 + require(sha1(blob).hexdigest() == row["git_blob"], "source blob drift") + return len(manifest["files"]) + + +def rejection_controls(): + # Mathematical controls bypass source hashes and test plausible wrong claims. + # The first one shows that deleting the endpoint prefactor is unsound. + x, endpoint, gap = step(4, 5, 2, 1) + energy = Q(5, 4) + require(x == Q(1, 2) and endpoint == Q(-3, 4) and gap == 0, + "fixed no-prefactor witness changed") + require(x < energy, "zero burn-in mutation was not refuted") + # Endpoint direction and coefficient are independently falsifiable. + require(x != energy - endpoint + gap, "reversed endpoint mutation") + require(x != energy + Q(5, 4) * endpoint + gap, "sigma/theta endpoint mutation") + require(phase(2, 3, 1) == Q(-1, 2), "half-up tie control") + # Counting only the residual is insufficient for the inverse tail. + e = Q(-1, 4) + require(abs(e ** 2) == Q(1, 16) and abs(e ** 2 / (1 + e)) > Q(1, 16), + "residual-versus-tail control") + for args in ((0, 2, 5, 6), (100, 1, 5, 6), (100, 2, 4, 6), + (100, 2, 6, 5), (True, 2, 5, 6)): + try: + counts(*args) + except ValueError: + continue + raise ValueError("invalid domain accepted") + return 10 + + +def certificate(root=ROOT): + pins = source_check(root) + constant_checks() + require(Q(201, 100) ** 100 < 2 ** 101, "log2(2.01) bound") + # With a = pi*alpha^2*sigma > 12 and exp(-a) < 1/4096, + # sum_{h != 0} exp(-a*h^2) <= 2 exp(-a)/(1-exp(-3a)) < 2.01 exp(-a). + require(Q(2, 1) / (1 - Q(1, 4096 ** 3)) < Q(201, 100), "Gaussian tail bound") + pairs = [(s, t) for s in range(2, 33) for t in range(s + 1, 3 * s + 1) + if gcd(s, t) == 1] + steps = 0 + for s, t in pairs: + betas = [phase(s, t, j) for j in range(s)] + require(min(b * b for b in betas) == 0, "phase minimum") + require(max(b * b for b in betas) == Q((s // 2) ** 2, s * s), "phase maximum") + for j in range(s): + for h in range(-4, 5): + if h: + audit_path(s, t, j, (h,)) + steps += 1 + paths = 0 + for s, t in ((2, 3), (3, 4), (4, 5), (5, 6), (7, 9), (5, 11)): + for length in range(1, 5): + for moves in product((-2, -1, 1, 2), repeat=length): + for j in range(s): + audit_path(s, t, j, moves) + paths += 1 + rng = random.Random(62) + for _ in range(620): + s = rng.randrange(2, 100) + t = rng.randrange(s + 1, 4 * s) + while gcd(s, t) != 1: + t += 1 + moves = tuple(rng.choice((-8, -3, -1, 1, 3, 8)) for _ in range(rng.randrange(1, 17))) + audit_path(s, t, rng.randrange(-2 * s, 2 * s), moves) + paths += 1 + count_cases = 0 + endpoint_savings = 0 + for p in (101, 128, 256, 1024): + for alpha in range(2, 17): + if alpha * alpha >= p: + continue + for s, t in pairs: + theta = Q(t - s, s) + if Q(1, alpha * alpha) <= theta <= Q(1, 4): + row = counts(p, alpha, s, t) + count_cases += 1 + endpoint_savings += row["residual_count"] < row["old_endpoint_same_decay_count"] + examples = [counts(*args) for args in ((101, 2, 4, 5), (128, 4, 15, 16), + (1024, 8, 63, 64), (4096, 16, 255, 256))] + return dict(status="SCOPED_EXACT_AUDIT_NO_NEW_KAPPA", assignment_seed=62, + pinned_files=pins, coprime_pairs=len(pairs), exact_steps=steps, + exact_paths=paths, count_cases=count_cases, + strict_endpoint_only_count_savings=endpoint_savings, + controls=rejection_controls(), examples=examples) + + +def check_receipt(result, expected): + require(json.dumps(result, sort_keys=True) == json.dumps(expected, sort_keys=True), + "receipt mismatch (including JSON value types)") + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--root", type=Path, default=ROOT) + parser.add_argument("--write", type=Path, help="write a new receipt; refuse existing output") + args = parser.parse_args() + result = certificate(args.root) + if args.write: + with args.write.open("x", encoding="utf-8", newline="\n") as stream: + json.dump(result, stream, indent=2, sort_keys=True) + stream.write("\n") + else: + expected = json.loads((HERE / "RESULT.json").read_text(encoding="utf-8")) + check_receipt(result, expected) + print("PASS_GAUSSIAN_ENDPOINT_POTENTIAL", json.dumps(result, sort_keys=True)) + + +if __name__ == "__main__": + main() From e17fd726b23ff009518c2fc7fa0c423e3c25a46d Mon Sep 17 00:00:00 2001 From: Alan Grillo <290989452+bg-grillo-alan@users.noreply.github.com> Date: Tue, 13 Oct 2026 13:24:09 +0200 Subject: [PATCH 2/2] Record Gaussian endpoint audit result and review link --- .../gaussian-endpoint-potential-audit/CLAIM.md | 16 ++++++++++++++++ .../VALIDATION.md | 4 ++++ 2 files changed, 20 insertions(+) diff --git a/research/gaussian-endpoint-potential-audit/CLAIM.md b/research/gaussian-endpoint-potential-audit/CLAIM.md index 9d7e6f005e..6d74262b77 100644 --- a/research/gaussian-endpoint-potential-audit/CLAIM.md +++ b/research/gaussian-endpoint-potential-audit/CLAIM.md @@ -11,3 +11,19 @@ - Overlap: current open PR titles through #898; targeted all-state searches for selected-bit, signed packing, resampling, Neumann and correction powers. #5 supplies the original potential; #684 audits chirp windows and explicitly excludes Neumann evaluation. No duplicate endpoint-power refinement found in these searches. This is a bounded metadata inspection, not an exhaustive review of every PR's source. - Coordination: the open-issue query returned only #650, a request to enable Discussions, not a pinned sprint issue. Claim recorded locally; no reservation issue opened. - Budget: scope now frozen; reserve the final quarter of implementation/verification effort for adversarial checks and handoff. + +## Result (single completion update) + +Completed: the combined endpoint potential removes the additive `1/2` from +the old burn-in exponent and gives the exact odd/even denominator refinement. +The same-decay term count improves on 1,876 of 3,296 declared parameter cases. +Eight new test groups pass normally and under optimized Python; isolated +reproduction and the existing selected-record checks pass. No new kappa. + +Review: https://github.com/CrocSwap/integer-mult-bounds/pull/902 + +The final overlap refresh covered arrivals through #901 and the targeted +Gaussian/potential search. The remote main still equals the recorded base. +The base ledger records #5 as partially reviewed and #371 as unreviewed; +these wider predecessor reviews are not completed by this narrow audit. +All scientific changes are confined to this package; see VALIDATION.md. diff --git a/research/gaussian-endpoint-potential-audit/VALIDATION.md b/research/gaussian-endpoint-potential-audit/VALIDATION.md index b8c901ad21..be16397567 100644 --- a/research/gaussian-endpoint-potential-audit/VALIDATION.md +++ b/research/gaussian-endpoint-potential-audit/VALIDATION.md @@ -22,6 +22,10 @@ Executed 2026-10-13. No wall-time speedup or Linux/hosted-CI pass is claimed. kappa `1661634653669567/10^18` unchanged. - `python -B -m unittest discover -s tests -p test_selected_result.py -v`: all five existing tests pass. +- `git diff --cached --check`: passes. The only changed paths are the seven + files in this research package; the selected record and `upstream/` have + no diff. Remote main was rechecked before submission and still equals + the exact base above. The scientific receipt contains 646 coprime pairs, 112,672 exact single-step checks, 9,460 longer/supplemental path checks, and 3,296 parameter-count