示例#1
0
def hurwitz_kronecker_class_no_x( n, D):
    r"""
    OUTPUT
        The generalized Hurwitz-Kronecker class number $H_n(D)$
        as defined in [S-Z].

    INPUT
        n -- an integer $\ge 1$
        D -- an integer $\le 0$
    """
    n = Integer(n)
    D = Integer(D)
    if n <= 0:
        raise ValueError, "%s: must be an integer >=1" % n
    if D > 0:
        raise ValueError, "%s: must be an integer <= 0" % D
    g = D.gcd( n)
    a,b = _ab(g)
    h = g*b
    if 0 != D%h:
        return 0
    Dp = D//h
    H1 = Rational( gp.qfbhclassno( -Dp))
    if 0 == H1:
        return H1
    return g * Dp.kronecker( n//g) * H1
示例#2
0
def __check( k, m, l, n):
    k = Integer(k)
    m = Integer(m)
    l = Integer(l)
    n = Integer(n)

    if m <= 0:
        raise ValueError, "%s: m must be a positive integer" % m

    if l < 1 or 1 != l.gcd( m):
        raise ValueError, "%s: l must be a positive integer prime to %d" \
              % ( l, m)

    if n <=0 or 0 != m%n or 1 != n.gcd( m//n):
        raise ValueError, "%s: n must be an exact divisor of %d" \
              ( n, m)

    return k, m, l, n
示例#3
0
def _sz_s( k, m, l, n):
    r"""
    OUTPUT
        The function  $s_{k,m}(l,n)$, i.e.~the trace
        of $T(l) \circ W_n$ on the "certain" space
        $\mathcal{M}_{2k-2}^{\text{cusp}}(m)$ of modular forms
        as defined in [S-Z].

    INPUT
        l -- index of the Hecke operator, rel. prime to the level $m$
        n -- index of the Atkin-Lehner involution (exact divisor of $m$)
        k -- integer ($2k-2$ is the weight)
        m -- level
    """
    k = Integer(k)
    m = Integer(m)
    l = Integer(l)
    n = Integer(n)
    if k < 2:
        return 0
    if 1 != m.gcd(l):
        raise ValueError, \
              "gcd(%s,%s) != 1: not yet implemented" % (m,l)

    ellT = 0
    for np in n.divisors():
        ellT -= sum( l**(k-2) \
                     * _gegenbauer_pol( k-2, s*s*np/l) \
                     * hurwitz_kronecker_class_no_x( m/n, s*s*np*np - 4*l*np) \
                     for s in range( -(Integer(4*l*np).isqrt()//np), \
                                     1+(Integer(4*l*np).isqrt()//np)) \
                     if (n//np).gcd(s*s).is_squarefree())/2

    parT = -sum( min( lp, l//lp)**(2*k-3) \
                 * _ab(n)[0].gcd( lp+l//lp) \
                 * _ab(m/n)[0].gcd( lp-l//lp) \
                 for lp in l.divisors())/2
    
    if 2 == k and (m//n).is_square():
        corT = sigma(n,0)*sigma(l,1)
    else:
        corT = 0
        
    return Integer( ellT + parT + corT)