File size: 3,383 Bytes
848d4b7 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 | from mpmath import mp
mp.dps = 110
def compute():
"""
3-loop sunrise (banana) integral at threshold s = 16m^2.
B(c) = int_0^inf r * I_0(c*r) * K_0(r)^4 dr
This is the position-space Bessel representation of the L=3 loop banana
Feynman integral with 4 equal-mass propagators. The parameter c = sqrt(s)/m,
so threshold s = (4m)^2 = 16m^2 corresponds to c = 4.
No closed form is known at threshold. (By contrast, the on-shell value
B(1) at s = m^2 has a known closed form proved by Zhou (2018):
B(1) = Gamma(1/15)*Gamma(2/15)*Gamma(4/15)*Gamma(8/15) / (240*sqrt(5)).
This known special case can be used to validate the integrand formula by
setting c=1 and checking against the closed form.)
At threshold c=4, the exponential factors in I_0 and K_0 cancel exactly,
so the integrand decays as r^{-3/2} (power law, not exponential).
Strategy:
- [0, R]: numerical integration using mpmath Bessel functions
- [R, inf]: analytical integral of asymptotic expansion
C * r^{-3/2} * sum_n s_n * r^{-n}
Asymptotic tail accuracy at R=100: ~exp(-200) ~ 10^{-87}.
Working at 70 dps, combined accuracy is ~50 digits.
This is a computationally intensive integral; higher precision would
require significantly more time due to the power-law tail decay.
"""
c = mp.mpf(4)
R = mp.mpf(100)
# Working precision balances accuracy vs speed.
# At threshold, Bessel evaluations for r in [30,100] are expensive.
wdps = 70
def integrand(t):
if t == 0:
return mp.zero
if t < mp.mpf('1e-15'):
L = -mp.log(t / 2) - mp.euler
return t * (mp.one + (c * c * t * t) / 4) * (L ** 4)
return t * mp.besseli(0, c * t) * mp.besselk(0, t) ** 4
pts = [mp.mpf(0)]
for x in [0.5, 1, 2, 4, 8, 16, 30, 50, 75]:
pts.append(mp.mpf(x))
pts.append(R)
with mp.workdps(wdps):
main = mp.quad(integrand, pts)
# Asymptotic tail from R to infinity.
# r * I_0(4r) * K_0(r)^4 ~ C * r^{-3/2} * sum_n s_n * r^{-n}
# C = pi^{3/2} / (8*sqrt(2))
#
# Bessel asymptotic coefficients: a_k = [(2k-1)!!]^2 / (k! * 8^k)
# I_0(z) ~ e^z/sqrt(2*pi*z) * sum_k a_k/z^k (positive)
# K_0(z) ~ sqrt(pi/(2z)) * e^{-z} * sum_k (-1)^k * a_k/z^k
N = 60
a = [mp.mpf(0)] * N
a[0] = mp.one
for k in range(1, N):
dbl_fac = mp.one
for j in range(1, k + 1):
dbl_fac *= (2 * j - 1)
a[k] = dbl_fac ** 2 / (mp.fac(k) * mp.power(8, k))
p_I = [a[k] / mp.power(4, k) for k in range(N)]
p_K = [(-1) ** k * a[k] for k in range(N)]
def poly_mul(aa, bb, n):
result = [mp.zero] * n
for i in range(min(n, len(aa))):
for j in range(min(n - i, len(bb))):
result[i + j] += aa[i] * bb[j]
return result
pk2 = poly_mul(p_K, p_K, N)
pk4 = poly_mul(pk2, pk2, N)
s = poly_mul(p_I, pk4, N)
C = mp.power(mp.pi, mp.mpf('1.5')) / (8 * mp.sqrt(2))
tail = mp.zero
for n in range(N):
tail += s[n] * 2 / ((2 * n + 1) * mp.power(R, (2 * n + 1) / mp.mpf(2)))
tail *= C
val = main + tail
return +val
if __name__ == "__main__":
print(str(compute()))
|