def coefficients(self, nrange=range(1, 10), save_to_db=False):
r"""
Gives the coefficients in a range.
We assume that the self._ap containing Hecke eigenvalues
are stored.
"""
if len(nrange) == 0:
return []
if not isinstance(nrange, list):
M = nrange
nrange = range(0, M)
if len(nrange) > 1:
emf_logger.debug("getting coeffs in range {0}--{1}".format(nrange[0],nrange[-1]))
else:
emf_logger.debug("getting coeffs in range {0}--{0}".format(nrange[0]))
res = []
recompute = False
for n in nrange:
c = self._coefficients.get(n, None)
#emf_logger.debug("c({0}) in self._coefficients={1}".format(n,c))
if c is None:
if n == 0 and self.is_cuspidal:
c = 0
else:
recompute = True
c = self.coefficient_n_recursive(n)
self._coefficients[n] = c
res.append(c)
if recompute and save_to_db:
self.save_to_db(update=True)
return res
def get_coefficients(info):
r"""
Return a file with the Fourier coefficients in desired format.
"""
emf_logger.debug("IN GET_COEFFICIENTS!!!")
level = my_get(info, 'level', -1, int)
weight = my_get(info, 'weight', -1, int)
character = my_get(info, 'character', '', str) # int(info.get('weight',0))
emf_logger.debug("info={0}".format(info))
if character == '':
character = 0
label = info.get('label', '')
# we only want one form or one embedding
s = print_list_of_coefficients(info)
print "s=",s
if info['format']=="sage":
ending = "sobj"
else:
ending = "txt"
info['filename'] = str(weight) + '-' + str(
level) + '-' + str(character) + '-' + label + 'coefficients-0to' + info['number'] + "."+ending
# return send_file(info['tempfile'], as_attachment=True, attachment_filename=info['filename'])
strIO = StringIO.StringIO()
strIO.write(s)
strIO.seek(0)
return send_file(strIO,
attachment_filename=info["filename"],
as_attachment=True)
def render_elliptic_modular_form_space_list_chars(level, weight):
r"""
Renders a page with list of spaces of elliptic forms of given
level and weight (list all characters)
"""
emf_logger.debug(
"In render_elliptic_modular_form_space_list_chars(level={0},weight={1})".format(level, weight))
info = dict()
# s = make_table_of_characters(level,weight)
info['level'] = level
info['weight'] = weight
# if not isinstance(s,str):
# info['character'] = s
# return redirect(url_for("emf.render_elliptic_modular_forms", **info))
# info['list_spaces']=s
title = "Newforms of weight {0} for \(\Gamma_1({1})\)".format(weight, level)
# bread =[(MF_TOP,url_for('mf.modular_form_main_page'))]
bread = [(EMF_TOP, url_for('emf.render_elliptic_modular_forms'))]
bread.append(("Level %s" % level, url_for("emf.render_elliptic_modular_forms", level=level)))
bread.append(
("Weight %s" % weight, url_for("emf.render_elliptic_modular_forms", level=level, weight=weight)))
# info['browse_type']=" of level %s and weight %s " % (level,weight)
dimtbl = DimensionTable(1)
info['grouptype'] = 1
disp = ClassicalMFDisplay('modularforms')
disp.set_table_browsing(limit=[(weight, weight), (level, level)], keys=['Weight', 'Level'],
character='all', dimension_table=dimtbl, title='Dimension of newforms')
info['show_all_characters'] = 1
info['browse_table'] = disp._table
info['bread'] = bread
info['title'] = title
return render_template("emf_browse_fixed_level.html", **info)
def get_coefficients(info):
r"""
Return a file with the Fourier coefficients in desired format.
"""
emf_logger.debug("IN GET_COEFFICIENTS!!!")
level = my_get(info, 'level', -1, int)
weight = my_get(info, 'weight', -1, int)
character = my_get(info, 'character', '', str) # int(info.get('weight',0))
emf_logger.debug("info={0}".format(info))
if character == '':
character = 0
label = info.get('label', '')
# we only want one form or one embedding
s = print_list_of_coefficients(info)
print "s=", s
if info['format'] == "sage":
ending = "sobj"
else:
ending = "txt"
info['filename'] = str(weight) + '-' + str(level) + '-' + str(
character
) + '-' + label + 'coefficients-0to' + info['number'] + "." + ending
# return send_file(info['tempfile'], as_attachment=True, attachment_filename=info['filename'])
strIO = StringIO.StringIO()
strIO.write(s)
strIO.seek(0)
return send_file(strIO,
attachment_filename=info["filename"],
as_attachment=True)
def return_dimension(level=None, weight=None, chi=None, **kwds):
if request.method == 'GET':
info = to_dict(request.args)
else:
info = to_dict(request.form)
level = my_get(info, 'level', level, int)
weight = my_get(info, 'weight', weight, int)
chi = my_get(info, 'chi', chi, int)
if level is None or weight is None:
return emf_error("Please supply level weight (and optional character)!"), 500
ttype = my_get(kwds, 'ttype', info.get('ttype', 'new'), str)
emf_logger.debug("level,weight,chi: {0},{1},{2}, type={3}".format(level, weight, chi, ttype))
if chi == 0 or chi is None:
x = level
else:
x = DirichletGroup(level).list()[chi]
if ttype == 'new':
return str(dimension_new_cusp_forms(x, weight))
if ttype == 'cusp':
return str(dimension_cusp_forms(x, weight))
if ttype == 'modular':
return str(dimension_modular_forms(x, weight))
if ttype == 'eisenstein':
return str(dimension_eis(x, weight))
s = "Please use one of the available table types: 'new', 'cusp','modular', 'eisenstein' Got:{0}".format(
ttype)
return emf_error(s), 500
def get_new_and_oldspace_decomposition(k, N, xi=0):
r"""
Get decomposition of the new and oldspace S_k(N,xi) into submodules.
"""
M = ModularSymbols(N, k, sign=1).cuspidal_submodule()
L = list()
L = [M.new_submodule().dimension()]
check_dim = M.new_submodule().dimension()
for d in divisors(N):
if (d == 1):
continue
O = M.old_submodule(d)
Od = O.dimension()
if (d == N and k == 2 or Od == 0):
continue
S = ModularSymbols(ZZ(N / d), k,
sign=1).cuspidal_submodule().new_submodule()
Sd = S.dimension()
if (Sd == 0):
logger.debug("%s, %s" % (O, Od))
logger.debug("%s, %s" % (S, Sd))
mult = len(divisors(ZZ(d)))
check_dim = check_dim + mult * Sd
L.append((ZZ(N / d), mult, Sd))
check_dim = check_dim - M.dimension()
if (check_dim != 0):
raise ArithmeticError("Something wrong! check_dim=%s" % check_dim)
return str(M.dimension(), L)
def compute(self, save=True):
emf_logger.debug('in compute for WebChar number {0} of modulus {1}'.format(self.number, self.modulus))
c = self.character
changed = False
if self.conductor == 0:
self.conductor = c.conductor()
changed = True
if self.order == 0:
self.order = c.multiplicative_order()
changed = True
if self.latex_name == '':
self.latex_name = "\chi_{" + str(self.modulus) + "}(" + str(self.number) + ", \cdot)"
changed = True
if self._values_algebraic == {} or self._values_float == {}:
changed = True
for i in range(self.modulus):
self.value(i,value_format='float')
self.value(i,value_format='algebraic')
if self.modulus_euler_phi == 0:
changed = True
self.modulus_euler_phi = euler_phi(self.modulus)
if changed and save and False: # temporary hack to prevent fatal error when save_to_db fails
self.save_to_db()
else:
emf_logger.debug('Not saving.')
def __init__(self,
name,
level=1,
weight=12,
character=1,
value=None,
update_hecke_orbits=False,
include_in_update=False):
self.level = level
self.weight = weight
self.character = character
emf_logger.debug("CCCCharacter = {0}".format(self.character))
if value is None:
value = WebModFormSpace_cached(
self.level,
self.weight,
self.character,
update_hecke_orbits=update_hecke_orbits)
emf_logger.debug("CCCCharacter = {0}".format(self.character))
super(WebModFormSpaceProperty,
self).__init__(name,
include_in_update=include_in_update,
save_to_db=True,
save_to_fs=False,
value=value)
def extract_data_from_jump_to(s):
label = ''
args = dict()
if s == 'delta':
weight = 12
level = 1
label = "a"
else:
# first see if we have a label or not, i.e. if we have precisely one string of letters at the end
test = re.findall("[a-z]+", s)
if len(test) == 1:
args['label'] = test[0]
# emf_logger.debug("label1={0}".format(label))
# the first string of integers should be the level
test = re.findall("\d+", s)
if not test is None and len(test)>0:
args['level'] = int(test[0])
if len(test) > 1: # we also have weight
args['weight'] = int(test[1])
if len(test) > 2: # we also have character
args['character']=int(test[2])
emf_logger.debug("args=%s" % label)
return args
def print_coefficients_for_one_form(F, number, fmt, bitprec=53):
emf_logger.debug(
"in print {2} coefs for 1 form: format={0} bitprec={1}".format(
fmt, bitprec, number))
# Start with some meta-data
s = "## level={N}, weight={k}, character={ch},label={label} \n".format(
N=F.level(), k=F.weight(), ch=F.chi(), label=F.label())
max_cn = F.max_cn()
if number > max_cn:
number = max_cn
if fmt == "q_expansion":
s += F.print_q_expansion(number)
if fmt == "coefficients":
qe = F.coefficients(range(number))
if F.degree() > 1:
s += "## " + str(F.polynomial(type='coefficient_field')) + "=0"
s += "\n"
for n in range(len(qe)):
c = qe[n]
s += "{n} \t {c} \n".format(n=n, c=c)
if fmt == "embeddings":
embeddings = F.q_expansion_embeddings(number,
bitprec=bitprec,
format='numeric')
if F.degree() > 1:
for j in range(F.degree()):
s += "# Embedding nr. {j} \n".format(j=j)
for n in range(number):
s += str(n) + "\t" + str(embeddings[n][j]) + "\n"
else:
for n in range(number):
s += str(n) + "\t" + str(embeddings[n]) + "\n"
emf_logger.debug("s={0}".format(s))
return s
def coefficients(self, nrange=range(1, 10), save_to_db=True):
r"""
Gives the coefficients in a range.
We assume that the self._ap containing Hecke eigenvalues
are stored.
"""
emf_logger.debug("computing coeffs in range {0}".format(nrange))
if not isinstance(nrange, list):
M = nrange
nrange = range(0, M)
res = []
recompute = False
for n in nrange:
c = self._coefficients.get(n, None)
#emf_logger.debug("c({0}) in self._coefficients={1}".format(n,c))
if c is None:
if n == 0 and self.is_cuspidal:
c = self.coefficient_field(0)
else:
recompute = True
c = self.coefficient_n_recursive(n)
self._coefficients[n] = c
res.append(c)
if recompute and save_to_db:
self.save_to_db(update=True)
return res
def compute(self, save=True):
emf_logger.debug(
'in compute for WebChar number {0} of modulus {1}'.format(
self.number, self.modulus))
c = self.character
changed = False
if self.conductor == 0:
self.conductor = c.conductor()
changed = True
if self.order == 0:
self.order = c.multiplicative_order()
changed = True
if self.latex_name == '':
self.latex_name = "\chi_{" + str(self.modulus) + "}(" + str(
self.number) + ", \cdot)"
changed = True
if self._values_algebraic == {} or self._values_float == {}:
changed = True
for i in range(self.modulus):
self.value(i, value_format='float')
self.value(i, value_format='algebraic')
if self.modulus_euler_phi == 0:
changed = True
self.modulus_euler_phi = euler_phi(self.modulus)
if changed and save:
self.save_to_db()
else:
emf_logger.debug('Not saving.')
def render_web_modform_space_gamma1(level=None,
weight=None,
character=None,
label=None,
**kwds):
r"""
Render the webpage for the space of elliptic modular forms on gamma1 as a table of spaces of spaces on gamma0 with associated characters.
"""
emf_logger.debug(
"In render_ellitpic_modular_form_space kwds: {0}".format(kwds))
emf_logger.debug(
"Input: level={0},weight={1},character={2},label={3}".format(
level, weight, character, label))
info = to_dict(kwds)
info['level'] = level
info['weight'] = weight
info['character'] = character
title = "Newforms of weight {0} for \(\Gamma_1({1})\)".format(
weight, level)
bread = [(EMF_TOP, url_for('emf.render_elliptic_modular_forms'))]
bread.append(("Level %s" % level,
url_for("emf.render_elliptic_modular_forms", level=level)))
bread.append(("Weight %s" % weight,
url_for("emf.render_elliptic_modular_forms",
level=level,
weight=weight)))
info['grouptype'] = 1
info['show_all_characters'] = 1
info['table'] = set_info_for_gamma1(level, weight)
info['bread'] = bread
info['title'] = title
info['showGaloisOrbits'] = 1
return render_template("emf_render_web_modform_space_gamma1.html", **info)
def get_downloads(level=None, weight=None, character=None, label=None, **kwds):
keys = ['download', 'download_file', 'tempfile', 'format', 'number','bitprec']
info = get_args(request, level, weight, character, label, keys=keys)
# info = to_dict(request.form)
# info['level']=level; info['weight']=weight; info['character']=character; info['label']=label
if 'download' not in info:
emf_logger.critical("Download called without specifying what to download!")
return ""
emf_logger.debug("in get_downloads: info={0}".format(info))
if info['download'] == 'file':
# there are only a certain number of fixed files that we want people to download
filename = info['download_file']
if filename == "web_modforms.py":
dirname = emf.app.root_static_folder
try:
emf_logger.debug("Dirname:{0}, Filename:{1}".format(dirname, filename))
return send_from_directory(dirname, filename, as_attachment=True, attachment_filename=filename)
except IOError:
info['error'] = "Could not find file! "
if info['download'] == 'coefficients':
info['tempfile'] = "/tmp/tmp_web_mod_form.txt"
return get_coefficients(info)
if info['download'] == 'object':
return download_web_modform(info)
info['error'] = "Could not find file! "
def dimension_gamma1(self, arg1, k=3):
if self._table is None:
return "n/a"
if type(arg1) == sage.modular.dirichlet.DirichletCharacter:
N = arg1.modulus()
character = arg1.parent().galois_orbits().index(arg1.galois_orbit())
else:
if type(arg1) == int or type(arg1) == Integer:
N = arg1
character = -1
else:
return -1
emf_logger.debug(
'Lookup dimension for Gamma1({0}), weight={1}, character={2}'.format(N, k, character))
if N in self._table.keys():
# emf_logger.debug('Have information for level {0}'.format(N))
tblN = self._table[N]
if k in tblN.keys() and character in tblN[k].keys():
# emf_logger.debug('Lookup dimension for Gamma1({0}), weight={1},
# character={2}'.format(N,k,character))
dim = tblN[k][character]['dimension']
# emf_logger.debug('Have dimension for Gamma1({0}), weight={1},
# character={1}'.format(N,k,character))
return dim
return "n/a"
def print_coefficients_for_one_form(F, number, fmt,bitprec=53):
emf_logger.debug("in print {2} coefs for 1 form: format={0} bitprec={1}".format(fmt,bitprec,number))
# Start with some meta-data
s = "## level={N}, weight={k}, character={ch},label={label} \n".format(N=F.level(),k=F.weight(),ch=F.chi(),label=F.label())
max_cn = F.max_cn()
if number > max_cn:
number = max_cn
if fmt == "q_expansion":
s += F.print_q_expansion(number)
if fmt == "coefficients":
qe = F.coefficients(range(number))
if F.degree() > 1:
s += "## "+str(F.polynomial(type='coefficient_field'))+"=0"
s += "\n"
for n in range(len(qe)):
c=qe[n]
s += "{n} \t {c} \n".format(n=n,c=c)
if fmt == "embeddings":
embeddings = F.q_expansion_embeddings(number,bitprec=bitprec,format='numeric')
if F.degree() > 1:
for j in range(F.degree()):
s+="# Embedding nr. {j} \n".format(j=j)
for n in range(number):
s += str(n) + "\t" + str(embeddings[n][j]) + "\n"
else:
for n in range(number):
s += str(n) + "\t" + str(embeddings[n]) + "\n"
emf_logger.debug("s={0}".format(s))
return s
def extract_limits_as_tuple(arg, field):
fld = arg.get(field)
try:
if isinstance(fld,basestring):
tmp = parse_range(fld, use_dollar_vars=False)
if isinstance(tmp,dict):
limits = (tmp['min'],tmp['max'])
else:
limits = (tmp,tmp)
elif isinstance(fld,(tuple,list)):
limits = (int(fld[0]),int(fld[1]))
elif isinstance(fld,dict):
limits = (fld['min'], fld['max'])
elif not fld is None:
limits = (fld,fld)
else:
limits = None
except (TypeError,ValueError) as e:
emf_logger.debug("Error in search parameters. {0} ".format(e))
msg = safe_non_valid_input_error(arg.get(field),field)
if field == 'label':
msg += " Need a label which is a sequence of letters, for instance 'a' or 'ab' for input"
else:
msg += " Need either a positive integer or a range of positive integers as input."
flash(msg,"error")
return None
return limits
def extract_limits_as_tuple(arg, field):
fld = arg.get(field)
try:
if isinstance(fld, basestring):
tmp = parse_range(fld, use_dollar_vars=False)
if isinstance(tmp, dict):
limits = (tmp['min'], tmp['max'])
else:
limits = (tmp, tmp)
elif isinstance(fld, (tuple, list)):
limits = (int(fld[0]), int(fld[1]))
elif isinstance(fld, dict):
limits = (fld['min'], fld['max'])
elif not fld is None:
limits = (fld, fld)
else:
limits = None
except (TypeError, ValueError) as e:
emf_logger.debug("Error in search parameters. {0} ".format(e))
msg = safe_non_valid_input_error(arg.get(field), field)
if field == 'label':
msg += " Need a label which is a sequence of letters, for instance 'a' or 'ab' for input"
else:
msg += " Need either a positive integer or a range of positive integers as input."
flash(msg, "error")
return None
return limits
def init_dynamic_properties(self, embeddings=False):
if self.number is not None:
emf_logger.debug('number: {0}'.format(self.number))
self.character = DirichletCharacter_conrey(
DirichletGroup_conrey(self.modulus), self.number)
if not self.number == 1:
self.sage_character = self.character.sage_character()
else:
self.sage_character = trivial_character(self.modulus)
self.name = "Character nr. {0} of modulus {1}".format(
self.number, self.modulus)
if embeddings:
from lmfdb.modular_forms.elliptic_modular_forms.backend.emf_utils import dirichlet_character_conrey_galois_orbit_embeddings
emb = dirichlet_character_conrey_galois_orbit_embeddings(
self.modulus, self.number)
self.set_embeddings(emb)
c = self.character
if self.conductor == 0:
self.conductor = c.conductor()
if self.order == 0:
self.order = c.multiplicative_order()
if self.modulus_euler_phi == 0:
self.modulus_euler_phi = euler_phi(self.modulus)
if self.latex_name == '':
self.latex_name = "\chi_{" + str(self.modulus) + "}(" + str(
self.number) + ", \cdot)"
def download_to_sage(self, prec=None):
r"""
Minimal version for now to download to sage.
Does not work for high values of prec for large degree number fields (timeout).
"""
if prec is None:
prec = self.prec
s = "var('x')\n"
if self.base_ring.absolute_degree() > 1:
s += "K.<brgen>=NumberField(crpol)\n".format(brgen=str(self.base_ring.gen()), crpol=self.base_ring.polynomial())
if self.coefficient_field.absolute_degree() > 1:
s += "L.<{cfgen}> = NumberField({cfpol})\n".format(
cfgen=str(self.coefficient_field.gen()), cfpol=self.absolute_polynomial
)
s = s + "D = DirichletGroup({N})\n".format(
N = self.level
)
C = self.character.sage_character.parent()
if C.zeta_order()>2:
s = s + "{Dzeta}=CyclotomicField({Dzord}).gen()\n".format(Dzord=C.zeta_order(), Dzeta = C.zeta())
s = s + "f = {{'coefficients': {coeffs}, 'level' : {level}, 'weight': {weight}, 'character': D.Element(D,{vog}), 'label': '{label}','dimension': {dim}, 'is_cm': {cm} , 'cm_discriminant': {cm_disc}, 'atkin_lehner': {al}, 'explicit_formulas': {ep}}}".format(coeffs = self.coefficients(range(prec)),
level=self.level, weight=self.weight, vog = self.character.sage_character.values_on_gens(), label=self.hecke_orbit_label, dim=self.dimension, cm=self.is_cm, cm_disc=None if not self.is_cm else self.cm_disc , al=self.atkin_lehner_eigenvalues(),
ep = self.explicit_formulas
)
s = s + "\n\n#EXAMPLE\n"
s = s + "#sage: f['coefficients'][7]\n#{}\n".format(self.coefficient(7))
s = s + "#sage: f['character']\n#{}".format(self.character.sage_character)
emf_logger.debug("Generated sage file for {}".format(self.hecke_orbit_label))
return s
def compute(self, save=True):
emf_logger.debug("in compute for WebChar number {0} of modulus {1}".format(self.number, self.modulus))
c = self.character
changed = False
if self.conductor == 0:
self.conductor = c.conductor()
changed = True
if self.order == 0:
self.order = c.multiplicative_order()
changed = True
if self.latex_name == "":
self.latex_name = "\chi_{" + str(self.modulus) + "}(" + str(self.number) + ", \cdot)"
changed = True
if self._values_algebraic == {} or self._values_float == {}:
changed = True
for i in range(self.modulus):
self.value(i, value_format="float")
self.value(i, value_format="algebraic")
if self.modulus_euler_phi == 0:
changed = True
self.modulus_euler_phi = euler_phi(self.modulus)
if changed and save:
self.save_to_db()
else:
emf_logger.debug("Not saving.")
def __init__(self, dbname='', **kwds):
emf_logger.debug("in ClassicalMFDisplay kwds={0}".format(kwds))
MFDisplay.__init__(self, dbname, **kwds)
import lmfdb.base
Conn = lmfdb.base.getDBConnection()
#if dbname == '':
dbname = 'modularforms2'
def create_small_record(self, min_prec=10, want_prec=100, max_length = 5242880, max_height_qexp = default_max_height):
### creates a duplicate record (fs) of this webnewform
### with lower precision to load faster on the web
### we aim to have at most max_length bytes
### but at least min_prec coefficients and we desire to have want_prec
if min_prec>=self.prec:
raise ValueError("Need higher precision, self.prec = {}".format(self.prec))
if not hasattr(self, '_file_record_length'):
self.update_from_db()
l = self._file_record_length
if l > max_length or self.prec > want_prec:
nl = float(l)/float(self.prec)*float(want_prec)
if nl > max_length:
prec = max([floor(float(self.prec)/float(l)*float(max_length)), min_prec])
else:
prec = want_prec
emf_logger.debug("Creating a new record with prec = {}".format(prec))
self.prec = prec
include_coeffs = self.complexity_of_first_nonvanishing_coefficients() <= default_max_height
if include_coeffs:
self.q_expansion = self.q_expansion.truncate_powerseries(prec)
self._coefficients = {n:c for n,c in self._coefficients.iteritems() if n<prec}
else:
self.q_expansion = self.q_expansion.truncate_powerseries(1)
self._coefficients = {}
self.prec = 0
self.coefficient_field = NumberField(self.absolute_polynomial, names=str(self.coefficient_field.gen()))
self._embeddings['values'] = {n:c for n,c in self._embeddings['values'].iteritems() if n<prec}
self._embeddings['prec'] = prec
self.save_to_db()
def save_to_db(self, update=True):
r"""
Saves ```self``` to the database, i.e.
save the meta record and the file in the gridfs file system.
"""
fs = self._files
file_key = self.file_key_dict()
coll = self._file_collection
if fs.exists(file_key):
if not update:
return True
else:
fid = coll.find_one(file_key, projection=['_id'])['_id']
fs.delete(fid)
emf_logger.debug("Deleted file with fid={0}".format(fid))
# insert
s = dumps(self.fs_dict())
if not self._use_separate_db:
file_key.update(self.db_dict())
try:
t = fs.put(s, **file_key)
emf_logger.debug("Inserted file t={0}, filekey={1}".format(
t, file_key))
except Exception, e:
emf_logger.warn("Error inserting record: {0}".format(e))
def __init__(self, modulus=1, number=1, update_from_db=True, compute=False):
r"""
Init self.
"""
emf_logger.critical("In WebChar {0}".format((modulus, number, update_from_db, compute)))
if not gcd(number, modulus) == 1:
raise ValueError, "Character number {0} of modulus {1} does not exist!".format(number, modulus)
if number > modulus:
number = number % modulus
self._properties = WebProperties(
WebInt("conductor"),
WebInt("modulus", value=modulus),
WebInt("number", value=number),
WebInt("modulus_euler_phi"),
WebInt("order"),
WebStr("latex_name"),
WebStr("label", value="{0}.{1}".format(modulus, number)),
WebNoStoreObject("sage_character", type(trivial_character(1))),
WebDict("_values_algebraic"),
WebDict("_values_float"),
WebDict("_embeddings"),
WebFloat("version", value=float(emf_version)),
)
emf_logger.debug("Set properties in WebChar!")
super(WebChar, self).__init__(update_from_db=update_from_db)
if self._has_updated_from_db is False:
self.init_dynamic_properties() # this was not done if we exited early
compute = True
if compute:
self.compute(save=True)
# emf_logger.debug('In WebChar, self.__dict__ = {0}'.format(self.__dict__))
emf_logger.debug("In WebChar, self.number = {0}".format(self.number))
def download_to_sage(self, prec=None):
r"""
Minimal version for now to download to sage.
Does not work for high values of prec for large degree number fields (timeout).
"""
if prec is None:
prec = self.prec
s = "var('x')\n"
if self.base_ring.absolute_degree() > 1:
s += "K.<{brgen}>=NumberField({crpol})\n".format(brgen=str(self.base_ring.gen()), crpol=self.base_ring.polynomial().change_variable_name('x'))
if self.coefficient_field.is_absolute():
if self.coefficient_field.absolute_degree() > 1:
s += "L.<{cfgen}> = NumberField({cfpol})\n".format(
cfgen=str(self.coefficient_field.gen()), cfpol=self.absolute_polynomial
)
elif self.coefficient_field.relative_degree() > 1:
s += "y = polygen(K)\n"
s += "L.<{cfgen}> = NumberField({cfpol})\n".format(
cfgen=str(self.coefficient_field.gen()), cfpol=self.coefficient_field.relative_polynomial().change_variable_name('y')
)
s = s + "D = DirichletGroup({N})\n".format(
N = self.level
)
C = self.character.sage_character.parent()
s = s + "f = {{'coefficients': {coeffs}, 'level' : {level}, 'weight': {weight}, 'character': D.Element(D,vector({elt})), 'label': '{label}','dimension': {dim}, 'is_cm': {cm} , 'cm_discriminant': {cm_disc}, 'atkin_lehner': {al}, 'explicit_formulas': {ep}}}".format(coeffs = self.coefficients(range(prec)),
level=self.level, weight=self.weight, elt = list(self.character.sage_character.element()), label=self.hecke_orbit_label, dim=self.dimension, cm=self.is_cm, cm_disc=None if not self.is_cm else self.cm_disc , al=self.atkin_lehner_eigenvalues(),
ep = self.explicit_formulas
)
s = s + "\n\n#EXAMPLE\n"
s = s + "#sage: f['coefficients'][7]\n#{}\n".format(self.coefficient(7))
s = s + "#sage: f['character']\n#{}".format(self.character.sage_character)
emf_logger.debug("Generated sage file for {}".format(self.hecke_orbit_label))
return s
def convert(self):
if len(self._value) == 0:
return
convert_to = self._convert_to
#more types to come?
if not convert_to in ['auto', 'poly', None]:
raise NotImplementedError("convert to {} not Implemented".format(convert_to))
if convert_to is None:
pass
if self._elt_type is None:
self.set_elt_type()
if convert_to == 'auto':
if self._elt_type == 'nfrel':
convert_to = 'poly'
if convert_to == 'poly':
elt = self._value.values()[0]
if self._elt_type == 'nfabs':
emf_logger.debug("Converting from nfabs to poly!")
R = PolynomialRing(QQ,names=str(elt.parent().gen()))
self._value = {k: R(str(v)) for k,v in self._value.iteritems()}
elif self._elt_type == 'nfrel':
emf_logger.debug("Converting from nfrel to poly!")
if elt.parent().base_ring() == QQ:
R = QQ
else:
R = PolynomialRing(QQ,names=str(elt.parent().base_ring().gen()))
T = PolynomialRing(R,names=str(elt.parent().gen()))
#R = PolynomialRing(QQ, names=[str(self._value.values()[0].parent().base_ring().gen()),\
# str(self._value.values()[0].parent().gen())])
self._elt_type = 'poly'
self._value = {k: T(str(v)) for k,v in self._value.iteritems()}
def print_list_of_coefficients(info):
r"""
Print a table of Fourier coefficients in the requested format
"""
level = my_get(info, 'level', -1, int)
weight = my_get(info, 'weight', -1, int)
prec = my_get(info, 'prec', 12, int) # number of digits
bitprec = my_get(info, 'bitprec', 12, int) # number of digits
character = my_get(info, 'character', '', str) # int(info.get('weight',0))
fmt = info.get("format", "q_expansion")
if character == '':
character = '1'
label = info.get('label', '')
if character.isalnum():
character = int(character)
else:
return "The character '{0}' is not well-defined!".format(character)
print "--------------"
if label == '' or level == -1 or weight == -1:
return "Need to specify a modular form completely!!"
number = int(info['number']) + 1 if 'number' in info else 20
emf_logger.debug("number = {}".format(number))
F = WebNewForm(level=level,
weight=weight,
character=character,
label=label,
prec=number)
if not F.has_updated():
return ""
if not 'number' in info:
F.prec = number = max(F.parent.sturm_bound + 1, 20)
F.update_from_db()
shead = "Cusp forms of weight " + str(weight) + "on \(" + latex(
F.parent.group) + "\)"
s = ""
if ((character is not None) and (character > 0)):
shead = shead + " and character \( \chi_{" + str(character) + "}\)"
# s="<table><tr><td>"
coefs = ""
if fmt == "sage":
res = []
if number > F.max_available_prec():
raise IndexError, "The database does not contain this many ({0}) coefficients for this modular form! We only have {1}".format(
number, F.max_available_prec())
if fmt == "sage":
qe = F.coefficients(range(number))
res.append(qe)
else:
coefs += print_coefficients_for_one_form(F,
number,
info['format'],
bitprec=bitprec)
if not fmt == "sage":
return s + "\n" + coefs
else:
if len(res) == 1:
res = res[0]
#print "res=",res
return dumps(res)
def get_new_and_oldspace_decomposition(k, N, xi=0):
r"""
Get decomposition of the new and oldspace S_k(N,xi) into submodules.
"""
M = ModularSymbols(N, k, sign=1).cuspidal_submodule()
L = list()
L = [M.new_submodule().dimension()]
check_dim = M.new_submodule().dimension()
for d in divisors(N):
if(d == 1):
continue
O = M.old_submodule(d)
Od = O.dimension()
if(d == N and k == 2 or Od == 0):
continue
S = ModularSymbols(ZZ(N / d), k, sign=1).cuspidal_submodule().new_submodule()
Sd = S.dimension()
if(Sd == 0):
logger.debug("%s, %s" % (O, Od))
logger.debug("%s, %s" % (S, Sd))
mult = len(divisors(ZZ(d)))
check_dim = check_dim + mult * Sd
L.append((ZZ(N / d), mult, Sd))
check_dim = check_dim - M.dimension()
if(check_dim != 0):
raise ArithmeticError("Something wrong! check_dim=%s" % check_dim)
return str(M.dimension(), L)
def extract_data_from_jump_to(s):
label = ''
weight = 0
character = 0
level = 1
if s == 'delta':
weight = 12
level = 1
label = "a"
else:
# first see if we have a label or not, i.e. if we have precisely one string of letters at the end
test = re.findall("[a-z]+", s)
if len(test) == 1:
label = test[0]
# emf_logger.debug("label1={0}".format(label))
# the first string of integers should be the level
test = re.findall("\d+", s)
if not test is None and len(test)>0:
level = int(test[0])
if len(test) > 1: # we also have weight
weight = int(test[1])
if len(test) > 2: # we also have character
character = int(test[2])
emf_logger.debug("label=%s" % label)
emf_logger.debug("level=%s" % level)
args = dict()
args['level'] = int(level)
args['weight'] = int(weight)
args['character'] = int(character)
if label: args['label'] = label
return args
def dimension_gamma1(self, arg1, k=3):
if self._table is None:
return "n/a"
if type(arg1) == sage.modular.dirichlet.DirichletCharacter:
N = arg1.modulus()
character = arg1.parent().galois_orbits().index(
arg1.galois_orbit())
else:
if type(arg1) == int or type(arg1) == Integer:
N = arg1
character = -1
else:
return -1
emf_logger.debug(
'Lookup dimension for Gamma1({0}), weight={1}, character={2}'.
format(N, k, character))
if N in self._table.keys():
# emf_logger.debug('Have information for level {0}'.format(N))
tblN = self._table[N]
if k in tblN.keys() and character in tblN[k].keys():
# emf_logger.debug('Lookup dimension for Gamma1({0}), weight={1},
# character={2}'.format(N,k,character))
dim = tblN[k][character]['dimension']
# emf_logger.debug('Have dimension for Gamma1({0}), weight={1},
# character={1}'.format(N,k,character))
return dim
return "n/a"
def get_downloads(level=None, weight=None, character=None, label=None, **kwds):
keys = [
'download', 'download_file', 'tempfile', 'format', 'number', 'bitprec'
]
info = get_args(request, level, weight, character, label, keys=keys)
# info = to_dict(request.form)
# info['level']=level; info['weight']=weight; info['character']=character; info['label']=label
if 'download' not in info:
emf_logger.critical(
"Download called without specifying what to download!")
return ""
emf_logger.debug("in get_downloads: info={0}".format(info))
if info['download'] == 'file':
# there are only a certain number of fixed files that we want people to download
filename = info['download_file']
if filename == "web_modforms.py":
dirname = emf.app.root_static_folder
try:
emf_logger.debug("Dirname:{0}, Filename:{1}".format(
dirname, filename))
return send_from_directory(dirname,
filename,
as_attachment=True,
attachment_filename=filename)
except IOError:
info['error'] = "Could not find file! "
if info['download'] == 'coefficients':
info['tempfile'] = "/tmp/tmp_web_mod_form.txt"
return get_coefficients(info)
if info['download'] == 'object':
return download_web_modform(info)
info['error'] = "Could not find file! "
def create_small_record(self, min_prec=10, want_prec=100, max_length = 5242880, max_height_qexp = default_max_height):
### creates a duplicate record (fs) of this webnewform
### with lower precision to load faster on the web
### we aim to have at most max_length bytes
### but at least min_prec coefficients and we desire to have want_prec
if min_prec>=self.prec:
raise ValueError("Need higher precision, self.prec = {}".format(self.prec))
l = self._file_record_length
if l > max_length or self.prec > want_prec:
nl = float(l)/float(self.prec)*float(want_prec)
if nl > max_length:
prec = max([floor(float(self.prec)/float(l)*float(max_length)), min_prec])
else:
prec = want_prec
emf_logger.debug("Creating a new record with prec = {}".format(prec))
self.prec=prec
include_qexp = self.complexity_of_first_nonvanishing_coefficients() <= default_max_height
if include_qexp:
self.q_expansion = self.q_expansion.truncate_powerseries(prec)
else:
self.q_expansion = self.q_expansion.truncate_powerseries(1)
self._coefficients = {n:c for n,c in self._coefficients.iteritems() if n<prec}
self._embeddings['values'] = {n:c for n,c in self._embeddings['values'].iteritems() if n<prec}
self._embeddings['prec'] = prec
self.save_to_db()
def WebNewForm_cached(level,weight,character,label,parent=None, **kwds):
if use_cache:
M = WebModFormSpace_cached(level, weight, character, **kwds)
return M.hecke_orbits[label]
else:
F = WebNewForm(level,weight,character,label,**kwds)
emf_logger.debug("Computed F not using cache!")
return F
def update_from_db(self, **kwargs):
self._add_to_fs_query = {'prec': {'$gt': int(self.prec-1)}}
self._sort = [('prec', pymongo.ASCENDING)]
self._sort_files = [('prec', pymongo.ASCENDING)]
emf_logger.debug(self._add_to_fs_query)
super(WebEigenvalues,self).update_from_db(**kwargs)
#remember the precision we got after updating for every query (not only update_from_db uses this)
self._add_to_fs_query = {'prec': {'$gt': int(self.prec-1)}}
def update_from_db(self, **kwargs):
self._add_to_fs_query = {'prec': {'$gt': int(self.prec-1)}}
self._sort = [('prec', pymongo.ASCENDING)]
self._sort_files = [('prec', pymongo.ASCENDING)]
emf_logger.debug(self._add_to_fs_query)
super(WebEigenvalues,self).update_from_db(**kwargs)
#remember the precision we got after updating for every query (not only update_from_db uses this)
self._add_to_fs_query = {'prec': {'$gt': int(self.prec-1)}}
def WebNewForm_cached(level,weight,character,label,parent=None, **kwds):
if use_cache:
M = WebModFormSpace_cached(level, weight, character, **kwds)
return M.hecke_orbits[label]
else:
F = WebNewForm(level,weight,character,label,**kwds)
emf_logger.debug("Computed F not using cache!")
return F
def __init__(self, dbname='', **kwds):
MFDisplay.__init__(self, dbname, **kwds)
import lmfdb.base
Conn = lmfdb.base.getDBConnection()
#if dbname == '':
dbname = 'modularforms2'
self._files = Conn[dbname].Newform_factors.files
emf_logger.debug("files : {0}".format(self._files))
def file_key_dict(self):
r"""
Return a dictionary where the keys are the dbkeys of ``self``` and
the values are the corresponding values of ```self```.
"""
emf_logger.debug('key: {0}'.format(self._key))
#emf_logger.debug('properties: {0}'.format(self._properties))
return { key : self._properties[key].to_db() for key in self._file_key }
def init_dynamic_properties(self):
if self.number is not None:
emf_logger.debug('number: {0}'.format(self.number))
self.character = DirichletCharacter_conrey(
DirichletGroup_conrey(self.modulus), self.number)
self.sage_character = self.character.sage_character()
self.name = "Character nr. {0} of modulus {1}".format(
self.number, self.modulus)
def file_key_dict(self):
r"""
Return a dictionary where the keys are the dbkeys of ``self``` and
the values are the corresponding values of ```self```.
"""
emf_logger.debug('key: {0}'.format(self._key))
#emf_logger.debug('properties: {0}'.format(self._properties))
return {key: self._properties[key].to_db() for key in self._file_key}
def __init__(self, dbname='', **kwds):
emf_logger.debug("in ClassicalMFDisplay kwds={0}".format(kwds))
MFDisplay.__init__(self, dbname, **kwds)
import lmfdb.base
Conn = lmfdb.base.getDBConnection()
#if dbname == '':
dbname = 'modularforms2'
self._files = Conn[dbname].Newform_factors.files
emf_logger.debug("files db : {0} with nr. of recs:{1}".format(self._files,self._files.find().count()))
def init_dynamic_properties(self):
from lmfdb.modular_forms.elliptic_modular_forms.backend.emf_utils import dirichlet_character_conrey_galois_orbit_embeddings
if self.number is not None:
emf_logger.debug('number: {0}'.format(self.number))
self.character = DirichletCharacter_conrey(DirichletGroup_conrey(self.modulus),self.number)
self.sage_character = self.character.sage_character()
self.name = "Character nr. {0} of modulus {1}".format(self.number,self.modulus)
emb = dirichlet_character_conrey_galois_orbit_embeddings(self.modulus,self.number)
self.set_embeddings(emb)
def __init__(self, dbname="", **kwds):
MFDisplay.__init__(self, dbname, **kwds)
import lmfdb.base
Conn = lmfdb.base.getDBConnection()
# if dbname == '':
dbname = "modularforms2"
self._files = Conn[dbname].Newform_factors.files
emf_logger.debug("files : {0}".format(self._files))
def __init__(self, dbname='', **kwds):
emf_logger.debug("in ClassicalMFDisplay kwds={0}".format(kwds))
MFDisplay.__init__(self, dbname, **kwds)
import lmfdb.base
Conn = lmfdb.base.getDBConnection()
#if dbname == '':
dbname = 'modularforms2'
self._files = Conn[dbname].Newform_factors.files
emf_logger.debug("files db : {0} with nr. of recs:{1}".format(self._files,self._files.find().count()))
def __init__(self, name, level, weight, character, parent=None,**kwds):
emf_logger.debug("Get Hecke orbits! {0},{1},{2},{3},{4},kwds={5}".format(name,level,weight,character,type(parent),kwds))
self.level = level
self.weight = weight
self.character = character
self.parent = parent
super(WebHeckeOrbits, self).__init__(
name, None, save_to_db=True, save_to_fs=False,**kwds
)
emf_logger.debug("Initiated Hecke orbits!")
def browse_web_modform_spaces_in_ranges(**kwds):
r"""
Browse spaces with level and weight within given ranges. level and weight should be of the form N1-N2 and k1-k2
"""
emf_logger.debug("request.args={0}".format(request.args))
level=request.args.getlist('level')
weight=request.args.getlist('weight')
group=request.args.getlist('group')
return _browse_web_modform_spaces_in_ranges(level=level,weight=weight,group=group)
def redirect_false_route(level=None,weight=None,character=None,label='',emb=None):
## jumps only have one field (here level)
if weight is None:
args = extract_data_from_jump_to(level)
emf_logger.debug("args={0}".format(args))
else:
args = {'level':level,'weight':weight,'character':character,'label':label}
#validate_parameters(level,weight,character,label,args)
return redirect(url_for("emf.render_elliptic_modular_forms",**args), code=301)
def redirect_false_route(level=None,weight=None,character=None,label='',emb=None):
## jumps only have one field (here level)
if weight is None:
args = extract_data_from_jump_to(level)
emf_logger.debug("args={0}".format(args))
else:
args = {'level':level,'weight':weight,'character':character,'label':label}
#validate_parameters(level,weight,character,label,args)
return redirect(url_for("emf.render_elliptic_modular_forms",**args), code=301)
def browse_web_modform_spaces_in_ranges(**kwds):
r"""
Browse spaces with level and weight within given ranges. level and weight should be of the form N1-N2 and k1-k2
"""
emf_logger.debug("request.args={0}".format(request.args))
level=request.args.getlist('level')
weight=request.args.getlist('weight')
group=request.args.getlist('group')
return render_elliptic_modular_form_navigation_wp(level=level,weight=weight,group=group)
def get_coefficients(info):
r"""
Return a file with the Fourier coefficients in desired format.
"""
emf_logger.debug("IN GET_COEFFICIENTS!!!")
level = my_get(info, 'level', -1, int)
weight = my_get(info, 'weight', -1, int)
character = my_get(info, 'character', '', int) # int(info.get('weight',0))
number = my_get(info, 'number', 100, int)
label = my_get(info, 'label', '', str)
emf_logger.debug("info={0}".format(info))
if character == '':
character = 1
label = info.get('label', '')
if info['format'] == "sage":
ending = "sage"
f = WebNewForm(level, weight, character, label, prec=number)
s = f.download_to_sage(number)
elif info['format'] == "sobj":
ending = "sobj"
f = WebNewForm(level, weight, character, label, prec=number)
s = f.dump_coefficients(number)
else:
# we only want one form or one embedding
try:
s = print_list_of_coefficients(info)
except IndexError as e:
info['error'] = str(e)
flask.flash(str(e))
return redirect(url_for("emf.render_elliptic_modular_forms",
level=level,
weight=weight,
character=character,
label=label),
code=301)
ending = "txt"
if info['format'] == 'q_expansion':
fmt = '-qexp'
elif info['format'] == "coefficients" or info['format'] == "sobj":
fmt = '-coef'
elif info['format'] == "embeddings":
fmt = '-emb'
else:
fmt = ''
info['filename'] = "{0}-{1}-{2}-{3}-coefficients-0-to-{4}{5}.{6}".format(
level, weight, character, label, number, fmt, ending)
# return send_file(info['tempfile'], as_attachment=True, attachment_filename=info['filename'], add_etags=False)
strIO = StringIO.StringIO()
strIO.write(s)
strIO.seek(0)
return send_file(strIO,
attachment_filename=info["filename"],
as_attachment=True,
add_etags=False)
def authorize(cls):
r"""
Need to be authorized to insert data
"""
from os.path import dirname, join
pw_filename = join(dirname(dirname(__file__)), "password")
user = '******'
password = open(pw_filename, "r").readlines()[0].strip()
emf_logger.debug("Authenticating user={0} password={1}".format(user,password))
cls.connect_to_db().authenticate(user,password)
emf_logger.debug("Authenticated with user:{0} and pwd:{1}".format(user,password))
def file_key_dict(self, include_multi=True):
r"""
Return a dictionary where the keys are the dbkeys of ``self``` and
the values are the corresponding values of ```self```.
"""
emf_logger.debug('key: {0}'.format(self._key))
#emf_logger.debug('properties: {0}'.format(self._properties))
keys = copy(self._file_key)
if include_multi and self._file_key_multi is not None:
keys += self._file_key_multi
return {key: self._properties[key].to_db() for key in keys}
def authorize(cls):
r"""
Need to be authorized to insert data
"""
from os.path import dirname, join
pw_filename = join(dirname(dirname(__file__)), "password")
user = '******'
password = open(pw_filename, "r").readlines()[0].strip()
emf_logger.debug("Authenticating user={0} password={1}".format(user,password))
cls.connect_to_db().authenticate(user,password)
emf_logger.debug("Authenticated with user:{0} and pwd:{1}".format(user,password))
def compute_values(self, save=False):
emf_logger.debug('in compute_values for WebChar number {0} of modulus {1}'.format(self.number, self.modulus))
if self._values_algebraic == {} or self._values_float == {}:
changed = True
for i in range(self.modulus):
self.value(i,value_format='float')
self.value(i,value_format='algebraic')
if changed and save:
self.save_to_db()
else:
emf_logger.debug('Not saving.')
def file_key_dict(self, include_multi = True):
r"""
Return a dictionary where the keys are the dbkeys of ``self``` and
the values are the corresponding values of ```self```.
"""
emf_logger.debug('key: {0}'.format(self._key))
#emf_logger.debug('properties: {0}'.format(self._properties))
keys = copy(self._file_key)
if include_multi and self._file_key_multi is not None:
keys += self._file_key_multi
return { key : self._properties[key].to_db() for key in keys }
def __init__(self, name, level, weight, character, parent=None, prec=10, **kwds):
emf_logger.debug("Get Hecke orbits! {0},{1},{2},{3},{4},kwds={5}".format(name,level,weight,character,type(parent),kwds))
self.level = level
self.weight = weight
self.character = character
self.parent = parent
self.prec = prec
super(WebHeckeOrbits, self).__init__(
name, None, save_to_db=True, save_to_fs=False,**kwds
)
emf_logger.debug("Initiated Hecke orbits!")
def render_web_newform(level, weight, character, label, **kwds):
r"""
Renders the webpage for one elliptic modular form.
"""
# citation = ['Sage:' + version()] # never used
info = set_info_for_web_newform(level, weight, character, label, **kwds)
emf_logger.debug("info={0}".format(info.keys()))
## Check if we want to download either file of the function or Fourier coefficients
if 'download' in info and 'error' not in info:
return send_file(info['tempfile'], as_attachment=True, attachment_filename=info['filename'])
return render_template("emf_web_newform.html", **info)
