def _D_times_c_star(self,c,as_int=False):
r"""
Return the set D^c*=x_c+{c*x | x in D}, where x_c=0 or 1/2
INPUT:
-''c'' -- integer
-''as_int'' -- logical, if true then we return the set D^c as a list of integers
"""
Dc=self._D_times_c(c,as_int)
Dcs=list()
x_c=self._xc(c,as_int)
for x in Dc:
if(as_int):
z=(x + x_c) % len(self._D)
else:
y=QQ(c*x)+x_c
p=y.numer(); q=y.denom(); z=QQ(p % q)/QQ(q)
#print "c*",x,"=",z
Dcs.append(z)
Dcs.sort()
# make unique
for x in Dcs:
i=Dcs.count(x)
if(i>1):
for j in range(i-1):
Dcs.remove(x)
return Dcs
def is_consistent(self,k):
r"""
Return True if the Weil representation is a multiplier of weight k.
"""
if self._verbose>0:
print "is_consistent at wr! k={0}".format(k)
twok =QQ(2)*QQ(k)
if not twok.is_integral():
return False
if self._sym_type <>0:
if self.is_dual():
sig_mod_4 = -self._weil_module.signature() % 4
else:
sig_mod_4 = self._weil_module.signature() % 4
if is_odd(self._weil_module.signature()):
return (twok % 4 == (self._sym_type*sig_mod_4 %4))
else:
if sig_mod_4 == (1 - self._sym_type) % 4:
return twok % 4 == 0
else:
return twok % 4 == 2
if is_even(twok) and is_even(self._weil_module.signature()):
return True
if is_odd(twok) and is_odd(self._weil_module.signature()):
return True
return False
def to_polredabs(K):
"""
INPUT:
* "K" - a number field
OUTPUT:
* "phi" - an isomorphism K -> L, where L = QQ['x']/f and f a polynomial such that f = polredabs(f)
"""
R = PolynomialRing(QQ,'x')
x = R.gen(0)
if K == QQ:
L = QQ.extension(x,'w')
return QQ.hom(L)
L = K.absolute_field('a')
m1 = L.structure()[1]
f = L.absolute_polynomial()
g = pari(f).polredabs(1)
g,h = g[0].sage(locals={'x':x}),g[1].lift().sage(locals={'x':x})
if debug:
print 'f',f
print 'g',g
print 'h',h
M = QQ.extension(g,'w')
m2 = L.hom([h(M.gen(0))])
return m2*m1
class TestMultiplier(MultiplierSystem):
r"""
Test of multiplier for f(q). As in e.g. the paper of Bringmann and Ono.
"""
def __init__(self,group,dchar=(0,0),dual=False,weight=QQ(1)/QQ(2),dimension=1,version=1,**kwargs):
self._weight=QQ(weight)
MultiplierSystem.__init__(self,group,dchar=dchar,dual=dual,dimension=dimension,**kwargs)
self._k_den=self._weight.denominator()
self._k_num=self._weight.numerator()
self._K = CyclotomicField(12*self._k_den)
self._z = self._K.gen()**self._k_num
self._sqrti = CyclotomicField(8).gen()
self._i = CyclotomicField(4).gen()
self._fak = CyclotomicField(2*self._k_den).gen()**-self._k_num
self._fak_arg=QQ(self._weight)/QQ(2)
self._version = version
self.is_consistent(weight) # test consistency
def order(self):
return 12*self._k_den
def z(self):
return self._z
def __repr__(self):
s="Test multiplier"
if self._character<>None and not self._character.is_trivial():
s+="and character "+str(self._character)
return s
def _action(self,A):
[a,b,c,d]=A
fak=0
if c<0:
a=-a; b=-b; c=-c; d=-d; fak=self._fak_arg
if c==0:
if a>0:
res = self._z**-b
else:
res = self._fak*self._z**-b
else:
arg=-QQ(1)/QQ(8)+QQ(c+a*d+1)/QQ(4)-QQ(a+d)/QQ(24*c)-QQ(a)/QQ(4)+QQ(3*d*c)/QQ(8)
# print "arg=",arg
arg = arg-dedekind_sum(-d,c)/QQ(2)+fak #self._fak_arg
den=arg.denominator()
num=arg.numerator()
# print "den=",den
# print "num=",num
res = self._K(CyclotomicField(den).gen())**num
#res = res*fak
if self._is_dual:
return res**-1
return res
def _hecke_pol_klingen(k, j):
'''k: even.
F: Kligen-Eisenstein series of determinant weight k whose Hecke field is
the rational filed. Return the Hecke polynomial of F at 2.
'''
f = CuspForms(1, k + j).basis()[0]
R = PolynomialRing(QQ, names="x")
x = R.gens()[0]
pl = QQ(1) - f[2] * x + QQ(2) ** (k + j - 1) * x ** 2
return pl * pl.subs({x: x * QQ(2) ** (k - 2)})
def _latex_using_dpd_depth1(self, dpd_dct):
names = [dpd_dct[c] for c in self._consts]
_gcd = QQ(gcd(self._coeffs))
coeffs = [c / _gcd for c in self._coeffs]
coeffs_names = [(c, n) for c, n in zip(coeffs, names) if c != 0]
tail_terms = ["%s %s %s" % ("+" if c > 0 else "", c, n) for c, n in coeffs_names[1:]]
c0, n0 = coeffs_names[0]
head_term = str(c0) + " " + str(n0)
return r"\frac{{{pol_num}}}{{{pol_dnm}}} \left({terms}\right)".format(
pol_dnm=latex(_gcd.denominator() * self._scalar_const._polynomial_expr()),
pol_num=latex(_gcd.numerator()),
terms=" ".join([head_term] + tail_terms),
)
def EllipticCurve_from_hoeij_data(line):
"""Given a line of the file "http://www.math.fsu.edu/~hoeij/files/X1N/LowDegreePlaces"
that is actually corresponding to an elliptic curve, this function returns the elliptic
curve corresponding to this
"""
Rx=PolynomialRing(QQ,'x')
x = Rx.gen(0)
Rxy = PolynomialRing(Rx,'y')
y = Rxy.gen(0)
N=ZZ(line.split(",")[0].split()[-1])
x_rel=Rx(line.split(',')[-2][2:-4])
assert x_rel.leading_coefficient()==1
y_rel=line.split(',')[-1][1:-5]
K = QQ.extension(x_rel,'x')
x = K.gen(0)
y_rel=Rxy(y_rel).change_ring(K)
y_rel=y_rel/y_rel.leading_coefficient()
if y_rel.degree()==1:
y = - y_rel[0]
else:
#print "needing an extension!!!!"
L = K.extension(y_rel,'y')
y = L.gen(0)
K = L
#B=L.absolute_field('s')
#f1,f2 = B.structure()
#x,y=f2(x),f2(y)
r = (x**2*y-x*y+y-1)/x/(x*y-1)
s = (x*y-y+1)/x/y
b = r*s*(r-1)
c = s*(r-1)
E=EllipticCurve([1-c,-b,-b,0,0])
return N,E,K
def __init__(self,G,k=QQ(1)/QQ(2),number=0,ch=None,dual=False,version=1,dimension=1,**kwargs):
r"""
Initialize the Eta multiplier system: $\nu_{\eta}^{2(k+r)}$.
INPUT:
- G -- Group
- ch -- character
- dual -- if we have the dual (in this case conjugate)
- weight -- Weight (recall that eta has weight 1/2 and eta**2k has weight k. If weight<>k we adjust the power accordingly.
- number -- we consider eta^power (here power should be an integer so as not to change the weight...)
"""
self._weight=QQ(k)
if floor(self._weight-QQ(1)/QQ(2))==ceil(self._weight-QQ(1)/QQ(2)):
self._half_integral_weight=1
else:
self._half_integral_weight=0
MultiplierSystem.__init__(self,G,character=ch,dual=dual,dimension=dimension)
number = number % 12
if not is_even(number):
raise ValueError,"Need to have v_eta^(2(k+r)) with r even!"
self._pow=QQ((self._weight+number)) ## k+r
self._k_den=self._pow.denominator()
self._k_num=self._pow.numerator()
self._K = CyclotomicField(12*self._k_den)
self._z = self._K.gen()**self._k_num
self._i = CyclotomicField(4).gen()
self._fak = CyclotomicField(2*self._k_den).gen()**-self._k_num
self._version = version
self.is_consistent(k) # test consistency
def get_cusp_expansions_of_newform(k, N=1, fi=0, prec=10):
r"""
Get and return Fourier coefficients of all cusps where there exist Atkin-Lehner involutions for these cusps.
INPUT:
- ''k'' -- positive integer : the weight
- ''N'' -- positive integer (default 1) : level
- ''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)
OUTPUT:
- ''s'' string giving the Atkin-Lehner eigenvalues corresponding to the Cusps (where possible)
"""
res = dict()
(t, f) = _get_newform(k, N, 0, fi)
if(not t):
return s
res[Infinity] = 1
for c in f.group().cusps():
if(c == Cusp(Infinity)):
continue
res[c] = list()
cusp = QQ(c)
q = cusp.denominator()
p = cusp.numerator()
d = ZZ(cusp * N)
if(d == 0):
ep = f.atkin_lehner_eigenvalue()
if(d.divides(N) and gcd(ZZ(N / d), ZZ(d)) == 1):
ep = f.atkin_lehner_eigenvalue(ZZ(d))
else:
# this case is not known...
res[c] = None
continue
res[c] = ep
s = html.table([res.keys(), res.values()])
return s
class EtaMultiplier(MultiplierSystem):
r"""
Eta multiplier. Valid for any (real) weight.
"""
def __init__(self,G,k=QQ(1)/QQ(2),number=0,ch=None,dual=False,version=1,dimension=1,**kwargs):
r"""
Initialize the Eta multiplier system: $\nu_{\eta}^{2(k+r)}$.
INPUT:
- G -- Group
- ch -- character
- dual -- if we have the dual (in this case conjugate)
- weight -- Weight (recall that eta has weight 1/2 and eta**2k has weight k. If weight<>k we adjust the power accordingly.
- number -- we consider eta^power (here power should be an integer so as not to change the weight...)
"""
self._weight=QQ(k)
if floor(self._weight-QQ(1)/QQ(2))==ceil(self._weight-QQ(1)/QQ(2)):
self._half_integral_weight=1
else:
self._half_integral_weight=0
MultiplierSystem.__init__(self,G,character=ch,dual=dual,dimension=dimension)
number = number % 12
if not is_even(number):
raise ValueError,"Need to have v_eta^(2(k+r)) with r even!"
self._pow=QQ((self._weight+number)) ## k+r
self._k_den=self._pow.denominator()
self._k_num=self._pow.numerator()
self._K = CyclotomicField(12*self._k_den)
self._z = self._K.gen()**self._k_num
self._i = CyclotomicField(4).gen()
self._fak = CyclotomicField(2*self._k_den).gen()**-self._k_num
self._version = version
self.is_consistent(k) # test consistency
def __repr__(self):
s="Eta multiplier "
if self._pow<>1:
s+="to power 2*"+str(self._pow)+" "
if self._character<>None and not self._character.is_trivial():
s+=" and character "+str(self._character)
s+="with weight="+str(self._weight)
return s
def order(self):
return 12*self._k_den
def z(self):
return self._z
def _action(self,A):
if self._version==1:
return self._action1(A)
elif self._version==2:
return self._action2(A)
else:
raise ValueError
def _action1(self,A):
[a,b,c,d]=A
return self._action0(a,b,c,d)
def _action0(self,a,b,c,d):
r"""
Recall that the formula is valid only for c>0. Otherwise we have to use:
v(A)=v((-I)(-A))=sigma(-I,-A)v(-I)v(-A).
Then note that by the formula for sigma we have:
sigma(-I,SL2Z[a, b, c, d])=-1 if (c=0 and d<0) or c>0 and other wise it is =1.
"""
fak=1
if c<0:
a=-a; b=-b; c=-c; d=-d; fak=-self._fak
if c==0:
if a>0:
res = self._z**b
else:
res = self._fak*self._z**b
else:
if is_even(c):
arg = (a+d)*c-b*d*(c*c-1)+3*d-3-3*c*d
v=kronecker(c,d)
else:
arg = (a+d)*c-b*d*(c*c-1)-3*c
v=kronecker(d,c)
if not self._half_integral_weight:
# recall that we can use eta for any real weight
v=v**(2*self._weight)
arg=arg*(self._k_num)
res = v*fak*self._z**arg
if self._character:
res = res * self._character(d)
if self._is_dual:
res=res**-1
return res
def _action2(self,A):
[a,b,c,d]=A
#.........这里部分代码省略.........
def hgm_search(**args):
info = to_dict(args)
bread = get_bread([("Search results", url_for('.search'))])
C = base.getDBConnection()
query = {}
if 'jump_to' in info:
return render_hgm_webpage({'label': info['jump_to']})
family_search = False
if info.get('Submit Family') or info.get('family'):
family_search = True
# generic, irreducible not in DB yet
for param in ['A', 'B', 'hodge', 'a2', 'b2', 'a3', 'b3', 'a5', 'b5', 'a7', 'b7']:
if info.get(param):
info[param] = clean_input(info[param])
if IF_RE.match(info[param]):
query[param] = split_list(info[param])
query[param].sort()
else:
name = param
if field == 'hodge':
name = 'Hodge vector'
info['err'] = 'Error parsing input for %s. It needs to be a list of integers in square brackets, such as [2,3] or [1,1,1]' % name
return search_input_error(info, bread)
if info.get('t') and not family_search:
info['t'] = clean_input(info['t'])
try:
tsage = QQ(str(info['t']))
tlist = [int(tsage.numerator()), int(tsage.denominator())]
query['t'] = tlist
except:
info['err'] = 'Error parsing input for t. It needs to be a rational number, such as 2/3 or -3'
# sign can only be 1, -1, +1
if info.get('sign') and not family_search:
sign = info['sign']
sign = re.sub(r'\s','',sign)
sign = clean_input(sign)
if sign == '+1':
sign = '1'
if not (sign == '1' or sign == '-1'):
info['err'] = 'Error parsing input %s for sign. It needs to be 1 or -1' % sign
return search_input_error(info, bread)
query['sign'] = int(sign)
for param in ['degree','weight','conductor']:
# We don't look at conductor in family searches
if info.get(param) and not (param=='conductor' and family_search):
if param=='conductor':
cond = info['conductor']
try:
cond = re.sub(r'(\d)\s+(\d)', r'\1 * \2', cond) # implicit multiplication of numbers
cond = cond.replace(r'..', r'-') # all ranges use -
cond = re.sub(r'[a..zA..Z]', '', cond)
cond = clean_input(cond)
tmp = parse_range2(cond, 'cond', myZZ)
except:
info['err'] = 'Error parsing input for conductor. It needs to be an integer (e.g., 8), a range of integers (e.g. 10-100), or a list of such (e.g., 5,7,8,10-100). Integers may be given in factored form (e.g. 2^5 3^2) %s' % cond
return search_input_error(info, bread)
else: # not conductor
info[param] = clean_input(info[param])
ran = info[param]
ran = ran.replace(r'..', r'-')
if LIST_RE.match(ran):
tmp = parse_range2(ran, param)
else:
names = {'weight': 'weight', 'degree': 'degree'}
info['err'] = 'Error parsing input for the %s. It needs to be an integer (such as 5), a range of integers (such as 2-10 or 2..10), or a comma-separated list of these (such as 2,3,8 or 3-5, 7, 8-11).' % names[param]
return search_input_error(info, bread)
# work around syntax for $or
# we have to foil out multiple or conditions
if tmp[0] == '$or' and '$or' in query:
newors = []
for y in tmp[1]:
oldors = [dict.copy(x) for x in query['$or']]
for x in oldors:
x.update(y)
newors.extend(oldors)
tmp[1] = newors
query[tmp[0]] = tmp[1]
#print query
count_default = 20
if info.get('count'):
try:
count = int(info['count'])
except:
count = count_default
else:
count = count_default
info['count'] = count
start_default = 0
if info.get('start'):
try:
start = int(info['start'])
if(start < 0):
#.........这里部分代码省略.........
def compute_satake_parameters_numeric(self, prec=10, bits=53,insert_in_db=True):
r""" Compute the Satake parameters and return an html-table.
We only do satake parameters for primes p primitive to the level.
By defintion the S. parameters are given as the roots of
X^2 - c(p)X + chi(p)*p^(k-1) if (p,N)=1
INPUT:
-''prec'' -- compute parameters for p <=prec
-''bits'' -- do real embedings intoi field of bits precision
"""
if self.character().order()>2:
## We only implement this for trival or quadratic characters.
## Otherwise there is difficulty to figure out what the embeddings mean...
return
K = self.coefficient_field()
degree = self.degree()
RF = RealField(bits)
CF = ComplexField(bits)
ps = prime_range(prec)
self._satake['ps'] = []
alphas = dict()
thetas = dict()
aps = list()
tps = list()
k = self.weight()
for j in range(degree):
alphas[j] = dict()
thetas[j] = dict()
for j in xrange(len(ps)):
p = ps[j]
try:
ap = self.coefficient(p)
except IndexError:
break
# Remove bad primes
if p.divides(self.level()):
continue
self._satake['ps'].append(p)
chip = self.character().value(p)
wmf_logger.debug("p={0}".format(p))
wmf_logger.debug("chip={0} of type={1}".format(chip,type(chip)))
if hasattr(chip,'complex_embeddings'):
wmf_logger.debug("embeddings(chip)={0}".format(chip.complex_embeddings()))
wmf_logger.debug("ap={0}".format(ap))
wmf_logger.debug("K={0}".format(K))
# ap=self._f.coefficients(ZZ(prec))[p]
if K.absolute_degree()==1:
f1 = QQ(4 * chip * p ** (k - 1) - ap ** 2)
alpha_p = (QQ(ap) + I * f1.sqrt()) / QQ(2)
ab = RF(p ** ((k - 1) / 2))
norm_alpha = alpha_p / ab
t_p = CF(norm_alpha).argument()
thetas[0][p] = t_p
alphas[0][p] = (alpha_p / ab).n(bits)
else:
for jj in range(degree):
app = ap.complex_embeddings(bits)[jj]
wmf_logger.debug("chip={0}".format(chip))
wmf_logger.debug("app={0}".format(app))
wmf_logger.debug("jj={0}".format(jj))
if not hasattr(chip,'complex_embeddings'):
f1 = (4 * CF(chip) * p ** (k - 1) - app ** 2)
else:
f1 = (4 * chip.complex_embeddings(bits)[jj] * p ** (k - 1) - app ** 2)
alpha_p = (app + I * abs(f1).sqrt())
# ab=RF(/RF(2)))
# alpha_p=alpha_p/RealField(bits)(2)
wmf_logger.debug("f1={0}".format(f1))
alpha_p = alpha_p / RF(2)
wmf_logger.debug("alpha_p={0}".format(alpha_p))
t_p = CF(alpha_p).argument()
# tps.append(t_p)
# aps.append(alpha_p)
alphas[jj][p] = alpha_p
thetas[jj][p] = t_p
self._satake['alphas'] = alphas
self._satake['thetas'] = thetas
self._satake['alphas_latex'] = dict()
self._satake['thetas_latex'] = dict()
for j in self._satake['alphas'].keys():
self._satake['alphas_latex'][j] = dict()
for p in self._satake['alphas'][j].keys():
s = latex(self._satake['alphas'][j][p])
self._satake['alphas_latex'][j][p] = s
for j in self._satake['thetas'].keys():
self._satake['thetas_latex'][j] = dict()
for p in self._satake['thetas'][j].keys():
s = latex(self._satake['thetas'][j][p])
self._satake['thetas_latex'][j][p] = s
wmf_logger.debug("satake=".format(self._satake))
return self._satake
客服电话
APP下载
官方微信
请发表评论