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 = 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] + '}>] := ' + 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_hmfnf().find_one({'label':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 __init__(self, label):
self.Fdata = db_hmfnf().find_one({"label": 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 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 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['gal']['n'],abvar['gal']['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 EllipticCurve_to_ecnf_dict(E):
"""
Make the dict that should be fed to `make_curves_line` in `lmfdb/scripts/ecnf/import_utils.py`.
It sets `iso_label`, 'a' and `number` to '1' and `cm` and `base_change` to '?'
INPUT:
* E - A sage elliptic curve over a number field
"""
E = EllipticCurve_polredabs(E)
K = E.base_field()
WNF = WebNumberField.from_polredabs(K.polynomial())
ainvs = [map(str,ai) for ai in map(list,E.a_invariants())]
conductor = E.conductor()
conductor_str = "".join(str([conductor.norm()]+list(conductor.gens_two())).split())
ec = {'field_label':WNF.label,
'conductor_label':ideal_label(conductor),
'iso_label':'a',
'number':'1',
'conductor_ideal':conductor_str,
'conductor_norm':str(conductor.norm()),
'ainvs':ainvs,
'cm':'?',
'base_change':'?'}
return ec
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 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 = f['hecke_eigenvalues']
AL_eigs = f['AL_eigenvalues']
F = WebNumberField(f['field_label'])
F_hmf = get_hmf_field(f['field_label'])
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 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.transitive_group import WebGaloisGroup
tg = WebGaloisGroup.from_nt(self.polredabs().degree(), galt)
return tg.display_short()
return self._data["G-Name"]
def FIELD(label):
nf = WebNumberField(label, gen_name=special_names.get(label, "a"))
nf.parse_NFelt = lambda s: nf.K()([QQ(str(c)) for c in s])
nf.latex_poly = web_latex(nf.poly())
return nf
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 wnf(self):
return WebNumberField.from_polredabs(self.polredabs())
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'] = 10
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'] = [
('Download to Magma', url_for(".render_hmf_webpage_download", field_label=info['field_label'], label=info['label'], download_type='magma')),
('Download to Sage', url_for(".render_hmf_webpage_download", field_label=info['field_label'], label=info['label'], download_type='sage'))
]
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_ecnf().find_one({"label": label + '1'})
if ec_from_hmf == 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('mf.modular_form_main_page')), ('Hilbert Modular Forms', url_for(".hilbert_modular_form_render_webpage")),
('%s' % data['label'], ' ')]
t = "Hilbert Cusp Form %s" % info['label']
forms_space = db_forms().find(
{'field_label': data['field_label'], 'level_ideal': data['level_ideal']},{'dimension':True})
dim_space = 0
for v in forms_space:
dim_space += v['dimension']
info['newspace_dimension'] = dim_space
# 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 = 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 number_field_search(**args):
info = to_dict(args)
info['learnmore'] = [('Global number field labels', url_for(".render_labels_page")), ('Galois group labels', url_for(".render_groups_page")), (Completename, url_for(".render_discriminants_page")), ('Quadratic imaginary class groups', url_for(".render_class_group_data"))]
t = 'Global Number Field search results'
bread = [('Global Number Fields', url_for(".number_field_render_webpage")), ('Search results', ' ')]
# for k in info.keys():
# nf_logger.debug(str(k) + ' ---> ' + str(info[k]))
# nf_logger.debug('******************* '+ str(info['search']))
if 'natural' in info:
query = {'label_orig': info['natural']}
try:
parse_nf_string(info,query,'natural',name="Label",qfield='label')
return redirect(url_for(".by_label", label= clean_input(query['label_orig'])))
except ValueError:
query['err'] = info['err']
return search_input_error(query, bread)
if 'algebra' in info:
fields=info['algebra'].split('_')
fields2=[WebNumberField.from_coeffs(a) for a in fields]
for j in range(len(fields)):
if fields2[j] is None:
fields2[j] = WebNumberField.fakenf(fields[j])
t = 'Number field algebra'
info = {}
info = {'fields': fields2}
return render_template("number_field_algebra.html", info=info, title=t, bread=bread)
query = {}
try:
parse_galgrp(info,query, qfield='galois')
parse_ints(info,query,'degree')
parse_bracketed_posints(info,query,'signature',split=False,exactlength=2)
parse_signed_ints(info,query,'discriminant',qfield=('disc_sign','disc_abs_key'),parse_one=make_disc_key)
parse_ints(info,query,'class_number')
parse_bracketed_posints(info,query,'class_group',split=False,check_divisibility='increasing')
parse_primes(info,query,'ur_primes',name='Unramified primes',qfield='ramps',mode='complement',to_string=True)
# modes are now contained (in), exactly, include
if 'ram_quantifier' in info and str(info['ram_quantifier']) == 'include':
mode = 'append'
parse_primes(info,query,'ram_primes','ramified primes','ramps',mode,to_string=True)
elif 'ram_quantifier' in info and str(info['ram_quantifier']) == 'contained':
parse_primes(info,query,'ram_primes','ramified primes','ramps_all','subsets',to_string=False)
pass # build list
else:
mode = 'liststring'
parse_primes(info,query,'ram_primes','ramified primes','ramps_all',mode)
except ValueError:
return search_input_error(info, bread)
count = parse_count(info)
start = parse_start(info)
if info.get('paging'):
try:
paging = int(info['paging'])
if paging == 0:
start = 0
except:
pass
C = base.getDBConnection()
# nf_logger.debug(query)
info['query'] = dict(query)
if 'lucky' in args:
one = C.numberfields.fields.find_one(query)
if one:
label = one['label']
return redirect(url_for(".by_label", label=clean_input(label)))
fields = C.numberfields.fields
res = fields.find(query)
res = res.sort([('degree', ASC), ('disc_abs_key', ASC),('disc_sign', ASC)])
if 'download' in info and info['download'] != '0':
return download_search(info, res)
nres = res.count()
res = res.skip(start).limit(count)
if(start >= nres):
start -= (1 + (start - nres) / count) * count
if(start < 0):
start = 0
info['fields'] = res
info['number'] = nres
info['start'] = start
if nres == 1:
info['report'] = 'unique match'
else:
if nres > count or start != 0:
info['report'] = 'displaying matches %s-%s of %s' % (start + 1, min(nres, start + count), nres)
else:
info['report'] = 'displaying all %s matches' % nres
info['wnf'] = WebNumberField.from_data
return render_template("number_field_search.html", info=info, title=t, bread=bread)
def __init__(self, **args):
# Check for compulsory arguments
if not ('label' in args.keys()):
raise KeyError("You have to supply label for a Hilbert modular form L-function")
logger.debug(str(args))
# Initialize default values
if not args['number']:
args['number'] = 0 # Default choice of embedding of the coefficients
args['character'] = 0 # Only trivial character
# Put the arguments into the object dictionary
self.__dict__.update(args)
logger.debug(str(self.character) + str(self.label) + str(self.number))
# Load form from database
C = base.getDBConnection()
f = C.hmfs.forms.find_one({'label': self.label})
if f is None:
raise KeyError("There is no Hilbert modular form with that label")
logger.debug(str(args))
F = WebNumberField(f['field_label'])
F_hmf = C.hmfs.fields.find_one({'label': f['field_label']})
self.character = args['character']
if self.character > 0:
raise KeyError("The L-function of a Hilbert modular form with non-trivial character has not been implemented yet.")
self.number = int(args['number'])
# It is a Sage int
self.field_disc = F.disc()
self.field_degree = int(F.degree())
try:
self.weight = int(f['parallel_weight'])
except KeyError:
self.weight = int(f['weight'].split(', ')[0][1:])
self.level = f['level_norm'] * self.field_disc ** 2
# Extract the L-function information from the elliptic modular form
self.automorphyexp = float(self.weight - 1) / float(2)
self.Q_fe = float(sqrt(self.level)) / (2 * math.pi) ** (self.field_degree)
R = QQ['x']
(x,) = R._first_ngens(1)
K = NumberField(R(str(f['hecke_polynomial']).replace('^', '**')), 'e')
e = K.gens()[0]
iota = K.complex_embeddings()[self.number]
if self.level == 1: # For level 1, the sign is always plus
self.sign = 1
else: # for level not 1, calculate sign from Fricke involution and weight
AL_signs = [iota(eval(al[1])) for al in f['AL_eigenvalues']]
self.sign = prod(AL_signs) * (-1) ** (float(self.weight * self.field_degree / 2))
logger.debug("Sign: " + str(self.sign))
self.kappa_fe = [1 for i in range(self.field_degree)]
self.lambda_fe = [self.automorphyexp for i in range(self.field_degree)]
self.mu_fe = []
self.nu_fe = [self.automorphyexp for i in range(self.field_degree)]
self.selfdual = True
self.langlands = True
self.primitive = True
self.degree = 2 * self.field_degree
self.poles = []
self.residues = []
# Compute Dirichlet coefficients
hecke_eigenvalues = [iota(K(str(ae))) for ae in f['hecke_eigenvalues']]
primes = [pp_str.split(', ') for pp_str in F_hmf['primes']]
primes = [[int(pp[0][1:]), int(pp[1])] for pp in primes]
primes = [[pp[0], pp[1], factor(pp[0])[0][1]] for pp in primes]
PP = primes[-1][0]
self.numcoeff = PP # The number of coefficients is given by the norm of the last prime
ppmidNN = [c[0] for c in f['AL_eigenvalues']]
ratl_primes = [p for p in range(primes[-1][0] + 1) if is_prime(p)]
RCC = CC['T']
(T,) = RCC._first_ngens(1)
heckepols = [RCC(1) for p in ratl_primes]
for l in range(len(hecke_eigenvalues)):
if F_hmf['primes'][l] in ppmidNN:
heckepols[ratl_primes.index(primes[l][1])] *= 1 - hecke_eigenvalues[l] / \
float(sqrt(primes[l][0])) * (T ** primes[l][2])
else:
heckepols[ratl_primes.index(primes[l][1])] *= 1 - hecke_eigenvalues[l] / float(
sqrt(primes[l][0])) * (T ** primes[l][2]) + (T ** (2 * primes[l][2]))
# Compute inverses up to given degree
heckepolsinv = [heckepols[i].xgcd(T ** ceil(log(PP * 1.0) / log(ratl_primes[i] * 1.0)))[1]
for i in range(len(heckepols))]
dcoeffs = [0, 1]
for n in range(2, ratl_primes[-1] + 1):
nfact = factor(n)
if len(nfact) == 1:
# prime power
p = nfact[0][0]
k = nfact[0][1]
S = [1] + [dcoeffs[p ** i] for i in range(1, k)]
heckepol = heckepolsinv[ratl_primes.index(p)]
dcoeffs.append(heckepol[k])
else:
# composite
ancoeff = prod([dcoeffs[pe[0] ** pe[1]] for pe in nfact])
dcoeffs.append(ancoeff)
# ff = open('dcoeffs.txt', 'w')
# ff.write(str(primes) + '\n')
# ff.write(str(heckepols) + '\n')
# ff.write(str(ratl_primes) + '\n')
# ff.close()
self.dirichlet_coefficients = dcoeffs[1:]
self.coefficient_period = 0 # HUH?
self.coefficient_type = 0 # HUH?
self.quasidegree = 1 # HUH?
self.checkselfdual()
self.texname = "L(s,f)"
self.texnamecompleteds = "\\Lambda(s,f)"
if self.selfdual:
self.texnamecompleted1ms = "\\Lambda(1-s,f)"
else:
self.texnamecompleted1ms = "\\Lambda(1-s,\\overline{f})"
self.title = "$L(s,f)$, " + "where $f$ is a holomorphic Hilbert cusp form with parallel weight " + str(self.weight) + ", level norm " + str(f['level_norm']) + ", and character " + str(self.character)
self.citation = ''
self.credit = ''
self.generateSageLfunction()
constructor_logger(self, args)
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 = 0
if 'start' in argsdict:
start = int(argsdict['start'])
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 = 50
if 'count' in argsdict:
count = int(argsdict['count'])
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_dims().find(query)
data = data.sort([('level_norm', ASCENDING)])
info['number'] = nres = data.count()
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)]
data = data[start:start+count]
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)
info['count'] = count
info['start'] = start
info['more'] = int(start + count < nres)
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 = [('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 = []
properties2 = []
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_dims().find({'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_dims().find({'field_label': field_label, 'level_label': level_label})
nres = data.count()
if nres==0:
info['err'] = "no dimension information exists in the database for level %s and field %s" % (level_label, pretty_field_label)
else:
data = data.next()
info['label'] = data['label']
nf = WebNumberField(field_label)
info['base_galois_group'] = nf.galois_string()
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_degree'] = nf.degree()
info['field_classno'] = nf.class_number()
info['field_disc'] = str(nf.disc())
info['field_poly'] = teXify_pol(str(nf.poly()))
info['field_knowl'] = nf_display_knowl(field_label, getDBConnection(), 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'] = latex(I.factor())
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_forms().find({'field_label':field_label, 'level_label':level_label}).sort('label_suffix', ASCENDING)
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['sfe']==1 else "-1",
'bc': bc_info(f['bc']),
'cm': cm_info(f['CM']),
} for f in newforms]
info['nnewforms'] = len(info['nfdata'])
properties2 = [('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, properties2=properties2, friends=friends)
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 = 0
if 'start' in argsdict:
start = int(argsdict['start'])
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 = 50
if 'count' in argsdict:
count = int(argsdict['count'])
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}
if level_flag != 'all':
# find which weights are present (TODO: get this from a stats collection)
wts = list(sum((Set(d.keys()) for d in db_dims().distinct(gl_or_sl)),Set()))
if level_flag == 'cusp':
# restrict the query to only return levels where at least one
# cuspidal dimension is positive:
query.update(
{'$or':[{gl_or_sl+'.{}.cuspidal_dim'.format(w):{'$gt':0}} for w in wts]}
)
if level_flag == 'new':
# restrict the query to only return levels where at least one
# new dimension is positive:
query.update(
{'$or':[{gl_or_sl+'.{}.new_dim'.format(w):{'$gt':0}} for w in wts]}
)
data = db_dims().find(query)
data = data.sort([('level_norm', ASCENDING)])
info['number'] = nres = data.count()
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
data = list(data.skip(start).limit(count))
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)
info['count'] = count
info['start'] = start
info['more'] = int(start + count < nres)
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]
print("Length of dimtable = {}".format(len(dimtable)))
info['dimtable'] = dimtable
return render_template("bmf-field_dim_table.html", info=info, title=t, properties=properties, bread=bread)
def wnf(self):
return WebNumberField.from_polredabs(self.polredabs())
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 get_WNF(label, gen_name):
if not label in WNFs:
WNFs[label] = WebNumberField(label, gen_name=gen_name)
return WNFs[label]
def number_field_search(**args):
info = to_dict(args)
info['learnmore'] = [
('Global number field labels', url_for(".render_labels_page")),
('Galois group labels', url_for(".render_groups_page")),
(Completename, url_for(".render_discriminants_page")),
('Quadratic imaginary class groups',
url_for(".render_class_group_data"))
]
t = 'Global Number Field search results'
bread = [('Global Number Fields', url_for(".number_field_render_webpage")),
('Search results', ' ')]
# for k in info.keys():
# nf_logger.debug(str(k) + ' ---> ' + str(info[k]))
# nf_logger.debug('******************* '+ str(info['search']))
if 'natural' in info:
query = {'label_orig': info['natural']}
try:
parse_nf_string(info,
query,
'natural',
name="Label",
qfield='label')
return redirect(
url_for(".by_label", label=clean_input(query['label_orig'])))
except ValueError:
query['err'] = info['err']
return search_input_error(query, bread)
if 'algebra' in info:
fields = info['algebra'].split('_')
fields2 = [WebNumberField.from_coeffs(a) for a in fields]
for j in range(len(fields)):
if fields2[j] is None:
fields2[j] = WebNumberField.fakenf(fields[j])
t = 'Number field algebra'
info = {}
info = {'fields': fields2}
return render_template("number_field_algebra.html",
info=info,
title=t,
bread=bread)
query = {}
try:
parse_galgrp(info, query, qfield='galois')
parse_ints(info, query, 'degree')
parse_bracketed_posints(info,
query,
'signature',
split=False,
exactlength=2)
parse_signed_ints(info,
query,
'discriminant',
qfield=('disc_sign', 'disc_abs_key'),
parse_one=make_disc_key)
parse_ints(info, query, 'class_number')
parse_bracketed_posints(info,
query,
'class_group',
split=False,
check_divisibility='increasing')
parse_primes(info,
query,
'ur_primes',
name='Unramified primes',
qfield='ramps',
mode='complement',
to_string=True)
# modes are now contained (in), exactly, include
if 'ram_quantifier' in info and str(
info['ram_quantifier']) == 'include':
mode = 'append'
parse_primes(info,
query,
'ram_primes',
'ramified primes',
'ramps',
mode,
to_string=True)
elif 'ram_quantifier' in info and str(
info['ram_quantifier']) == 'contained':
parse_primes(info,
query,
'ram_primes',
'ramified primes',
'ramps_all',
'subsets',
to_string=False)
pass # build list
else:
mode = 'liststring'
parse_primes(info, query, 'ram_primes', 'ramified primes',
'ramps_all', mode)
except ValueError:
return search_input_error(info, bread)
count = parse_count(info)
start = parse_start(info)
if info.get('paging'):
try:
paging = int(info['paging'])
if paging == 0:
start = 0
except:
pass
C = base.getDBConnection()
# nf_logger.debug(query)
info['query'] = dict(query)
if 'lucky' in args:
one = C.numberfields.fields.find_one(query)
if one:
label = one['label']
return redirect(url_for(".by_label", label=clean_input(label)))
fields = C.numberfields.fields
res = fields.find(query)
res = res.sort([('degree', ASC), ('disc_abs_key', ASC),
('disc_sign', ASC)])
if 'download' in info and info['download'] != '0':
return download_search(info, res)
nres = res.count()
res = res.skip(start).limit(count)
if (start >= nres):
start -= (1 + (start - nres) / count) * count
if (start < 0):
start = 0
info['fields'] = res
info['number'] = nres
info['start'] = start
if nres == 1:
info['report'] = 'unique match'
else:
if nres > count or start != 0:
info['report'] = 'displaying matches %s-%s of %s' % (
start + 1, min(nres, start + count), nres)
else:
info['report'] = 'displaying all %s matches' % nres
info['wnf'] = WebNumberField.from_data
return render_template("number_field_search.html",
info=info,
title=t,
bread=bread)
def render_field_webpage(args):
data = None
C = base.getDBConnection()
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():
bread.append(('Search results', ' '))
info['err'] = 'There is no field with label %s in the database' % label
info['label'] = args['label_orig'] if 'label_orig' in args else args['label']
return search_input_error(info, bread)
info['wnf'] = nf
data['degree'] = nf.degree()
data['class_number'] = nf.class_number()
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:
data['conductor'] = "\(%s=%s\)" % (str(data['conductor']), latex(data['conductor'].factor()))
data['galois_group'] = group_display_knowl(n, t, C)
data['cclasses'] = cclasses_display_knowl(n, t, C)
data['character_table'] = character_table_display_knowl(n, t, C)
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()
ram_primes = D.prime_factors()
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'])
npr = len(ram_primes)
ram_primes = str(ram_primes)[1:-1]
if ram_primes == '':
ram_primes = r'\textrm{None}'
data['frob_data'], data['seeram'] = frobs(nf)
data['phrase'] = group_phrase(n, t, C)
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()[2]
rootofunity = Ra(str(pari("lift(%s)" % gpK.nfbasistoalg(rootof1coeff))).replace('x','a'))
else:
rootofunity = Ra('-1')
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': web_latex(rootofunity),
'fund_units': nf.units(),
'grh_label': grh_label
})
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 group', url_for("characters.dirichlet_group_table",
modulus=int(conductor),
char_number_list=','.join(
[str(a) for a in dirichlet_chars]),
poly=info['polynomial'])))
info['learnmore'] = [('Global number field labels', url_for(
".render_labels_page")),
(Completename, url_for(".render_discriminants_page")),
('How data was computed', url_for(".how_computed_page"))]
if info['signature'] == [0,1]:
info['learnmore'].append(('Quadratic imaginary class groups', url_for(".render_class_group_data")))
# With Galois group labels, probably not needed here
# info['learnmore'] = [('Global number field labels',
# url_for(".render_labels_page")), ('Galois group
# labels',url_for(".render_groups_page")),
# (Completename,url_for(".render_discriminants_page"))]
title = "Global Number Field %s" % info['label']
if npr == 1:
primes = 'prime'
else:
primes = 'primes'
properties2 = [('Label', label),
('Degree', '%s' % data['degree']),
('Signature', '$%s$' % data['signature']),
('Discriminant', '$%s$' % data['disc_factor']),
('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_display_short(data['degree'], t, C))
]
from lmfdb.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
# del info['_id']
return render_template("number_field.html", properties2=properties2, credit=NF_credit, title=title, bread=bread, code=nf.code, friends=info.pop('friends'), learnmore=info.pop('learnmore'), info=info)
def render_field_webpage(args):
data = None
C = base.getDBConnection()
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():
bread.append(('Search results', ' '))
info['err'] = 'There is no field with label %s in the database' % label
info['label'] = args['label_orig'] if 'label_orig' in args else args[
'label']
return search_input_error(info, bread)
info['wnf'] = nf
data['degree'] = nf.degree()
data['class_number'] = nf.class_number()
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:
data['conductor'] = "\(%s=%s\)" % (str(
data['conductor']), latex(data['conductor'].factor()))
data['galois_group'] = group_display_knowl(n, t, C)
data['cclasses'] = cclasses_display_knowl(n, t, C)
data['character_table'] = character_table_display_knowl(n, t, C)
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()
ram_primes = D.prime_factors()
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'])
npr = len(ram_primes)
ram_primes = str(ram_primes)[1:-1]
if ram_primes == '':
ram_primes = r'\textrm{None}'
data['frob_data'], data['seeram'] = frobs(nf)
data['phrase'] = group_phrase(n, t, C)
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()[2]
rootofunity = Ra(
str(pari("lift(%s)" % gpK.nfbasistoalg(rootof1coeff))).replace(
'x', 'a'))
else:
rootofunity = Ra('-1')
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': web_latex(rootofunity),
'fund_units': nf.units(),
'grh_label': grh_label
})
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 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] = [z[0] for z in sibdeg[2]]
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
info['learnmore'] = [
('Global number field labels', url_for(".render_labels_page")),
(Completename, url_for(".render_discriminants_page")),
('How data was computed', url_for(".how_computed_page"))
]
if info['signature'] == [0, 1]:
info['learnmore'].append(('Quadratic imaginary class groups',
url_for(".render_class_group_data")))
# With Galois group labels, probably not needed here
# info['learnmore'] = [('Global number field labels',
# url_for(".render_labels_page")), ('Galois group
# labels',url_for(".render_groups_page")),
# (Completename,url_for(".render_discriminants_page"))]
title = "Global Number Field %s" % info['label']
if npr == 1:
primes = 'prime'
else:
primes = 'primes'
properties2 = [('Label', label), ('Degree', '%s' % data['degree']),
('Signature', '$%s$' % data['signature']),
('Discriminant', '$%s$' % data['disc_factor']),
('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_display_short(data['degree'], t, C))]
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
# del info['_id']
return render_template("number_field.html",
properties2=properties2,
credit=NF_credit,
title=title,
bread=bread,
code=nf.code,
friends=info.pop('friends'),
learnmore=info.pop('learnmore'),
info=info)
def render_hmf_webpage(**args):
C = getDBConnection()
if 'data' in args:
data = args['data']
label = data['label']
else:
label = str(args['label'])
data = C.hmfs.forms.find_one({'label': label})
if data is None:
return "No such form"
info = {}
try:
info['count'] = args['count']
except KeyError:
info['count'] = 10
try:
numeigs = request.args['numeigs']
numeigs = int(numeigs)
except:
numeigs = 20
info['numeigs'] = numeigs
hmf_field = C.hmfs.fields.find_one({'label': 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'] = [('Download to Magma',
url_for(".render_hmf_webpage_download",
field_label=info['field_label'],
label=info['label'],
download_type='magma')),
('Download to Sage',
url_for(".render_hmf_webpage_download",
field_label=info['field_label'],
label=info['label'],
download_type='sage'))]
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_ecnf().find_one({"label": label + '1'})
if ec_from_hmf == 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 = [('Hilbert Modular Forms',
url_for(".hilbert_modular_form_render_webpage")),
('%s' % data['label'], ' ')]
t = "Hilbert Cusp Form %s" % info['label']
forms_space = C.hmfs.forms.search.find(
{
'field_label': data['field_label'],
'level_ideal': data['level_ideal']
}, {'dimension': True})
dim_space = 0
for v in forms_space:
dim_space += v['dimension']
info['newspace_dimension'] = dim_space
eigs = data['hecke_eigenvalues']
eigs = eigs[:min(len(eigs), numeigs)]
primes = hmf_field['primes']
n = min(len(eigs), len(primes))
info['eigs'] = [{
'eigenvalue': 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(info['hecke_polynomial']))
if 'AL_eigenvalues_fixed' in data:
if data['AL_eigenvalues_fixed'] == 'done':
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']]
else:
info['AL_eigs'] = [{'eigenvalue': '?', 'prime_ideal': '?'}]
else:
info['AL_eigs'] = [{'eigenvalue': '?', 'prime_ideal': '?'}]
info['AL_eigs_count'] = len(info['AL_eigs']) != 0
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'] = '...'
for eig in info['AL_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 poly_to_field_label(pol):
try:
wnf = WebNumberField.from_polynomial(pol)
return wnf.get_label()
except:
return None
def FIELD(label):
nf = WebNumberField(label, gen_name=special_names.get(label, 'a'))
nf.parse_NFelt = lambda s: nf.K()([QQ(str(c)) for c in s])
return nf
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():
bread.append(('Search Results', ' '))
info['err'] = 'There is no field with label %s in the database' % label
info['label'] = args['label_orig'] if 'label_orig' in args else args['label']
return search_input_error(info, bread)
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_display_knowl(n, t)
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)
# 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])
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]
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()
#if info['signature'] == [0,1]:
# info['learnmore'].append(('Quadratic imaginary class groups', url_for(".render_class_group_data")))
# With Galois group labels, probably not needed here
# info['learnmore'] = [('Global number field labels',
# url_for(".render_labels_page")), ('Galois group
# labels',url_for(".render_groups_page")),
# (Completename,url_for(".render_discriminants_page"))]
title = "Global Number Field %s" % info['label']
if npr == 1:
primes = 'prime'
else:
primes = 'primes'
properties2 = [('Label', label),
('Degree', '$%s$' % data['degree']),
('Signature', '$%s$' % data['signature']),
('Discriminant', '$%s$' % data['disc_factor']),
('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_display_short(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)
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'] = 10
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'] = [('Download to Magma',
url_for(".render_hmf_webpage_download",
field_label=info['field_label'],
label=info['label'],
download_type='magma')),
('Download to Sage',
url_for(".render_hmf_webpage_download",
field_label=info['field_label'],
label=info['label'],
download_type='sage'))]
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_ecnf().find_one({"label": label + '1'})
if ec_from_hmf == 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 = [('Hilbert Modular Forms',
url_for(".hilbert_modular_form_render_webpage")),
('%s' % data['label'], ' ')]
t = "Hilbert Cusp Form %s" % info['label']
forms_space = db_forms().find(
{
'field_label': data['field_label'],
'level_ideal': data['level_ideal']
}, {'dimension': True})
dim_space = 0
for v in forms_space:
dim_space += v['dimension']
info['newspace_dimension'] = dim_space
# 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 = 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 render_hmf_webpage(**args):
C = getDBConnection()
if 'data' in args:
data = args['data']
label = data['label']
else:
label = str(args['label'])
data = C.hmfs.forms.find_one({'label': label})
if data is None:
return "No such form"
info = {}
try:
info['count'] = args['count']
except KeyError:
info['count'] = 10
try:
numeigs = request.args['numeigs']
numeigs = int(numeigs)
except:
numeigs = 20
hmf_field = C.hmfs.fields.find_one({'label': 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'] = [
('Download to Magma', url_for(".render_hmf_webpage_download", field_label=info['field_label'], label=info['label'], download_type='magma')),
('Download to Sage', url_for(".render_hmf_webpage_download", field_label=info['field_label'], label=info['label'], download_type='sage'))
]
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_ecnf().find_one({"label": label + '1'})
if ec_from_hmf == 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 = [('Hilbert Modular Forms', url_for(".hilbert_modular_form_render_webpage")), ('%s' % data[
'label'], ' ')]
t = "Hilbert Cusp Form %s" % info['label']
forms_space = C.hmfs.forms.search.find(
{'field_label': data['field_label'], 'level_ideal': data['level_ideal']},{'dimension':True})
dim_space = 0
for v in forms_space:
dim_space += v['dimension']
info['newspace_dimension'] = dim_space
eigs = data['hecke_eigenvalues']
eigs = eigs[:min(len(eigs), numeigs)]
primes = hmf_field['primes']
n = min(len(eigs), len(primes))
info['eigs'] = [{'eigenvalue': 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(info['hecke_polynomial'])
if 'AL_eigenvalues_fixed' in data:
if data['AL_eigenvalues_fixed'] == 'done':
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']]
else:
info['AL_eigs'] = [{'eigenvalue': '?', 'prime_ideal': '?'}]
else:
info['AL_eigs'] = [{'eigenvalue': '?', 'prime_ideal': '?'}]
info['AL_eigs_count'] = len(info['AL_eigs']) != 0
max_eig_len = max([len(eig['eigenvalue']) for eig in info['eigs']])
display_eigs = display_eigs or (max_eig_len<=300)
if not display_eigs:
for eig in info['eigs']:
if len(eig['eigenvalue']) > 300:
eig['eigenvalue'] = '...'
for eig in info['AL_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 FIELD(label):
nf = WebNumberField(label, gen_name=special_names.get(label, 'a'))
nf.parse_NFelt = lambda s: nf.K()([QQ(str(c)) for c in s])
return nf
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 += 'x = polygen(QQ) \n'
s += 'data = [ '
else:
s += 'data = [ '
s += '\\\n'
nf_dict = {}
res = db_ecnf().find(ast.literal_eval(info["query"]))
for f in res:
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('\'', '')
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 = StringIO.StringIO()
strIO.write(s)
strIO.seek(0)
return send_file(strIO,
attachment_filename=filename,
as_attachment=True,
add_etags=False)
def __init__(self, **args):
constructor_logger(self, args)
self.motivic_weight = 0
# Check for compulsory arguments
if not 'label' in args.keys():
raise Exception("You have to supply a label for a Dedekind zeta function")
# Initialize default values
# Put the arguments into the object dictionary
self.__dict__.update(args)
# Fetch the polynomial of the field from the database
wnf = WebNumberField(self.label)
# poly_coeffs = wnf.coeffs()
# Extract the L-function information from the polynomial
R = QQ['x']
(x,) = R._first_ngens(1)
# self.polynomial = sum([poly_coeffs[i]*x**i for i in range(len(poly_coeffs))])
self.NF = wnf.K() # NumberField(self.polynomial, 'a')
self.signature = wnf.signature() # self.NF.signature()
self.sign = 1
self.quasidegree = sum(self.signature)
self.level = wnf.disc().abs() # self.NF.discriminant().abs()
self.degreeofN = self.NF.degree()
self.Q_fe = float(
sqrt(self.level) / (2 ** (self.signature[1]) * (math.pi) ** (float(self.degreeofN) / 2.0)))
self.kappa_fe = self.signature[0] * [0.5] + self.signature[1] * [1]
self.lambda_fe = self.quasidegree * [0]
self.mu_fe = self.signature[0] * [0] # not in use?
self.nu_fe = self.signature[1] * [0] # not in use?
self.langlands = True
# self.degree = self.signature[0] + 2 * self.signature[1] # N = r1 +2r2
self.degree = self.degreeofN
self.dirichlet_coefficients = [Integer(x) for x in self.NF.zeta_coefficients(5000)]
self.h = wnf.class_number() # self.NF.class_number()
self.R = wnf.regulator() # self.NF.regulator()
self.w = len(self.NF.roots_of_unity())
self.res = RR(2 ** self.signature[0] * self.h * self.R / self.w) # r1 = self.signature[0]
self.grh = wnf.used_grh()
if self.degree > 1:
if wnf.is_abelian():
cond = wnf.conductor()
dir_group = wnf.dirichlet_group()
# Remove 1 from the list
j = 0
while dir_group[j] != 1:
j += 1
dir_group.pop(j)
self.factorization = r'\(\zeta_K(s) =\) <a href="/L/Riemann/">\(\zeta(s)\)</a>'
fullchargroup = wnf.full_dirichlet_group()
for j in dir_group:
chij = fullchargroup[j]
mycond = chij.conductor()
myj = j % mycond
self.factorization += r'\(\;\cdot\) <a href="/L/Character/Dirichlet/%d/%d/">\(L(s,\chi_{%d}(%d, \cdot))\)</a>' % (mycond, myj, mycond, myj)
self.poles = [1, 0] # poles of the Lambda(s) function
self.residues = [self.res, -self.res] # residues of the Lambda(s) function
self.poles_L = [1] # poles of L(s) used by createLcalcfile_ver2
self.residues_L = [1234]
# residues of L(s) used by createLcalcfile_ver2, XXXXXXXXXXXX needs to be set
self.coefficient_period = 0
self.selfdual = True
self.primitive = True
self.coefficient_type = 0
self.texname = "\\zeta_K(s)"
self.texnamecompleteds = "\\Lambda_K(s)"
if self.selfdual:
self.texnamecompleted1ms = "\\Lambda_K(1-s)"
else:
self.texnamecompleted1ms = "\\Lambda_K(1-s)"
self.title = "Dedekind zeta-function: $\\zeta_K(s)$"
self.title = self.title + ", where $K$ is the " + str(self.NF).replace("in a ", "")
self.credit = 'Sage'
self.citation = ''
self.generateSageLfunction()
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 poly_to_field_label(pol):
try:
wnf = WebNumberField.from_polynomial(pol)
return wnf.get_label()
except:
return None
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