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
