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