def compute_more_rational_eigenvalues(s, N, bound, verb=False): """ Computes rational eigenvalues for all rational eigenvectors in the given space up to the given bound. Commits result to database only if it succeeds at computing all the (good) eigenvalues. """ if not know_all_rational_newforms(s, N): if verb: print "Can't compute more rational eigenvalues until we know all rational eigenvectors at level %s (of norm %s)"%(N, N.norm()) return else: print "Computing more rational eigenvalues for eigenvectors of level %s (of norm %s)"%(N, N.norm()) NrmN = N.norm() H = get_space(s, N) M = H.hmf() V = M.vector_space() I = M._icosians_mod_p1 import sys for f in H.rational_newforms: vector = V(eval(f.vector)) if f.vector is not None else None dual_vector = V(eval(f.dual_vector)) i = dual_vector.nonzero_positions()[0] c = dual_vector[i] for P in primes_of_bounded_norm(bound): Ps = P.sage_ideal() # 1. Do we already know this eigenvalue or not? if s.query(RationalEigenvalue).filter( RationalEigenvalue.newform_id == f.id).filter( RationalEigenvalue.p == P.p).filter( RationalEigenvalue.r == P.r).count() > 0: continue # 2. We do not know it, so compute it -- two cases: # 2a. if it has residue char coprime to the level, use dual eigenvector ap = None if NrmN % P.p != 0: print P,; sys.stdout.flush() ap = I.hecke_operator_on_basis_element(Ps, i).dot_product(dual_vector)/c # 2b. if it has residue char not coprime to level, use slower direct approaches else: if (Ps*Ps).divides(N): ap = 0 elif not Ps.divides(N): if vector is None: if verb: print "You need to compute subspace vector to compute a_p at present." else: j = vector.nonzero_positions()[0] ap = (vector*M.hecke_matrix(Ps))[j] / vector[j] else: # we have no algorithm directly at present to decide if this is 1 or -1. if verb: print "Can't compute ap for p=%s"%P # 3. Store eigenvalue ap in the database. if ap is not None: f.store_eigenvalue(P, ap)
def compute_more_rational_eigenvalues_in_parallel(B1, B2, bound, ncpus=8): print "Preloading Hecke operator sets before forking." from sage.modular.hilbert.sqrt5 import hecke_elements from ideals_of_norm import ideals_of_norm for P in primes_of_bounded_norm(bound): print P, len(hecke_elements(P.sage_ideal())) @parallel(ncpus) def f(N): for I in ideals_of_norm(N): s = session() compute_more_rational_eigenvalues(s, I, bound=bound) s.commit() for X in f(range(max(2,B1), B2+1)): print X
def known_aplist(self): """ Output is a 2-tuple (aplist, primes,), where: aplist = list of integers of None primes = list of psage fast primes """ if len(self.eigenvalues) == 0: return [], [], [] B = self.eigenvalues[-1].norm primes = primes_of_bounded_norm(B+1) aplist = [None]*len(primes) last_p = None for ap in self.eigenvalues: P = Prime(ap.p, ap.r, first = (last_p != ap.p)) last_p = ap.p i = primes.index(P) # potentially "slow" but nothing compared to DB accesses... aplist[i] = ap.value return aplist, primes
def compute_rational_eigenvectors(s, N, bound=100): """ N = ideal, the level bound = compute this many a_p and use this many for ruling out oldforms This functions calls the "inefficient" elliptic_curve_factors method on the Hilbert modular forms space of level N, which has some problems: (1) some of the returned factors may actually be *old* (2) it is potentially very slow, since it computes the factors of all dimensions WARNING!: Just *loading* from disk the pre-computed elts of norm pi_p up to norm 4096 takes nearly *20 minutes*, but afterwards computing particular aplists for any form takes way under 20 *seconds*. """ # First do a query to see if we already know *all* of the rational # eigenvectors. if know_all_rational_newforms(s, N): print "We already know all rational eigenvectors at level %s (of norm %s)"%(N, N.norm()) return H = get_space(s, N) M = H.hmf() primes = primes_of_bounded_norm(bound) num_forms = 0 for E in M.elliptic_curve_factors(): if not N.is_prime(): # worry about E possibly actually being old v = E.aplist(bound) if is_rational_old(s, v, primes, N)[0]: print "*"*80 print "skipping a form that is old" print "*"*80 f = store_rational_newform(s, M, E._S.basis()[0], E.dual_eigenvector()) num_forms += 1 print "*"*80 print "form %s"%num_forms print "*"*80 # store eigenvalues v = E.aplist(bound) for i in range(len(v)): if v[i] != '?': f.store_eigenvalue(primes[i], int(v[i])) H.number_of_rational_newforms = num_forms s.commit()