import json
import math
from decimal import Decimal, getcontext

# Set high precision for exact threshold comparisons at N ~ 10^12
getcontext().prec = 80


def seifert_matrix(p_list):
    m = len(p_list)
    V = [[0] * (m - 1) for _ in range(m - 1)]
    for j in range(m - 1):
        V[j][j] = (p_list[j] + p_list[j + 1]) // 2
        if j + 1 < m - 1:
            V[j][j + 1] = -(p_list[j + 1] + 1) // 2
        if j - 1 >= 0:
            V[j][j - 1] = -(p_list[j] - 1) // 2
    return V


def det_int(M):
    n = len(M)
    A = [row[:] for row in M]
    sign = 1
    prev = 1
    for i in range(n):
        pivot = i
        while pivot < n and A[pivot][i] == 0:
            pivot += 1
        if pivot == n:
            return 0
        if pivot != i:
            A[i], A[pivot] = A[pivot], A[i]
            sign = -sign
        for j in range(i + 1, n):
            for k in range(i + 1, n):
                A[j][k] = (A[i][i] * A[j][k] - A[j][i] * A[i][k]) // prev
            A[j][i] = 0
        prev = A[i][i]
    return sign * A[n - 1][n - 1]


def signature_3strand_from_trace_det(tr, det):
    """
    For a 2x2 Hermitian matrix with real trace `tr` and real determinant `det`:
    - If det < 0: one positive, one negative eigenvalue -> signature = 0.
    - If det > 0: two eigenvalues of the same sign as `tr` -> signature = +2 if tr > 0 else -2.
    - If det == 0: one zero eigenvalue, one eigenvalue equal to `tr` -> +1 if tr > 0, -1 if tr < 0, 0 if tr == 0.
    """
    if det < 0:
        return 0
    elif det > 0:
        if tr > 0:
            return 2
        elif tr < 0:
            return -2
        else:
            return 0
    else:
        if tr > 0:
            return 1
        elif tr < 0:
            return -1
        else:
            return 0


