File size: 4,142 Bytes
6395f35 | 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 | import json
import math
import cmath
def get_tau(n):
"""Compute Ramanujan tau function using the divisor sum identities or recursion."""
# Small values for tau(n)
if n == 1: return 1
if n == 2: return -24
if n == 3: return 252
if n == 4: return -1472
if n == 5: return 4830
if n == 6: return -6048
if n == 7: return -16744
# General recursion for prime powers or products could be used,
# but we only need up to n=7.
return 0
def solve():
# 1. Normalized tau(7)
# tau(n) * n^(-11/2)
tau_7 = get_tau(7)
normalized_tau_7 = tau_7 * (7**(-5.5))
# 2. Von Mangoldt Lambda_L(4)
# n = 4 = 2^2. Lambda_L(p^k) = (alpha_p^k + beta_p^k) * log(p)
# alpha_p, beta_p are roots of x^2 - tau_tilde(p)x + 1 = 0
p = 2
tau_tilde_2 = get_tau(2) * (2**(-5.5))
# alpha^2 + beta^2 = (alpha+beta)^2 - 2*alpha*beta = tau_tilde_2^2 - 2(1)
lambda_4 = (tau_tilde_2**2 - 2) * math.log(2)
# 3. Analytic Conductor Q(0)
# For L(s, Delta), the degree is 2. The functional equation involves Gamma(s + 11/2).
# The normalized version L(s + 11/2) involves Gamma(s + 11/2).
# Q(t) = q * (2*pi)^-d * prod |it + mu_j + 1/2|
# Here d=1 in the sense of one Gamma factor, but it's degree 2.
# The standard form for L(s, Delta) is (2pi)^-s Gamma(s) L(s).
# Shifted: (2pi)^-(s+11/2) Gamma(s+11/2) L(s+11/2).
# The conductor q=1. The Gamma factor is Gamma(s + 11/2).
# At s = 1/2 + it, the argument is it + 6.
# Q(t) = (2*pi)^-1 * |it + 6| (if we treat it as degree 1 with shift)
# However, the Selberg class definition for degree 2 usually has two Gamma factors
# or one Gamma factor with a specific scaling. For L(s, Delta), d=2.
# The conductor is Q = 1/(2pi). The term is |s + 5.5| / (2pi).
# At t=0, s=1/2, so |0.5 + 5.5| / (2*pi) = 6 / (2*pi) = 3/pi.
analytic_conductor_zero = 3.0 / math.pi
# 4. Riemann-von Mangoldt N(T) for T=30
# N(T) = (T/pi) * log(T/(2*pi*e)) + (11/(2*pi))*T + phase_correction
# More accurately: N(T) = (1/pi) * arg(Lambda(1/2 + iT))
# Lambda(s) = (2pi)^-s Gamma(s + 5.5) L(s + 5.5)
# arg Lambda(1/2 + iT) = Im(log Lambda(1/2 + iT))
# = Im( - (1/2 + iT)log(2pi) + logGamma(6 + iT) + log L(6 + iT) )
# For T=30, log L(6 + iT) is very small, so we approximate with the first two terms.
T = 30.0
term1 = -T * math.log(2 * math.pi)
# Stirling for logGamma(z): (z - 0.5)log z - z + 0.5 log(2pi)
z = complex(6, T)
log_gamma = (z - 0.5) * cmath.log(z) - z + 0.5 * math.log(2 * math.pi)
arg_lambda = term1 + log_gamma.imag
n_t = arg_lambda / math.pi
# 5. Critical line phase constant
# The constant term in N(T) = (T/pi)log(T/2pi e) + ...
# From the expansion of Im log Gamma(6 + iT):
# Im((5.5 + iT)log(6+iT) - (6+iT)) = T log|6+iT| + 5.5 arg(6+iT) - T
# As T -> inf, 5.5 arg(6+iT) -> 5.5 * (pi/2) = 2.75 * pi.
# The constant is (2.75 * pi + 0.5 * log(2pi) term? No.)
# The standard constant for zeta is -1/8. For this L-function:
# The constant term in the expansion of (1/pi) arg Gamma(s + k) is related to k.
# For Gamma(s + 5.5), at s=1/2, the constant is (1/pi) * Im(logGamma(6)) = 0 (since 6 is real).
# But we want the constant in the asymptotic N(T) ~ ... + C
# N(T) = (T/pi) log(T/2pi e) + (k-0.5)/2 + ...
# For L(s, Delta), k=6. Constant approx (6 - 0.5)/2 = 2.75.
# Let's use the precise value of the phase at T=0: (1/pi) arg Gamma(6) = 0.
# However, the question asks for the constant offset in the formula.
# Standard formula: N(T) = (T/pi) log(T/2pi e) + (11/4) + S(T).
# The constant is 11/4 = 2.75.
critical_line_phase_const = 2.75
res = {
"problem_id": "MATH4",
"normalized_tau_7": round(normalized_tau_7, 6),
"von_mangoldt_lambda_4": round(lambda_4, 6),
"analytic_conductor_zero": round(analytic_conductor_zero, 6),
"riemann_von_mangoldt_30": round(n_t, 6),
"critical_line_phase_const": round(critical_line_phase_const, 6)
}
print(json.dumps(res))
if __name__ == "__main__":
solve()
|