def populate_all_characters(self, level, weight, verbose=True):
from sage.all import DirichletGroup
G = DirichletGroup(level)
B = G.galois_orbits()
B = [character[0].minimize_base_ring() for character in B]
for character in B:
self.populate(level, weight, character, verbose)
def generate_dimension_table_gamma1(maxN=100, maxk=12, minN=3, mink=2):
C = pymongo.connection.Connection(port=int(37010))
ms = C['modularforms']['Modular_symbols.files']
print ms
data = dict()
for N in range(minN, maxN + 1):
data[N] = dict()
for k in range(mink, maxk + 1):
data[N][k] = dict()
if N > 2:
D = DirichletGroup(N)
G = D.galois_orbits(reps_only=True)
dimall = 0
in_db_all = True
for xi, x in enumerate(G):
dim = dimension_new_cusp_forms(x, k)
dimall += dim
finds = ms.find({'t': [int(N), int(k), int(xi)]})
in_db = finds.count() > 0
if not in_db:
in_db_all = False
data[N][k][xi] = {'dimension': dim, 'in_db': in_db}
else:
in_db_all = True
# we only have the trivial character
finds = ms.find({'t': [int(N), int(k), int(0)]})
in_db = finds.count() > 0
if not in_db:
in_db_all = False
dimall = dimension_new_cusp_forms(N, k)
data[N][k][0] = {'dimension': dimall, 'in_db': in_db}
# print N,k,data[N][k]
data[N][k][-1] = {'dimension': dimall, 'in_db': in_db_all}
print "Computed data for level ", N
return ms, data
def populate_all_characters(self, level, weight, verbose=True):
from sage.all import DirichletGroup
G = DirichletGroup(level)
B = G.galois_orbits()
B = [character[0].minimize_base_ring() for character in B]
for character in B:
self.populate(level, weight, character, verbose)
def populate_quadratic_characters(self, level, weight, verbose=True):
from sage.all import DirichletGroup, QQ
G = DirichletGroup(level,QQ)
B = G.galois_orbits()
B = [character[0].minimize_base_ring() for character in B
if character[0].order()==2]
for character in B:
self.populate(level, weight, character, verbose)
def populate_quadratic_characters(self, level, weight, verbose=True):
from sage.all import DirichletGroup, QQ
G = DirichletGroup(level, QQ)
B = G.galois_orbits()
B = [
character[0].minimize_base_ring() for character in B
if character[0].order() == 2
]
for character in B:
self.populate(level, weight, character, verbose)
def to_dirichlet_character(self, character):
if character['order'] == 1:
from sage.all import trivial_character
return trivial_character(character['modulus'])
from sage.all import DirichletGroup, CyclotomicField, QQ
from sage.modular.dirichlet import DirichletCharacter
zeta_order = character['zeta_order']
R = QQ if zeta_order == 2 else CyclotomicField(zeta_order)
G = DirichletGroup(character['modulus'], R, zeta_order=zeta_order)
v = G.an_element().element().parent()(character['element'])
return DirichletCharacter(G, v)
def to_dirichlet_character(self, character):
if character['order'] == 1:
from sage.all import trivial_character
return trivial_character(character['modulus'])
from sage.all import DirichletGroup, CyclotomicField, QQ
from sage.modular.dirichlet import DirichletCharacter
zeta_order = character['zeta_order']
R = QQ if zeta_order == 2 else CyclotomicField(zeta_order)
G = DirichletGroup(character['modulus'], R, zeta_order=zeta_order)
v = G.an_element().element().parent()(character['element'])
return DirichletCharacter(G, v)
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_sturm_bound(k, N, xi=0):
r""" Return the Sturm bound of S_k(N,xi), i.e. the number of coefficients necessary to determine a form uniquely in the space.
INPUT:
- ''k'' -- positive integer : the weight
- ''N'' -- positive integer (default 1) : level
- ''xi''-- non-negative integer (default 0) : use character nr. xi in DirichletGroup(N)
OUTPUT:
- ''s'' -- string representation of t = sturm bound of S_k(N,xi)
EXAMPLES::
sage: get_sturm_bound(11,2)
'3'
sage: get_sturm_bound(3,14,3)
'7'
"""
# check input
if (N <= 0 or k <= 0):
raise ValueError("Need positive level and weight!")
if (xi == 0):
d = sturm_bound(N, k)
else:
chi = DirichletGroup(N)[xi]
S = CuspForms(chi, k)
d = S.sturm_bound()
return str(d)
def get_dimension_cusp_forms(k, N=1, xi=0):
r""" Return the dimension of S_k(N,xi).
INPUT:
- ''k'' -- positive integer : the weight
- ''N'' -- positive integer (default 1) : level
- ''xi''-- non-negative integer (default 0) : use character nr. xi in DirichletGroup(N)
OUTPUT:
- ''s'' -- string representation of d = dimension of S_k(N,xi)
EXAMPLES::
sage: get_dimension_cusp_forms(2,11)
'1'
sage: get_dimension_cusp_forms(3,14,3)
'2'
"""
# check input
if (N <= 0 or k <= 0):
raise ValueError("Need positive level and weight!")
if (xi < 0):
raise ValueError("Need positive character index!")
elif (xi == 0):
d = dimension_cusp_forms(N, k)
else:
DG = DirichletGroup(N)
chi = list(DG)[xi]
d = dimension_cusp_forms(chi, k)
return str(d)
def sage_character(self, order, genvalues):
H = DirichletGroup(self.modulus,
base_ring=CyclotomicField(
self.sage_zeta_order(order)))
M = H._module
order_corrected_genvalues = get_sage_genvalues(
self.modulus, order, genvalues, self.sage_zeta_order(order))
return DirichletCharacter(H, M(order_corrected_genvalues))
def twist_by(self, x):
r"""
twist self by a primitive Dirichlet character x
"""
# xx = x.primitive()
assert x.is_primitive()
q = x.conductor()
# what level will the twist live on?
level = self.level()
qq = self.character().conductor()
new_level = lcm(self.level(), lcm(q * q, q * qq))
D = DirichletGroup(new_level)
new_x = D(self.character()) * D(x) * D(x)
ix = D.list().index(new_x)
# the correct space
NS = WebModFormSpace(self._k, new_level, ix, self._prec)
# have to find whih form wee want
NS.galois_decomposition()
M = NS.sturm_bound() + len(divisors(new_level))
C = self.coefficients(range(M))
for label in NS._galois_orbits_labels:
wmf_logger.debug("label={0}".format(label))
FT = NS.f(label)
CT = FT.f.coefficients(M)
wmf_logger.debug("{0}".format(CT))
K = FT.f.hecke_eigenvalue_field()
try:
for n in range(2, M):
if(new_level % n + 1 == 0):
continue
wmf_logger.debug("n={0}".format(n))
ct = CT[n]
c = K(x(n)) * K(C[n])
wmf_logger.debug("{0} {1}".format(ct, c))
if ct != c:
raise StopIteration()
except StopIteration:
pass
else:
wmf_logger.debug("Twist of f={0}".format(FT))
return FT
def _get_newform(k, N, chi, fi):
r"""
Get an element of the space of newforms, incuding some error handling.
INPUT:
- ''k'' -- positive integer : the weight
- ''N'' -- positive integer (default 1) : level
- ''chi'' -- non-neg. integer (default 0) use character nr. chi
- ''fi'' -- integer (default 0) We want to use the element nr. fi f=Newforms(N,k)[fi]. fi=-1 returns the whole list
- ''prec'' -- integer (the number of coefficients to get)
OUTPUT:
-''t'' -- bool, returning True if we succesfully created the space and picked the wanted f
-''f'' -- equals f if t=True, otherwise contains an error message.
EXAMPLES::
sage: _get_newform(16,10,1)
(False, 'Could not construct space $S^{new}_{16}(10)$')
sage: _get_newform(10,16,1)
(True, q - 68*q^3 + 1510*q^5 + O(q^6))
sage: _get_newform(10,16,3)
(True, q + 156*q^3 + 870*q^5 + O(q^6))
sage: _get_newform(10,16,4)
(False, '')
"""
t = False
try:
if (chi == 0):
S = Newforms(N, k, names='x')
else:
S = Newforms(DirichletGroup(N)[chi], k, names='x')
if (fi >= 0 and fi < len(S)):
f = S[fi]
t = True
elif (fi == -1):
return S
else:
f = ""
except RuntimeError:
if (chi == 0):
f = "Could not construct space $S^{new}_{%s}(%s)$" % (k, N)
else:
f = "Could not construct space $S^{new}_{%s}(%s,\chi_{%s})$" % (
k, N, chi)
return (t, f)
def generate_dimension_table_gamma1(maxN=100, maxk=12, minN=3, mink=2):
C = pymongo.connection.Connection(port=dbport)
C = pymongo.connection.Connection(port=dbport)
ms = C['modularforms']['Modular_symbols.files']
print ms
data = dict()
for N in range(minN, maxN + 1):
data[N] = dict()
for k in range(mink, maxk + 1):
data[N][k] = dict()
if N > 2:
D = DirichletGroup(N)
G = D.galois_orbits(reps_only=True)
dimall = 0
in_db_all = True
for xi, x in enumerate(G):
dim = dimension_new_cusp_forms(x, k)
dimall += dim
finds = ms.find({'t': [int(N), int(k), int(xi)]})
in_db = finds.count() > 0
if not in_db:
in_db_all = False
data[N][k][xi] = {'dimension': dim, 'in_db': in_db}
else:
in_db_all = True
# we only have the trivial character
finds = ms.find({'t': [int(N), int(k), int(0)]})
in_db = finds.count() > 0
if not in_db:
in_db_all = False
dimall = dimension_new_cusp_forms(N, k)
data[N][k][0] = {'dimension': dimall, 'in_db': in_db}
# print N,k,data[N][k]
data[N][k][-1] = {'dimension': dimall, 'in_db': in_db_all}
print "Computed data for level ", N
return ms, data
def is_CM(k, N=1, chi=0, fi=0, prec=10):
r"""
Checks if f has complex multiplication and if it has then it returns the character.
INPUT:
- ''k'' -- positive integer : the weight
- ''N'' -- positive integer (default 1) : level
- ''chi'' -- non-neg. integer (default 0) use character nr. chi - ''fi'' -- non-neg. integer (default 0) We want to use the element nr. fi f=Newforms(N,k)[fi]
OUTPUT:
-''[t,x]'' -- string saying whether f is CM or not and if it is, the corresponding character
EXAMPLES::
"""
(t, f) = _get_newform(k, N, chi, fi)
if (not t):
return f
max_nump = number_of_hecke_to_check(f)
coeffs = f.coefficients(max_nump + 1)
nz = coeffs.count(0) # number of zero coefficients
nnz = len(coeffs) - nz # number of non-zero coefficients
if (nz == 0):
return [False, 0]
# probaly checking too many
for D in range(3, ceil(QQ(max_nump) / QQ(2))):
try:
for x in DirichletGroup(D):
if (x.order() != 2):
continue
# we know that for CM we need x(p) = -1 => c(p)=0
# (for p not dividing N)
if (x.values().count(-1) > nz):
raise StopIteration() # do not have CM with this char
for p in prime_range(max_nump + 1):
if (x(p) == -1 and coeffs[p] != 0):
raise StopIteration() # do not have CM with this char
# if we are here we have CM with x.
return [True, x]
except StopIteration:
pass
return [False, 0]
def insert_dirichlet_L_functions(start, end):
print "Putting Dirichlet L-functions into database."
start = max(3, start)
for q in range(start, end):
print "Working on modulus", q
sys.stdout.flush()
G = DirichletGroup(q)
for n in range(len(G)):
chi = G[n]
if chi.is_primitive():
L = lc.Lfunction_from_character(chi)
z = L.find_zeros_via_N(1)[0]
Lfunction_data = {}
Lfunction_data['first_zero'] = float(z)
Lfunction_data[
'description'] = "Dirichlet L-function for character number " + str(
n) + " modulo " + str(q)
Lfunction_data['degree'] = 1
Lfunction_data['signature'] = (1, 0)
if chi.is_odd():
Lfunction_data['mu'] = [
(1.0, 0.0),
]
else:
Lfunction_data['mu'] = [
(0.0, 0.0),
]
Lfunction_data['level'] = q
coeffs = []
for k in range(0, 10):
coeffs.append(CC(chi(k)))
Lfunction_data['coeffs'] = [(float(x.real()), float(x.imag()))
for x in coeffs]
Lfunction_data['special'] = {
'type': 'dirichlet',
'modulus': q,
'number': n
}
Lfunctions.insert(Lfunction_data)
def compare_vv_scalar(V, k):
dv = V.dimension_cusp_forms(k)
N = V._level
m = V._M.order()
if k in ZZ:
D = DirichletGroup(N)
if is_even(k):
chi = D(kronecker_character(m))
else:
chi = D(kronecker_character(-m))
S = CuspForms(chi, k)
N = Newforms(chi, k, names='a')
ds = S.dimension()
B = N
else:
D = magma.DirichletGroup(V._level)
chi = magma.D(magma.KroneckerCharacter(2 * m))
M = magma.HalfIntegralWeightForms(chi, k)
S = M.CuspidalSubspace()
ds = S.Dimension()
B = S.Basis()
return dv, ds, S, B
def compare_formulas_1(D, k):
DG = DirichletGroup(abs(D))
chi = DG(kronecker_character(D))
d1 = dimension_new_cusp_forms(chi, k)
#if D>0:
# lvals=sage.lfunctions.all.lcalc.twist_values(1,2,D)
#else:
# lvals=sage.lfunctions.all.lcalc.twist_values(1,D,0)
#s1=RR(sum([sqrt(abs(lv[0]))*lv[1]*2**len(prime_factors(D/lv[0])) for lv in lvals if lv[0].divides(D) and Zmod(lv[0])(abs(D/lv[0])).is_square()]))
#d2=RR(1/pi*s1)
d2 = 0
for d in divisors(D):
if is_fundamental_discriminant(-d):
K = QuadraticField(-d)
DD = old_div(ZZ(D), ZZ(d))
ep = euler_phi((chi * DG(kronecker_character(-d))).conductor())
#ep=euler_phi(squarefree_part(abs(D*d)))
print("ep=", ep, D, d)
ids = [a for a in K.ideals_of_bdd_norm(-DD)[-DD]]
eulers1 = []
for a in ids:
e = a.euler_phi()
if e != 1 and ep == 1:
if K(-1).mod(a) != K(1).mod(a):
e = old_div(e, (2 * ep))
else:
e = old_div(e, ep)
eulers1.append(e)
print(eulers1, ep)
s = sum(eulers1)
if ep == 1 and not (d.divides(DD) or abs(DD) == 1):
continue
print(d, s)
if len(eulers1) > 0:
d2 += s * K.class_number()
return d1 - d2
def find_inverse_images_of_twists(k, N=1, chi=0, fi=0, prec=10, verbose=0):
r"""
Checks if f is minimal and if not, returns the associated
minimal form to precision prec.
INPUT:
- ''k'' -- positive integer : the weight
- ''N'' -- positive integer (default 1) : level
- ''chi'' -- non-neg. integer (default 0) use character nr. chi
- ''fi'' -- non-neg. integer (default 0) We want to use the element nr. fi f=Newforms(N,k)[fi]
- ''prec'' -- integer (the number of coefficients to get)
- ''verbose'' -- integer
OUTPUT:
-''[t,l]'' -- tuple of a Bool t and a list l. The list l contains all tuples of forms which twists to the given form.
The actual minimal one is the first element of this list.
EXAMPLES::
"""
(t, f) = _get_newform(k, N, chi, fi)
if (not t):
return f
if (is_squarefree(ZZ(N))):
return [True, f]
# We need to check all square factors of N
logger.debug("investigating: %s" % f)
N_sqfree = squarefree_part(ZZ(N))
Nsq = ZZ(N / N_sqfree)
twist_candidates = list()
KF = f.base_ring()
# check how many Hecke eigenvalues we need to check
max_nump = number_of_hecke_to_check(f)
maxp = max(primes_first_n(max_nump))
for d in divisors(N):
# we look at all d such that d^2 divdes N
if (not ZZ(d**2).divides(ZZ(N))):
continue
D = DirichletGroup(d)
# check possible candidates to twist into f
# g in S_k(M,chi) wit M=N/d^2
M = ZZ(N / d**2)
logger.debug("Checking level %s" % M)
for xig in range(euler_phi(M)):
(t, glist) = _get_newform(k, M, xig)
if (not t):
return glist
for g in glist:
logger.debug("Comparing to function %s" % g)
KG = g.base_ring()
# we now see if twisting of g by xi in D gives us f
for xi in D:
try:
for p in primes_first_n(max_nump):
if (ZZ(p).divides(ZZ(N))):
continue
bf = f.q_expansion(maxp + 1)[p]
bg = g.q_expansion(maxp + 1)[p]
if (bf == 0 and bg == 0):
continue
elif (bf == 0 and bg != 0 or bg == 0 and bf != 0):
raise StopIteration()
if (ZZ(p).divides(xi.conductor())):
raise ArithmeticError("")
xip = xi(p)
# make a preliminary check that the base rings match with respect to being
# real or not
try:
QQ(xip)
XF = QQ
if (KF != QQ or KG != QQ):
raise StopIteration
except TypeError:
# we have a non-rational (i.e. complex) value of the character
XF = xip.parent()
if ((KF == QQ or KF.is_totally_real()) and
(KG == QQ or KG.is_totally_real())):
raise StopIteration
## it is diffcult to compare elements from diferent rings in general but we make some checcks
# is it possible to see if there is a larger ring which everything can be
# coerced into?
ok = False
try:
a = KF(bg / xip)
b = KF(bf)
ok = True
if (a != b):
raise StopIteration()
except TypeError:
pass
try:
a = KG(bg)
b = KG(xip * bf)
ok = True
if (a != b):
raise StopIteration()
except TypeError:
pass
if (
not ok
): # we could coerce and the coefficients were equal
return "Could not compare against possible candidates!"
# otherwise if we are here we are ok and found a candidate
twist_candidates.append([dd, g.q_expansion(prec), xi])
except StopIteration:
# they are not equal
pass
# logger.debug("Candidates=%s" % twist_candidates)
if (len(twist_candidates) == 0):
return (True, None)
else:
return (False, twist_candidates)
def make_table_of_dimensions(level_start=1, level_stop=50, weight_start=1, weight_stop=24, char=0, **kwds):
r"""
make an html table with information about spaces of modular forms
with parameters in the given ranges. using a fixed character.
Should use database in the future...
"""
D = 0
rowlen = 15 # split into rows of this length...
rowlen0 = rowlen
rowlen1 = rowlen
characters = dict()
level = 'N'
weight = 'k'
print "char=", char
if level_start == level_stop:
level = level_start
count_min = weight_start
count_max = weight_stop
if (weight_stop - weight_start + 1) < rowlen:
rowlen0 = weight_stop - weight_start + 1
if weight_start == weight_stop:
weight = weight_start
count_min = level_start
count_max = level_stop
if (level_stop - level_start + 1) < rowlen:
rowlen0 = level_stop - level_start + 1
# else:
# return ""
tbl = dict()
if(char == 0):
tbl['header'] = '' # Dimension of \( S_{'+str(weight)+'}('+str(level)+',\chi_{n})\)'
charst = ""
else:
# s = 'Dimension of \( S_{'+str(weight)+'}('+str(level)+')\)'
# s += ' (trivial character)'
charst = ",\chi_{%s}" % char
tbl['header'] = ''
tbl['headersv'] = list()
tbl['headersh'] = list()
if weight == 'k':
tbl['corner_label'] = "weight \(k\):"
else:
tbl['corner_label'] = "level \(N\):"
tbl['data'] = list()
tbl['data_format'] = 'html'
tbl['class'] = "dimension_table"
tbl['atts'] = "border=\"1\" class=\"nt_data\" padding=\"25\" width=\"100%\""
num_rows = ceil(QQ(count_max - count_min + 1) / QQ(rowlen0))
print "num_rows=", num_rows
for i in range(1, rowlen0 + 1):
tbl['headersh'].append(i + count_min - 1)
if level_start == level_stop:
st = "Dimension of \(S_{k}(%s%s) \):" % (level, charst)
tbl['headersv'] = [st]
else:
st = "Dimension of \(S_{%s}(N%s) \):" % (weight, charst)
tbl['headersv'] = [st]
tbl['headersv'].append('Link to space:')
# make a dummy table first
# num_rows = (num_rows-1)*2
for r in range(num_rows * 2):
row = []
for k in range(1, rowlen0 + 1):
row.append("")
tbl['data'].append(row)
tbl['data_format'] = dict()
for k in range(0, rowlen0):
tbl['data_format'][k] = 'html'
print "nu_rows=", len(tbl['data'])
print "num_cols=", rowlen0
print "num_cols=", [len(r) for r in tbl['data']]
for r in range(num_rows):
for k in range(0, rowlen0):
cnt = count_min + r * rowlen0 + k
if level_start == level_stop:
weight = cnt
else:
level = cnt
url = url_for('emf.render_elliptic_modular_forms', level=level, weight=weight)
if(cnt > count_max or cnt < count_min):
tbl['data'][2 * r][k] = ""
continue
# s="<a name=\"#%s,%s\"></a>" % (level,weight)
if(char == 0):
d = dimension_cusp_forms(level, weight)
else:
x = DirichletGroup(level)[char]
d = dimension_cusp_forms(x, weight)
tbl['data'][2 * r][k] = str(d)
if d > 0:
s = "\(S_{%s}(%s)\)" % (weight, level)
ss = "<a href=\"" + url + "\">" + s + "</a>"
tbl['data'][2 * r + 1][k] = ss
s = html_table(tbl)
# s=s+"\n <br> \(N="+str(rowlen0)+"\cdot row+col\)"
# print "SS=",s
return s
def set_table_browsing(self,skip=[0,0],limit=[(2,16),(1,50)],keys=['Weight','Level'],character=0,dimension_fun=dimension_new_cusp_forms,title='Dimension of newforms'):
r"""
Table of Holomorphic modular forms spaces.
Skip tells you how many chunks of data you want to skip (from the geginning) and limit tells you how large each chunk is.
INPUT:
- dimension_fun should be a function which gives you the desired dimensions, as functions of level N and weight k
- character = 0 for trivial character and 1 for Kronecker symbol.
set to 'all' for all characters.
"""
self._keys=keys
self._skip=skip
self._limit=limit
self._metadata=[]
self._title=''
self._cols=[]
self.table={}
self._character = character
emf_logger.debug("skip= {0}".format(self._skip))
emf_logger.debug("limit= {0}".format(self._limit))
il = self._keys.index('Level')
iwt = self._keys.index('Weight')
level_len = self._limit[il][1]-self._limit[il][0]+1
level_ll=self._skip[il]*level_len+self._limit[il][0]; level_ul=self._skip[il]*level_len+self._limit[il][1]
wt_len = self._limit[iwt][1]-self._limit[iwt][0]+1
wt_ll=self._skip[iwt]*wt_len+self._limit[iwt][0]; wt_ul=self._skip[iwt]*wt_len+self._limit[iwt][1]
if level_ll<1: level_l=1
self._table={}
self._table['rows']=[]
self._table['col_heads']=[] #range(wt_ll,wt_ul+1)
self._table['row_heads']=[] #range(level_ll,level_ul+1)
emf_logger.debug("wt_range: {0} -- {1}".format(wt_ll,wt_ul))
emf_logger.debug("level_range: {0} -- {1}".format(level_ll,level_ul))
if character in [0,1]:
if level_ll == level_ul:
N=level_ll
self._table['rowhead']='Weight'
if character==0:
self._table['row_heads']=['Trivial character']
else:
self._table['row_heads']=['\( \\( \frac{\cdot}{N} \\)\)']
row=[]
for k in range(wt_ll,wt_ul+1):
if character == 0 and is_odd(k):
continue
try:
if character==0:
d = dimension_fun(N,k)
elif character==1:
x = kronecker_character_upside_down(N)
d = dimension_fun(x,k)
except Exception as ex:
emf_logger.critical("Exception: {0}. \n Could not compute the dimension with function {0}".format(ex,dimension_fun))
url = url_for('emf.render_elliptic_modular_form_browsing',level=N,weight=k)
if not k in self._table['col_heads']:
self._table['col_heads'].append(k)
row.append({'N':N,'k':k,'url':url,'dim':d})
self._table['rows'].append(row)
else:
for N in range(level_ll,level_ul+1):
if not N in self._table['row_heads']:
self._table['row_heads'].append(N)
row=[]
for k in range(wt_ll,wt_ul+1):
if character == 0 and is_odd(k):
continue
try:
if character==0:
d = dimension_fun(N,k)
elif character==1:
x = kronecker_character_upside_down(N)
d = dimension_fun(x,k)
except Exception as ex:
emf_logger.critical("Exception: {0}. \n Could not compute the dimension with function {0}".format(ex,dimension_fun))
url = url_for('emf.render_elliptic_modular_form_browsing',level=N,weight=k)
if not k in self._table['col_heads']:
self._table['col_heads'].append(k)
row.append({'N':N,'k':k,'url':url,'dim':d})
self._table['rows'].append(row)
elif character=='all':
# make table with all characters.
self._table['characters']=dict()
if level_ll == level_ul:
N = level_ll
D = DirichletGroup(N)
emf_logger.debug("I am here!")
self._table['rowhead']='Character \ Weight'
for x in D:
xi = D.list().index(x)
row=[]
self._table['row_heads'].append(xi)
for k in range(wt_ll,wt_ul+1):
if not k in self._table['col_heads']:
self._table['col_heads'].append(k)
try:
d = dimension_fun(x,k)
except Exception as ex:
emf_logger.critical("Exception: {0} \n Could not compute the dimension with function {0}".format(ex,dimension_fun))
d = -1
url = url_for('emf.render_elliptic_modular_form_space',level=N,weight=k,character=xi)
row.append({'N':N,'k':k,'chi':xi,'url':url,'dim':d})
self._table['rows'].append(row)
else:
for N in range(level_ll,level_ul+1):
self._table['row_heads'].append(N)
self._table['characters'][N]=list()
row=[]
if N==0: continue
D = DirichletGroup(N)
for k in range(wt_ll,wt_ul+1):
tbl=[]
for x in D:
xi = D.list().index(x)
if not N in self._table['characters'][N]:
self._table['characters'][N].append(xi)
if x.is_even() and is_odd(k):
continue
if x.is_odd() and is_even(k):
continue
try:
d = dimension_fun(x,k)
except Exception as ex:
emf_logger.critical("Exception: {0} \n Could not compute the dimension with function {0}".format(ex,dimension_fun))
url = url_for('emf.render_elliptic_modular_form_browsing',level=N,weight=k)
if not k in self._table['col_heads']:
self._table['col_heads'].append(k)
tbl.append({'N':N,'k':k,'chi':xi,'url':url,'dim':d})
row.append(tbl)
self._table['rows'].append(row)
def set_table_browsing(self,
skip=[0, 0],
limit=[(2, 16), (1, 50)],
keys=['Weight', 'Level'],
character=0,
dimension_fun=dimension_new_cusp_forms,
title='Dimension of newforms'):
r"""
Table of Holomorphic modular forms spaces.
Skip tells you how many chunks of data you want to skip (from the geginning) and limit tells you how large each chunk is.
INPUT:
- dimension_fun should be a function which gives you the desired dimensions, as functions of level N and weight k
- character = 0 for trivial character and 1 for Kronecker symbol.
set to 'all' for all characters.
"""
self._keys = keys
self._skip = skip
self._limit = limit
self._metadata = []
self._title = ''
self._cols = []
self.table = {}
self._character = character
emf_logger.debug("skip= {0}".format(self._skip))
emf_logger.debug("limit= {0}".format(self._limit))
il = self._keys.index('Level')
iwt = self._keys.index('Weight')
level_len = self._limit[il][1] - self._limit[il][0] + 1
level_ll = self._skip[il] * level_len + self._limit[il][0]
level_ul = self._skip[il] * level_len + self._limit[il][1]
wt_len = self._limit[iwt][1] - self._limit[iwt][0] + 1
wt_ll = self._skip[iwt] * wt_len + self._limit[iwt][0]
wt_ul = self._skip[iwt] * wt_len + self._limit[iwt][1]
if level_ll < 1: level_l = 1
self._table = {}
self._table['rows'] = []
self._table['col_heads'] = [] #range(wt_ll,wt_ul+1)
self._table['row_heads'] = [] #range(level_ll,level_ul+1)
emf_logger.debug("wt_range: {0} -- {1}".format(wt_ll, wt_ul))
emf_logger.debug("level_range: {0} -- {1}".format(level_ll, level_ul))
if character in [0, 1]:
if level_ll == level_ul:
N = level_ll
self._table['rowhead'] = 'Weight'
if character == 0:
self._table['row_heads'] = ['Trivial character']
else:
self._table['row_heads'] = ['\( \\( \frac{\cdot}{N} \\)\)']
row = []
for k in range(wt_ll, wt_ul + 1):
if character == 0 and is_odd(k):
continue
try:
if character == 0:
d = dimension_fun(N, k)
elif character == 1:
x = kronecker_character_upside_down(N)
d = dimension_fun(x, k)
except Exception as ex:
emf_logger.critical(
"Exception: {0}. \n Could not compute the dimension with function {0}"
.format(ex, dimension_fun))
url = url_for('emf.render_elliptic_modular_form_browsing',
level=N,
weight=k)
if not k in self._table['col_heads']:
self._table['col_heads'].append(k)
row.append({'N': N, 'k': k, 'url': url, 'dim': d})
self._table['rows'].append(row)
else:
for N in range(level_ll, level_ul + 1):
if not N in self._table['row_heads']:
self._table['row_heads'].append(N)
row = []
for k in range(wt_ll, wt_ul + 1):
if character == 0 and is_odd(k):
continue
try:
if character == 0:
d = dimension_fun(N, k)
elif character == 1:
x = kronecker_character_upside_down(N)
d = dimension_fun(x, k)
except Exception as ex:
emf_logger.critical(
"Exception: {0}. \n Could not compute the dimension with function {0}"
.format(ex, dimension_fun))
url = url_for(
'emf.render_elliptic_modular_form_browsing',
level=N,
weight=k)
if not k in self._table['col_heads']:
self._table['col_heads'].append(k)
row.append({'N': N, 'k': k, 'url': url, 'dim': d})
self._table['rows'].append(row)
elif character == 'all':
# make table with all characters.
self._table['characters'] = dict()
if level_ll == level_ul:
N = level_ll
D = DirichletGroup(N)
emf_logger.debug("I am here!")
self._table['rowhead'] = 'Character \ Weight'
for x in D:
xi = D.list().index(x)
row = []
self._table['row_heads'].append(xi)
for k in range(wt_ll, wt_ul + 1):
if not k in self._table['col_heads']:
self._table['col_heads'].append(k)
try:
d = dimension_fun(x, k)
except Exception as ex:
emf_logger.critical(
"Exception: {0} \n Could not compute the dimension with function {0}"
.format(ex, dimension_fun))
d = -1
url = url_for('emf.render_elliptic_modular_form_space',
level=N,
weight=k,
character=xi)
row.append({
'N': N,
'k': k,
'chi': xi,
'url': url,
'dim': d
})
self._table['rows'].append(row)
else:
for N in range(level_ll, level_ul + 1):
self._table['row_heads'].append(N)
self._table['characters'][N] = list()
row = []
if N == 0: continue
D = DirichletGroup(N)
for k in range(wt_ll, wt_ul + 1):
tbl = []
for x in D:
xi = D.list().index(x)
if not N in self._table['characters'][N]:
self._table['characters'][N].append(xi)
if x.is_even() and is_odd(k):
continue
if x.is_odd() and is_even(k):
continue
try:
d = dimension_fun(x, k)
except Exception as ex:
emf_logger.critical(
"Exception: {0} \n Could not compute the dimension with function {0}"
.format(ex, dimension_fun))
url = url_for(
'emf.render_elliptic_modular_form_browsing',
level=N,
weight=k)
if not k in self._table['col_heads']:
self._table['col_heads'].append(k)
tbl.append({
'N': N,
'k': k,
'chi': xi,
'url': url,
'dim': d
})
row.append(tbl)
self._table['rows'].append(row)
def Dirichlet_Lfunctions_iterator(qMax):
for q in [3..qMax]:
for n in range(len(DirichletGroup(q))):
yield Lfunction_Dirichlet(charactermodulus=q, characternumber=n)
import sys
from sage.all import DirichletGroup
import pymongo
from pymongo import Connection
import sage.libs.lcalc.lcalc_Lfunction as lc
from lmfdb import base
C = base.getDBConnection()
db = C.Lfunctions
first_zeros = db.first_zeros_testing
first_zeros.drop()
for q in range(3, 1500):
print q
sys.stdout.flush()
G = DirichletGroup(q)
for n in range(len(G)):
if G[n].is_primitive():
L = lc.Lfunction_from_character(G[n])
z = L.find_zeros_via_N(1)[0]
first_zeros.insert({
'zero': float(z),
'modulus': int(q),
'character': int(n)
})
def set_table_browsing(self,
skip=[0, 0],
limit=[(2, 16), (1, 50)],
keys=['Weight', 'Level'],
character=0,
dimension_table=None,
dimension_fun=dimension_new_cusp_forms,
title='Dimension of newforms',
check_db=True):
r"""
Table of Holomorphic modular forms spaces.
Skip tells you how many chunks of data you want to skip (from the geginning) and limit tells you how large each chunk is.
INPUT:
- dimension_fun should be a function which gives you the desired dimensions, as functions of level N and weight k
- character = 0 for trivial character and 1 for Kronecker symbol.
set to 'all' for all characters.
- check_db=True means, that we will only link to spaces which are in the database
"""
self._keys = keys
self._skip = skip
self._limit = limit
self._metadata = []
self._title = ''
self._cols = []
self.table = {}
self._character = character
emf_logger.debug("skip= {0}".format(self._skip))
emf_logger.debug("limit= {0}".format(self._limit))
il = self._keys.index('Level')
iwt = self._keys.index('Weight')
level_len = self._limit[il][1] - self._limit[il][0] + 1
level_ll = self._skip[il] * level_len + self._limit[il][0]
level_ul = self._skip[il] * level_len + self._limit[il][1]
wt_len = self._limit[iwt][1] - self._limit[iwt][0] + 1
wt_ll = self._skip[iwt] * wt_len + self._limit[iwt][0]
wt_ul = self._skip[iwt] * wt_len + self._limit[iwt][1]
if level_ll < 1:
level_l = 1
self._table = {}
self._table['rows'] = []
self._table['col_heads'] = [] # range(wt_ll,wt_ul+1)
self._table['row_heads'] = [] # range(level_ll,level_ul+1)
emf_logger.debug("wt_range: {0} -- {1}".format(wt_ll, wt_ul))
emf_logger.debug("level_range: {0} -- {1}".format(level_ll, level_ul))
emf_logger.debug("character: {0}".format(character))
self._table['characters'] = dict()
if dimension_table is not None:
dimension_fun = dimension_table.dimension
is_data_in_db = dimension_table.is_in_db
factors = connect_db()['Newform_factors.files']
list_of_data = factors.distinct('hecke_orbit_label')
#else:
#def is_data_in_db(N, k, character):
# n = self._files.find({'N':int(N),'k':int(k),'chi':int(character)}).count()
# emf_logger.debug("is_Data_in: N,k,character: {0} no. recs: {1} in {2}".format((N,k,character),n,self._files))
# return n>0
# fixed level
if level_ll == level_ul:
N = level_ll
# specific character =0,1
if character == 0 or character == 1:
self._table['rowhead'] = 'Weight'
if character == 0:
cchi = 1 #xc = DirichletGroup_conrey(N)[1]
else:
D = DirichletGroup_conrey(N)
for xc in D:
x = xc.sage_character()
if x == kronecker_character_upside_down(N):
cchi = xc.number()
break
row = dict()
row['head'] = "\(\chi_{" + str(N) + "}(" + str(
cchi) + ",\cdot) \)"
row['url'] = url_for('characters.render_Dirichletwebpage',
modulus=N,
number=cchi)
row['cells'] = list()
for k in range(wt_ll, wt_ul + 1):
if character == 0 and is_odd(k):
continue
try:
if character == 0:
d = dimension_fun(N, k)
elif character == 1:
d = dimension_fun(x, k)
except Exception as ex:
emf_logger.critical(
"Exception: {0}. \n Could not compute the dimension with function {0}"
.format(ex, dimension_fun))
if (not check_db) or "{0}.{1}.{2}a".format(
N, k, cchi
) in list_of_data: #is_data_in_db(N, k, character):
url = url_for('emf.render_elliptic_modular_forms',
level=N,
weight=k,
character=character)
else:
url = ''
if not k in self._table['col_heads']:
self._table['col_heads'].append(k)
row['cells'].append({'N': N, 'k': k, 'url': url, 'dim': d})
self._table['rows'].append(row)
else:
D = DirichletGroup(N)
G = D.galois_orbits()
Greps = [X[0] for X in G]
Dc = DirichletGroup_conrey(N)
Gcreps = dict()
# A security check, if we have at least weight 2 and trivial character,
# otherwise don't show anything
#if check_db and not is_data_in_db(N, 2, 0):
# emf_logger.debug("No data for level {0} and weight 2, trivial character".format(N)#)
#self._table = None
# return None
Gc = dict()
for xi, g in enumerate(G):
Gc[xi] = list()
self._table['maxGalCount'] = 0
for xc in Dc:
x = xc.sage_character()
xi = G.index(x.galois_orbit())
# emf_logger.debug('Dirichlet Character Conrey {0} = sage_char {1}, has
# Galois orbit nr. {2}'.format(xc,x,xi))
Gc[xi].append(xc)
if x == Greps[xi]:
Gcreps[xi] = xc
emf_logger.debug('Gc={0}'.format(Gc))
for xi in Gc:
g = Gc[xi]
if len(g) > self._table['maxGalCount']:
self._table['maxGalCount'] = len(g)
emf_logger.debug('xi,g={0},{1}'.format(xi, g))
x = Greps[xi]
xc = Gcreps[xi]
cchi = xc.number()
row = dict()
row['head'] = "\(\chi_{" + str(N) + "}(" + str(
cchi) + ",\cdot) \)"
row['url'] = url_for('characters.render_Dirichletwebpage',
modulus=N,
number=cchi)
row['galois_orbit'] = [{
'chi':
str(xc.number()),
'url':
url_for('characters.render_Dirichletwebpage',
modulus=N,
number=cchi)
} for xc in g]
row['cells'] = []
for k in range(wt_ll, wt_ul + 1):
if not k in self._table['col_heads']:
# emf_logger.debug("Adding to col_heads:{0}s".format(k))
self._table['col_heads'].append(k)
try:
d = dimension_fun(x, k)
except Exception as ex:
emf_logger.critical(
"Exception: {0} \n Could not compute the dimension with function {1}"
.format(ex, dimension_fun))
if (not check_db) or "{0}.{1}.{2}a".format(
N, k, cchi
) in list_of_data: #is_data_in_db(N, k, xi):
url = url_for('emf.render_elliptic_modular_forms',
level=N,
weight=k,
character=xi)
else:
url = ''
row['cells'].append({
'N': N,
'k': k,
'chi': xi,
'url': url,
'dim': d
})
self._table['rows'].append(row)
else:
for k in range(wt_ll, wt_ul + 1):
if character == 0 and is_odd(k):
continue
row = []
for N in range(level_ll, level_ul + 1):
if not N in self._table['col_heads']:
self._table['col_heads'].append(N)
try:
if character == 0:
d = dimension_fun(N, k)
elif character == 1:
x = kronecker_character_upside_down(N)
d = dimension_fun(x, k)
else:
d = dimension_fun(N, k)
except Exception as ex:
emf_logger.critical(
"Exception: {0}. \n Could not compute the dimension with function {0}"
.format(ex, dimension_fun))
# emf_logger.debug("N,k,char,dim: {0},{1},{2},{3}".format(N,k,character,d))
if character == 0 or character == 1:
if (not check_db) or "{0}.{1}.{2}a".format(
N, k, 1
) in list_of_data: #is_data_in_db(N, k, character):
url = url_for('emf.render_elliptic_modular_forms',
level=N,
weight=k,
character=character)
else:
url = ''
else:
t1 = "{0}.{1}.{2}a".format(N, k, 1)
t2 = "{0}.{1}.{2}a".format(N, k, 2)
if (
not check_db
) or t1 in list_of_data or t2 in list_of_data: # is_data_in_db(N, k, character):
url = url_for('emf.render_elliptic_modular_forms',
level=N,
weight=k)
else:
url = ''
if not k in self._table['row_heads']:
self._table['row_heads'].append(k)
row.append({'N': N, 'k': k, 'url': url, 'dim': d})
emf_logger.debug("row:{0}".format(row))
self._table['rows'].append(row)