def solve():
    # ---------------------------------------------------------
    # Key 1: Determinant of K_1 = P(3, -5, -7, 9, -11, 13, -17)
    # ---------------------------------------------------------
    p1 = [3, -5, -7, 9, -11, 13, -17]
    V1 = seifert_matrix(p1)
    n1 = len(V1)
    S1 = [[V1[i][j] + V1[j][i] for j in range(n1)] for i in range(n1)]
    knot_det = abs(det_int(S1))

    # ---------------------------------------------------------
    # General 2x2 Hermitian form H(omega) for 3-strand P(p, q, r):
    # V = [[(p+q)/2, -(q+1)/2], [-(q-1)/2, (q+r)/2]]
    # Let x = 1 - cos(theta) = 2 * sin^2(theta/2) in (0, 2] for omega = e^{i theta} != 1.
    # Notice:
    # H(omega) = (1 - omega) V + (1 - bar(omega)) V^T
    #          = x (V + V^T) - i sin(theta) (V - V^T)
    # Since S = V + V^T = [[p+q, -q], [-q, q+r]] and A = V - V^T = [[0, -1], [1, 0]],
    # we have:
    # Tr(H(omega)) = x * Tr(S) = x * (p + 2q + r).
    # det(H(omega)) = x^2 * det(S) - sin^2(theta) * 1
    # Since sin^2(theta) = x * (2 - x),
    # det(H(omega)) = x * (x * det(S) - (2 - x)) = x * ((det(S) + 1) * x - 2).
    # Since x > 0 for omega != 1:
    # - sign(Tr(H(omega))) = sign(p + 2q + r)
    # - sign(det(H(omega))) = sign((D + 1) * x - 2), where D = det(S) = pq + qr + rp.
    # ---------------------------------------------------------

    # For K(n) = P(2n+1, -(4n+1), -(6n+3)):
    # p = 2n+1, q = -4n-1, r = -6n-3
    # Tr(S) = p + 2q + r = (2n+1) - 2(4n+1) - (6n+3) = -12n - 4 < 0 for all n >= 1.
    # D(n) = pq + qr + rp
    #      = (2n+1)(-4n-1) + (-4n-1)(-6n-3) + (-6n-3)(2n+1)
    #      = (2n+1)(-4n - 1 - 6n - 3) + (4n+1)(6n+3)
    #      = (2n+1)(-10n - 4) + (24n^2 + 18n + 3)
    #      = -20n^2 - 18n - 4 + 24n^2 + 18n + 3 = 4n^2 - 1.
    # Wait: For n >= 1, D(n) = 4n^2 - 1 >= 3 > 0!
    # Let's check when D(n) can change sign or if we wait:
    # At omega = -1 (x = 2): (D(n)+1)*2 - 2 = 2*D(n) > 0 for all n >= 1.
    # At omega = e^{2pi i / 3} (x = 3/2): (D(n)+1)*(3/2) - 2 = (3/2)*4n^2 - 2 = 6n^2 - 2 > 0 for all n >= 1.
    # That's constant for all n! Let's double check if K(n) has constant signature for Keys 2 and 3:
    # Yes, for K(n) = P(2n+1, -(4n+1), -(6n+3)), D(n) = 4n^2 - 1 > 0 for all n >= 1.
    # Let's still compute Keys 2 and 3 directly from the formula.

    sig_sum_k2 = 0
    for n in range(1, 2500 + 1):
        p = 2 * n + 1
        q = -(4 * n + 1)
        r = -(6 * n + 3)
        D = p * q + q * r + r * p
        tr_S = p + 2 * q + r
        # omega = -1 => x = 2
        det_H = 2 * ((D + 1) * 2 - 2)
        tr_H = 2 * tr_S
        sig_sum_k2 += signature_3strand_from_trace_det(tr_H, det_H)

    # Key 3: sum_{n=1}^{5,000,000} sigma_{omega_3}(K(n))
    # For omega_3 = e^{2pi i / 3}, x = 1 - cos(2pi/3) = 3/2.
    # Since D(n) = 4n^2 - 1 >= 3 for all n >= 1, (D(n)+1)*(3/2) - 2 = 6n^2 - 2 > 0,
    # and tr_S = -12n - 4 < 0, every term has signature -2.
    N3 = 5000000
    tl_1_3 = -2 * N3

    # ---------------------------------------------------------
    # Keys 4 and 5: K_* = P(2000003, -4000005, -6000007)
    # Let's compute D_* and tr_S_* for K_*:
    # ---------------------------------------------------------
    p_star = 2000003
    q_star = -4000005
    r_star = -6000007
    D_star = p_star * q_star + q_star * r_star + r_star * p_star
    tr_S_star = p_star + 2 * q_star + r_star
    # Let's check D_star:
    # p_star = 2*10^6 + 3
    # q_star = -4*10^6 - 5
    # r_star = -6*10^6 - 7
    # D_star = (2e6+3)(-4e6-5) + (-4e6-5)(-6e6-7) + (-6e6-7)(2e6+3)
    #        = 4*10^12 + 12*10^6 + 1
    # Since D_star + 1 > 0 and tr_S_star < 0:
    # For omega = e^{2pi i r / q} (1 <= r < q):
    # x(r/q) = 1 - cos(2pi r / q) = 2 sin^2(pi r / q).
    # det(H(omega)) > 0  <=>  (D_star + 1) * 2 sin^2(pi r / q) > 2
    #                    <=>  sin(pi r / q) > 1 / sqrt(D_star + 1).
    # Let alpha = (1 / pi) * arcsin(1 / sqrt(D_star + 1)) in (0, 1/2).
    # Then for 1 <= r < q:
    # - If r/q in (0, alpha) or r/q in (1 - alpha, 1): det(H) < 0 => signature = 0.
    # - If r/q == alpha or r/q == 1 - alpha: det(H) == 0 => signature = -1 (cannot happen for rational r/q since D_star + 1 > 2).
    # - If r/q in (alpha, 1 - alpha): det(H) > 0 and Tr(H) < 0 => signature = -2.
    #
    # Therefore, for any modulus q >= 2:
    # Let K_cut(q) = floor(alpha * q).
    # For 1 <= r < q:
    # sigma_{e^{2pi i r / q}}(K_*) = 0 if 1 <= r <= K_cut(q) or q - K_cut(q) <= r <= q - 1,
    # and -2 if K_cut(q) < r < q - K_cut(q).
    #
    # Consequently, the primitive cyclotomic sum is:
    # S_prim(K_*, q) = -2 * #{ 1 <= r < q : gcd(r, q) = 1 and K_cut(q) < r < q - K_cut(q) }
    #                = -2 * ( phi(q) - 2 * #{ 1 <= r <= K_cut(q) : gcd(r, q) = 1 } )
    # (for q > 2; since K_cut(q) < q/2).

    # Compute alpha to 80 decimal digits using Newton/Taylor series for arcsin:
    # Since u = 1 / sqrt(D_star + 1) ~ 5 * 10^-7 is very small,
    # arcsin(u) = u + u^3/6 + 3*u^5/40 + 5*u^7/112 + 35*u^9/1152 + ...
    D_plus_1 = Decimal(D_star + 1)
    u = Decimal(1) / D_plus_1.sqrt()
    u2 = u * u
    arcsin_u = u * (
        Decimal(1)
        + u2 / Decimal(6)
        + (Decimal(3) * u2 * u2) / Decimal(40)
        + (Decimal(5) * (u2**3)) / Decimal(112)
        + (Decimal(35) * (u2**4)) / Decimal(1152)
        + (Decimal(63) * (u2**5)) / Decimal(2816)
    )
    pi_dec = Decimal(
        "3.14159265358979323846264338327950288419716939937510582097494459230781640628620899"
    )
    alpha = arcsin_u / pi_dec

    # Sieve primes up to 10^6 + 100 for factoring q in [10^12, 10^12 + 2000]
    Q_start = 10**12
    Q_end = 10**12 + 2000
    limit = int(math.isqrt(Q_end)) + 10
    is_prime = bytearray([1]) * (limit + 1)
    is_prime[0] = is_prime[1] = 0
    for i in range(2, int(math.isqrt(limit)) + 1):
        if is_prime[i]:
            is_prime[i * i : limit + 1 : i] = bytearray(len(range(i * i, limit + 1, i)))
    primes = [i for i, v in enumerate(is_prime) if v]

    # Segmented factorization for [Q_start, Q_end]
    span = Q_end - Q_start + 1
    rem = [Q_start + i for i in range(span)]
    prime_factors = [[] for _ in range(span)]

    for p in primes:
        start_idx = (-Q_start) % p
        for idx in range(start_idx, span, p):
            prime_factors[idx].append(p)
            while rem[idx] % p == 0:
                rem[idx] //= p

    for idx in range(span):
        if rem[idx] > 1:
            prime_factors[idx].append(rem[idx])

    def s_prim_from_factors(q, p_facs):
        k_cut = int(alpha * Decimal(q))
        # Generate squarefree divisors of q with their Mobius values and compute phi(q)
        divs = [(1, 1)]
        phi_q = q
        for p in p_facs:
            phi_q = (phi_q // p) * (p - 1)
            divs += [(d * p, -mu) for d, mu in divs]
        # Count #{1 <= r <= k_cut : gcd(r, q) == 1} = sum_{d | q} mu(d) * floor(k_cut / d)
        coprime_le_k = 0
        for d, mu in divs:
            coprime_le_k += mu * (k_cut // d)
        return -2 * (phi_q - 2 * coprime_le_k)

    # Key 4: Q = 10^12 + 39
    Q4 = 10**12 + 39
    s_prim_Q4 = s_prim_from_factors(Q4, prime_factors[Q4 - Q_start])

    # Key 5: sum_{q = 10^12}^{10^12 + 2000} S_prim(K_*, q)
    total_s_prim = 0
    for idx in range(span):
        q = Q_start + idx
        total_s_prim += s_prim_from_factors(q, prime_factors[idx])

    res = {
        "problem_id": "MATH5",
        "knot_determinant": knot_det,
        "knot_signature": sig_sum_k2,
        "tristram_levine_1_3": tl_1_3,
        "rasmussen_s_knot": s_prim_Q4,
        "rasmussen_s_sum": total_s_prim,
    }
    print(json.dumps(res))


if __name__ == "__main__":
    solve()