"""Rational-arithmetic checks of the moment kernel. No research utilities are imported.""" from fractions import Fraction as F from math import factorial, gcd, lcm, prod def primes(n): return [p for p in range(2, n+1) if n % p == 0 and all(p % k for k in range(2, p))] def multiply(a, b, length): out = [F(0)] * length for i, u in enumerate(a): for j, v in enumerate(b[:length-i]): out[i+j] += u * v return out def linear_factors(constants, slope, length): out = [F(1)] for c in constants: out = multiply(out, [F(c), F(slope)], length) return out + [F(0)] * (length-len(out)) def series_quotient(a, b): assert b[0] != 0 out = [] for i, v in enumerate(a): out.append((v - sum(b[j] * out[i-j] for j in range(1, i+1))) / b[0]) return out def scale(n, i): blocks, rem = divmod(i, n) return factorial(n)**blocks * factorial(rem) def basis_eval(z, n, i, j): return prod(z+r for extent in (i, j) for r in range(extent)) / F(scale(n,i)*scale(n,j)) def theta_grid(denominators): return sorted(F(a,b) for b in denominators for a in range(1,b) if gcd(a,b) == 1) class Kernel: def __init__(self, n, s, denominators): self.n, self.s = n, s self.theta = theta_grid(denominators) self.zeros = [theta + v for theta in self.theta for v in range(n)] A = 1 for b in denominators: tot = sum(gcd(a,b) == 1 for a in range(1,b)) A *= b**tot * prod(p**(tot//(p-1)) for p in primes(b)) self.A = A self.constant = A**n * F(factorial(n))**(s-len(self.theta)) def value(self, t): return self.constant * prod(t+r for r in self.zeros) / prod(t+k for k in range(self.n+1))**self.s def partial(self, i, j): n, s = self.n, self.s assert (n+1)*s-n*len(self.theta)-2 >= i+j out = {} for k in range(n+1): # Expand the regularized quotient at t=-k+u through degree s-1. z = F(n,2)-k parts = [] for a in (1, -1): offsets = [a*z+r for extent in (i,j) for r in range(extent)] parts.append(linear_factors(offsets, a, s)) test = [(x+y)/F(scale(n,i)*scale(n,j)) for x,y in zip(*parts)] numerator = multiply(test, linear_factors([r-k for r in self.zeros], 1, s), s) denominator = linear_factors([v-k for v in range(n+1) if v != k for _ in range(s)], 1, s) coef = series_quotient(numerator, denominator) for order in range(1,s+1): out[k,order] = self.constant * coef[s-order] return out def check_partials(kernel, counts): n, s, theta = kernel.n, kernel.s, kernel.theta dn = lcm(*range(1,n+1)) for i,j in ((0,0),(0,2),(1,3),(2,2),(2,3),(0,5)): a = kernel.partial(i,j) counts["coefs"] += len(a) for (k,r), v in a.items(): assert (dn**(s-r)*v).denominator == 1 assert a[n-k,r] == (-1)**(s+r)*v assert sum(a[k,1] for k in range(n+1)) == 0 for r in range(1,s+1): if (s-r) % 2: assert sum(a[k,r] for k in range(n+1)) == 0 for t in (F(1,7), F(9,4), F(-11,7)): z = t + F(n,2) target = kernel.value(t) * (basis_eval(z,n,i,j) + basis_eval(-z,n,i,j)) assert target == sum(v/(t+k)**r for (k,r),v in a.items()) counts["reconstructions"] += 1 for th in theta+[F(1)]: for k in range(1,n+1): for ell in range(k): terms = [dn**s * a[k,r]/(ell+th)**r for r in range(1,s+1)] assert sum(terms).denominator == 1 counts["tails"] += 1 if any(v.denominator > 1 for v in terms): counts["cancellations"] += 1 if not counts["example"]: primes_needed = sorted({p for v in terms for p in primes_smallest(v.denominator)}) counts["example"] = (n,s,i,j,th,k,ell,primes_needed) def primes_smallest(n): p = 2 while p*p <= n: if n % p == 0: yield p while n % p == 0: n //= p p += 1 if n > 1: yield n def check_boundary_and_basis(kernel, D, f, qw, counts): n, s, theta = kernel.n, kernel.s, kernel.theta center = F(n,2) offsets = theta + [F(1)] def W(x): return sum(w * f[int(q*x) % D] for q,w in qw if (q*x).denominator == 1) def mass(x): t = abs(x)-center if t <= 0 or not W(abs(x)): return F(0) # Construct both tails by reflecting the actual positive-grid summation. return W(abs(x)) * kernel.value(t) for off in offsets + [F(1,19)]: for k in range(-n-5,n+5): x = k+off P = (x+1+center)**(s+1) * (x-center) * prod(x+a-center for a in theta) Q = (x-center)**(s+1) * (x+1+center) * prod(x+a+center for a in theta) assert P*mass(x+1) == Q*mass(x) counts["recurrence"] += 1 for th in offsets: for v in range(5): t = v+th z = t+center for i in range(6*len(offsets)+2): nu, rem = divmod(i, 2*len(offsets)) value = z**rem * prod(z*z - (m+u+center)**2 for m in range(nu) for u in offsets) if v < nu: assert value == 0 else: assert abs(value) <= (t+n)**i counts["basis"] += 1 def main(): cases = [ (2,7,(),1,(1,),((1,1),)), (4,9,(2,4),2,(1,-2),((2,2),(4,-1))), (4,10,(2,3,6),3,(2,0,-1),((3,-3),(6,2))), (2,12,(5,10),5,(0,0,1,-1,0),((5,1),(10,-2))), (2,13,(2,5,10),5,(3,0,1,-2,0),((5,1),(10,-2))), ] counts = dict.fromkeys(("coefs","reconstructions","tails","cancellations","recurrence","basis"),0) counts["example"] = None for n,s,den,D,f,qw in cases: kernel = Kernel(n,s,den) check_partials(kernel, counts) check_boundary_and_basis(kernel,D,f,qw,counts) print(f"Passed n={n}, s={s}, D={D}, proper reduced denominators={den}") print(f"Checked {counts['coefs']} Laurent coefficients and {counts['reconstructions']} independent function evaluations.") print(f"Checked {counts['tails']} finite-tail sums; {counts['cancellations']} needed cancellation between separately nonintegral terms.") print(f"First genuine cancellation (n,s,i,j,theta,k,ell,primes): {counts['example']}") print(f"Checked {counts['recurrence']} signed-mass recurrences and {counts['basis']} analytic-basis zeros or upper bounds.") assert counts["cancellations"] > 0 if __name__ == "__main__": main()