def sieve(X, bound): r""" Returns the list of all projective, rational points on scheme ``X`` of height up to ``bound``. Height of a projective point X = (x_1, x_2,..., x_n) is given by H_X = max(y_1, y_2,..., y_n), where H_X is height of point X and y_i's are the normalized coordinates such that all y_i are integers and gcd(y_1, y_2,..., y_n) = 1. ALGORITHM: Main idea behind the algorithm is to find points modulo primes and then reconstruct them using chinese remainder theorem. We find modulo primes parallelly and then lift them and apply LLL in parallel. For the algorithm to work correctly, sufficient primes need to be present, these are calculated using the bound given in this([Hutz2015]_) paper. INPUT: - ``X`` - a scheme with ambient space defined over projective space - ``bound`` - a positive integer bound OUTPUT: - a list containing the projective rational points of ``X`` of height up to ``bound``, sorted EXAMPLES:: sage: from sage.schemes.projective.projective_rational_point import sieve sage: P.<x,y,z,q>=ProjectiveSpace(QQ,3) sage: Y=P.subscheme([x^2-3^2*y^2+z*q,x+z+4*q]) sage: sorted(sieve(Y, 12)) # long time [(-4 : -4/3 : 0 : 1), (-4 : 4/3 : 0 : 1), (-1 : -1/3 : 1 : 0), (-1 : 1/3 : 1 : 0)] :: sage: from sage.schemes.projective.projective_rational_point import sieve sage: E = EllipticCurve('37a') sage: sorted(sieve(E, 14)) # long time [(-1 : -1 : 1), (-1 : 0 : 1), (0 : -1 : 1), (0 : 0 : 1), (0 : 1 : 0), (1/4 : -5/8 : 1), (1/4 : -3/8 : 1), (1 : -1 : 1), (1 : 0 : 1), (2 : -3 : 1), (2 : 2 : 1), (6 : 14 : 1)] TESTS: Algorithm works even if coefficients are fraction:: sage: from sage.schemes.projective.projective_rational_point import sieve sage: P.<x,y,z> = ProjectiveSpace(2,QQ) sage: X = P.subscheme(3*x - 3/2*y) sage: sieve(X, 3) [(-1 : -2 : 1), (-1/2 : -1 : 1), (-1/3 : -2/3 : 1), (0 : 0 : 1), (1/3 : 2/3 : 1), (1/2 : 1 : 0), (1/2 : 1 : 1), (1 : 2 : 1)] """ if bound < 1: # no projective rational point with height less than 1 return [] modulo_points = [] # list to store point modulo primes len_modulo_points = [ ] # stores number of points with respect to each prime primes_list = [] # list of good primes X.normalize_defining_polynomials() P = X.ambient_space() N = P.dimension() dim_scheme = X.dimension() # bound as per preposition - 4, in preperiodic points paper B = RR(2**(N / 4 + 1) * bound**2 * (N + 1).sqrt()) m = [0 for _ in range(N + 1)] def sufficient_primes(x): r""" Returns a list of primes whose product is > `x` """ small_primes = [2, 3] prod_primes = 6 while prod_primes < x: p = next_prime(small_primes[-1]) small_primes.append(p) prod_primes *= p return small_primes def good_primes(B): r""" Given the bound returns the prime whose product is greater than ``B`` and which would take least amount of time to run main sieve algorithm Complexity of finding points modulo primes is assumed to be N^2 * P_max^{N}. Complexity of lifting points and LLL() function is assumed to be close to N^5 * (alpha^dim_scheme / P_max). where alpha is product of all primes, and P_max is largest prime in list. """ M = dict() # stores optimal list of primes, corresponding to list size small_primes = sufficient_primes(B) max_length = len(small_primes) M[max_length] = small_primes current_count = max_length - 1 while current_count > 1: current_list = [] # stores prime which are bigger than least updated_list = [] best_list = [] least = (RR(B)**(1.00 / current_count)).floor() for i in range(current_count): current_list.append(next_prime(least)) least = current_list[-1] # improving list of primes by taking prime less than least # this part of algorithm is used to centralize primes around `least` prod_prime = prod(current_list) least = current_list[0] while least != 2 and prod_prime > B and len( updated_list) < current_count: best_list = updated_list + current_list[:current_count - len(updated_list)] updated_list.append(previous_prime(least)) least = updated_list[-1] removed_prime = current_list[current_count - len(updated_list)] prod_prime = (prod_prime * least) / removed_prime M[current_count] = sorted(best_list) current_count = current_count - 1 best_size = 2 best_time = (N**2) * M[2][-1]**(N) + ( N**5 * RR(prod(M[2])**dim_scheme / M[2][-1])) for i in range(2, max_length + 1): current_time = (N**2) * M[i][-1]**(N) + ( N**5 * RR(prod(M[i])**dim_scheme / M[i][-1])) if current_time < best_time: best_size = i best_time = current_time return M[best_size] def parallel_function(X, p): r""" Function used in parallel computation, computes a list of all rational points in modulo ring. """ Xp = X.change_ring(GF(p)) L = Xp.rational_points() return [list(_) for _ in L] def points_modulo_primes(X, primes): r""" Return a list of rational points modulo all `p` in primes, computed parallelly. """ normalized_input = [] for p in primes_list: normalized_input.append((( X, p, ), {})) p_iter = p_iter_fork(ncpus()) points_pair = list(p_iter(parallel_function, normalized_input)) points_pair.sort() return [pair[1] for pair in points_pair] def parallel_function_combination(point_p_max): r""" Function used in parallel computation, computes rational points lifted. """ rat_points = set() for tupl in xmrange(len_modulo_points): point = [] for k in range(N + 1): # lift all coordinates of given point using chinese remainder theorem L = [ modulo_points[j][tupl[j]][k].lift() for j in range(len_primes - 1) ] L.append(point_p_max[k].lift()) point.append(crt(L, primes_list)) for i in range(N + 1): m[i] = point[i] M = matrix(ZZ, N + 2, N + 1, m) A = M.LLL() point = list(A[1]) # check if all coordinates of this point satisfy height bound bound_satisfied = True for coordinate in point: if coordinate.abs() > bound: bound_satisfied = False break if not bound_satisfied: continue try: pt = X(list(A[1])) except TypeError: pass else: rat_points.add(pt) return [list(_) for _ in rat_points] def lift_all_points(): r""" Return list of all rational points lifted parallelly. """ normalized_input = [] points = modulo_points.pop( ) # remove the list of points corresponding to largest prime len_modulo_points.pop() for point in points: normalized_input.append(((point, ), {})) p_iter = p_iter_fork(ncpus()) points_satisfying = list( p_iter(parallel_function_combination, normalized_input)) lifted_points = set() for pair in points_satisfying: L = pair[1] for point in L: lifted_points.add(X(tuple(point))) return list(lifted_points) # start of main algorithm primes_list = good_primes(B.ceil()) modulo_points = points_modulo_primes(X, primes_list) len_modulo_points = [len(pt) for pt in modulo_points] len_primes = len(primes_list) prod_primes = prod(primes_list) # stores final result for i in range(N + 1): w = [0 for _ in range(N + 1)] w[i] = prod_primes m.extend(w) rat_points = lift_all_points() return sorted(rat_points)
def sieve(X, bound): r""" Returns the list of all rational points on scheme ``X`` of height up to ``bound``. ALGORITHM: Main idea behind the algorithm is to find points modulo primes and then reconstruct them using chinese remainder theorem. We compute the points modulo primes parallely and then lift them via chinese remainder theorem in parallel. The LLL reduction algorithm is applied to each component of the points, and finally the result is merged and converted to a point on the subscheme. For the algorithm to work correctly, sufficient primes need to be chosen, these are determined using the bounds dependent on the bound given in [Hutz2015]_. INPUT: - ``X`` - a scheme with ambient space defined over a product of projective spaces - ``bound`` - a positive integer bound OUTPUT: - a list containing the rational points of ``X`` of height up to ``bound``, sorted EXAMPLES:: sage: from sage.schemes.product_projective.rational_point import sieve sage: PP.<x,y,z,u,v> = ProductProjectiveSpaces([2,1], QQ) sage: X = PP.subscheme([x^2 + y^2 - x*z, u*u-v*u]) sage: sieve(X, 2) [(0 : 0 : 1 , 0 : 1), (0 : 0 : 1 , 1 : 1), (1/2 : -1/2 : 1 , 0 : 1), (1/2 : -1/2 : 1 , 1 : 1), (1/2 : 1/2 : 1 , 0 : 1), (1/2 : 1/2 : 1 , 1 : 1), (1 : 0 : 1 , 0 : 1), (1 : 0 : 1 , 1 : 1)] """ if bound < 1: return [] modulo_points = [] len_modulo_points = [] primes_list = [] P = X.ambient_space() N = P.ngens() dim_scheme = X.dimension() num_comp = P.num_components() comp_dim_relative = [P[i].dimension_relative() + 1 for i in range(num_comp)] dim_prefix = [0, comp_dim_relative[0]] # prefixes dim list for i in range(1, len(comp_dim_relative)): dim_prefix.append(dim_prefix[i] + comp_dim_relative[i]) dim_max = max(P[i].dimension() for i in range(num_comp)) B = RR(2**(dim_max/4+1)*bound**2*(dim_max+1).sqrt()) m = [] def sufficient_primes(x): r""" Returns a list of primes whose product is > `x` """ small_primes = [2,3] prod_primes = 6 while prod_primes < x: p = next_prime(small_primes[-1]) small_primes.append(p) prod_primes *= p return small_primes def good_primes(B): r""" Given the bound, returns the primes whose product is greater than ``B`` and which would take the least amount of time to run the main sieve algorithm Complexity of finding points modulo primes is assumed to be N^2 * P_max^{N}. Complexity of lifting points and the LLL() function is assumed to be close to (dim_max^5) * (alpha / P_max)^dim_scheme. where alpha is the product of all primes, P_max is the largest prime in the list, dim_max is the max dimension of all components, and N is the dimension of the ambient space. """ M = dict() # stores optimal list of primes, corresponding to list size small_primes = sufficient_primes(B) max_length = len(small_primes) M[max_length] = small_primes current_count = max_length - 1 dim = X.ambient_space().dimension() while current_count > 1: current_list = [] # stores prime which are bigger than least updated_list = [] best_list = [] least = (RR(B)**(1.00/current_count)).floor() for i in range(current_count): current_list.append(next_prime(least)) least = current_list[-1] # improving list of primes by taking primes less than least # this part of algorithm is used to centralize primes around `least` prod_prime = prod(current_list) least = current_list[0] while least != 2 and prod_prime > B and len(updated_list) < current_count: best_list = updated_list + current_list[:current_count - len(updated_list)] updated_list.append(previous_prime(least)) least = updated_list[-1] removed_prime = current_list[current_count - len(updated_list)] prod_prime = (prod_prime * least) / removed_prime M[current_count] = sorted(best_list) current_count = current_count - 1 best_size = 2 best_time = (dim**2)*M[2][-1]**(dim) + (dim_max**5 * (prod(M[2])/M[2][-1])**dim_scheme) for i in range(2, max_length + 1): current_time = (dim**2)*M[i][-1]**(dim) + (dim_max**5 * (prod(M[i])/M[i][-1])**dim_scheme) if current_time < best_time: best_size = i best_time = current_time return M[best_size] def parallel_function(X, p): r""" Function used in parallel computation, computes a list of all rational points in modulo p. """ Xp = X.change_ring(GF(p)) L = Xp.rational_points() return [list(_) for _ in L] def points_modulo_primes(X, primes): r""" Return a list of rational points modulo all `p` in primes, computed parallely. """ normalized_input = [] for p in primes_list: normalized_input.append(((X, p, ), {})) p_iter = p_iter_fork(ncpus()) points_pair = list(p_iter(parallel_function, normalized_input)) points_pair.sort() modulo_points = [] for pair in points_pair: modulo_points.append(pair[1]) return modulo_points def parallel_function_combination(point_p_max): r""" Function used in parallel computation, computes rational points lifted. """ rat_points = set() for tupl in xmrange(len_modulo_points): point = [] for k in range(N): # lift all coordinates of given point using chinese remainder theorem L = [modulo_points[j][tupl[j]][k].lift() for j in range(len_primes - 1)] L.append(point_p_max[k].lift()) point.append( crt(L, primes_list) ) for i in range(num_comp): for j in range(comp_dim_relative[i]): m[i][j] = point[dim_prefix[i] + j] # generating matrix to compute LLL reduction for each component M = [matrix(ZZ, comp_dim_relative[i] + 1, comp_dim_relative[i], m[i]) \ for i in range(num_comp)] A = [M[i].LLL() for i in range(num_comp)] point = [] for i in range(num_comp): point.extend(A[i][1]) # check if all coordinates of this point satisfy height bound bound_satisfied = True for coordinate in point: if coordinate.abs() > bound: bound_satisfied = False break if not bound_satisfied: continue try: rat_points.add(X(point)) # checks if this point lies on X or not except: pass return [list(_) for _ in rat_points] def lift_all_points(): r""" Returns list of all rational points lifted parallely. """ normalized_input = [] points = modulo_points.pop() # remove the list of points corresponding to largest prime len_modulo_points.pop() for point in points: normalized_input.append(( (point, ), {})) p_iter = p_iter_fork(ncpus()) points_satisfying = list(p_iter(parallel_function_combination, normalized_input)) lifted_points = set() for pair in points_satisfying: L = pair[1] for point in L: lifted_points.add(X(tuple(point))) return list(lifted_points) primes_list = good_primes(B.ceil()) modulo_points = points_modulo_primes(X, primes_list) len_modulo_points = [len(_) for _ in modulo_points] len_primes = len(primes_list) prod_primes = prod(primes_list) # construct m for each component projective space for i in range(num_comp): dim = comp_dim_relative[i] temp = [0 for _ in range(dim)] for j in range(dim): w = [0 for _ in range(dim)] w[j] = prod_primes temp.extend(w) m.append(temp) rat_points = lift_all_points() return sorted(rat_points)