def init_dynamic_properties(self, embeddings=False): if self.number is not None: emf_logger.debug('number: {0}'.format(self.number)) self.character = DirichletCharacter_conrey( DirichletGroup_conrey(self.modulus), self.number) if not self.number == 1: self.sage_character = self.character.sage_character() else: self.sage_character = trivial_character(self.modulus) self.name = "Character nr. {0} of modulus {1}".format( self.number, self.modulus) if embeddings: from lmfdb.modular_forms.elliptic_modular_forms.backend.emf_utils import dirichlet_character_conrey_galois_orbit_embeddings emb = dirichlet_character_conrey_galois_orbit_embeddings( self.modulus, self.number) self.set_embeddings(emb) c = self.character if self.conductor == 0: self.conductor = c.conductor() if self.order == 0: self.order = c.multiplicative_order() if self.modulus_euler_phi == 0: self.modulus_euler_phi = euler_phi(self.modulus) if self.latex_name == '': self.latex_name = "\chi_{" + str(self.modulus) + "}(" + str( self.number) + ", \cdot)"
def doline(inputs, line, lfun_dir, check_for_lpdata = True, check_for_lfunction = True): linesplit = line.rstrip('\n').split(':') hoc, label, conrey_label, embedding_index, embedding_m, ap_txt = linesplit lpfilename = os.path.join(lfun_dir, label + ".lpdata") lfunctionfilename = os.path.join(lfun_dir, label + ".lpdata.lfunction") level, weight, char_orbit, hecke_orbit, conrey_label_again, embedding = label.split('.') assert conrey_label_again == conrey_label level = int(level) weight = int(weight) conrey_label = int(conrey_label) ap_list = None G = DirichletGroup_conrey(level, CCC) char = DirichletCharacter_conrey(G, conrey_label) if not os.path.exists(lpfilename) or not check_for_lpdata: ap_list = read_aps(ap_txt) euler_factors = [[elt[0], euler_factor(level, weight, char, elt[0], elt[1])] for elt in ap_list] with open(lpfilename, 'w') as LPDATA: for p, ep in euler_factors: LPDATA.write("%d, [ %s ]\n" % (p, ", ".join(map(print_CCC, ep)))) if not os.path.exists(lfunctionfilename) or not check_for_lfunction: if weight not in inputs: inputs[weight] = [] sd = self_dual_by_char(char) if sd is None: if ap_list is None: ap_list = read_aps(ap_txt) sd = self_dual(char, ap_list) inputs[weight].append("%d %d %d %s %s" % (weight, sd, level, label, lpfilename))
def check_all_files(filename, linecount, chunk = 100): k = 0 base_dir = os.path.dirname(os.path.abspath(filename)) lfun_dir = os.path.join(base_dir, 'lfun') inputs_dir = os.path.join(base_dir, 'inputs') inputs = {} with open(filename, 'r') as F: for line in F: linesplit = line[:-1].split(':') hoc, label, conrey_label_tmp, embedding_index_tmp, embedding_m, ap_txt = linesplit lpdatafilename = os.path.join(lfun_dir, label + ".lpdata") lfunfilename = os.path.join(lfun_dir, label + ".lpdata.lfunction") if not os.path.exists(lpdatafilename): print "%s\tMissing lpdata file: %s" % (label, lpdatafilename) print "Use generate_lpdata_and_inputs.py to generate those files" sys.exit(1) if not os.path.exists(lfunfilename): print "%s\tMissing lfunction file: for %s" % (label, lfunfilename) # reading the line level, weight, char_orbit, hecke_orbit, conrey_label, embedding_index = label.split(".") level, weight, conrey_label, embedding_index = map(int, [level, weight, conrey_label, embedding_index]) ap_list = [ toCCC(*elt.split(',')) for elt in ap_txt[2:-2].split('],[')] ap_list = zip(primes_first_n(len(ap_list)),ap_list) G = DirichletGroup_conrey(level, CCC) char = DirichletCharacter_conrey(G, conrey_label) if weight not in inputs: inputs[weight] = [] inputs[weight].append("%d %d %d %s %s" % (weight, self_dual(char, ap_list) , level, label, lpdatafilename)) k += 1 if linecount > 10: if (k % (linecount//10)) == 0: print "check_all_files %.2f%% done" % (k*100./linecount) if len(inputs) > 0: real_filename = os.path.abspath(filename).split('/')[-1] parallel_inputs = os.path.join(base_dir, real_filename + '.tsv.missing') with open(parallel_inputs, 'w') as I: for weight, lines in inputs.iteritems(): if chunk is None: chunked_lines = [lines] else: chunked_lines = [ lines[i:i+chunk] for i in range(0, len(lines), chunk)] assert sum(map(len, chunked_lines)) == len(lines), "%d != %d" % (sum(map(len, chunked_lines)), len(lines)) for i, line_block in enumerate(chunked_lines): inputsfilename = os.path.join(inputs_dir, real_filename + '_wt%d_%d.missing.input' % (weight, i)) with open(inputsfilename , 'w') as W: W.write('\n'.join(line_block) + '\n') #print "wrote %d lines to %s" % (len(line_block), inputsfilename) I.write("%d\t%s\n" % (weight, inputsfilename)) print "There were some missing lfunction files!" print "please set LFUNCTIONS and run:" print r"""parallel -a %s --colsep '\t' --progress ${LFUNCTIONS}/euler_factors 11 200 ${LFUNCTIONS}/gamma_files/mf.{1} {2} 100""" % (parallel_inputs,) sys.exit(1) print "check_all_files done" return None
def primitivize(label): m, n = [ZZ(a) for a in label.split(".")] char = DirichletCharacter_conrey(DirGroup(m), n).primitive_character() return "%d.%d" % (char.modulus(), char.number())
def angles_euler_factors(coeffs, level, weight, chi): """ - ``coeffs`` -- a list of Dirichlet coefficients, as elements of CCC - ``level`` -- the level N - ``weight`` -- the weight k - ``chi`` -- the index of the Dirichlet character in the Conrey labeling returns a triple: (angles, euler_factos, bad_euler_factors) """ G = DirichletGroup_conrey(level, CCC) char = DirichletCharacter_conrey(G, chi) euler = [] bad_euler = [] angles = [] for p in prime_range(to_store): b = -coeffs[p] c = 1 if p.divides(level): bad_euler.append([p, [c, b]]) euler.append([c, b]) a = 0 angles.append(None) else: charval = CCC(2 * char.logvalue(int(p))).exppii() if charval.contains_exact(ZZ(1)): charval = 1 elif charval.contains_exact(ZZ(-1)): charval = -1 a = (p**QQ(weight - 1)) * charval euler.append([c, b, a]) # alpha solves T^2 - a_p T + chi(p)*p^(k-1) sqrt_disc = sqrt_hack(b**2 - 4 * a * c) thetas = [] for sign in [1, -1]: alpha = (-b + sign * sqrt_disc) / (2 * c) theta = (arg_hack(alpha) / (2 * CCC.pi().real())).mid() if theta > 0.5: theta -= 1 elif theta <= -0.5: theta += 1 assert theta <= 0.5 and theta > -0.5, "%s %s %s" % ( theta, arg_hack(alpha), alpha) thetas.append(theta) angles.append(float(min(thetas))) if len(coeffs) > p**2: if coeffs[p**2].abs().contains_zero(): match = (coeffs[p**2] - (b**2 - a)).abs().mid() < 1e-5 else: match = ((coeffs[p**2] - (b**2 - a)).abs() / coeffs[p**2].abs()).mid() < 1e-5 if not match: print "coeffs[p**2] doesn't match euler recursion" print zip(range(len(coeffs)), map(CDF, coeffs)) print "(level, weight, chi, p) = %s\n%s != %s\na_p2**2 - (b**2 - a)= %s\n b**2 - a = %s\na_p2 = %s\na=%s\nb = %s\nap = %s" % ( (level, weight, chi, p), CDF(coeffs[p**2]), CDF(b**2 - a), coeffs[p**2] - (b**2 - a), b**2 - a, coeffs[p**2], CDF(a), CDF(b), CDF(coeffs[p])) assert False an_f = [ CBF_to_pair(RRR(n)**(QQ(-(weight - 1)) / 2) * c) for n, c in enumerate(coeffs[:to_store + 1]) ] return an_f, angles, euler, bad_euler
def read_all(filename): # label -> [p, Lp] euler_factors_cc = {} # label -> labels orbits = {} # label -> postgres row as list rows = {} instances = {} base_dir = os.path.dirname(os.path.abspath(filename)) lfun_dir = os.path.join(base_dir, 'lfun') linecount = line_count(filename) check_all_files(filename, linecount) k = 0 with open(filename, 'r') as F: for line in F: linesplit = line[:-1].split(':') hoc, label, conrey_label_tmp, embedding_index_tmp, embedding_m, ap_txt = linesplit level, weight, char_orbit, hecke_orbit, conrey_label, embedding_index = label.split(".") assert conrey_label_tmp == conrey_label assert embedding_index_tmp == embedding_index mf_orbit_label = ".".join([level, weight, char_orbit, hecke_orbit]) if mf_orbit_label not in orbits: orbits[mf_orbit_label] = [] orbits[mf_orbit_label].append(label) ap_list = [ toCCC(*elt.split(',')) for elt in ap_txt[2:-2].split('],[')] ap_list = zip(primes_first_n(len(ap_list)),ap_list) lpfilename = os.path.join(lfun_dir, label + ".lpdata") lffilename = os.path.join(lfun_dir, label + ".lpdata.lfunction") if not all(map(os.path.exists, [lpfilename, lffilename])): continue level, weight, conrey_label, embedding_index = map(int, [level, weight, conrey_label, embedding_index]) G = DirichletGroup_conrey(level, CCC) char = DirichletCharacter_conrey(G, conrey_label) # the basis row = constant_lf(level, weight, 2) row['origin'] = "ModularForm/GL2/Q/holomorphic/%d/%d/%s/%s/%d/%d" % (level, weight, char_orbit, hecke_orbit, conrey_label, embedding_index) row['self_dual'] = self_dual(char, ap_list) row['central_character'] = "%s.%s" % (level, conrey_label) # sets accuracy, root_number, sign_arg, leading_term, order_of_vanishing, positive_zeros, plot_delta, plot_values for key, val in read_lfunction_file(lffilename).iteritems(): row[key] = val if row['self_dual']: row['conjugate'] = '\N' else: lfconjfilename= os.path.join(lfun_dir, label + ".lpdata.conj.lfunction") assert os.path.exists(lfconjfilename) row['conjugate'] = read_lfunction_file(lfconjfilename)['Lhash'] def euler_factor(p, ap): if p.divides(level): return [1, -ap] charval = CCC(2*char.logvalue(p)).exppii() if charval.contains_exact(ZZ(1)): charval = 1 elif charval.contains_exact(ZZ(-1)): charval = -1 return [1, -ap, (p**(weight-1))*charval] cut = 30 if level == 1 else max(30, prime_pi(max(prime_divisors(level)))) euler_factors = [ euler_factor(*elt) for elt in ap_list[:cut] ] bad_euler_factors = [ [elt[0], euler_factor(*elt)] for elt in ap_list if elt[0].divides(level)] euler_factors_cc[label] = euler_factors row['euler_factors'] = map( lambda x : map(CBF_to_pair, x), euler_factors) row['bad_lfactors'] = map( lambda x: [int(x[0]), map(CBF_to_pair, x[1])], bad_euler_factors) row['coefficient_field'] = 'CDF' for i, ai in enumerate(dirichlet(CCC, euler_factors[:11])[2:12]): if i + 2 <= 10: row['a' + str(i+2)] = CBF_to_pair(ai) for key in schema_lf: assert key in row, "%s not in row = %s" % (key, row) assert len(row) == len(schema_lf), "%s != %s" % (len(row) , len(schema_lf)) rows[label] = [row[key] for key in schema_lf] instances[label] = (row['origin'], row['Lhash'], 'CMF') k += 1 if linecount > 10: if (k % (linecount//10)) == 0: print "read_all %.2f%% done" % (k*100./linecount) print "read_all Done" rational_rows = populate_rational_rows(orbits, euler_factors_cc, rows, instances) positive_zeros = schema_lf_dict['positive_zeros'] for elt, val in rows.iteritems(): assert isinstance(val[positive_zeros], str), "%s, %s, %s" % (elt, type(val[positive_zeros]), val[positive_zeros]) lfun_filename = filename + ".lfunctions" instances_filename = filename + ".instances" export_lfunctions(rows, rational_rows, instances, lfun_filename, instances_filename) return 0
def conrey_character_from_number(N, c): D = DirichletGroup_conrey(N) return DirichletCharacter_conrey(D, c)
def setup_cc_data(self, info): """ INPUT: - ``info`` -- a dictionary with keys - ``m`` -- a string describing the embedding indexes desired - ``n`` -- a string describing the a_n desired - ``CC_m`` -- a list of embedding indexes - ``CC_n`` -- a list of desired a_n - ``format`` -- one of 'embed', 'analytic_embed', 'satake', or 'satake_angle' """ an_formats = ['embed','analytic_embed',None] angles_formats = ['satake','satake_angle',None] m = info.get('m','1-%s'%(min(self.dim,20))) n = info.get('n','1-10') CC_m = info.get('CC_m', integer_options(m)) CC_n = info.get('CC_n', integer_options(n)) # convert CC_n to an interval in [1,an_storage_bound] CC_n = ( max(1, min(CC_n)), min(an_storage_bound, max(CC_n)) ) an_keys = (CC_n[0]-1, CC_n[1]) # extra 5 primes in case we hit too many bad primes angles_keys = (bisect.bisect_left(primes_for_angles, CC_n[0]), bisect.bisect_right(primes_for_angles, CC_n[1]) + 5) format = info.get('format') cc_proj = ['conrey_label','embedding_index','embedding_m','embedding_root_real','embedding_root_imag'] an_projection = 'an[%d:%d]' % an_keys angles_projection = 'angles[%d:%d]' % angles_keys if format in an_formats: cc_proj.append(an_projection) if format in angles_formats: cc_proj.append(angles_projection) query = {'hecke_orbit_code':self.hecke_orbit_code} range_match = INTEGER_RANGE_RE.match(m) if range_match: low, high = int(range_match.group(1)), int(range_match.group(2)) query['embedding_m'] = {'$gte':low, '$lte':high} else: query['embedding_m'] = {'$in': CC_m} cc_data= list(db.mf_hecke_cc.search(query, projection = cc_proj)) if not cc_data: self.has_complex_qexp = False self.cqexp_prec = 0 else: self.has_complex_qexp = True self.cqexp_prec = an_keys[1] + 1 self.cc_data = {} for embedded_mf in cc_data: #as they are stored as a jsonb, large enough elements might be recognized as an integer if format in an_formats: # we don't store a_0, thus the +1 embedded_mf['an'] = {i: [float(x), float(y)] for i, (x, y) in enumerate(embedded_mf.pop(an_projection), an_keys[0] + 1)} if format in angles_formats: embedded_mf['angles'] = {primes_for_angles[i]: theta for i, theta in enumerate(embedded_mf.pop(angles_projection), angles_keys[0])} self.cc_data[embedded_mf.pop('embedding_m')] = embedded_mf if format in ['analytic_embed',None]: self.analytic_shift = {i : float(i)**((1-ZZ(self.weight))/2) for i in self.cc_data.values()[0]['an'].keys()} if format in angles_formats: self.character_values = defaultdict(list) G = DirichletGroup_conrey(self.level) chars = [DirichletCharacter_conrey(G, char) for char in self.char_labels] for p in self.cc_data.values()[0]['angles'].keys(): if p.divides(self.level): continue for chi in chars: c = chi.logvalue(p) * self.char_order angle = float(c / self.char_order) value = CDF(0,2*CDF.pi()*angle).exp() self.character_values[p].append((angle, value))
def dirichlet_character_from_lmfdb_mf(data): G = DirichletGroup_conrey(data[u'level']) return DirichletCharacter_conrey(G, data[u'conrey_indexes'][0])
def generate_lpdata_and_inputs(filename, check_for_lpdata=True, check_for_lfunction=True, chunk=100): linecount = line_count(filename) def print_RRR(elt): if elt.contains_integer(): try: return "%d" % ZZ(elt) except ValueError: pass return RRR(elt).str(style="question").replace('?', '') def print_CCC(elt): elt = CCC(elt) return "[ %s, %s]" % tuple(map(print_RRR, [elt.real(), elt.imag()])) def self_dual(char, aps): if char.is_trivial(): return True if (char * char).is_trivial(): for _, z in aps: if not z.imag().contains_zero(): return False return True else: return False base_dir = os.path.dirname(os.path.abspath(filename)) real_filename = os.path.abspath(filename).split('/')[-1] lfun_dir = os.path.join(base_dir, 'lfun') inputs_dir = os.path.join(base_dir, 'inputs') for d in [inputs_dir, lfun_dir]: if not os.path.exists(d): os.mkdir(d) inputs = {} k = 0 with open(filename, 'r') as F: for line in F: linesplit = line[:-1].split(':') hoc, label, conrey_label, embedding_index, embedding_m, ap_txt = linesplit lpfilename = os.path.join(lfun_dir, label + ".lpdata") lfunctionfilename = os.path.join(lfun_dir, label + ".lpdata.lfunction") level, weight, char_orbit, hecke_orbit, conrey_label_again, embedding = label.split( '.') assert conrey_label_again == conrey_label level = int(level) weight = int(weight) conrey_label = int(conrey_label) ap_list = [ toCCC(*elt.split(',')) for elt in ap_txt[2:-2].split('],[') ] ap_list = zip(primes_first_n(len(ap_list)), ap_list) G = DirichletGroup_conrey(level, CCC) char = DirichletCharacter_conrey(G, conrey_label) def euler_factor(p, ap): if p.divides(level): return [1, -ap] charval = CCC(2 * char.logvalue(p)).exppii() if charval.contains_exact(ZZ(1)): charval = 1 elif charval.contains_exact(ZZ(-1)): charval = -1 return [1, -ap, (p**(weight - 1)) * charval] euler_factors = [[elt[0], euler_factor(*elt)] for elt in ap_list] if not os.path.exists(lpfilename) or not check_for_lpdata: with open(lpfilename, 'w') as LPDATA: for p, ep in euler_factors: LPDATA.write("%d, [ %s ]\n" % (p, ", ".join(map(print_CCC, ep)))) if not os.path.exists( lfunctionfilename) or not check_for_lfunction: if weight not in inputs: inputs[weight] = [] inputs[weight].append( "%d %d %d %s %s" % (weight, self_dual( char, ap_list), level, label, lpfilename)) k += 1 if (k % (linecount // 10)) == 0: print "generate_lpdata_and_inputs %.2f%% done" % (k * 100. / linecount) parallel_inputs = os.path.join(base_dir, real_filename + '.tsv') with open(parallel_inputs, 'w') as I: for weight, lines in inputs.iteritems(): if chunk is None: chunked_lines = [lines] else: chunked_lines = [ lines[i:i + chunk] for i in range(0, len(lines), chunk) ] assert sum(map(len, chunked_lines)) == len(lines), "%d != %d" % (sum( map(len, chunked_lines)), len(lines)) for i, line_block in enumerate(chunked_lines): inputsfilename = os.path.join( inputs_dir, real_filename + '_wt%d_%d.input' % (weight, i)) with open(inputsfilename, 'w') as W: W.write('\n'.join(line_block) + '\n') #print "wrote %d lines to %s" % (len(line_block), inputsfilename) I.write("%d\t%s\n" % (weight, inputsfilename)) print "now set LFUNCTIONS and run:" print r"""parallel -a %s --colsep '\t' --progress ${LFUNCTIONS}/euler_factors 11 200 ${LFUNCTIONS}/gamma_files/mf.{1} {2} 100""" % ( parallel_inputs, )