def download_hmf_magma(**args):
label = str(args['label'])
f = get_hmf(label)
if f is None:
return "No such form"
F = WebNumberField(f['field_label'])
F_hmf = get_hmf_field(f['field_label'])
hecke_pol = f['hecke_polynomial']
hecke_eigs = map(str, f['hecke_eigenvalues'])
AL_eigs = f['AL_eigenvalues']
outstr = 'P<x> := PolynomialRing(Rationals());\n'
outstr += 'g := P!' + str(F.coeffs()) + ';\n'
outstr += 'F<w> := NumberField(g);\n'
outstr += 'ZF := Integers(F);\n\n'
# outstr += 'ideals_str := [' + ','.join([st for st in F_hmf["ideals"]]) + '];\n'
# outstr += 'ideals := [ideal<ZF | {F!x : x in I}> : I in ideals_str];\n\n'
outstr += 'NN := ideal<ZF | {' + f["level_ideal"][1:-1] + '}>;\n\n'
outstr += 'primesArray := [\n' + ','.join([st for st in F_hmf["primes"]]).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<e> := NumberField(heckePol);\n'
else:
outstr += 'heckePol := x;\nK := Rationals(); e := 1;\n'
outstr += '\nheckeEigenvaluesArray := [' + ', '.join([st for st in hecke_eigs]) + '];'
outstr += '\nheckeEigenvalues := AssociativeArray();\n'
outstr += 'for i := 1 to #heckeEigenvaluesArray do\n heckeEigenvalues[primes[i]] := heckeEigenvaluesArray[i];\nend for;\n\n'
outstr += 'ALEigenvalues := AssociativeArray();\n'
for s in AL_eigs:
outstr += 'ALEigenvalues[ideal<ZF | {' + s[0][1:-1] + '}>] := ' + str(s[1]) + ';\n'
outstr += '\n// EXAMPLE:\n// pp := Factorization(2*ZF)[1][1];\n// heckeEigenvalues[pp];\n\n'
outstr += '/* EXTRA CODE: recompute eigenform (warning, may take a few minutes or longer!):\n'
outstr += 'M := HilbertCuspForms(F, NN);\n'
outstr += 'S := NewSubspace(M);\n'
outstr += '// SetVerbose("ModFrmHil", 1);\n'
outstr += 'newspaces := NewformDecomposition(S);\n'
outstr += 'newforms := [Eigenform(U) : U in newspaces];\n'
outstr += 'ppind := 0;\n'
outstr += 'while #newforms gt 1 do\n'
outstr += ' pp := primes[ppind];\n'
outstr += ' newforms := [f : f in newforms | HeckeEigenvalue(f,pp) eq heckeEigenvalues[pp]];\n'
outstr += 'end while;\n'
outstr += 'f := newforms[1];\n'
outstr += '// [HeckeEigenvalue(f,pp) : pp in primes] eq heckeEigenvaluesArray;\n'
outstr += '*/\n'
return outstr
def __init__(self, label):
self.Fdata = db.hmf_fields.lookup(label)
self.ideals = self.Fdata['ideals']
self.primes = self.Fdata['primes']
self.var = findvar(self.ideals)
WebNumberField.__init__(self, label, gen_name=self.var)
self.ideal_dict = {}
self.label_dict = {}
for I in self.ideals_iter():
self.ideal_dict[I['label']] = I['ideal']
self.label_dict[I['ideal']] = I['label']
def __init__(self, label):
self.Fdata = db.hmf_fields.lookup(label)
self.ideals = self.Fdata['ideals']
self.primes = self.Fdata['primes']
self.var = findvar(self.ideals)
WebNumberField.__init__(self,label,gen_name=self.var)
self.ideal_dict = {}
self.label_dict = {}
for I in self.ideals_iter():
self.ideal_dict[I['label']]=I['ideal']
self.label_dict[I['ideal']]=I['label']
def render_Heckewebpage(number_field=None, modulus=None, number=None):
#args = request.args
#temp_args = to_dict(args)
args = {}
args['type'] = 'Hecke'
args['number_field'] = number_field
args['modulus'] = modulus
args['number'] = number
if number_field == None:
info = WebHeckeExamples(**args).to_dict()
return render_template('Hecke.html', **info)
else:
WNF = WebNumberField(number_field)
if WNF.is_null():
return flask.abort(404, "Number field %s not found."%number_field)
if modulus == None:
try:
info = WebHeckeFamily(**args).to_dict()
except (ValueError,KeyError,TypeError) as err:
return flask.abort(404,err.args)
return render_template('CharFamily.html', **info)
elif number == None:
try:
info = WebHeckeGroup(**args).to_dict()
except (ValueError,KeyError,TypeError) as err:
# Typical failure case is a GP error inside bnrinit which we don't really want to display
return flask.abort(404,'Unable to construct modulus %s for number field %s'%(modulus,number_field))
m = info['modlabel']
info['bread'] = [('Characters', url_for(".render_characterNavigation")),
('Hecke', url_for(".render_Heckewebpage")),
('Number Field %s'%number_field, url_for(".render_Heckewebpage", number_field=number_field)),
('%s'%m, url_for(".render_Heckewebpage", number_field=number_field, modulus=m))]
info['code'] = dict([(k[4:],info[k]) for k in info if k[0:4] == "code"])
info['code']['show'] = { lang:'' for lang in info['codelangs'] } # use default show names
return render_template('CharGroup.html', **info)
else:
try:
X = WebHeckeCharacter(**args)
except (ValueError,KeyError,TypeError) as err:
return flask.abort(404, 'Unable to construct Hecke character %s modulo %s in number field %s.'%(number,modulus,number_field))
info = X.to_dict()
info['bread'] = [('Characters',url_for(".render_characterNavigation")),
('Hecke', url_for(".render_Heckewebpage")),
('Number Field %s'%number_field,url_for(".render_Heckewebpage", number_field=number_field)),
('%s'%X.modulus, url_for(".render_Heckewebpage", number_field=number_field, modulus=X.modlabel)),
('%s'%X.number2label(X.number), '')]
info['code'] = dict([(k[4:],info[k]) for k in info if k[0:4] == "code"])
info['code']['show'] = { lang:'' for lang in info['codelangs'] } # use default show names
return render_template('Character.html', **info)
def render_Heckewebpage(number_field=None, modulus=None, number=None):
#args = request.args
#temp_args = to_dict(args)
args = {}
args['type'] = 'Hecke'
args['number_field'] = number_field
args['modulus'] = modulus
args['number'] = number
if number_field == None:
info = WebHeckeExamples(**args).to_dict()
return render_template('Hecke.html', **info)
else:
WNF = WebNumberField(number_field)
if WNF.is_null():
return flask.abort(404, "Number field %s not found."%number_field)
if modulus == None:
try:
info = WebHeckeFamily(**args).to_dict()
except (ValueError,KeyError,TypeError) as err:
return flask.abort(404,err.args)
return render_template('CharFamily.html', **info)
elif number == None:
try:
info = WebHeckeGroup(**args).to_dict()
except (ValueError,KeyError,TypeError) as err:
# Typical failure case is a GP error inside bnrinit which we don't really want to display
return flask.abort(404,'Unable to construct modulus %s for number field %s'%(modulus,number_field))
m = info['modlabel']
info['bread'] = [('Characters', url_for(".render_characterNavigation")),
('Hecke', url_for(".render_Heckewebpage")),
('Number Field %s'%number_field, url_for(".render_Heckewebpage", number_field=number_field)),
('%s'%m, url_for(".render_Heckewebpage", number_field=number_field, modulus=m))]
info['code'] = dict([(k[4:],info[k]) for k in info if k[0:4] == "code"])
info['code']['show'] = { lang:'' for lang in info['codelangs'] } # use default show names
return render_template('CharGroup.html', **info)
else:
try:
X = WebHeckeCharacter(**args)
except (ValueError,KeyError,TypeError) as err:
return flask.abort(404, 'Unable to construct Hecke character %s modulo %s in number field %s.'%(number,modulus,number_field))
info = X.to_dict()
info['bread'] = [('Characters',url_for(".render_characterNavigation")),
('Hecke', url_for(".render_Heckewebpage")),
('Number Field %s'%number_field,url_for(".render_Heckewebpage", number_field=number_field)),
('%s'%X.modulus, url_for(".render_Heckewebpage", number_field=number_field, modulus=X.modlabel)),
('%s'%X.number2label(X.number), '')]
info['code'] = dict([(k[4:],info[k]) for k in info if k[0:4] == "code"])
info['code']['show'] = { lang:'' for lang in info['codelangs'] } # use default show names
return render_template('Character.html', **info)
def nf_code(**args):
label = args['nf']
lang = args['download_type']
nf = WebNumberField(label)
nf.make_code_snippets()
code = "{} {} code for working with number field {}\n\n".format(Comment[lang],Fullname[lang],label)
code += "{} (Note that not all these functions may be available, and some may take a long time to execute.)\n".format(Comment[lang])
if lang == 'gp':
lang = 'pari'
for k in sorted_code_names:
if lang in nf.code[k]:
code += "\n{} {}: \n".format(Comment[lang],code_names[k])
code += nf.code[k][lang] + ('\n' if '\n' not in nf.code[k][lang] else '')
return code
def av_data(label):
abvar = db.av_fqisog.lookup(label)
wnf = WebNumberField(abvar['nf'])
inf = '<div>Dimension: ' + str(abvar['g']) + '<br />'
if not wnf.is_null():
inf += 'Number field: ' + nf_display_knowl(abvar['nf'], name = abvar['nf']) + '<br />'
inf += 'Galois group: ' + group_display_knowl(abvar['galois_n'],abvar['galois_t']) + '<br />'
inf += '$p$-rank: ' + str(abvar['p_rank']) + '</div>'
inf += '<div align="right">'
g, q, iso = split_label(label)
url = url_for("abvarfq.abelian_varieties_by_gqi", g = g, q = q, iso = iso)
inf += '<a href="%s">%s home page</a>' % (url, label)
inf += '</div>'
return inf
def nf_code(**args):
label = args['nf']
nf = WebNumberField(label)
nf.make_code_snippets()
lang = args['download_type']
code = "{} {} code for working with number field {}\n\n".format(Comment[lang],Fullname[lang],label)
code += "{} (Note that not all these functions may be available, and some may take a long time to execute.)\n".format(Comment[lang])
if lang=='gp':
lang = 'pari'
for k in sorted_code_names:
if lang in nf.code[k]:
code += "\n{} {}: \n".format(Comment[lang],code_names[k])
code += nf.code[k][lang] + ('\n' if not '\n' in nf.code[k][lang] else '')
return code
def valuefield(self):
order2 = self.order if self.order % 4 != 2 else self.order / 2
nf = WebNumberField.from_cyclo(order2)
if not nf.is_null():
return nf_display_knowl(nf.get_label(), nf.field_pretty())
else:
return r'$\Q(\zeta_{%d})$' % order2
def vflabel(self):
order2 = self.order if self.order % 4 != 2 else self.order / 2
nf = WebNumberField.from_cyclo(order2)
if not nf.is_null():
return nf.label
else:
return ''
def lf_formatfield(coef):
coef = string2list(coef)
thefield = WebNumberField.from_coeffs(coef)
thepoly = '$%s$' % latex(coeff_to_poly(coef))
if thefield._data is None:
return thepoly
return nf_display_knowl(thefield.get_label(), thepoly)
def poly_to_field_label(pol):
try:
wnf = WebNumberField.from_polynomial(pol)
return wnf.get_label()
except Exception:
raise
return None
def download_hmf_sage(**args):
label = str(args['label'])
f = get_hmf(label)
if f is None:
return "No such form"
hecke_pol = f['hecke_polynomial']
hecke_eigs = map(str, f['hecke_eigenvalues'])
AL_eigs = f['AL_eigenvalues']
F = WebNumberField(f['field_label'])
F_hmf = get_hmf_field(f['field_label'])
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 HMF, including\n'
outstr += ' the field, level, and Hecke and Atkin-Lehner eigenvalue data.\n'
outstr += '*/\n\n'
outstr += 'P.<x> = PolynomialRing(QQ)\n'
outstr += 'g = P(' + str(F.coeffs()) + ')\n'
outstr += 'F.<w> = NumberField(g)\n'
outstr += 'ZF = F.ring_of_integers()\n\n'
outstr += 'NN = ZF.ideal(' + f["level_ideal"] + ')\n\n'
outstr += 'primes_array = [\n' + ','.join(
[st for st in F_hmf["primes"]]).replace('],[', '],\\\n[') + ']\n'
outstr += 'primes = [ZF.ideal(I) for I in primes_array]\n\n'
if hecke_pol != 'x':
outstr += 'heckePol = ' + hecke_pol + '\n'
outstr += 'K.<e> = NumberField(heckePol)\n'
else:
outstr += 'heckePol = x\nK = QQ\ne = 1\n'
outstr += '\nhecke_eigenvalues_array = [' + ', '.join(
[st for st in hecke_eigs]) + ']'
outstr += '\nhecke_eigenvalues = {}\n'
outstr += 'for i in range(len(hecke_eigenvalues_array)):\n hecke_eigenvalues[primes[i]] = hecke_eigenvalues_array[i]\n\n'
outstr += 'AL_eigenvalues = {}\n'
for s in AL_eigs:
outstr += 'AL_eigenvalues[ZF.ideal(%s)] = %s\n' % (s[0], s[1])
outstr += '\n# EXAMPLE:\n# pp = ZF.ideal(2).factor()[0][0]\n# hecke_eigenvalues[pp]\n'
return outstr
def download_hmf_sage(**args):
label = str(args['label'])
f = get_hmf(label)
if f is None:
return "No such form"
hecke_pol = f['hecke_polynomial']
hecke_eigs = map(str, f['hecke_eigenvalues'])
AL_eigs = f['AL_eigenvalues']
F = WebNumberField(f['field_label'])
F_hmf = get_hmf_field(f['field_label'])
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 HMF, including\n'
outstr += ' the field, level, and Hecke and Atkin-Lehner eigenvalue data.\n'
outstr += '*/\n\n'
outstr += 'P.<x> = PolynomialRing(QQ)\n'
outstr += 'g = P(' + str(F.coeffs()) + ')\n'
outstr += 'F.<w> = NumberField(g)\n'
outstr += 'ZF = F.ring_of_integers()\n\n'
outstr += 'NN = ZF.ideal(' + f["level_ideal"] + ')\n\n'
outstr += 'primes_array = [\n' + ','.join([st for st in F_hmf["primes"]]).replace('],[',
'],\\\n[') + ']\n'
outstr += 'primes = [ZF.ideal(I) for I in primes_array]\n\n'
if hecke_pol != 'x':
outstr += 'heckePol = ' + hecke_pol + '\n'
outstr += 'K.<e> = NumberField(heckePol)\n'
else:
outstr += 'heckePol = x\nK = QQ\ne = 1\n'
outstr += '\nhecke_eigenvalues_array = [' + ', '.join([st for st in hecke_eigs]) + ']'
outstr += '\nhecke_eigenvalues = {}\n'
outstr += 'for i in range(len(hecke_eigenvalues_array)):\n hecke_eigenvalues[primes[i]] = hecke_eigenvalues_array[i]\n\n'
outstr += 'AL_eigenvalues = {}\n'
for s in AL_eigs:
outstr += 'AL_eigenvalues[ZF.ideal(%s)] = %s\n' % (s[0],s[1])
outstr += '\n# EXAMPLE:\n# pp = ZF.ideal(2).factor()[0][0]\n# hecke_eigenvalues[pp]\n'
return outstr
def nf_postprocess(res, info, query):
galois_labels = [rec["galois_label"] for rec in res if rec.get("galois_label")]
cache = knowl_cache(list(set(galois_labels)))
for rec in res:
wnf = WebNumberField.from_data(rec)
rec["poly"] = wnf.web_poly()
rec["disc"] = wnf.disc_factored_latex()
rec["galois"] = wnf.galois_string(cache=cache)
rec["class_group_desc"] = wnf.class_group_invariants()
return res
def label(self):
if "label" in self._data.keys():
return self._data["label"]
else:
#from number_fields.number_field import poly_to_field_label
#pol = PolynomialRing(QQ, 'x')(map(str,self.polynomial()))
#label = poly_to_field_label(pol)
label = WebNumberField.from_coeffs(self._data["Polynomial"]).get_label()
if label:
self._data["label"] = label
return label
def av_data(label):
abvar = db.av_fq_isog.lookup(label)
if abvar is None:
return "This isogeny class is not in the database."
inf = "<div>Dimension: " + str(abvar["g"]) + "<br />"
if abvar["is_simple"]:
nf = abvar["number_fields"][0]
wnf = WebNumberField(nf)
if not wnf.is_null():
inf += ("Number field: " +
nf_display_knowl(nf, name=field_pretty(nf)) + "<br />")
inf += "Galois group: " + transitive_group_display_knowl(
abvar["galois_groups"][0]) + "<br />"
inf += "$p$-rank: " + str(abvar["p_rank"]) + "</div>"
inf += '<div align="right">'
g, q, iso = split_label(label)
url = url_for("abvarfq.abelian_varieties_by_gqi", g=g, q=q, iso=iso)
inf += '<a href="%s">%s home page</a>' % (url, label)
inf += "</div>"
return inf
def label(self):
if "label" in self._data.keys():
return self._data["label"]
else:
#from number_fields.number_field import poly_to_field_label
#pol = PolynomialRing(QQ, 'x')(map(str,self.polynomial()))
#label = poly_to_field_label(pol)
label = WebNumberField.from_coeffs(self._data["Polynomial"]).get_label()
if label:
self._data["label"] = label
return label
def G_name(self):
"""
More-or-less standardized name of the abstract group
"""
wnf = WebNumberField.from_polredabs(self.polredabs())
if not wnf.is_null():
mygalstring = wnf.galois_string()
if re.search('Trivial', mygalstring) is not None:
return '$C_1$'
# Have to remove dollar signs
return mygalstring
if self.polredabs().degree() < 12:
# Let pari compute it for us now
from sage.all import pari
galt = int(list(pari('polgalois(' + str(self.polredabs()) + ')'))[2])
from lmfdb.galois_groups.transitive_group import WebGaloisGroup
tg = WebGaloisGroup.from_nt(self.polredabs().degree(), galt)
return tg.display_short()
return self._data["G-Name"]
def G_name(self):
"""
More-or-less standardized name of the abstract group
"""
import re
wnf = WebNumberField.from_polredabs(self.polredabs())
if not wnf.is_null():
mygalstring = wnf.galois_string()
if re.search('Trivial', mygalstring) is not None:
return '$C_1$'
# Have to remove dollar signs
return mygalstring
if self.polredabs().degree() < 12:
# Let pari compute it for us now
from sage.all import pari
galt = int(list(pari('polgalois(' + str(self.polredabs()) + ')'))[2])
from lmfdb.galois_groups.transitive_group import WebGaloisGroup
tg = WebGaloisGroup.from_nt(self.polredabs().degree(), galt)
return tg.display_short()
return self._data["G-Name"]
def poly_to_field_label(pol):
try:
wnf = WebNumberField.from_polynomial(pol)
return wnf.get_label()
except:
return None
def wnf(self):
return WebNumberField.from_polredabs(self.polredabs())
def render_artin_representation_webpage(label):
if re.compile(r'^\d+$').match(label):
return artin_representation_search(**{
'dimension': label,
'search_array': ArtinSearchArray()
})
# label=dim.cond.nTt.indexcj, c is literal, j is index in conj class
# Should we have a big try around this to catch bad labels?
clean_label = clean_input(label)
if clean_label != label:
return redirect(
url_for('.render_artin_representation_webpage', label=clean_label),
301)
# We could have a single representation or a Galois orbit
case = parse_any(label)
if case[0] == 'malformed':
try:
raise ValueError
except:
flash_error(
"%s is not in a valid form for the label for an Artin representation or a Galois orbit of Artin representations",
label)
return redirect(url_for(".index"))
# Do this twice to customize error messages
newlabel = case[1]
case = case[0]
if case == 'rep':
try:
the_rep = ArtinRepresentation(newlabel)
except:
newlabel = parse_artin_label(label)
flash_error("Artin representation %s is not in database", label)
return redirect(url_for(".index"))
else: # it is an orbit
try:
the_rep = ArtinRepresentation(newlabel + '.a')
except:
newlabel = parse_artin_orbit_label(newlabel)
flash_error(
"Galois orbit of Artin representations %s is not in database",
label)
return redirect(url_for(".index"))
# in this case we want all characters
num_conj = the_rep.galois_conjugacy_size()
allchars = [
ArtinRepresentation(newlabel + '.' +
num2letters(j)).character_formatted()
for j in range(1, num_conj + 1)
]
label = newlabel
bread = get_bread([(label, ' ')])
#artin_logger.info("Found %s" % (the_rep._data))
if case == 'rep':
title = "Artin representation %s" % label
else:
title = "Galois orbit of Artin representations %s" % label
the_nf = the_rep.number_field_galois_group()
if the_rep.sign() == 0:
processed_root_number = "not computed"
else:
processed_root_number = str(the_rep.sign())
properties = [("Label", label), ("Dimension", str(the_rep.dimension())),
("Group", the_rep.group()),
("Conductor", "$" + the_rep.factored_conductor_latex() + "$")
]
if case == 'rep':
properties.append(("Root number", processed_root_number))
properties.append(("Frobenius-Schur indicator", str(the_rep.indicator())))
friends = []
wnf = None
nf_url = the_nf.url_for()
if nf_url:
friends.append(("Artin field", nf_url))
wnf = the_nf.wnf()
proj_nf = WebNumberField.from_coeffs(the_rep._data['Proj_Polynomial'])
if proj_nf:
friends.append(
("Projective Artin field",
str(url_for("number_fields.by_label",
label=proj_nf.get_label()))))
if case == 'rep':
cc = the_rep.central_character()
if cc is not None:
if the_rep.dimension() == 1:
if cc.order == 2:
cc_name = cc.symbol
else:
cc_name = cc.texname
friends.append(("Dirichlet character " + cc_name,
url_for("characters.render_Dirichletwebpage",
modulus=cc.modulus,
number=cc.number)))
else:
detrep = the_rep.central_character_as_artin_rep()
friends.append(("Determinant representation " + detrep.label(),
detrep.url_for()))
add_lfunction_friends(friends, label)
# once the L-functions are in the database, the link can always be shown
#if the_rep.dimension() <= 6:
if the_rep.dimension() == 1:
# Zeta is loaded differently
if cc.modulus == 1 and cc.number == 1:
friends.append(
("L-function",
url_for("l_functions.l_function_dirichlet_page",
modulus=cc.modulus,
number=cc.number)))
else:
# looking for Lhash dirichlet_L_modulus.number
mylhash = 'dirichlet_L_%d.%d' % (cc.modulus, cc.number)
lres = db.lfunc_instances.lucky({'Lhash': mylhash})
if lres is not None:
friends.append(
("L-function",
url_for("l_functions.l_function_dirichlet_page",
modulus=cc.modulus,
number=cc.number)))
# Dimension > 1
elif int(the_rep.conductor())**the_rep.dimension() <= 729000000000000:
friends.append(("L-function",
url_for("l_functions.l_function_artin_page",
label=the_rep.label())))
orblabel = re.sub(r'\.[a-z]+$', '', label)
friends.append(("Galois orbit " + orblabel,
url_for(".render_artin_representation_webpage",
label=orblabel)))
else:
add_lfunction_friends(friends, label)
friends.append(("L-function",
url_for("l_functions.l_function_artin_page",
label=the_rep.label())))
for j in range(1, 1 + the_rep.galois_conjugacy_size()):
newlabel = label + '.' + num2letters(j)
friends.append(("Artin representation " + newlabel,
url_for(".render_artin_representation_webpage",
label=newlabel)))
info = {} # for testing
if case == 'rep':
return render_template("artin-representation-show.html",
credit=tim_credit,
support=support_credit,
title=title,
bread=bread,
friends=friends,
object=the_rep,
cycle_string=cycle_string,
wnf=wnf,
properties=properties,
info=info,
learnmore=learnmore_list())
# else we have an orbit
return render_template("artin-representation-galois-orbit.html",
credit=tim_credit,
support=support_credit,
title=title,
bread=bread,
allchars=allchars,
friends=friends,
object=the_rep,
cycle_string=cycle_string,
wnf=wnf,
properties=properties,
info=info,
learnmore=learnmore_list())
def download_hmf_magma(**args):
label = str(args['label'])
f = get_hmf(label)
if f is None:
return "No such form"
F = WebNumberField(f['field_label'])
F_hmf = get_hmf_field(f['field_label'])
hecke_pol = f['hecke_polynomial']
hecke_eigs = [str(eig) for eig in f['hecke_eigenvalues']]
AL_eigs = f['AL_eigenvalues']
outstr = '/*\n This code can be loaded, or copied and pasted, into Magma.\n'
outstr += ' It will load the data associated to the HMF, 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 += ' Hilbert modular form in Magma, by creating the HMF 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<w> := NumberField(g);\n'
outstr += 'ZF := Integers(F);\n\n'
# outstr += 'ideals_str := [' + ','.join([st for st in F_hmf["ideals"]]) + '];\n'
# outstr += 'ideals := [ideal<ZF | {F!x : x in I}> : I in ideals_str];\n\n'
outstr += 'NN := ideal<ZF | {' + f["level_ideal"][1:-1] + '}>;\n\n'
outstr += 'primesArray := [\n' + ','.join(
[st for st in F_hmf["primes"]]).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<e> := NumberField(heckePol);\n'
else:
outstr += 'heckePol := x;\nK := Rationals(); e := 1;\n'
outstr += '\nheckeEigenvaluesArray := [' + ', '.join(
[st for st in hecke_eigs]) + '];'
outstr += '\nheckeEigenvalues := AssociativeArray();\n'
outstr += 'for i := 1 to #heckeEigenvaluesArray do\n heckeEigenvalues[primes[i]] := heckeEigenvaluesArray[i];\nend for;\n\n'
outstr += 'ALEigenvalues := AssociativeArray();\n'
for s in AL_eigs:
outstr += 'ALEigenvalues[ideal<ZF | {' + s[0][1:-1] + '}>] := ' + str(
s[1]) + ';\n'
outstr += '\n// EXAMPLE:\n// pp := Factorization(2*ZF)[1][1];\n// heckeEigenvalues[pp];\n\n'
outstr += '\n'.join([
'print "To reconstruct the Hilbert newform f, type',
' f, iso := Explode(make_newform());";', '',
'function make_newform();', ' M := HilbertCuspForms(F, NN);',
' S := NewSubspace(M);', ' // SetVerbose("ModFrmHil", 1);',
' NFD := NewformDecomposition(S);',
' newforms := [* Eigenform(U) : U in NFD *];', '',
' if #newforms eq 0 then;',
' print "No Hilbert 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 Hilbert 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;', ' 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 Hilbert 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 for;',
' print #newforms, "Hilbert newforms found which match the Hecke eigenvalues";',
' return newforms[1];', '', 'end function;'
])
return outstr
def render_hmf_webpage(**args):
if 'data' in args:
data = args['data']
label = data['label']
else:
label = str(args['label'])
data = get_hmf(label)
if data is None:
flash(Markup("Error: <span style='color:black'>%s</span> is not a valid Hilbert modular form label. It must be of the form (number field label) - (level label) - (orbit label) separated by dashes, such as 2.2.5.1-31.1-a" % args['label']), "error")
return search_input_error()
info = {}
try:
info['count'] = args['count']
except KeyError:
info['count'] = 50
hmf_field = get_hmf_field(data['field_label'])
gen_name = findvar(hmf_field['ideals'])
nf = WebNumberField(data['field_label'], gen_name=gen_name)
info['hmf_field'] = hmf_field
info['field'] = nf
info['base_galois_group'] = nf.galois_string()
info['field_degree'] = nf.degree()
info['field_disc'] = str(nf.disc())
info['field_poly'] = teXify_pol(str(nf.poly()))
info.update(data)
info['downloads'] = [
('Modular form to Magma', url_for(".render_hmf_webpage_download", field_label=info['field_label'], label=info['label'], download_type='magma')),
('Eigenvalues to Sage', url_for(".render_hmf_webpage_download", field_label=info['field_label'], label=info['label'], download_type='sage'))
]
# figure out friends
# first try to see if there is an instance of this HMF on Lfun db
url = 'ModularForm/GL2/TotallyReal/{}/holomorphic/{}'.format(
info['field_label'],
info['label'])
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
info['friends'] = names_and_urls(instances, exclude={url})
info['friends'] += [('L-function',
url_for("l_functions.l_function_hmf_page", field=info['field_label'], label=info['label'], character='0', number='0'))]
else:
# if there is no instance
# old code
if hmf_field['narrow_class_no'] == 1 and nf.disc()**2 * data['level_norm'] < 40000:
info['friends'] = [('L-function',
url_for("l_functions.l_function_hmf_page", field=info['field_label'], label=info['label'], character='0', number='0'))]
else:
info['friends'] = [('L-function not available', "")]
if data['dimension'] == 1: # Try to attach associated elliptic curve
lab = split_class_label(info['label'])
ec_from_hmf = db.ec_nfcurves.lookup(label + '1')
if ec_from_hmf is None:
info['friends'] += [('Elliptic curve not available', "")]
else:
info['friends'] += [('Isogeny class ' + info['label'], url_for("ecnf.show_ecnf_isoclass", nf=lab[0], conductor_label=lab[1], class_label=lab[2]))]
bread = [("Modular Forms", url_for('modular_forms')), ('Hilbert Modular Forms', url_for(".hilbert_modular_form_render_webpage")),
('%s' % data['label'], ' ')]
t = "Hilbert Cusp Form %s" % info['label']
forms_dims = db.hmf_forms.search({'field_label': data['field_label'], 'level_ideal': data['level_ideal']}, projection='dimension')
info['newspace_dimension'] = sum(forms_dims)
# Get hecke_polynomial, hecke_eigenvalues and AL_eigenvalues
try:
numeigs = request.args['numeigs']
numeigs = int(numeigs)
except:
numeigs = 20
info['numeigs'] = numeigs
hecke_pol = data['hecke_polynomial']
eigs = map(str, data['hecke_eigenvalues'])
eigs = eigs[:min(len(eigs), numeigs)]
AL_eigs = data['AL_eigenvalues']
primes = hmf_field['primes']
n = min(len(eigs), len(primes))
info['eigs'] = [{'eigenvalue': add_space_if_positive(teXify_pol(eigs[i])),
'prime_ideal': teXify_pol(primes[i]),
'prime_norm': primes[i][1:primes[i].index(',')]} for i in range(n)]
try:
display_eigs = request.args['display_eigs']
if display_eigs in ['True', 'true', '1', 'yes']:
display_eigs = True
else:
display_eigs = False
except KeyError:
display_eigs = False
if 'numeigs' in request.args:
display_eigs = True
info['hecke_polynomial'] = web_latex_split_on_pm(teXify_pol(hecke_pol))
if not AL_eigs: # empty list
if data['level_norm']==1: # OK, no bad primes
info['AL_eigs'] = 'none'
else: # not OK, AL eigs are missing
info['AL_eigs'] = 'missing'
else:
info['AL_eigs'] = [{'eigenvalue': teXify_pol(al[1]),
'prime_ideal': teXify_pol(al[0]),
'prime_norm': al[0][1:al[0].index(',')]} for al in data['AL_eigenvalues']]
max_eig_len = max([len(eig['eigenvalue']) for eig in info['eigs']])
display_eigs = display_eigs or (max_eig_len<=300)
info['display_eigs'] = display_eigs
if not display_eigs:
for eig in info['eigs']:
if len(eig['eigenvalue']) > 300:
eig['eigenvalue'] = '...'
info['level_ideal'] = teXify_pol(info['level_ideal'])
if 'is_CM' in data:
is_CM = data['is_CM']
else:
is_CM = '?'
info['is_CM'] = is_CM
if 'is_base_change' in data:
is_base_change = data['is_base_change']
else:
is_base_change = '?'
info['is_base_change'] = is_base_change
if 'q_expansions' in data:
info['q_expansions'] = data['q_expansions']
properties2 = [('Base field', '%s' % info['field'].field_pretty()),
('Weight', '%s' % data['weight']),
('Level norm', '%s' % data['level_norm']),
('Level', '$' + teXify_pol(data['level_ideal']) + '$'),
('Label', '%s' % data['label']),
('Dimension', '%s' % data['dimension']),
('CM', is_CM),
('Base change', is_base_change)
]
return render_template("hilbert_modular_form.html", downloads=info["downloads"], info=info, properties2=properties2, credit=hmf_credit, title=t, bread=bread, friends=info['friends'], learnmore=learnmore_list())
def FIELD(label):
nf = WebNumberField(label, gen_name=special_names.get(label, 'a'))
nf.parse_NFelt = lambda s: nf.K()([QQ(c.encode()) for c in s.split(",")])
nf.latex_poly = web_latex(nf.poly())
return nf
def bmf_field_dim_table(**args):
argsdict = to_dict(args)
argsdict.update(to_dict(request.args))
gl_or_sl = argsdict['gl_or_sl']
field_label=argsdict['field_label']
field_label = nf_string_to_label(field_label)
start = parse_start(argsdict)
info={}
info['gl_or_sl'] = gl_or_sl
# level_flag controls whether to list all levels ('all'), only
# those with positive cuspidal dimension ('cusp'), or only those
# with positive new dimension ('new'). Default is 'cusp'.
level_flag = argsdict.get('level_flag', 'cusp')
info['level_flag'] = level_flag
count = parse_count(argsdict, 50)
pretty_field_label = field_pretty(field_label)
bread = [('Bianchi Modular Forms', url_for(".index")), (
pretty_field_label, ' ')]
properties = []
query = {}
query['field_label'] = field_label
if gl_or_sl=='gl2_dims':
info['group'] = 'GL(2)'
info['bgroup'] = '\GL(2,\mathcal{O}_K)'
else:
info['group'] = 'SL(2)'
info['bgroup'] = '\SL(2,\mathcal{O}_K)'
if level_flag == 'all':
query[gl_or_sl] = {'$exists': True}
else:
# Only get records where the cuspdial/new dimension is positive for some weight
totaldim = gl_or_sl.replace('dims', level_flag) + '_totaldim'
query[totaldim] = {'$gt': 0}
t = ' '.join(['Dimensions of Spaces of {} Bianchi Modular Forms over'.format(info['group']), pretty_field_label])
data = list(db.bmf_dims.search(query, limit=count, offset=start, info=info))
nres = info['number']
if not info['exact_count']:
info['number'] = nres = db.bmf_dims.count(query)
info['exact_count'] = True
if nres > count or start != 0:
info['report'] = 'Displaying items %s-%s of %s levels,' % (start + 1, min(nres, start + count), nres)
else:
info['report'] = 'Displaying all %s levels,' % nres
info['field'] = field_label
info['field_pretty'] = pretty_field_label
nf = WebNumberField(field_label)
info['base_galois_group'] = nf.galois_string()
info['field_degree'] = nf.degree()
info['field_disc'] = str(nf.disc())
info['field_poly'] = teXify_pol(str(nf.poly()))
weights = set()
for dat in data:
weights = weights.union(set(dat[gl_or_sl].keys()))
weights = list([int(w) for w in weights])
weights.sort()
info['weights'] = weights
info['nweights'] = len(weights)
data.sort(key = lambda x: [int(y) for y in x['level_label'].split(".")])
dims = {}
for dat in data:
dims[dat['level_label']] = d = {}
for w in weights:
sw = str(w)
if sw in dat[gl_or_sl]:
d[w] = {'d': dat[gl_or_sl][sw]['cuspidal_dim'],
'n': dat[gl_or_sl][sw]['new_dim']}
else:
d[w] = {'d': '?', 'n': '?'}
info['nlevels'] = len(data)
dimtable = [{'level_label': dat['level_label'],
'level_norm': dat['level_norm'],
'level_space': url_for(".render_bmf_space_webpage", field_label=field_label, level_label=dat['level_label']) if gl_or_sl=='gl2_dims' else "",
'dims': dims[dat['level_label']]} for dat in data]
info['dimtable'] = dimtable
return render_template("bmf-field_dim_table.html", info=info, title=t, properties=properties, bread=bread)
def render_bmf_space_webpage(field_label, level_label):
info = {}
t = "Bianchi Modular Forms of Level %s over %s" % (level_label, field_label)
credit = bianchi_credit
bread = [('Modular Forms', url_for('modular_forms')),
('Bianchi Modular Forms', url_for(".index")),
(field_pretty(field_label), url_for(".render_bmf_field_dim_table_gl2", field_label=field_label)),
(level_label, '')]
friends = []
properties = []
if not field_label_regex.match(field_label):
info['err'] = "%s is not a valid label for an imaginary quadratic field" % field_label
else:
pretty_field_label = field_pretty(field_label)
if not db.bmf_dims.exists({'field_label': field_label}):
info['err'] = "no dimension information exists in the database for field %s" % pretty_field_label
else:
t = "Bianchi Modular Forms of level %s over %s" % (level_label, pretty_field_label)
data = db.bmf_dims.lucky({'field_label': field_label, 'level_label': level_label})
if not data:
info['err'] = "no dimension information exists in the database for level %s and field %s" % (level_label, pretty_field_label)
else:
info['label'] = data['label']
info['nf'] = nf = WebNumberField(field_label)
info['field_label'] = field_label
info['pretty_field_label'] = pretty_field_label
info['level_label'] = level_label
info['level_norm'] = data['level_norm']
info['field_poly'] = teXify_pol(str(nf.poly()))
info['field_knowl'] = nf_display_knowl(field_label, pretty_field_label)
w = 'i' if nf.disc()==-4 else 'a'
L = nf.K().change_names(w)
alpha = L.gen()
info['field_gen'] = latex(alpha)
I = ideal_from_label(L,level_label)
info['level_gen'] = latex(I.gens_reduced()[0])
info['level_fact'] = web_latex_ideal_fact(I.factor(), enclose=False)
dim_data = data['gl2_dims']
weights = dim_data.keys()
weights.sort(key=lambda w: int(w))
for w in weights:
dim_data[w]['dim']=dim_data[w]['cuspidal_dim']
info['dim_data'] = dim_data
info['weights'] = weights
info['nweights'] = len(weights)
newdim = data['gl2_dims']['2']['new_dim']
newforms = db.bmf_forms.search({'field_label':field_label, 'level_label':level_label})
info['nfdata'] = [{
'label': f['short_label'],
'url': url_for(".render_bmf_webpage",field_label=f['field_label'], level_label=f['level_label'], label_suffix=f['label_suffix']),
'wt': f['weight'],
'dim': f['dimension'],
'sfe': "+1" if f.get('sfe',None)==1 else "-1" if f.get('sfe',None)==-1 else "?",
'bc': bc_info(f['bc']),
'cm': cm_info(f.get('CM','?')),
} for f in newforms]
info['nnewforms'] = len(info['nfdata'])
# currently we have newforms of dimension 1 and 2 only (mostly dimension 1)
info['nnf1'] = sum(1 for f in info['nfdata'] if f['dim']==1)
info['nnf2'] = sum(1 for f in info['nfdata'] if f['dim']==2)
info['nnf_missing'] = dim_data['2']['new_dim'] - info['nnf1'] - 2*info['nnf2']
properties = [('Base field', pretty_field_label), ('Level',info['level_label']), ('Norm',str(info['level_norm'])), ('New dimension',str(newdim))]
friends = [('Newform {}'.format(f['label']), f['url']) for f in info['nfdata'] ]
return render_template("bmf-space.html", info=info, credit=credit, title=t, bread=bread, properties=properties, friends=friends, learnmore=learnmore_list())
def belyi_base_field(galmap):
fld_coeffs = galmap["base_field"]
if fld_coeffs == [-1, 1]:
fld_coeffs = [0, 1]
F = WebNumberField.from_coeffs(fld_coeffs)
return F
def bmf_field_dim_table(**args):
argsdict = to_dict(args)
argsdict.update(to_dict(request.args))
gl_or_sl = argsdict['gl_or_sl']
field_label=argsdict['field_label']
field_label = nf_string_to_label(field_label)
start = parse_start(argsdict)
info={}
info['gl_or_sl'] = gl_or_sl
# level_flag controls whether to list all levels ('all'), only
# those with positive cuspidal dimension ('cusp'), or only those
# with positive new dimension ('new'). Default is 'cusp'.
level_flag = argsdict.get('level_flag', 'cusp')
info['level_flag'] = level_flag
count = parse_count(argsdict, 50)
pretty_field_label = field_pretty(field_label)
bread = [('Bianchi Modular Forms', url_for(".index")), (
pretty_field_label, ' ')]
properties = []
if gl_or_sl=='gl2_dims':
info['group'] = 'GL(2)'
info['bgroup'] = '\GL(2,\mathcal{O}_K)'
else:
info['group'] = 'SL(2)'
info['bgroup'] = '\SL(2,\mathcal{O}_K)'
t = ' '.join(['Dimensions of Spaces of {} Bianchi Modular Forms over'.format(info['group']), pretty_field_label])
query = {}
query['field_label'] = field_label
query[gl_or_sl] = {'$exists': True}
data = db.bmf_dims.search(query, limit=count, offset=start, info=info)
nres = info['number']
if nres > count or start != 0:
info['report'] = 'Displaying items %s-%s of %s levels,' % (start + 1, min(nres, start + count), nres)
else:
info['report'] = 'Displaying all %s levels,' % nres
# convert data to a list and eliminate levels where all
# new/cuspidal dimensions are 0. (This could be done at the
# search stage, but that requires adding new fields to each
# record.)
def filter(dat, flag):
dat1 = dat[gl_or_sl]
return any([int(dat1[w][flag])>0 for w in dat1])
flag = 'cuspidal_dim' if level_flag=='cusp' else 'new_dim'
data = [dat for dat in data if level_flag == 'all' or filter(dat, flag)]
info['field'] = field_label
info['field_pretty'] = pretty_field_label
nf = WebNumberField(field_label)
info['base_galois_group'] = nf.galois_string()
info['field_degree'] = nf.degree()
info['field_disc'] = str(nf.disc())
info['field_poly'] = teXify_pol(str(nf.poly()))
weights = set()
for dat in data:
weights = weights.union(set(dat[gl_or_sl].keys()))
weights = list([int(w) for w in weights])
weights.sort()
info['weights'] = weights
info['nweights'] = len(weights)
data.sort(key = lambda x: [int(y) for y in x['level_label'].split(".")])
dims = {}
for dat in data:
dims[dat['level_label']] = d = {}
for w in weights:
sw = str(w)
if sw in dat[gl_or_sl]:
d[w] = {'d': dat[gl_or_sl][sw]['cuspidal_dim'],
'n': dat[gl_or_sl][sw]['new_dim']}
else:
d[w] = {'d': '?', 'n': '?'}
info['nlevels'] = len(data)
dimtable = [{'level_label': dat['level_label'],
'level_norm': dat['level_norm'],
'level_space': url_for(".render_bmf_space_webpage", field_label=field_label, level_label=dat['level_label']) if gl_or_sl=='gl2_dims' else "",
'dims': dims[dat['level_label']]} for dat in data]
info['dimtable'] = dimtable
return render_template("bmf-field_dim_table.html", info=info, title=t, properties=properties, bread=bread)
def download_hmf_magma(**args):
label = str(args['label'])
f = get_hmf(label)
if f is None:
return "No such form"
F = WebNumberField(f['field_label'])
F_hmf = get_hmf_field(f['field_label'])
hecke_pol = f['hecke_polynomial']
hecke_eigs = map(str, f['hecke_eigenvalues'])
AL_eigs = f['AL_eigenvalues']
outstr = '/*\n This code can be loaded, or copied and pasted, into Magma.\n'
outstr += ' It will load the data associated to the HMF, 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 += ' Hilbert modular form in Magma, by creating the HMF 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<w> := NumberField(g);\n'
outstr += 'ZF := Integers(F);\n\n'
# outstr += 'ideals_str := [' + ','.join([st for st in F_hmf["ideals"]]) + '];\n'
# outstr += 'ideals := [ideal<ZF | {F!x : x in I}> : I in ideals_str];\n\n'
outstr += 'NN := ideal<ZF | {' + f["level_ideal"][1:-1] + '}>;\n\n'
outstr += 'primesArray := [\n' + ','.join([st for st in F_hmf["primes"]]).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<e> := NumberField(heckePol);\n'
else:
outstr += 'heckePol := x;\nK := Rationals(); e := 1;\n'
outstr += '\nheckeEigenvaluesArray := [' + ', '.join([st for st in hecke_eigs]) + '];'
outstr += '\nheckeEigenvalues := AssociativeArray();\n'
outstr += 'for i := 1 to #heckeEigenvaluesArray do\n heckeEigenvalues[primes[i]] := heckeEigenvaluesArray[i];\nend for;\n\n'
outstr += 'ALEigenvalues := AssociativeArray();\n'
for s in AL_eigs:
outstr += 'ALEigenvalues[ideal<ZF | {' + s[0][1:-1] + '}>] := ' + str(s[1]) + ';\n'
outstr += '\n// EXAMPLE:\n// pp := Factorization(2*ZF)[1][1];\n// heckeEigenvalues[pp];\n\n'
outstr += '/* EXTRA CODE: recompute eigenform (warning, may take a few minutes or longer!):\n'
outstr += 'M := HilbertCuspForms(F, NN);\n'
outstr += 'S := NewSubspace(M);\n'
outstr += '// SetVerbose("ModFrmHil", 1);\n'
outstr += 'newspaces := NewformDecomposition(S);\n'
outstr += 'newforms := [Eigenform(U) : U in newspaces];\n'
outstr += 'ppind := 0;\n'
outstr += 'while #newforms gt 1 do\n'
outstr += ' pp := primes[ppind];\n'
outstr += ' newforms := [f : f in newforms | HeckeEigenvalue(f,pp) eq heckeEigenvalues[pp]];\n'
outstr += 'end while;\n'
outstr += 'f := newforms[1];\n'
outstr += '// [HeckeEigenvalue(f,pp) : pp in primes] eq heckeEigenvaluesArray;\n'
outstr += '*/\n'
return outstr
def wnf(self):
return WebNumberField.from_polredabs(self.polredabs())
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 nf_data(**args):
label = args['nf']
nf = WebNumberField(label)
data = '/* Data is in the following format\n'
data += ' Note, if the class group has not been computed, it, the class number, the fundamental units, regulator and whether grh was assumed are all 0.\n'
data += '[polynomial,\ndegree,\nt-number of Galois group,\nsignature [r,s],\ndiscriminant,\nlist of ramifying primes,\nintegral basis as polynomials in a,\n1 if it is a cm field otherwise 0,\nclass number,\nclass group structure,\n1 if grh was assumed and 0 if not,\nfundamental units,\nregulator,\nlist of subfields each as a pair [polynomial, number of subfields isomorphic to one defined by this polynomial]\n]'
data += '\n*/\n\n'
zk = nf.zk()
Ra = PolynomialRing(QQ, 'a')
zk = [str(Ra(x)) for x in zk]
zk = ', '.join(zk)
units = str(unlatex(nf.units()))
units = units.replace(' ', ' ')
subs = nf.subfields()
subs = [[coeff_to_poly(string2list(z[0])), z[1]] for z in subs]
# Now add actual data
data += '[%s, ' % nf.poly()
data += '%s, ' % nf.degree()
data += '%s, ' % nf.galois_t()
data += '%s, ' % nf.signature()
data += '%s, ' % nf.disc()
data += '%s, ' % nf.ramified_primes()
data += '[%s], ' % zk
data += '%s, ' % str(1 if nf.is_cm_field() else 0)
if nf.can_class_number():
data += '%s, ' % nf.class_number()
data += '%s, ' % nf.class_group_invariants_raw()
data += '%s, ' % (1 if nf.used_grh() else 0)
data += '[%s], ' % units
data += '%s, ' % nf.regulator()
else:
data += '0,0,0,0,0, '
data += '%s' % subs
data += ']'
return data
def download_search(info):
dltype = info['Submit']
delim = 'bracket'
com = r'\\' # single line comment start
com1 = '' # multiline comment start
com2 = '' # multiline comment end
filename = 'elliptic_curves.gp'
mydate = time.strftime("%d %B %Y")
if dltype == 'sage':
com = '#'
filename = 'elliptic_curves.sage'
if dltype == 'magma':
com = ''
com1 = '/*'
com2 = '*/'
delim = 'magma'
filename = 'elliptic_curves.m'
s = com1 + "\n"
s += com + ' Elliptic curves downloaded from the LMFDB downloaded on %s.\n' % (
mydate)
s += com + ' Below is a list called data. Each entry has the form:\n'
s += com + ' [[field_poly],[Weierstrass Coefficients, constant first in increasing degree]]\n'
s += '\n' + com2
s += '\n'
if dltype == 'magma':
s += 'P<x> := PolynomialRing(Rationals()); \n'
s += 'data := ['
elif dltype == 'sage':
s += 'R.<x> = QQ[]; \n'
s += 'data = [ '
else:
s += 'data = [ '
s += '\\\n'
nf_dict = {}
for f in db.ec_nfcurves.search(ast.literal_eval(info["query"]),
['field_label', 'ainvs']):
nf = str(f['field_label'])
# look up number field and see if we already have the min poly
if nf in nf_dict:
poly = nf_dict[nf]
else:
poly = str(WebNumberField(f['field_label']).poly())
nf_dict[nf] = poly
entry = str(f['ainvs'])
entry = entry.replace('u', '')
entry = entry.replace('\'', '')
entry = entry.replace(';', '],[')
s += '[[' + poly + '], [[' + entry + ']]],\\\n'
s = s[:-3]
s += ']\n'
if delim == 'brace':
s = s.replace('[', '{')
s = s.replace(']', '}')
if delim == 'magma':
s = s.replace('[', '[*')
s = s.replace(']', '*]')
s += ';'
strIO = BytesIO()
strIO.write(s.encode('utf-8'))
strIO.seek(0)
return send_file(strIO,
attachment_filename=filename,
as_attachment=True,
add_etags=False)
def render_field_webpage(args):
data = None
info = {}
bread = bread_prefix()
# This function should not be called unless label is set.
label = clean_input(args['label'])
nf = WebNumberField(label)
data = {}
if nf.is_null():
if re.match(r'^\d+\.\d+\.\d+\.\d+$', label):
flash_error("Number field %s was not found in the database.",
label)
else:
flash_error("%s is not a valid label for a number field.", label)
return redirect(url_for(".number_field_render_webpage"))
info['wnf'] = nf
data['degree'] = nf.degree()
data['class_number'] = nf.class_number_latex()
ram_primes = nf.ramified_primes()
t = nf.galois_t()
n = nf.degree()
data['is_galois'] = nf.is_galois()
data['autstring'] = r'\Gal' if data['is_galois'] else r'\Aut'
data['is_abelian'] = nf.is_abelian()
if nf.is_abelian():
conductor = nf.conductor()
data['conductor'] = conductor
dirichlet_chars = nf.dirichlet_group()
if dirichlet_chars:
data['dirichlet_group'] = [
r'<a href = "%s">$\chi_{%s}(%s,·)$</a>' %
(url_for('characters.render_Dirichletwebpage',
modulus=data['conductor'],
number=j), data['conductor'], j)
for j in dirichlet_chars
]
if len(data['dirichlet_group']) == 1:
data[
'dirichlet_group'] = r'<span style="white-space:nowrap">$\lbrace$' + data[
'dirichlet_group'][0] + r'$\rbrace$</span>'
else:
data['dirichlet_group'] = r'$\lbrace$' + ', '.join(
data['dirichlet_group']
[:-1]) + '<span style="white-space:nowrap">' + data[
'dirichlet_group'][-1] + r'$\rbrace$</span>'
if data['conductor'].is_prime() or data['conductor'] == 1:
data['conductor'] = r"\(%s\)" % str(data['conductor'])
else:
factored_conductor = factor_base_factor(data['conductor'],
ram_primes)
factored_conductor = factor_base_factorization_latex(
factored_conductor)
data['conductor'] = r"\(%s=%s\)" % (str(
data['conductor']), factored_conductor)
data['galois_group'] = group_pretty_and_nTj(n, t, True)
data['auts'] = db.gps_transitive.lookup(r'{}T{}'.format(n, t))['auts']
data['cclasses'] = cclasses_display_knowl(n, t)
data['character_table'] = character_table_display_knowl(n, t)
data['class_group'] = nf.class_group()
data['class_group_invs'] = nf.class_group_invariants()
data['signature'] = nf.signature()
data['coefficients'] = nf.coeffs()
nf.make_code_snippets()
D = nf.disc()
data['disc_factor'] = nf.disc_factored_latex()
if D.abs().is_prime() or D == 1:
data['discriminant'] = bigint_knowl(D, cutoff=60, sides=3)
else:
data['discriminant'] = bigint_knowl(
D, cutoff=60,
sides=3) + r"\(\medspace = %s\)" % data['disc_factor']
if nf.frobs():
data['frob_data'], data['seeram'] = see_frobs(nf.frobs())
else: # fallback in case we haven't computed them in a case
data['frob_data'], data['seeram'] = frobs(nf)
# This could put commas in the rd, we don't want to trigger spaces
data['rd'] = ('$%s$' % fixed_prec(nf.rd(), 2)).replace(',', '{,}')
# Bad prime information
npr = len(ram_primes)
ramified_algebras_data = nf.ramified_algebras_data()
if isinstance(ramified_algebras_data, str):
loc_alg = ''
else:
# [label, latex, e, f, c, gal]
loc_alg = ''
for j in range(npr):
if ramified_algebras_data[j] is None:
loc_alg += '<tr><td>%s<td colspan="7">Data not computed' % str(
ram_primes[j]).rstrip('L')
else:
from lmfdb.local_fields.main import show_slope_content
mydat = ramified_algebras_data[j]
p = ram_primes[j]
loc_alg += '<tr><td rowspan="%d">$%s$</td>' % (len(mydat),
str(p))
mm = mydat[0]
myurl = url_for('local_fields.by_label', label=mm[0])
lab = mm[0]
if mm[3] * mm[2] == 1:
lab = r'$\Q_{%s}$' % str(p)
loc_alg += '<td><a href="%s">%s</a><td>$%s$<td>$%d$<td>$%d$<td>$%d$<td>%s<td>$%s$' % (
myurl, lab, mm[1], mm[2], mm[3], mm[4], mm[5],
show_slope_content(mm[8], mm[6], mm[7]))
for mm in mydat[1:]:
lab = mm[0]
myurl = url_for('local_fields.by_label', label=lab)
if mm[3] * mm[2] == 1:
lab = r'$\Q_{%s}$' % str(p)
loc_alg += '<tr><td><a href="%s">%s</a><td>$%s$<td>$%d$<td>$%d$<td>$%d$<td>%s<td>$%s$' % (
myurl, lab, mm[1], mm[2], mm[3], mm[4], mm[5],
show_slope_content(mm[8], mm[6], mm[7]))
loc_alg += '</tbody></table>'
ram_primes = str(ram_primes)[1:-1]
# Get rid of python L for big numbers
ram_primes = ram_primes.replace('L', '')
if not ram_primes:
ram_primes = r'\textrm{None}'
data['phrase'] = group_phrase(n, t)
zk = nf.zk()
Ra = PolynomialRing(QQ, 'a')
zk = [latex(Ra(x)) for x in zk]
zk = ['$%s$' % x for x in zk]
zk = ', '.join(zk)
grh_label = '<small>(<a title="assuming GRH" knowl="nf.assuming_grh">assuming GRH</a>)</small>' if nf.used_grh(
) else ''
# Short version for properties
grh_lab = nf.short_grh_string()
if 'computed' in str(data['class_number']):
grh_lab = ''
grh_label = ''
pretty_label = field_pretty(label)
if label != pretty_label:
pretty_label = "%s: %s" % (label, pretty_label)
info.update(data)
rootofunity = '%s (order $%d$)' % (nf.root_of_1_gen(),
nf.root_of_1_order())
info.update({
'label': pretty_label,
'label_raw': label,
'polynomial': web_latex(nf.poly()),
'ram_primes': ram_primes,
'integral_basis': zk,
'regulator': web_latex(nf.regulator()),
'unit_rank': nf.unit_rank(),
'root_of_unity': rootofunity,
'fund_units': nf.units_safe(),
'cnf': nf.cnf(),
'grh_label': grh_label,
'loc_alg': loc_alg
})
bread.append(('%s' % nf_label_pretty(info['label_raw']), ' '))
info['downloads_visible'] = True
info['downloads'] = [('worksheet', '/')]
info['friends'] = []
if nf.can_class_number():
# hide ones that take a lond time to compute on the fly
# note that the first degree 4 number field missed the zero of the zeta function
if abs(D**n) < 50000000:
info['friends'].append(('L-function', "/L/NumberField/%s" % label))
info['friends'].append(('Galois group', "/GaloisGroup/%dT%d" % (n, t)))
if 'dirichlet_group' in info:
info['friends'].append(('Dirichlet character group',
url_for("characters.dirichlet_group_table",
modulus=int(conductor),
char_number_list=','.join(
str(a) for a in dirichlet_chars),
poly=info['polynomial'])))
resinfo = []
galois_closure = nf.galois_closure()
if galois_closure[0] > 0:
if galois_closure[1]:
resinfo.append(('gc', galois_closure[1]))
if galois_closure[2]:
info['friends'].append(('Galois closure',
url_for(".by_label",
label=galois_closure[2][0])))
else:
resinfo.append(('gc', [dnc]))
sextic_twins = nf.sextic_twin()
if sextic_twins[0] > 0:
if sextic_twins[1]:
resinfo.append(('sex', r' $\times$ '.join(sextic_twins[1])))
else:
resinfo.append(('sex', dnc))
siblings = nf.siblings()
# [degsib list, label list]
# first is list of [deg, num expected, list of knowls]
if siblings[0]:
for sibdeg in siblings[0]:
if not sibdeg[2]:
sibdeg[2] = dnc
else:
nsibs = len(sibdeg[2])
sibdeg[2] = ', '.join(sibdeg[2])
if nsibs < sibdeg[1]:
sibdeg[2] += ', some ' + dnc
resinfo.append(('sib', siblings[0]))
for lab in siblings[1]:
if lab:
labparts = lab.split('.')
info['friends'].append(("Degree %s sibling" % labparts[0],
url_for(".by_label", label=lab)))
arith_equiv = nf.arith_equiv()
if arith_equiv[0] > 0:
if arith_equiv[1]:
resinfo.append(
('ae', ', '.join(arith_equiv[1]), len(arith_equiv[1])))
for aelab in arith_equiv[2]:
info['friends'].append(('Arithmetically equivalent sibling',
url_for(".by_label", label=aelab)))
else:
resinfo.append(('ae', dnc, len(arith_equiv[1])))
info['resinfo'] = resinfo
learnmore = learnmore_list()
title = "Number field %s" % info['label']
if npr == 1:
primes = 'prime'
else:
primes = 'primes'
if len(ram_primes) > 30:
ram_primes = 'see page'
else:
ram_primes = '$%s$' % ram_primes
properties = [('Label', nf_label_pretty(label)),
('Degree', prop_int_pretty(data['degree'])),
('Signature', '$%s$' % data['signature']),
('Discriminant', prop_int_pretty(D)),
('Root discriminant', '%s' % data['rd']),
('Ramified ' + primes + '', ram_primes),
('Class number', '%s %s' % (data['class_number'], grh_lab)),
('Class group',
'%s %s' % (data['class_group_invs'], grh_lab)),
('Galois group', group_pretty_and_nTj(data['degree'], t))]
downloads = [('Stored data to gp',
url_for('.nf_download', nf=label, download_type='data'))]
for lang in [["Magma", "magma"], ["SageMath", "sage"], ["Pari/GP", "gp"]]:
downloads.append(('Download {} code'.format(lang[0]),
url_for(".nf_download",
nf=label,
download_type=lang[1])))
from lmfdb.artin_representations.math_classes import NumberFieldGaloisGroup
from lmfdb.artin_representations.math_classes import artin_label_pretty
try:
info["tim_number_field"] = NumberFieldGaloisGroup(nf._data['coeffs'])
arts = [
z.label()
for z in info["tim_number_field"].artin_representations()
]
#print arts
for ar in arts:
info['friends'].append((
'Artin representation ' + artin_label_pretty(ar),
url_for(
"artin_representations.render_artin_representation_webpage",
label=ar)))
v = nf.factor_perm_repn(info["tim_number_field"])
def dopow(m):
if m == 0:
return ''
if m == 1:
return '*'
return '*<sup>%d</sup>' % m
info["mydecomp"] = [dopow(x) for x in v]
except AttributeError:
pass
return render_template("nf-show-field.html",
properties=properties,
credit=NF_credit,
title=title,
bread=bread,
code=nf.code,
friends=info.pop('friends'),
downloads=downloads,
learnmore=learnmore,
info=info,
KNOWL_ID="nf.%s" % label)
def FIELD(label):
nf = WebNumberField(label, gen_name=special_names.get(label, 'a'))
nf.parse_NFelt = lambda s: nf.K()([QQ(c.encode()) for c in s.split(",")])
nf.latex_poly = web_latex(nf.poly())
return nf
def download_hmf_magma(**args):
label = str(args['label'])
f = get_hmf(label)
if f is None:
return "No such form"
F = WebNumberField(f['field_label'])
F_hmf = get_hmf_field(f['field_label'])
hecke_pol = f['hecke_polynomial']
hecke_eigs = map(str, f['hecke_eigenvalues'])
AL_eigs = f['AL_eigenvalues']
outstr = '/*\n This code can be loaded, or copied and pasted, into Magma.\n'
outstr += ' It will load the data associated to the HMF, 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 += ' Hilbert modular form in Magma, by creating the HMF 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<w> := NumberField(g);\n'
outstr += 'ZF := Integers(F);\n\n'
# outstr += 'ideals_str := [' + ','.join([st for st in F_hmf["ideals"]]) + '];\n'
# outstr += 'ideals := [ideal<ZF | {F!x : x in I}> : I in ideals_str];\n\n'
outstr += 'NN := ideal<ZF | {' + f["level_ideal"][1:-1] + '}>;\n\n'
outstr += 'primesArray := [\n' + ','.join(
[st for st in F_hmf["primes"]]).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<e> := NumberField(heckePol);\n'
else:
outstr += 'heckePol := x;\nK := Rationals(); e := 1;\n'
outstr += '\nheckeEigenvaluesArray := [' + ', '.join(
[st for st in hecke_eigs]) + '];'
outstr += '\nheckeEigenvalues := AssociativeArray();\n'
outstr += 'for i := 1 to #heckeEigenvaluesArray do\n heckeEigenvalues[primes[i]] := heckeEigenvaluesArray[i];\nend for;\n\n'
outstr += 'ALEigenvalues := AssociativeArray();\n'
for s in AL_eigs:
outstr += 'ALEigenvalues[ideal<ZF | {' + s[0][1:-1] + '}>] := ' + str(
s[1]) + ';\n'
outstr += '\n// EXAMPLE:\n// pp := Factorization(2*ZF)[1][1];\n// heckeEigenvalues[pp];\n\n'
outstr += '/* EXTRA CODE: recompute eigenform (warning, may take a few minutes or longer!):\n'
outstr += 'M := HilbertCuspForms(F, NN);\n'
outstr += 'S := NewSubspace(M);\n'
outstr += '// SetVerbose("ModFrmHil", 1);\n'
outstr += 'newspaces := NewformDecomposition(S);\n'
outstr += 'newforms := [Eigenform(U) : U in newspaces];\n'
outstr += 'ppind := 0;\n'
outstr += 'while #newforms gt 1 do\n'
outstr += ' pp := primes[ppind];\n'
outstr += ' newforms := [f : f in newforms | HeckeEigenvalue(f,pp) eq heckeEigenvalues[pp]];\n'
outstr += 'end while;\n'
outstr += 'f := newforms[1];\n'
outstr += '// [HeckeEigenvalue(f,pp) : pp in primes] eq heckeEigenvaluesArray;\n'
outstr += '*/\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
def render_hmf_webpage(**args):
if 'data' in args:
data = args['data']
label = data['label']
else:
label = str(args['label'])
data = get_hmf(label)
if data is None:
flash_error(
"%s is not a valid Hilbert modular form label. It must be of the form (number field label) - (level label) - (orbit label) separated by dashes, such as 2.2.5.1-31.1-a",
args['label'])
return search_input_error()
info = {}
try:
info['count'] = args['count']
except KeyError:
info['count'] = 50
hmf_field = get_hmf_field(data['field_label'])
gen_name = findvar(hmf_field['ideals'])
nf = WebNumberField(data['field_label'], gen_name=gen_name)
info['hmf_field'] = hmf_field
info['field'] = nf
info['base_galois_group'] = nf.galois_string()
info['field_degree'] = nf.degree()
info['field_disc'] = str(nf.disc())
info['field_poly'] = teXify_pol(str(nf.poly()))
info.update(data)
info['downloads'] = [('Modular form to Magma',
url_for(".render_hmf_webpage_download",
field_label=info['field_label'],
label=info['label'],
download_type='magma')),
('Eigenvalues to Sage',
url_for(".render_hmf_webpage_download",
field_label=info['field_label'],
label=info['label'],
download_type='sage'))]
# figure out friends
# first try to see if there is an instance of this HMF on Lfun db
url = 'ModularForm/GL2/TotallyReal/{}/holomorphic/{}'.format(
info['field_label'], info['label'])
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
info['friends'] = names_and_urls(instances, exclude={url})
info['friends'] += [('L-function',
url_for("l_functions.l_function_hmf_page",
field=info['field_label'],
label=info['label'],
character='0',
number='0'))]
else:
# if there is no instance
# old code
if hmf_field['narrow_class_no'] == 1 and nf.disc(
)**2 * data['level_norm'] < 40000:
info['friends'] = [('L-function',
url_for("l_functions.l_function_hmf_page",
field=info['field_label'],
label=info['label'],
character='0',
number='0'))]
else:
info['friends'] = [('L-function not available', "")]
if data['dimension'] == 1: # Try to attach associated elliptic curve
lab = split_class_label(info['label'])
ec_from_hmf = db.ec_nfcurves.lookup(label + '1')
if ec_from_hmf is None:
info['friends'] += [('Elliptic curve not available', "")]
else:
info['friends'] += [('Isogeny class ' + info['label'],
url_for("ecnf.show_ecnf_isoclass",
nf=lab[0],
conductor_label=lab[1],
class_label=lab[2]))]
bread = [("Modular Forms", url_for('modular_forms')),
('Hilbert Modular Forms',
url_for(".hilbert_modular_form_render_webpage")),
('%s' % data['label'], ' ')]
t = "Hilbert Cusp Form %s" % info['label']
forms_dims = db.hmf_forms.search(
{
'field_label': data['field_label'],
'level_ideal': data['level_ideal']
},
projection='dimension')
info['newspace_dimension'] = sum(forms_dims)
# Get hecke_polynomial, hecke_eigenvalues and AL_eigenvalues
try:
numeigs = request.args['numeigs']
numeigs = int(numeigs)
except:
numeigs = 20
info['numeigs'] = numeigs
hecke_pol = data['hecke_polynomial']
eigs = map(str, data['hecke_eigenvalues'])
eigs = eigs[:min(len(eigs), numeigs)]
AL_eigs = data['AL_eigenvalues']
primes = hmf_field['primes']
n = min(len(eigs), len(primes))
info['eigs'] = [{
'eigenvalue': add_space_if_positive(teXify_pol(eigs[i])),
'prime_ideal': teXify_pol(primes[i]),
'prime_norm': primes[i][1:primes[i].index(',')]
} for i in range(n)]
try:
display_eigs = request.args['display_eigs']
if display_eigs in ['True', 'true', '1', 'yes']:
display_eigs = True
else:
display_eigs = False
except KeyError:
display_eigs = False
if 'numeigs' in request.args:
display_eigs = True
info['hecke_polynomial'] = "\(" + teXify_pol(hecke_pol) + "\)"
if not AL_eigs: # empty list
if data['level_norm'] == 1: # OK, no bad primes
info['AL_eigs'] = 'none'
else: # not OK, AL eigs are missing
info['AL_eigs'] = 'missing'
else:
info['AL_eigs'] = [{
'eigenvalue': teXify_pol(al[1]),
'prime_ideal': teXify_pol(al[0]),
'prime_norm': al[0][1:al[0].index(',')]
} for al in data['AL_eigenvalues']]
max_eig_len = max([len(eig['eigenvalue']) for eig in info['eigs']])
display_eigs = display_eigs or (max_eig_len <= 300)
info['display_eigs'] = display_eigs
if not display_eigs:
for eig in info['eigs']:
if len(eig['eigenvalue']) > 300:
eig['eigenvalue'] = '...'
info['level_ideal'] = teXify_pol(info['level_ideal'])
if 'is_CM' in data:
is_CM = data['is_CM']
else:
is_CM = '?'
info['is_CM'] = is_CM
if 'is_base_change' in data:
is_base_change = data['is_base_change']
else:
is_base_change = '?'
info['is_base_change'] = is_base_change
if 'q_expansions' in data:
info['q_expansions'] = data['q_expansions']
properties = [('Base field', '%s' % info['field'].field_pretty()),
('Weight', '%s' % data['weight']),
('Level norm', '%s' % data['level_norm']),
('Level', '$' + teXify_pol(data['level_ideal']) + '$'),
('Label', '%s' % data['label']),
('Dimension', '%s' % data['dimension']), ('CM', is_CM),
('Base change', is_base_change)]
return render_template("hilbert_modular_form.html",
downloads=info["downloads"],
info=info,
properties=properties,
credit=hmf_credit,
title=t,
bread=bread,
friends=info['friends'],
learnmore=learnmore_list())
def render_field_webpage(args):
data = None
info = {}
bread = [('Global Number Fields', url_for(".number_field_render_webpage"))]
# This function should not be called unless label is set.
label = clean_input(args['label'])
nf = WebNumberField(label)
data = {}
if nf.is_null():
if re.match(r'^\d+\.\d+\.\d+\.\d+$', label):
flash_error("Number field %s was not found in the database.", label)
else:
flash_error("%s is not a valid label for a global number field.", label)
return redirect(url_for(".number_field_render_webpage"))
info['wnf'] = nf
data['degree'] = nf.degree()
data['class_number'] = nf.class_number_latex()
ram_primes = nf.ramified_primes()
t = nf.galois_t()
n = nf.degree()
data['is_galois'] = nf.is_galois()
data['is_abelian'] = nf.is_abelian()
if nf.is_abelian():
conductor = nf.conductor()
data['conductor'] = conductor
dirichlet_chars = nf.dirichlet_group()
if len(dirichlet_chars)>0:
data['dirichlet_group'] = ['<a href = "%s">$\chi_{%s}(%s,·)$</a>' % (url_for('characters.render_Dirichletwebpage',modulus=data['conductor'], number=j), data['conductor'], j) for j in dirichlet_chars]
data['dirichlet_group'] = r'$\lbrace$' + ', '.join(data['dirichlet_group']) + r'$\rbrace$'
if data['conductor'].is_prime() or data['conductor'] == 1:
data['conductor'] = "\(%s\)" % str(data['conductor'])
else:
factored_conductor = factor_base_factor(data['conductor'], ram_primes)
factored_conductor = factor_base_factorization_latex(factored_conductor)
data['conductor'] = "\(%s=%s\)" % (str(data['conductor']), factored_conductor)
data['galois_group'] = group_pretty_and_nTj(n,t,True)
data['cclasses'] = cclasses_display_knowl(n, t)
data['character_table'] = character_table_display_knowl(n, t)
data['class_group'] = nf.class_group()
data['class_group_invs'] = nf.class_group_invariants()
data['signature'] = nf.signature()
data['coefficients'] = nf.coeffs()
nf.make_code_snippets()
D = nf.disc()
data['disc_factor'] = nf.disc_factored_latex()
if D.abs().is_prime() or D == 1:
data['discriminant'] = "\(%s\)" % str(D)
else:
data['discriminant'] = "\(%s=%s\)" % (str(D), data['disc_factor'])
data['frob_data'], data['seeram'] = frobs(nf)
# This could put commas in the rd, we don't want to trigger spaces
data['rd'] = ('$%s$' % fixed_prec(nf.rd(),2)).replace(',','{,}')
# Bad prime information
npr = len(ram_primes)
ramified_algebras_data = nf.ramified_algebras_data()
if isinstance(ramified_algebras_data,str):
loc_alg = ''
else:
# [label, latex, e, f, c, gal]
loc_alg = ''
for j in range(npr):
if ramified_algebras_data[j] is None:
loc_alg += '<tr><td>%s<td colspan="7">Data not computed'%str(ram_primes[j]).rstrip('L')
else:
mydat = ramified_algebras_data[j]
p = ram_primes[j]
loc_alg += '<tr><td rowspan="%d">$%s$</td>'%(len(mydat),str(p))
mm = mydat[0]
myurl = url_for('local_fields.by_label', label=mm[0])
lab = mm[0]
if mm[3]*mm[2]==1:
lab = r'$\Q_{%s}$'%str(p)
loc_alg += '<td><a href="%s">%s</a><td>$%s$<td>$%d$<td>$%d$<td>$%d$<td>%s<td>$%s$'%(myurl,lab,mm[1],mm[2],mm[3],mm[4],mm[5],show_slope_content(mm[8],mm[6],mm[7]))
for mm in mydat[1:]:
lab = mm[0]
if mm[3]*mm[2]==1:
lab = r'$\Q_{%s}$'%str(p)
loc_alg += '<tr><td><a href="%s">%s</a><td>$%s$<td>$%d$<td>$%d$<td>$%d$<td>%s<td>$%s$'%(myurl,lab,mm[1],mm[2],mm[3],mm[4],mm[5],show_slope_content(mm[8],mm[6],mm[7]))
loc_alg += '</tbody></table>'
ram_primes = str(ram_primes)[1:-1]
# Get rid of python L for big numbers
ram_primes = ram_primes.replace('L', '')
if ram_primes == '':
ram_primes = r'\textrm{None}'
data['phrase'] = group_phrase(n, t)
zk = nf.zk()
Ra = PolynomialRing(QQ, 'a')
zk = [latex(Ra(x)) for x in zk]
zk = ['$%s$' % x for x in zk]
zk = ', '.join(zk)
grh_label = '<small>(<a title="assuming GRH" knowl="nf.assuming_grh">assuming GRH</a>)</small>' if nf.used_grh() else ''
# Short version for properties
grh_lab = nf.short_grh_string()
if 'Not' in str(data['class_number']):
grh_lab=''
grh_label=''
pretty_label = field_pretty(label)
if label != pretty_label:
pretty_label = "%s: %s" % (label, pretty_label)
info.update(data)
if nf.degree() > 1:
gpK = nf.gpK()
rootof1coeff = gpK.nfrootsof1()
rootofunityorder = int(rootof1coeff[1])
rootof1coeff = rootof1coeff[2]
rootofunity = web_latex(Ra(str(pari("lift(%s)" % gpK.nfbasistoalg(rootof1coeff))).replace('x','a')))
rootofunity += ' (order $%d$)' % rootofunityorder
else:
rootofunity = web_latex(Ra('-1'))+ ' (order $2$)'
info.update({
'label': pretty_label,
'label_raw': label,
'polynomial': web_latex_split_on_pm(nf.poly()),
'ram_primes': ram_primes,
'integral_basis': zk,
'regulator': web_latex(nf.regulator()),
'unit_rank': nf.unit_rank(),
'root_of_unity': rootofunity,
'fund_units': nf.units(),
'grh_label': grh_label,
'loc_alg': loc_alg
})
bread.append(('%s' % info['label_raw'], ' '))
info['downloads_visible'] = True
info['downloads'] = [('worksheet', '/')]
info['friends'] = []
if nf.can_class_number():
# hide ones that take a lond time to compute on the fly
# note that the first degree 4 number field missed the zero of the zeta function
if abs(D**n) < 50000000:
info['friends'].append(('L-function', "/L/NumberField/%s" % label))
info['friends'].append(('Galois group', "/GaloisGroup/%dT%d" % (n, t)))
if 'dirichlet_group' in info:
info['friends'].append(('Dirichlet character group', url_for("characters.dirichlet_group_table",
modulus=int(conductor),
char_number_list=','.join(
[str(a) for a in dirichlet_chars]),
poly=info['polynomial'])))
resinfo=[]
galois_closure = nf.galois_closure()
if galois_closure[0]>0:
if len(galois_closure[1])>0:
resinfo.append(('gc', galois_closure[1]))
if len(galois_closure[2]) > 0:
info['friends'].append(('Galois closure',url_for(".by_label", label=galois_closure[2][0])))
else:
resinfo.append(('gc', [dnc]))
sextic_twins = nf.sextic_twin()
if sextic_twins[0]>0:
if len(sextic_twins[1])>0:
resinfo.append(('sex', r' $\times$ '.join(sextic_twins[1])))
else:
resinfo.append(('sex', dnc))
siblings = nf.siblings()
# [degsib list, label list]
# first is list of [deg, num expected, list of knowls]
if len(siblings[0])>0:
for sibdeg in siblings[0]:
if len(sibdeg[2]) ==0:
sibdeg[2] = dnc
else:
sibdeg[2] = ', '.join(sibdeg[2])
if len(sibdeg[2])<sibdeg[1]:
sibdeg[2] += ', some '+dnc
resinfo.append(('sib', siblings[0]))
for lab in siblings[1]:
if lab != '':
labparts = lab.split('.')
info['friends'].append(("Degree %s sibling"%labparts[0] ,url_for(".by_label", label=lab)))
arith_equiv = nf.arith_equiv()
if arith_equiv[0]>0:
if len(arith_equiv[1])>0:
resinfo.append(('ae', ', '.join(arith_equiv[1]), len(arith_equiv[1])))
for aelab in arith_equiv[2]:
info['friends'].append(('Arithmetically equivalent sibling',url_for(".by_label", label=aelab)))
else:
resinfo.append(('ae', dnc, len(arith_equiv[1])))
info['resinfo'] = resinfo
learnmore = learnmore_list()
title = "Global Number Field %s" % info['label']
if npr == 1:
primes = 'prime'
else:
primes = 'primes'
if len(label)>25:
label = label[:16]+'...'+label[-6:]
properties2 = [('Label', label),
('Degree', '$%s$' % data['degree']),
('Signature', '$%s$' % data['signature']),
('Discriminant', '$%s$' % data['disc_factor']),
('Root discriminant', '%s' % data['rd']),
('Ramified ' + primes + '', '$%s$' % ram_primes),
('Class number', '%s %s' % (data['class_number'], grh_lab)),
('Class group', '%s %s' % (data['class_group_invs'], grh_lab)),
('Galois Group', group_pretty_and_nTj(data['degree'], t))
]
downloads = []
for lang in [["Magma","magma"], ["SageMath","sage"], ["Pari/GP", "gp"]]:
downloads.append(('Download {} code'.format(lang[0]),
url_for(".nf_code_download", nf=label, download_type=lang[1])))
from lmfdb.artin_representations.math_classes import NumberFieldGaloisGroup
try:
info["tim_number_field"] = NumberFieldGaloisGroup(nf._data['coeffs'])
v = nf.factor_perm_repn(info["tim_number_field"])
def dopow(m):
if m==0: return ''
if m==1: return '*'
return '*<sup>%d</sup>'% m
info["mydecomp"] = [dopow(x) for x in v]
except AttributeError:
pass
return render_template("number_field.html", properties2=properties2, credit=NF_credit, title=title, bread=bread, code=nf.code, friends=info.pop('friends'), downloads=downloads, learnmore=learnmore, info=info, KNOWL_ID="nf.%s"%label)
