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()