def make_form(self): # To start with the data fields of self are just those from # the database. We need to reformat these and compute some # further (easy) data about it. # from lmfdb.ecnf.WebEllipticCurve import FIELD self.field = FIELD(self.field_label) pretty_field = field_pretty(self.field_label) self.field_knowl = nf_display_knowl(self.field_label, pretty_field) try: dims = db.bmf_dims.lucky({'field_label':self.field_label, 'level_label':self.level_label}, projection='gl2_dims') self.newspace_dimension = dims[str(self.weight)]['new_dim'] except TypeError: self.newspace_dimension = 'not available' self.newspace_label = "-".join([self.field_label,self.level_label]) self.newspace_url = url_for(".render_bmf_space_webpage", field_label=self.field_label, level_label=self.level_label) K = self.field.K() if self.dimension>1: Qx = PolynomialRing(QQ,'x') self.hecke_poly = Qx(str(self.hecke_poly)) F = NumberField(self.hecke_poly,'z') self.hecke_poly = web_latex(self.hecke_poly) def conv(ap): if '?' in ap: return 'not known' else: return F(str(ap)) self.hecke_eigs = [conv(str(ap)) for ap in self.hecke_eigs] self.nap = len(self.hecke_eigs) self.nap0 = min(50, self.nap) self.hecke_table = [[web_latex(p.norm()), ideal_label(p), web_latex(p.gens_reduced()[0]), web_latex(ap)] for p,ap in zip(primes_iter(K), self.hecke_eigs[:self.nap0])] level = ideal_from_label(K,self.level_label) self.level_ideal2 = web_latex(level) badp = level.prime_factors() self.have_AL = self.AL_eigs[0]!='?' if self.have_AL: self.AL_table = [[web_latex(p.norm()), ideal_label(p), web_latex(p.gens_reduced()[0]), web_latex(ap)] for p,ap in zip(badp, self.AL_eigs)] self.sign = 'not determined' try: if self.sfe == 1: self.sign = "+1" elif self.sfe == -1: self.sign = "-1" except AttributeError: self.sfe = '?' if self.Lratio == '?': self.Lratio = "not determined" self.anrank = "not determined" else: self.Lratio = QQ(self.Lratio) self.anrank = "\(0\)" if self.Lratio!=0 else "odd" if self.sfe==-1 else "\(\ge2\), even" self.properties2 = [('Base field', pretty_field), ('Weight', str(self.weight)), ('Level norm', str(self.level_norm)), ('Level', self.level_ideal2), ('Label', self.label), ('Dimension', str(self.dimension)) ] try: if self.CM == '?': self.CM = 'not determined' elif self.CM == 0: self.CM = 'no' else: if self.CM%4 in [2,3]: self.CM = 4*self.CM except AttributeError: self.CM = 'not determined' self.properties2.append(('CM', str(self.CM))) self.bc_extra = '' self.bcd = 0 self.bct = self.bc!='?' and self.bc!=0 if self.bc == '?': self.bc = 'not determined' elif self.bc == 0: self.bc = 'no' elif self.bc == 1: self.bcd = self.bc self.bc = 'yes' elif self.bc >1: self.bcd = self.bc self.bc = 'yes' self.bc_extra = ', of a form over \(\mathbb{Q}\) with coefficients in \(\mathbb{Q}(\sqrt{'+str(self.bcd)+'})\)' elif self.bc == -1: self.bc = 'no' self.bc_extra = ', but is a twist of the base-change of a form over \(\mathbb{Q}\)' elif self.bc < -1: self.bcd = -self.bc self.bc = 'no' self.bc_extra = ', but is a twist of the base-change of a form over \(\mathbb{Q}\) with coefficients in \(\mathbb{Q}(\sqrt{'+str(self.bcd)+'})\)' self.properties2.append(('Base-change', str(self.bc))) curve_bc = db.ec_nfcurves.lucky({'class_label':self.label}, projection="base_change") if curve_bc is not None: self.ec_status = 'exists' self.ec_url = url_for("ecnf.show_ecnf_isoclass", nf=self.field_label, conductor_label=self.level_label, class_label=self.label_suffix) curve_bc_parts = [split_lmfdb_label(lab) for lab in curve_bc] bc_urls = [url_for("cmf.by_url_newform_label", level=cond, weight=2, char_orbit_label='a', hecke_orbit=iso) for cond, iso, num in curve_bc_parts] bc_labels = [".".join( [str(cond), str(2), 'a', iso] ) for cond,iso,_ in curve_bc_parts] bc_exists = [db.mf_newforms.label_exists(lab) for lab in bc_labels] self.bc_forms = [{'exists':ex, 'label':lab, 'url':url} for ex,lab,url in zip(bc_exists, bc_labels, bc_urls)] else: self.bc_forms = [] if self.bct: self.ec_status = 'none' else: self.ec_status = 'missing' self.properties2.append(('Sign', self.sign)) self.properties2.append(('Analytic rank', self.anrank)) self.friends = [] self.friends += [('Newspace {}'.format(self.newspace_label),self.newspace_url)] url = 'ModularForm/GL2/ImaginaryQuadratic/{}'.format( self.label.replace('-', '/')) Lfun = get_lfunction_by_url(url) if Lfun: # first by Lhash instances = get_instances_by_Lhash(Lfun['Lhash']) # then by trace_hash instances += get_instances_by_trace_hash(Lfun['degree'], Lfun['trace_hash']) # This will also add the EC/G2C, as this how the Lfun was computed self.friends = names_and_urls(instances) # remove itself self.friends.remove( ('Bianchi modular form {}'.format(self.label), '/' + url)) self.friends.append(('L-function', '/L/'+url)) else: # old code if self.dimension == 1: if self.ec_status == 'exists': self.friends += [('Isogeny class {}'.format(self.label), self.ec_url)] elif self.ec_status == 'missing': self.friends += [('Isogeny class {} missing'.format(self.label), "")] else: self.friends += [('No elliptic curve', "")] self.friends += [ ('L-function not available','')]
def check_curves(field_label='2.0.4.1', min_norm=0, max_norm=None, label=None, check_ap=False, verbose=False): r"""Go through all Bianchi Modular Forms with the given field label, assumed imaginary quadratic (i.e. '2.0.d.1' with d in {4,8,3,7,11}), check whether an elliptic curve exists with the same label. If so, and if check_ap is True, check that the a_P agree. """ if field_label not in fields: print("No BMF data available for field {}".format(field_label)) return else: K = field_from_label(field_label) print("Checking forms over {}, norms from {} to {}".format( field_label, min_norm, max_norm)) query = {} query['field_label'] = field_label query['dimension'] = 1 # only look at rational newforms if label: print("looking for {} only".format(label)) query['short_label'] = label # e.g. '91.1-a' else: query['level_norm'] = {'$gte': int(min_norm)} if max_norm: query['level_norm']['$lte'] = int(max_norm) cursor = forms.search(query, sort=['level_norm']) labels = [f['short_label'] for f in cursor] nforms = len(labels) print("found {} newforms".format(nforms)) labels = [lab for lab in labels if lab not in false_curves[field_label]] nforms = len(labels) print( " of which {} should have associated curves (not false ones)".format( nforms)) nfound = 0 nnotfound = 0 nok = 0 missing_curves = [] mismatches = [] primes = list(primes_iter(K, maxnorm=1000)) if check_ap else [] curve_ap = {} # curve_ap[conductor_label] will be a dict iso -> ap form_ap = {} # form_ap[conductor_label] will be a dict iso -> ap # Now look at all newforms, check that there is an elliptic # curve of the same label, and if so compare ap-lists. The # dicts curve_ap and form_ap store these when there is # disagreement: e.g. curve_ap[conductor_label][iso_label] = # aplist. print("checking {} newforms".format(nforms)) n = 0 for curve_label in labels: n += 1 if n % 100 == 0: perc = 100.0 * n / nforms print("{} forms checked ({}%)".format(n, perc)) # We find the forms again since otherwise the cursor might timeout during the loop. label = "-".join([field_label, curve_label]) if verbose: print("newform and isogeny class label {}".format(label)) f = forms.lucky({'label': label}) if f: if verbose: print("found newform with label {}".format(label)) else: print("no newform in database has label {}!".format(label)) continue ec = nfcurves.lucky({'class_label': label, 'number': 1}) if ec: if verbose: print("curve with label %s found in the database" % curve_label) nfound += 1 if not check_ap: continue ainvsK = parse_ainvs(K, ec['ainvs']) if verbose: print("E = {}".format(ainvsK)) E = EllipticCurve(ainvsK) if verbose: print("constructed elliptic curve {}".format(E.ainvs())) good_flags = [E.has_good_reduction(P) for P in primes] good_primes = [P for (P, flag) in zip(primes, good_flags) if flag] if verbose: print("{} good primes".format(len(good_primes))) f_aplist = f['hecke_eigs'] f_aplist = [ap for ap, flag in zip(f_aplist, good_flags) if flag] nap = len(f_aplist) if verbose: print("recovered {} ap from BMF".format(nap)) aplist = [ E.reduction(P).trace_of_frobenius() for P in good_primes[:nap] ] if verbose: print("computed {} ap from elliptic curve".format(nap)) if aplist[:nap] == f_aplist[:nap]: nok += 1 if verbose: print("Curve {} and newform agree! (checked {} ap)".format( ec['short_label'], nap)) else: print("Curve {} does NOT agree with newform".format( ec['short_label'])) mismatches.append(label) if verbose: for P, aPf, aPc in zip(good_primes[:nap], f_aplist[:nap], aplist[:nap]): if aPf != aPc: print("P = {} with norm {}".format( P, P.norm().factor())) print("ap from curve: %s" % aPc) print("ap from form: %s" % aPf) if not ec['conductor_label'] in curve_ap: curve_ap[ec['conductor_label']] = {} form_ap[ec['conductor_label']] = {} curve_ap[ec['conductor_label']][ec['iso_label']] = aplist form_ap[ec['conductor_label']][f['label_suffix']] = f_aplist else: if verbose: print("No curve with label %s found in the database!" % curve_label) missing_curves.append(f['short_label']) nnotfound += 1 # Report progress: n = nfound + nnotfound if nnotfound: print( "Out of %s newforms, %s curves were found in the database and %s were not found" % (n, nfound, nnotfound)) else: print( "Out of %s newforms, all %s had curves with the same label and ap" % (n, nfound)) if nfound == nok: print("All curves agree with matching newforms") else: print("%s curves agree with matching newforms, %s do not" % (nok, nfound - nok)) if nnotfound: print("%s missing curves" % len(missing_curves)) else: pass if mismatches: print("{} form-curve pairs had inconsistent ap:".format( len(mismatches))) print(mismatches)
def make_form(self): # To start with the data fields of self are just those from # the database. We need to reformat these and compute some # further (easy) data about it. # from lmfdb.ecnf.WebEllipticCurve import FIELD self.field = FIELD(self.field_label) pretty_field = field_pretty(self.field_label) self.field_knowl = nf_display_knowl(self.field_label, pretty_field) try: dims = db.bmf_dims.lucky( { 'field_label': self.field_label, 'level_label': self.level_label }, projection='gl2_dims') self.newspace_dimension = dims[str(self.weight)]['new_dim'] except TypeError: self.newspace_dimension = 'not available' self.newspace_label = "-".join([self.field_label, self.level_label]) self.newspace_url = url_for(".render_bmf_space_webpage", field_label=self.field_label, level_label=self.level_label) K = self.field.K() if self.dimension > 1: Qx = PolynomialRing(QQ, 'x') self.hecke_poly = Qx(str(self.hecke_poly)) F = NumberField(self.hecke_poly, 'z') self.hecke_poly = web_latex(self.hecke_poly) def conv(ap): if '?' in ap: return 'not known' else: return F(str(ap)) self.hecke_eigs = [conv(str(ap)) for ap in self.hecke_eigs] self.nap = len(self.hecke_eigs) self.nap0 = min(50, self.nap) self.hecke_table = [[ web_latex(p.norm()), ideal_label(p), web_latex(p.gens_reduced()[0]), web_latex(ap) ] for p, ap in zip(primes_iter(K), self.hecke_eigs[:self.nap0])] level = ideal_from_label(K, self.level_label) self.level_ideal2 = web_latex(level) badp = level.prime_factors() self.have_AL = self.AL_eigs[0] != '?' if self.have_AL: self.AL_table = [[ web_latex(p.norm()), ideal_label(p), web_latex(p.gens_reduced()[0]), web_latex(ap) ] for p, ap in zip(badp, self.AL_eigs)] self.sign = 'not determined' if self.sfe == 1: self.sign = "+1" elif self.sfe == -1: self.sign = "-1" if self.Lratio == '?': self.Lratio = "not determined" self.anrank = "not determined" else: self.Lratio = QQ(self.Lratio) self.anrank = "\(0\)" if self.Lratio != 0 else "odd" if self.sfe == -1 else "\(\ge2\), even" self.properties2 = [('Base field', pretty_field), ('Weight', str(self.weight)), ('Level norm', str(self.level_norm)), ('Level', self.level_ideal2), ('Label', self.label), ('Dimension', str(self.dimension))] if self.CM == '?': self.CM = 'not determined' elif self.CM == 0: self.CM = 'no' self.properties2.append(('CM', str(self.CM))) self.bc_extra = '' self.bcd = 0 self.bct = self.bc != '?' and self.bc != 0 if self.bc == '?': self.bc = 'not determined' elif self.bc == 0: self.bc = 'no' elif self.bc == 1: self.bcd = self.bc self.bc = 'yes' elif self.bc > 1: self.bcd = self.bc self.bc = 'yes' self.bc_extra = ', of a form over \(\mathbb{Q}\) with coefficients in \(\mathbb{Q}(\sqrt{' + str( self.bcd) + '})\)' elif self.bc == -1: self.bc = 'no' self.bc_extra = ', but is a twist of the base-change of a form over \(\mathbb{Q}\)' elif self.bc < -1: self.bcd = -self.bc self.bc = 'no' self.bc_extra = ', but is a twist of the base-change of a form over \(\mathbb{Q}\) with coefficients in \(\mathbb{Q}(\sqrt{' + str( self.bcd) + '})\)' self.properties2.append(('Base-change', str(self.bc))) curve_bc = db.ec_nfcurves.lucky({'class_label': self.label}, projection="base_change") if curve_bc is not None: self.ec_status = 'exists' self.ec_url = url_for("ecnf.show_ecnf_isoclass", nf=self.field_label, conductor_label=self.level_label, class_label=self.label_suffix) curve_bc_parts = [split_lmfdb_label(lab) for lab in curve_bc] bc_urls = [ url_for("emf.render_elliptic_modular_forms", level=cond, weight=2, character=1, label=iso) for cond, iso, num in curve_bc_parts ] bc_labels = [ newform_label(cond, 2, 1, iso) for cond, iso, num in curve_bc_parts ] bc_exists = [is_newform_in_db(lab) for lab in bc_labels] self.bc_forms = [{ 'exists': ex, 'label': lab, 'url': url } for ex, lab, url in zip(bc_exists, bc_labels, bc_urls)] else: self.bc_forms = [] if self.bct: self.ec_status = 'none' else: self.ec_status = 'missing' self.properties2.append(('Sign', self.sign)) self.properties2.append(('Analytic rank', self.anrank)) self.friends = [] if self.dimension == 1: if self.ec_status == 'exists': self.friends += [ ('Elliptic curve isogeny class {}'.format(self.label), self.ec_url) ] elif self.ec_status == 'missing': self.friends += [ ('Elliptic curve {} missing'.format(self.label), "") ] else: self.friends += [('No elliptic curve', "")] self.friends += [('Newspace {}'.format(self.newspace_label), self.newspace_url)] self.friends += [('L-function not available', '')]
def make_form(self, nap0=50): # To start with the data fields of self are just those from # the database. We need to reformat these and compute some # further (easy) data about it. # from lmfdb.ecnf.WebEllipticCurve import FIELD self.field = FIELD(self.field_label) pretty_field = field_pretty(self.field_label) self.field_knowl = nf_display_knowl(self.field_label, pretty_field) try: dims = db.bmf_dims.lucky( { 'field_label': self.field_label, 'level_label': self.level_label }, projection='gl2_dims') self.newspace_dimension = dims[str(self.weight)]['new_dim'] except TypeError: self.newspace_dimension = 'not available' self.newspace_label = "-".join([self.field_label, self.level_label]) self.newspace_url = url_for(".render_bmf_space_webpage", field_label=self.field_label, level_label=self.level_label) K = self.field.K() # 'hecke_poly_obj' is the non-LaTeX version of hecke_poly self.hecke_poly_obj = self.hecke_poly if self.dimension > 1: Qx = PolynomialRing(QQ, 'x') self.hecke_poly = Qx(str(self.hecke_poly)) F = NumberField(self.hecke_poly, 'z') self.hecke_poly = web_latex(self.hecke_poly) def conv(ap): if '?' in ap: return 'not known' else: return F(str(ap)) self.hecke_eigs = [conv(str(ap)) for ap in self.hecke_eigs] self.level = ideal_from_label(K, self.level_label) self.level_ideal2 = web_latex(self.level) badp = self.level.prime_factors() self.nap = len(self.hecke_eigs) self.nap0 = min(nap0, self.nap) self.neigs = self.nap0 + len(badp) self.hecke_table = [[ web_latex(p.norm()), ideal_label(p), web_latex(p.gens_reduced()[0]), web_latex(ap) ] for p, ap in zip(primes_iter(K), self.hecke_eigs[:self.neigs]) if not p in badp] self.have_AL = self.AL_eigs[0] != '?' if self.have_AL: self.AL_table = [[ web_latex(p.norm()), ideal_label(p), web_latex(p.gens_reduced()[0]), web_latex(ap) ] for p, ap in zip(badp, self.AL_eigs)] # The following helps to create Sage download data self.AL_table_data = [[p.gens_reduced(), ap] for p, ap in zip(badp, self.AL_eigs)] self.sign = 'not determined' try: if self.sfe == 1: self.sign = "$+1$" elif self.sfe == -1: self.sign = "$-1$" except AttributeError: self.sfe = '?' if self.Lratio == '?': self.Lratio = "not determined" self.anrank = "not determined" else: self.Lratio = QQ(self.Lratio) self.anrank = r"\(0\)" if self.Lratio != 0 else "odd" if self.sfe == -1 else r"\(\ge2\), even" self.properties = [('Label', self.label), ('Base field', pretty_field), ('Weight', prop_int_pretty(self.weight)), ('Level norm', prop_int_pretty(self.level_norm)), ('Level', self.level_ideal2), ('Dimension', prop_int_pretty(self.dimension))] try: if self.CM == '?': self.CM = 'not determined' elif self.CM == 0: self.CM = 'no' else: if int(self.CM) % 4 in [2, 3]: self.CM = 4 * int(self.CM) self.CM = "$%s$" % self.CM except AttributeError: self.CM = 'not determined' self.properties.append(('CM', str(self.CM))) self.bc_extra = '' self.bcd = 0 self.bct = self.bc != '?' and self.bc != 0 if self.bc == '?': self.bc = 'not determined' elif self.bc == 0: self.bc = 'no' elif self.bc == 1: self.bcd = self.bc self.bc = 'yes' elif self.bc > 1: self.bcd = self.bc self.bc = 'yes' self.bc_extra = r', of a form over \(\mathbb{Q}\) with coefficients in \(\mathbb{Q}(\sqrt{' + str( self.bcd) + r'})\)' elif self.bc == -1: self.bc = 'no' self.bc_extra = r', but is a twist of the base change of a form over \(\mathbb{Q}\)' elif self.bc < -1: self.bcd = -self.bc self.bc = 'no' self.bc_extra = r', but is a twist of the base change of a form over \(\mathbb{Q}\) with coefficients in \(\mathbb{Q}(\sqrt{' + str( self.bcd) + r'})\)' self.properties.append(('Base change', str(self.bc))) curve_bc = db.ec_nfcurves.lucky({'class_label': self.label}, projection="base_change") if curve_bc is not None: if curve_bc and "." not in curve_bc[0]: curve_bc = [ cremona_label_to_lmfdb_label(lab) for lab in curve_bc ] self.ec_status = 'exists' self.ec_url = url_for("ecnf.show_ecnf_isoclass", nf=self.field_label, conductor_label=self.level_label, class_label=self.label_suffix) curve_bc_parts = [split_lmfdb_label(lab) for lab in curve_bc] bc_urls = [ url_for("cmf.by_url_newform_label", level=cond, weight=2, char_orbit_label='a', hecke_orbit=iso) for cond, iso, num in curve_bc_parts ] bc_labels = [ ".".join([str(cond), str(2), 'a', iso]) for cond, iso, _ in curve_bc_parts ] bc_exists = [db.mf_newforms.label_exists(lab) for lab in bc_labels] self.bc_forms = [{ 'exists': ex, 'label': lab, 'url': url } for ex, lab, url in zip(bc_exists, bc_labels, bc_urls)] else: self.bc_forms = [] if self.bct or self.label in bmfs_with_no_curve: self.ec_status = 'none' else: self.ec_status = 'missing' self.properties.append(('Sign', self.sign)) self.properties.append(('Analytic rank', self.anrank)) self.friends = [] self.friends += [('Newspace {}'.format(self.newspace_label), self.newspace_url)] url = 'ModularForm/GL2/ImaginaryQuadratic/{}'.format( self.label.replace('-', '/')) Lfun = get_lfunction_by_url(url) if Lfun: instances = get_instances_by_Lhash_and_trace_hash( Lfun['Lhash'], Lfun['degree'], Lfun['trace_hash']) # This will also add the EC/G2C, as this how the Lfun was computed # and not add itself self.friends = names_and_urls(instances, exclude={url}) self.friends.append(('L-function', '/L/' + url)) else: # old code if self.dimension == 1: if self.ec_status == 'exists': self.friends += [('Isogeny class {}'.format(self.label), self.ec_url)] elif self.ec_status == 'missing': self.friends += [ ('Isogeny class {} missing'.format(self.label), "") ] else: self.friends += [('No elliptic curve', "")] self.friends += [('L-function not available', '')]
def make_form(self): # To start with the data fields of self are just those from # the database. We need to reformat these and compute some # further (easy) data about it. # from lmfdb.ecnf.WebEllipticCurve import FIELD self.field = FIELD(self.field_label) pretty_field = field_pretty(self.field_label) self.field_knowl = nf_display_knowl(self.field_label, getDBConnection(), pretty_field) try: dims = db_dims().find_one({'field_label':self.field_label, 'level_label':self.level_label})['gl2_dims'] self.newspace_dimension = dims[str(self.weight)]['new_dim'] except TypeError: self.newspace_dimension = 'not available' self.newspace_label = "-".join([self.field_label,self.level_label]) self.newspace_url = url_for(".render_bmf_space_webpage", field_label=self.field_label, level_label=self.level_label) K = self.field.K() if self.dimension>1: Qx = PolynomialRing(QQ,'x') self.hecke_poly = Qx(str(self.hecke_poly)) F = NumberField(self.hecke_poly,'z') self.hecke_poly = web_latex(self.hecke_poly) def conv(ap): if '?' in ap: return 'not known' else: return F(str(ap)) self.hecke_eigs = [conv(str(ap)) for ap in self.hecke_eigs] self.nap = len(self.hecke_eigs) self.nap0 = min(50, self.nap) self.hecke_table = [[web_latex(p.norm()), ideal_label(p), web_latex(p.gens_reduced()[0]), web_latex(ap)] for p,ap in zip(primes_iter(K), self.hecke_eigs[:self.nap0])] level = ideal_from_label(K,self.level_label) self.level_ideal2 = web_latex(level) badp = level.prime_factors() self.have_AL = self.AL_eigs[0]!='?' if self.have_AL: self.AL_table = [[web_latex(p.norm()), ideal_label(p), web_latex(p.gens_reduced()[0]), web_latex(ap)] for p,ap in zip(badp, self.AL_eigs)] self.sign = 'not determined' if self.sfe == 1: self.sign = "+1" elif self.sfe == -1: self.sign = "-1" if self.Lratio == '?': self.Lratio = "not determined" self.anrank = "not determined" else: self.Lratio = QQ(self.Lratio) self.anrank = "\(0\)" if self.Lratio!=0 else "odd" if self.sfe==-1 else "\(\ge2\), even" self.properties2 = [('Base field', pretty_field), ('Weight', str(self.weight)), ('Level norm', str(self.level_norm)), ('Level', self.level_ideal2), ('Label', self.label), ('Dimension', str(self.dimension)) ] if self.CM == '?': self.CM = 'not determined' elif self.CM == 0: self.CM = 'no' self.properties2.append(('CM', str(self.CM))) self.bc_extra = '' self.bcd = 0 self.bct = self.bc!='?' and self.bc!=0 if self.bc == '?': self.bc = 'not determined' elif self.bc == 0: self.bc = 'no' elif self.bc == 1: self.bcd = self.bc self.bc = 'yes' elif self.bc >1: self.bcd = self.bc self.bc = 'yes' self.bc_extra = ', of a form over \(\mathbb{Q}\) with coefficients in \(\mathbb{Q}(\sqrt{'+str(self.bcd)+'})\)' elif self.bc == -1: self.bc = 'no' self.bc_extra = ', but is a twist of the base-change of a form over \(\mathbb{Q}\)' elif self.bc < -1: self.bcd = -self.bc self.bc = 'no' self.bc_extra = ', but is a twist of the base-change of a form over \(\mathbb{Q}\) with coefficients in \(\mathbb{Q}(\sqrt{'+str(self.bcd)+'})\)' self.properties2.append(('Base-change', str(self.bc))) curve = db_ecnf().find_one({'class_label':self.label}) if curve: self.ec_status = 'exists' self.ec_url = url_for("ecnf.show_ecnf_isoclass", nf=self.field_label, conductor_label=self.level_label, class_label=self.label_suffix) curve_bc = curve['base_change'] curve_bc_parts = [split_lmfdb_label(lab) for lab in curve_bc] bc_urls = [url_for("emf.render_elliptic_modular_forms", level=cond, weight=2, character=1, label=iso) for cond, iso, num in curve_bc_parts] bc_labels = [newform_label(cond,2,1,iso) for cond,iso,num in curve_bc_parts] bc_exists = [is_newform_in_db(lab) for lab in bc_labels] self.bc_forms = [{'exists':ex, 'label':lab, 'url':url} for ex,lab,url in zip(bc_exists, bc_labels, bc_urls)] else: self.bc_forms = [] if self.bct: self.ec_status = 'none' else: self.ec_status = 'missing' self.properties2.append(('Sign', self.sign)) self.properties2.append(('Analytic rank', self.anrank)) self.friends = [] if self.dimension==1: if self.ec_status == 'exists': self.friends += [('Elliptic curve isogeny class {}'.format(self.label), self.ec_url)] elif self.ec_status == 'missing': self.friends += [('Elliptic curve {} missing'.format(self.label), "")] else: self.friends += [('No elliptic curve', "")] self.friends += [ ('Newspace {}'.format(self.newspace_label),self.newspace_url)] self.friends += [ ('L-function not available','')]
def download_bmf_sage(**args): """Generates the sage code for the user to obtain the BMF eigenvalues. As in the HMF case, and unlike the website, we export *all* eigenvalues in the database, not just 50, and not just those away from the level.""" label = "-".join([args['field_label'], args['level_label'], args['label_suffix']]) try: f = WebBMF.by_label(label) except ValueError: return "Bianchi newform not found" hecke_pol = f.hecke_poly_obj hecke_eigs = f.hecke_eigs F = WebNumberField(f.field_label) K = f.field.K() primes_in_K = [p for p,_ in zip(primes_iter(K),hecke_eigs)] prime_gens = [p.gens_reduced() for p in primes_in_K] outstr = '"""\n This code can be loaded, or copied and paste using cpaste, into Sage.\n' outstr += ' It will load the data associated to the BMF, including\n' outstr += ' the field, level, and Hecke and Atkin-Lehner eigenvalue data (if known).\n' outstr += '"""\n\n' outstr += 'P = PolynomialRing(QQ, "x")\nx = P.gen()\n' outstr += 'g = P(' + str(F.coeffs()) + ')\n' outstr += 'F = NumberField(g, "{}")\n'.format(K.gen()) outstr += '{} = F.gen()\n'.format(K.gen()) outstr += 'ZF = F.ring_of_integers()\n\n' outstr += 'NN = ZF.ideal({})\n\n'.format(f.level.gens()) outstr += 'primes_array = [\n' + ','.join([str(st).replace(' ', '') for st in prime_gens]).replace('],[', '],\\\n[') + ']\n' outstr += 'primes = [ZF.ideal(I) for I in primes_array]\n\n' Qx = PolynomialRing(QQ,'x') if hecke_pol != 'x': outstr += 'heckePol = P({})\n'.format(str((Qx(hecke_pol)).list())) outstr += 'K = NumberField(heckePol, "z")\nz = K.gen()\n' else: outstr += 'heckePol = x\nK = QQ\ne = 1\n' hecke_eigs_processed = [str(st).replace(' ', '') if st != 'not known' else '"not known"' for st in hecke_eigs] outstr += '\nhecke_eigenvalues_array = [' + ', '.join(hecke_eigs_processed) + ']' outstr += '\nhecke_eigenvalues = {}\n' outstr += 'for i in range(len(hecke_eigenvalues_array)):\n hecke_eigenvalues[primes[i]] = hecke_eigenvalues_array[i]\n\n' if f.have_AL: AL_eigs = f.AL_table_data outstr += 'AL_eigenvalues = {}\n' for s in AL_eigs: outstr += 'AL_eigenvalues[ZF.ideal(%s)] = %s\n' % (s[0],s[1]) else: outstr += 'AL_eigenvalues ="not known"\n' outstr += '\n# EXAMPLE:\n# pp = ZF.ideal(2).factor()[0][0]\n# hecke_eigenvalues[pp]\n' return outstr
def download_bmf_magma(**args): label = "-".join([args['field_label'], args['level_label'], args['label_suffix']]) try: f = WebBMF.by_label(label) except ValueError: return "Bianchi newform not found" hecke_pol = f.hecke_poly_obj hecke_eigs = f.hecke_eigs F = WebNumberField(f.field_label) K = f.field.K() primes_in_K = [p for p,_ in zip(primes_iter(K),hecke_eigs)] prime_gens = [list(p.gens()) for p in primes_in_K] outstr = '/*\n This code can be loaded, or copied and pasted, into Magma.\n' outstr += ' It will load the data associated to the BMF, including\n' outstr += ' the field, level, and Hecke and Atkin-Lehner eigenvalue data.\n' outstr += ' At the *bottom* of the file, there is code to recreate the\n' outstr += ' Bianchi modular form in Magma, by creating the BMF space\n' outstr += ' and cutting out the corresponding Hecke irreducible subspace.\n' outstr += ' From there, you can ask for more eigenvalues or modify as desired.\n' outstr += ' It is commented out, as this computation may be lengthy.\n' outstr += '*/\n\n' outstr += 'P<x> := PolynomialRing(Rationals());\n' outstr += 'g := P!' + str(F.coeffs()) + ';\n' outstr += 'F<{}> := NumberField(g);\n'.format(K.gen()) outstr += 'ZF := Integers(F);\n\n' outstr += 'NN := ideal<ZF | {}>;\n\n'.format(set(f.level.gens())) outstr += 'primesArray := [\n' + ','.join([str(st).replace(' ', '') for st in prime_gens]).replace('],[', '],\n[') + '];\n' outstr += 'primes := [ideal<ZF | {F!x : x in I}> : I in primesArray];\n\n' if hecke_pol != 'x': outstr += 'heckePol := ' + hecke_pol + ';\n' outstr += 'K<z> := NumberField(heckePol);\n' else: outstr += 'heckePol := x;\nK := Rationals(); e := 1;\n' hecke_eigs_processed = [str(st).replace(' ', '') if st != 'not known' else '"not known"' for st in hecke_eigs] outstr += '\nheckeEigenvaluesList := [*\n'+ ',\n'.join(hecke_eigs_processed) + '\n*];\n' outstr += '\nheckeEigenvalues := AssociativeArray();\n' outstr += 'for i in [1..#heckeEigenvaluesList] do\n heckeEigenvalues[primes[i]] := heckeEigenvaluesList[i];\nend for;\n' if f.have_AL: AL_eigs = f.AL_table_data outstr += '\nALEigenvalues := AssociativeArray();\n' for s in AL_eigs: outstr += 'ALEigenvalues[ideal<ZF | {}>] := {};\n'.format(set(s[0]), s[1]) else: outstr += '\nALEigenvalues := "not known";\n' outstr += '\n// EXAMPLE:\n// pp := Factorization(2*ZF)[1][1];\n// heckeEigenvalues[pp];\n\n' outstr += '\n'.join([ 'print "To reconstruct the Bianchi newform f, type', ' f, iso := Explode(make_newform());";', '', 'function make_newform();', ' M := BianchiCuspForms(F, NN);', ' S := NewSubspace(M);', ' // SetVerbose("Bianchi", 1);', ' NFD := NewformDecomposition(S);', ' newforms := [* Eigenform(U) : U in NFD *];', '', ' if #newforms eq 0 then;', ' print "No Bianchi newforms at this level";', ' return 0;', ' end if;', '', ' print "Testing ", #newforms, " possible newforms";', ' newforms := [* f: f in newforms | IsIsomorphic(BaseField(f), K) *];', ' print #newforms, " newforms have the correct Hecke field";', '', ' if #newforms eq 0 then;', ' print "No Bianchi newform found with the correct Hecke field";', ' return 0;', ' end if;', '', ' autos := Automorphisms(K);', ' xnewforms := [* *];', ' for f in newforms do;', ' if K eq RationalField() then;', ' Append(~xnewforms, [* f, autos[1] *]);', ' else;', ' flag, iso := IsIsomorphic(K,BaseField(f));', ' for a in autos do;', ' Append(~xnewforms, [* f, a*iso *]);', ' end for;', ' end if;', ' end for;', ' newforms := xnewforms;', '', ' for P in primes do;', ' if Valuation(NN,P) eq 0 then;', ' xnewforms := [* *];', ' for f_iso in newforms do;', ' f, iso := Explode(f_iso);', ' if HeckeEigenvalue(f,P) eq iso(heckeEigenvalues[P]) then;', ' Append(~xnewforms, f_iso);', ' end if;', ' end for;', ' newforms := xnewforms;', ' if #newforms eq 0 then;', ' print "No Bianchi newform found which matches the Hecke eigenvalues";', ' return 0;', ' else if #newforms eq 1 then;', ' print "success: unique match";', ' return newforms[1];', ' end if;', ' end if;', ' end if;', ' end for;', ' print #newforms, "Bianchi newforms found which match the Hecke eigenvalues";', ' return newforms[1];', '', 'end function;']) return outstr