Пример #1
0
def test2(B=500):
    from sage.all import polygen, primes, QQ, GF, HyperellipticCurve
    import psage.libs.smalljac.wrapper

    x = polygen(QQ, "x")
    J = psage.libs.smalljac.wrapper.SmallJac(x ** 5 + 17 * x + 3)
    N = 97 * 3749861
    for p in primes(45, B):  # 45 comes from "(2g+1)(2N-1) = 45"
        if N % p:
            x = polygen(GF(p), "x")
            C = HyperellipticCurve(x ** 5 + 17 * x + 3)
            assert C.frobenius_polynomial() == J.frob(p).charpoly()
Пример #2
0
def V4_extensions(K,S, verbose=False):
    r"""Return all V4 extensions of K unramified outside S.  The
    polynomials returned are irreducible.
    """
    from C2C3S3 import C2_extensions
    C2s = C2_extensions(K,S)
    ds = [f.discriminant() for f in C2s]
    if K==QQ:
        ds = [d.squarefree_part() for d in ds]
    #print("ds = {}".format(ds))
    ab_pairs = []
    all_pairs = []
    for i,a in enumerate(ds):
        for b in ds[:i]:
            if Set([a,b]) in all_pairs:
                continue
            c = a*b
            if K==QQ:
                c = c.squarefree_part()
            ab_pairs.append([a,b])
            all_pairs.append(Set([a,b]))
            all_pairs.append(Set([a,c]))
            all_pairs.append(Set([c,b]))
    #print("ab pairs = {}".format(ab_pairs))
    x = polygen(K)
    #print( [(x**4 - 2*(a+b)*x**2 + (a-b)**2) for a,b in ab_pairs])
    return [polredabs(x**4 - 2*(a+b)*x**2 + (a-b)**2) for a,b in ab_pairs]
Пример #3
0
def C2_extensions(K,S):
    r"""Return all quadratic extensions of K unramified outside S.

    INPUT:

    - ``K`` (number field) -- a number field, or ``QQ``.

    - ``S`` (list) -- a list of prime ideals in ``K``, or primes.

    OUTPUT:

    (list) A list of monic polynomials of the form `x^2-a` with `a\in
    K` defining all quadratic extensions of `K` unramified outside
    `S`.

    .. note::

       These all have the form `K(\sqrt{a})` for `a\in K(S,2)', but if
       `S` does not contain all primes dividing 2 then some of these
       may be ramified at primes dividing 2 not in `S`, so we need to
       do an additional check.
    """
    x = polygen(K)
    # if some primes above 2 are not in S then a further check is required
    if is_S_unit(K(2),S):
        test = lambda a: True
    else:
        test = lambda a: unramified_outside_S(K.extension(x**2-a,'t2'), S, 2)
    return [x**2-a for a in K.selmer_group_iterator(S,2) if not a.is_square() and test(a)]
Пример #4
0
def field_from_label(lab):
    r"""
    Returns a number field from its LMFDB label.

    INPUT:

    - ``s`` (string)-- an LMFDB field label

    OUTPUT:

    A number field.
    """
    dummy, deg, sig, abs_disc = field_data(lab)
    x = polygen(QQ)
    if deg==2:
        d = ZZ(abs_disc)
        if sig[0]==0: d=-d
        t = d%4
        assert t in [0,1]
        pol = x**2 - t*x + (t-d)/4
    elif lab=='3.1.23.1':
        pol = x**3 - x**2 +1
    else:
        raise NotImplementedError("cannot yet handle field %s" % lab)
    K = NumberField(pol, 'a')
    print "Created field from label %s: %s" % (lab,K)
    return K
Пример #5
0
def C4_extensions_with_quadratic(K,S,M, verbose=False):
    r"""Return all C4 extensions of K containing the quadratic
    extension M of K, unramified outside S.
    """
    if verbose:
        print("finding C4 extensions of {} over {} unramified outside {}".format(K,M,S))
    SM = sum([M.primes_above(P) for P in S],[])
    DM = M.defining_polynomial().discriminant()
    x = polygen(K)
    # if some primes above 2 are not in S then a further check is required
    from C2C3S3 import is_S_unit, unramified_outside_S
    if is_S_unit(M(2),SM):
        test = lambda a: True
    else:
        test = lambda a: unramified_outside_S(M.extension(polygen(M)**2-a,'t4'),SM)
    alphas = [a for a in M.selmer_group_iterator(SM,2) if not a.is_square() and (DM*a.relative_norm()).is_square() and test(a)]
    return [polredabs(x**4-a.trace(K)*x**2+a.norm(K)) for a in alphas]
def render_hmf_webpage(**args):
    C = getDBConnection()
    data = None
    if 'label' in args:
        label = str(args['label'])
        data = C.hmfs.forms.find_one({'label': label})
    if data is None:
        return "No such field"    
    info = {}
    try:
        info['count'] = args['count']
    except KeyError:
        info['count'] = 10

    hmf_field  = C.hmfs.fields.find_one({'label': data['field_label']})
    field_info = C.numberfields.fields.find_one({'label': data['field_label']})
    field_info['galois_group'] = str(field_info['galois_group'][3])
    info['field_info'] = field_info
    info['field_poly'] = pol_to_html(str(coeff_to_poly(field_info['coefficients'])))

    data['field_label'] = field_pretty(data['field_label'])
    info.update(data)
    info['downloads_visible'] = True
    info['downloads'] = [('worksheet (not yet)', '/')]
    info['friends'] = [('L-function (not yet)', '/')]
#    info['learnmore'] = [('Number Field labels', url_for("render_labels_page")), ('Galois group labels',url_for("render_groups_page")), ('Discriminant ranges',url_for("render_discriminants_page"))]
    bread = [('Hilbert Modular Forms', url_for("hilbert_modular_form_render_webpage")),('%s'%data['label'],' ')]

    t = "Hilbert Cusp Form %s" % info['label']
    credit = 'L. Dembele, S. Donnelly and J. Voight'

    eigs = eval(data['hecke_eigenvalues'])
    primes = hmf_field['primes']
    w = polygen(QQ,'w')
    n = min(len(eigs),len(primes))
    info['eigs'] = [{'eigenvalue': eigs[i],
                     'prime_ideal': primes[i], 
                     'prime_norm': primes[i][0]} for i in range(n)]
        
    properties = []
    properties = ['<br>']
    properties.extend('<table>')
    properties.extend('<tr><td align=left>Field:<td align=left>%s</td>'%data["field_label"])
    properties.extend('<tr><td align=left>Degree:<td align=left> %s</td>'%field_info['degree'])
    properties.extend('<tr><td align=left>Discriminant:<td align=left>%s</td>'%field_info['discriminant'])
    properties.extend('<tr><td align=left>Polynomial:<td align=left>%s</td>'%field_info['discriminant'])
    properties.extend('<tr><td align=left>Class number:<td align=left>%s</td>'%field_info['class_number'])
    properties.extend('<tr><td align=left>Galois group:<td align=left>%s</td>'%field_info['galois_group'])
    properties.extend('</table>')
    properties.extend('<hr>')
    properties.extend('<table>')
    properties.extend('<tr><td align=left>Weight:<td align=left>%s</td>'%data["weight"])
    properties.extend('<tr><td align=left>Level:<td align=left> %s</td>'%data['level_ideal'])
    properties.extend('<tr><td align=left>Level Norm:<td align=left>%s</td>'%data['level_norm'])
    properties.extend('<tr><td align=left>Label:<td align=left>%s</td>'%data['label_suffix'])
    properties.extend('</table>')

    return render_template("hilbert_modular_form/hilbert_modular_form.html", info = info, properties=properties, credit=credit, title = t, bread=bread)
Пример #7
0
 def make_quartic(a):
     # a is in the cubic extension M/K and has square norm, so has
     # char poly of the form x^3-p*x^2+q*x-r^2.
     r2, q, p, one = list(a.charpoly())
     p = -p
     assert (-r2).is_square()
     r = (-r2).sqrt()
     x = polygen(K)
     return polredabs((x**2-p)**2-8*r*x-4*q)
Пример #8
0
def test1(B=10 ** 4):
    from sage.all import polygen, primes, QQ, EllipticCurve
    import psage.libs.smalljac.wrapper

    x = polygen(QQ, "x")
    J = psage.libs.smalljac.wrapper.SmallJac(x ** 3 + 17 * x + 3)
    E = EllipticCurve([17, 3])
    N = E.conductor()
    for p in primes(B):
        if N % p:
            assert E.ap(p) == J.ap(p)
Пример #9
0
def vec123(K,basis):
    xK = polygen(K)
    quadratics = [xK**2-d for d in basis]
    r = len(basis)
    def vecP(P):
        ones = [lam(pol,P) for pol in quadratics]
        #print("ones: {}".format(ones))
        twos = [ones[i]*ones[j] for i in range(r) for j in range(i+1,r)]
        #print("twos: {}".format(twos))
        threes = [ones[i]*ones[j]*ones[k] for i in range(r) for j in range(i+1,r) for k in range(j+1,r)]
        #print("threes: {}".format(threes))
        vec = ones+twos+threes
        return vec
    return vecP
Пример #10
0
def _test_an_dict_over_Q(ainvs, B=100):
    """
    Test that the an_dict function works and gives the correct answer
    for an elliptic curve defined over QQ, by computing using the
    generic code in this file, and comparing with the output of Sage's
    anlist function for rational elliptic curves.
    """
    from sage.all import polygen, QQ, NumberField, EllipticCurve
    x = polygen(QQ,'x')
    F = NumberField(x - 1,'a'); a = F.gen()
    E = EllipticCurve(F, ainvs)
    EQ = EllipticCurve(QQ, ainvs)
    v = EQ.anlist(B)
    an = an_dict(E, B)
    for i, j in an.iteritems():
        assert j == v[i[0]]
Пример #11
0
def test1(B=50):
    """
    Tests that the functions all run without crashing over a specific number field.
    Does not test that the output is correct.  That should be in
    another test.
    """
    from sage.all import polygen, QQ, NumberField, EllipticCurve
    x = polygen(QQ,'x')
    F = NumberField(x**2 - x - 1,'a'); a = F.gen()
    E = EllipticCurve([1,a+1,a,a,0])
    ap(E,F.ideal(3))
    primes_of_bounded_norm(F,B)
    ap_list(E,B)
    assert len(ap_list(E,B,primes=True)) == 2
    apd = ap_dict(E,B)
    reduced_rep(F.ideal(3))
    assert an_dict(E,B) == an_dict_from_ap(apd, E.conductor(), B)
Пример #12
0
def V4_extensions_with_quadratic(K,S,M, verbose=False):
    r"""Return all V4 extensions of K unramified outside S which contain
    the quadratic extension M (also unramified outside S).  The
    polynomials returned are irreducible.
    """
    from C2C3S3 import C2_extensions
    C2s = C2_extensions(K,S)
    D = M.discriminant().squarefree_part()
    ds = [f.discriminant() for f in C2s]
    if K==QQ:
        ds = [d.squarefree_part() for d in ds]
    dMs = [d*D for d in ds]
    if K==QQ:
        dMs = [d.squarefree_part() for d in dMs]
    indices = [i for i in range(len(ds)) if ds[i]!=D and dMs.index(ds[i])<i]
    ds = [ds[i] for i in indices]
    x = polygen(K)
    return [polredabs(x**4 - 2*(D+d)*x**2 + (D-d)**2) for d in ds]
Пример #13
0
def get_T0_mod3(K,S, flist=None, verbose=False):
   # Compute all absolutely irreducible quartics unramified outside S
   # if not supplied:
   if flist == None:
      from S4 import abs_irred_extensions
      flist = abs_irred_extensions(K,S)
   if verbose:
      print("quartics: {}".format(flist))

# Append a poly with lam3=0
   x = polygen(K)
   flist0 = flist + [x**3]
   n = len(flist)

# Starting with no primes, compute the lambda matrix
   plist = []
   vlist = [lamvec(f,plist,lam3) for f in flist0]
   ij = equal_vecs(vlist)
   if verbose:
      print("With plist={}, vlist={}, ij={}".format(plist,vlist,ij));
   N = prod(S,1) * prod([f.discriminant() for f in flist])
# As long as the vectors in vlist are not all distinct, find two
# indices i,j for which they are the same and find a new prime which
# distinguishes these two, add it to the list and update.  The primes
# must not be in S or divide the discriminant of any of the quartics.
   while ij:
      i,j = ij
      if j==n:
         p = get_p_1(K,flist[i],N, lam3)
      else:
         p = get_p_2(K,flist[i],flist[j],N, lam3)
      plist = plist + [p]
      if verbose:
         print("plist = {}".format(plist))
      vlist = [lamvec(f,plist,lam3) for f in flist0]
      ij = equal_vecs(vlist)
      if verbose:
         print("With plist={}, vlist={}, ij={}".format(plist,vlist,ij));
   vlist = vlist[:-1]

   # Sort the primes into order and recompute the vectors:
   plist.sort()
   vlist = [lamvec(f,plist,lam3) for f in flist]
   return flist, plist, vlist
Пример #14
0
def alpha(p,D):
   """
   Return 1 if p is inert in K(sqrt(D)), 0 if p splits
   """
   # Over Q we just compute the kronecker symbol, returning 0 if it
   # equals 1 and 1 if it equals -1:
   if p in ZZ:
      return ((1-ZZ(D).kronecker(p))//2) % 2

   # Otherwise we retrieve the field K (here p may be a prime ideal or a prime element)
   try:
      K = p.ring()
   except AttributeError:
      K = p.parent()

   # and count how many primes in K lie above p:
   x = polygen(K)
   L = K.extension(x**2-D,'b')
   return 2-len(L.primes_above(p))
Пример #15
0
def field_from_label(lab):
    r"""
    Returns a number field from its LMFDB label.  Only for 5 IQFs at present.
    """
    global the_fields
    if lab in the_fields:
        return the_fields[lab]
    x = polygen(QQ)
    deg, s, abs_disc, _ = lab.split(".")
    assert deg == '2'
    assert s == '0'
    d = -ZZ(abs_disc)
    t = d%4
    assert t in [0,1]
    pol = x**2 - t*x + (t-d)//4
    K = NumberField(pol, 'a')
    print "Created field from label %s: %s" % (lab,K)
    the_fields[lab] = K
    return K
Пример #16
0
def get_T0(K,S, flist=None, verbose=False):
   # Compute all cubics unramified outside S if not supplied:
   if flist == None:
      from C2C3S3 import C3S3_extensions
      flist = C3S3_extensions(K,S)
   if verbose:
      print("cubics: {}".format(flist))

# Append the reducible cubic
   x = polygen(K)
   flist0 = flist + [x**3]
   n = len(flist)

# Starting with no primes, compute the lambda matrix
   plist = []
   vlist = [lamvec(f,plist) for f in flist0]
   ij = equal_vecs(vlist)
   if verbose:
      print("With plist={}, vlist={}, ij={}".format(plist,vlist,ij));
   N = prod(S,1)
# As long as the vectors in vlist are not all distinct, find two
# indices i,j for which they are the same and find a new prime which
# distinguishes these two, add it to the list and update:
   while ij:
      i,j = ij
      if j==n:
         p = get_p_1(K,flist[i],N)
      else:
         p = get_p_2(K,flist[i],flist[j],N)
      plist = plist + [p]
      if verbose:
         print("plist = {}".format(plist))
      vlist = [lamvec(f,plist) for f in flist0]
      ij = equal_vecs(vlist)
      if verbose:
         print("With plist={}, vlist={}, ij={}".format(plist,vlist,ij));
   vlist = vlist[:-1]

   # Sort the primes into order and recompute the vectors:
   plist.sort()
   vlist = [lamvec(f,plist) for f in flist]
   return flist, plist, vlist
Пример #17
0
def D4_extensions_with_quadratic(K,S,M, verbose=False):
    r"""Return all D4 extensions of K unramified outside S which are cyclic
    extensions of the quadratic field M, where M is also unramified
    outside S.
    """
    if verbose:
        print("finding D4 extensions of {} over {} unramified outside {}".format(K,M,S))

    SM = sum([M.primes_above(P) for P in S],[])
    sigma = M.automorphisms()[1]

    from KSp import pSelmerGroup
    MS2, MS2_gens, from_MS2, to_MS2 = pSelmerGroup(M,SM,ZZ(2))
    betas2 = [from_MS2(v) for v in MS2 if v]
    # remove conjugates (mod squares):
    conj_ind = lambda b: betas2.index(from_MS2(to_MS2(sigma(b))))
    betas = [b for i,b in enumerate(betas2) if not conj_ind(b)<i]
    # remove those whose norm is a square in M:
    norms  = [b.norm() for b in betas]
    betas = [b for b,n in zip(betas,norms) if not M(n).is_square()]
    norms  = [b.norm() for b in betas]
    traces = [b.trace() for b in betas]
    x = polygen(K)
    return [polredabs(x**4-t*x**2+n) for t,n in zip(traces,norms)]
Пример #18
0
def C3_extensions(K,S, verbose=False, debug=False):
    r"""Return all `C_3` extensions of ``K`` unramified outside ``S``.

    INPUT:

    - ``K`` (number field) -- a number field, or ``QQ``.

    - ``S`` (list) -- a list of prime ideals in ``K``, or primes.

    - ``verbose`` (boolean, default ``False``) -- verbosity flag.
    OUTPUT:

    - ``debug`` (boolean, default ``False``) -- debugging flag.
    OUTPUT:

    (list) A list of polynomials of degree 3 in `K[x]` defining all
    Galois cubic extensions of `K` unramified outside `S`.

    .. note::

       If `K` contains the cube roots of unity, these all have the
       form `K(\root[3]{a})` for `a\in (K(S,3)`, but if `S` does not
       contain all primes dividing 3 some of these may be ramified at
       primes dividing 3 not in `S` so we need to do an additional
       check. In the general case we need to work harder: we work over
       `K(\zeta_3)` and then descend.
    """
    from KSp import pSelmerGroup
    x = polygen(K)
    if verbose:
        print("finding C3 extensions over {} unramified outside {}".format(K,S))

    if K(-3).is_square(): ## K contains cube roots of unity
        if is_S_unit(K(3),S): # primes dividing 3 are in S -- easy case
            test = lambda a: True
        else:
            test = lambda a: unramified_outside_S(K.extension(x**3-a,'t3'), S, 3)
        # use K(S,3), omitting trivial element and only including one of a, a^-1:
        from KSp import selmer_group_projective
        return [x**3-a for a in selmer_group_projective(K,S,3) if test(a)]

    # now K does not contain the cube roots of unity.  We adjoin them.
    # See Angelos Koutsianas's thesis Algorithm 3 (page 45)

    if verbose:
        print("finding alphas")

    # Find downstairs Selmer group and maps:
    KS3, KS3_gens, from_KS3, to_KS3 = pSelmerGroup(K,S,ZZ(3))
    if verbose:
        print("Downstairs 3-Selmer group has dimension {}".format(KS3.dimension()))

    # Find upstairs Selmer group and maps:
    K3 = K.extension(x**2+x+1,'z3')
    nm = lambda p: p if p in ZZ else p.absolute_norm()
    S3 = sum([K3.primes_above(P) for P in S if nm(P)%3!=2],[])
    K3S3, K3S3_gens, from_K3S3, to_K3S3 = pSelmerGroup(K3,S3,ZZ(3))
    if verbose:
        print("Upstairs 3-Selmer group has dimension {}".format(K3S3.dimension()))

    # construct norm map from K3S3 to KS3 and find its kernel:
    N = K3S3.hom([to_KS3(from_K3S3(v).norm(K)) for v in K3S3.basis()], KS3)
    ker = N.kernel()
    Pker = ProjectiveSpace(ker.dimension()-1,ker.base())
    alphas = [from_K3S3(ker.linear_combination_of_basis(list(v))) for v in Pker]

    # The alphas are the elements of this kernel
    if verbose:
        print("found {} alphas".format(len(alphas)))
        #print(alphas)

    # Compute the trace of each alpha:
    try:
        traces = [a.trace(K) for a in alphas]
    except TypeError:
        traces = [a.trace() for a in alphas]
    if verbose: print("computed {} traces".format(len(traces)))

    # Compute the betas, cube roots of each alpha's norm:
    betas = [a.norm(K).nth_root(3) for a in alphas]
    if verbose: print("computed {} betas".format(len(betas)))

    # Form the polynomials
    polys = [x**3-3*b*x-t for b,t in zip(betas, traces)]
    if verbose: print("computed {} polys".format(len(polys)))

    # NB because of the additional extension, these may be ramified at
    # primes above 3, not all of which are necessarily in S, so we
    # must check.  If S already contained all primes dividing 3 this
    # would already be the desired list.

    check_3 = not is_S_unit(K(3),S)
    if debug or check_3:
        fields = [K.extension(f,'t3') for f in polys]
        if verbose: print("computed fields, checking ramification")
    if K == QQ:
        if not (debug or check_3):
            fields = [K.extension(f,'t3') for f in polys]

        fields = [L.optimized_representation()[0] for L in fields]
        polys = [L.defining_polynomial() for L in fields]

    # (debug) check the fields are not isomorphic (relative to K):
    if debug:
        if K==QQ:
            assert all([not any([fields[i].is_isomorphic(fields[j])
                                 for j in range(i)]) for i in range(len(fields))])
        else:
            assert all([not any([fields[i].is_isomorphic_relative(fields[j])
                                 for j in range(i)]) for i in range(len(fields))])

    # the polys we have are already guaranteed to be unramified
    # outside S, by construction, except possibly at primes dividing 3
    # not in S.
    if check_3:
        polys_and_fields = zip(polys,fields)
        if verbose:
            print("Final check of primes dividing 3 not in S")
        polys_and_fields = [fL for fL in polys_and_fields if unramified_outside_S(fL[1],S,3)]
        if verbose:
            print("After final check, {} polys remain".format(len(polys_and_fields)))
        polys  = [f for f,L in polys_and_fields]
        fields = [L for f,L in polys_and_fields]
    if debug:
        if not polys == [f for f,L in zip(polys,fields) if unramified_outside_S(L,S)]:
            print("Problem: relative discriminants are {}".format([L.relative_discriminant().factor() for L in fields]))
        else:
            if verbose: print("computed unramified polys OK")
    return polys
Пример #19
0
# 2020-04-15: first version by JEC

from sage.all import EllipticCurve, polygen, QQ, NumberField
from lmfdb import db
from lmfdb.nfutils.psort import primes_iter
from lmfdb.ecnf.WebEllipticCurve import parse_ainvs

print("setting nfcurves")
nfcurves = db.ec_nfcurves

print("setting bmf forms")
forms = db.bmf_forms

fields = ['2.0.{}.1'.format(d) for d in [4, 8, 3, 7, 11]]
x = polygen(QQ)

polys = {
    '2.0.4.1': x**2 + 1,
    '2.0.8.1': x**2 + 2,
    '2.0.3.1': x**2 - x + 1,
    '2.0.7.1': x**2 - x + 2,
    '2.0.11.1': x**2 - x + 3,
}

gen_names = {
    '2.0.4.1': 'i',
    '2.0.8.1': 't',
    '2.0.3.1': 'w',
    '2.0.7.1': 'a',
    '2.0.11.1': 'a',
Пример #20
0
def render_hmf_webpage(**args):
    C = getDBConnection()
    data = None
    if 'label' in args:
        label = str(args['label'])
        data = C.hmfs.forms.find_one({'label': label})
    if data is None:
        return "No such field"
    info = {}
    try:
        info['count'] = args['count']
    except KeyError:
        info['count'] = 10

    try:
        numeigs = request.args['numeigs']
        numeigs = int(numeigs)
    except:
        numeigs = 20

    hmf_field = C.hmfs.fields.find_one({'label': data['field_label']})
    gen_name = findvar(hmf_field['ideals'])
    nf = WebNumberField(data['field_label'], gen_name=gen_name)
    info['field'] = nf
    info['base_galois_group'] = nf.galois_string()
    info['field_degree'] = nf.degree()
    info['field_disc'] = str(nf.disc())
    info['field_poly'] = teXify_pol(str(nf.poly()))

    info.update(data)

    info['downloads'] = [('Download to Magma',
                          url_for(".render_hmf_webpage_download",
                                  field_label=info['field_label'],
                                  label=info['label'],
                                  download_type='magma')),
                         ('Download to Sage',
                          url_for(".render_hmf_webpage_download",
                                  field_label=info['field_label'],
                                  label=info['label'],
                                  download_type='sage'))]
    info['friends'] = [('L-function',
                        url_for("l_functions.l_function_hmf_page",
                                field=info['field_label'],
                                label=info['label'],
                                character='0',
                                number='0'))]

    if data['dimension'] == 1:  # Try to attach associated elliptic curve
        lab = split_class_label(info['label'])
        ec_from_hmf = db_ecnf().find_one({"label": label + '1'})
        if ec_from_hmf != None:
            info['friends'] += [('Isogeny class ' + info['label'],
                                 url_for("ecnf.show_ecnf_isoclass",
                                         nf=lab[0],
                                         conductor_label=lab[1],
                                         class_label=lab[2]))]

    bread = [('Hilbert Modular Forms',
              url_for(".hilbert_modular_form_render_webpage")),
             ('%s' % data['label'], ' ')]

    t = "Hilbert Cusp Form %s" % info['label']

    forms_space = C.hmfs.forms.find({
        'field_label': data['field_label'],
        'level_ideal': data['level_ideal']
    })
    dim_space = 0
    for v in forms_space:
        dim_space += v['dimension']

    info['newspace_dimension'] = dim_space

    w = polygen(QQ, 'w')
    e = polygen(QQ, 'e')
    eigs = data['hecke_eigenvalues']
    eigs = eigs[:min(len(eigs), numeigs)]

    primes = hmf_field['primes']
    n = min(len(eigs), len(primes))
    info['eigs'] = [{
        'eigenvalue': teXify_pol(eigs[i]),
        'prime_ideal': teXify_pol(primes[i]),
        'prime_norm': primes[i][1:primes[i].index(',')]
    } for i in range(n)]

    try:
        display_eigs = request.args['display_eigs']
        if display_eigs in ['True', 'true', '1', 'yes']:
            display_eigs = True
        else:
            display_eigs = False
    except KeyError:
        display_eigs = False

    if 'numeigs' in request.args:
        display_eigs = True

    info['hecke_polynomial'] = teXify_pol(info['hecke_polynomial'])

    if 'AL_eigenvalues_fixed' in data:
        if data['AL_eigenvalues_fixed'] == 'done':
            info['AL_eigs'] = [{
                'eigenvalue': teXify_pol(al[1]),
                'prime_ideal': teXify_pol(al[0]),
                'prime_norm': al[0][1:al[0].index(',')]
            } for al in data['AL_eigenvalues']]
        else:
            info['AL_eigs'] = [{'eigenvalue': '?', 'prime_ideal': '?'}]
    else:
        info['AL_eigs'] = [{'eigenvalue': '?', 'prime_ideal': '?'}]
    info['AL_eigs_count'] = len(info['AL_eigs']) != 0

    if not display_eigs:
        for eig in info['eigs']:
            if len(eig['eigenvalue']) > 300:
                eig['eigenvalue'] = '...'
        for eig in info['AL_eigs']:
            if len(eig['eigenvalue']) > 300:
                eig['eigenvalue'] = '...'

    info['level_ideal'] = teXify_pol(info['level_ideal'])

    if 'is_CM' in data:
        is_CM = data['is_CM']
    else:
        is_CM = '?'
    info['is_CM'] = is_CM

    if 'is_base_change' in data:
        is_base_change = data['is_base_change']
    else:
        is_base_change = '?'
    info['is_base_change'] = is_base_change

    if 'q_expansions' in data:
        info['q_expansions'] = data['q_expansions']

    properties2 = [('Base Field', '%s' % info['field'].field_pretty()),
                   ('Weight', '%s' % data['weight']),
                   ('Level Norm', '%s' % data['level_norm']),
                   ('Level', '$' + teXify_pol(data['level_ideal']) + '$'),
                   ('Label', '%s' % data['label_suffix']),
                   ('Dimension', '%s' % data['dimension']), ('CM', is_CM),
                   ('Base Change', is_base_change)]

    return render_template("hilbert_modular_form.html",
                           downloads=info["downloads"],
                           info=info,
                           properties2=properties2,
                           credit=hmf_credit,
                           title=t,
                           bread=bread,
                           friends=info['friends'])
Пример #21
0
def S3primes(K, S, f, verbose=False):
    """f(x) defines the S3-extension of K
    """
    # First: primes P such that f mod P is irreducible and P is inert
    # in K(sqrt(a)), for each a in K(S,2)/<D> where D=disc(f):

    if verbose:
        print("finding first set of primes")
    KS2, KS2_gens, from_KS2, to_KS2 = pSelmerGroup(K,S,ZZ(2))
    D = f.discriminant()
    quo = KS2 / KS2.subspace([to_KS2(D)])
    alphas = [from_KS2(quo.lift(w)) for w in quo if w]
    if verbose:
        print("alphas = {}".format(alphas))
    alpha_flags = [False for _ in alphas]
    xK = polygen(K)
    quads = [xK**2-alpha for alpha in alphas]
    primes = primes_iter(K,None)
    Ta = Set()
    N = prod(S,1)
    while sum(alpha_flags)<len(alphas):
        p = primes.next()
        while p.divides(N):
            p = primes.next()
        # Now p is a candidate test prime
        if verbose:
            print("testing P={} (have covered {} alphas so far)".format(p,sum(alpha_flags)))
        Fp = residue_field(p)
        while not f.change_ring(Fp).is_irreducible():
            if verbose:
                print("no good, f not irreducible mod p={}".format(p))
            p = primes.next()
            while p.divides(N):
                p = primes.next()
            Fp = residue_field(p)
        if verbose:
            print("P={} passes first test".format(p))
        # p has passed the first criterion: f mod p irreducible
        # p is useful if x^2-alpha irreducible mod p for some alpha
        for i,h in enumerate(quads):
            if not alpha_flags[i]:
                alpha_flags[i] = len(h.roots(Fp))==0
                if alpha_flags[i]:
                    if verbose:
                        print("This p is good for alpha = {}".format(alphas[i]))
                    Ta = Ta.union(Set([p]))
        # Now we try the next prime p, until all alphas are satisfied
    if verbose:
        print("Primes for first test: {}".format(Ta))

    # Second: primes P such that g mod P is irreducible, for each quartic g with cubic resolvent f:
    L = K.extension(f,'b')
    quartics = A4_extensions_with_resolvent(K,S,L)
    Tb = Set()
    primes = primes_iter(K,None)
    quartic_flags = [False for _ in quartics]
    while sum(quartic_flags)<len(quartics):
        p = primes.next()
        while p.divides(N):
            p = primes.next()
        # Now p is a candidate test prime
        Fp = residue_field(p)
        for i,h in enumerate(quartics):
            if not quartic_flags[i]:
                quartic_flags[i] = h.change_ring(Fp).is_irreducible()
                if quartic_flags[i]:
                    Tb = Tb.union(Set([p]))
    if verbose:
        print("Primes for second test: {}".format(Tb))
    T = list(Ta.union(Tb))
    if verbose:
        print("complete set of primes: {}".format(T))
    return T
Пример #22
0
    def create_from_data_string(self, label_or_field, L):
        """Takes an input line L from a raw data file and constructs the
        associated HMF object with given base field.

        String sample:
        <[31, 31, w + 12], "a", [-3, -2, 2, 4, -4, ...]>,
        """
        data = self.dbdata = {}
        if isinstance(label_or_field, str):
            label = label_or_field
            data['field_label'] = label
            F = HilbertNumberField(label)
            if not F:
                raise ValueError("No Hilbert number field with label %s is in the database" % label)
        elif label_or_field == None:
            raise ValueError("Must specify a valid field label")
        else: # we were passed a HilbertNumberField already
            F = label_or_field
            data['field_label'] = F.label
        #print("data['field_label'] = %s" % data['field_label'])

        # The level

        i = L.find('[')
        j = L.find(']')
        data['level_ideal'] = L[i:j+1]
        #print("data['level_ideal'] = %s" % data['level_ideal'])
        N, n, alpha = data['level_ideal'][1:-1].split(',')
        data['level_norm'] = int(N)
        #print("data['level_norm'] = %s" % data['level_norm'])
        level = F.ideal_from_str(data['level_ideal'])[2]
        #print("level = %s" % level)
        data['level_label'] = F.ideal_label(level)
        #print("data['level_label'] = %s" % data['level_label'])

        # The weight

        data['parallel_weight'] = int(2)
        data['weight'] = str([data['parallel_weight']] * F.degree())
        weight = [2] * F.degree()

        # The label

        i = L.find('"')
        j = L.find('"', i+1)
        data['label_suffix'] = L[i+1:j].replace(" ","")

        data['label'] = construct_full_label(data['field_label'],
                                             weight,
                                             data['level_label'],
                                             data['label_suffix'])
        data['short_label'] = '-'.join([data['level_label'], data['label_suffix']])
        #print("data['label'] = %s" % data['label'] )
        #print("data['short_label'] = %s" % data['short_label'] )

        # The hecke polynomial and degree

        if 'x' in L:
            # non-rational
            i = L.find("x")
            j = L.find(i+1,",")
            data['hecke_polynomial'] = pol = L[i:j]
            data['dimension'] = int(1)
            x = polygen(QQ)
            hpol = x.parent()(str(pol))
            data['dimension'] = int(hpol.degree())
        else:
            # rational
            data['hecke_polynomial'] = 'x'
            data['dimension'] = int(1)

        i = L.rfind("[")
        j = L.rfind("]")
        data['hecke_eigenvalues'] = L[i+1:j].replace(" ","").split(",")
        data['hecke_eigenvalues'] = [unicode(s) for s in data['hecke_eigenvalues']]
        #print("hecke_eigenvalues = %s..." % data['hecke_eigenvalues'][:20])

        # Find (some of the) AL-eigenvalues

        BP = level.prime_factors()
        BP_indices = [F.prime_index(P) for P in BP]
        print("BP_indices = %s" % BP_indices)
        BP_exponents = [level.valuation(P) for P in BP]
        #print("BP_exponents = %s" % BP_exponents)
        AL_eigs = [int(data['hecke_eigenvalues'][k]) for k in BP_indices]
        #print("AL_eigs      = %s" % AL_eigs)
        if not all([(e==1 and eig in [-1,1]) or (eig==0)
                    for e,eig in zip(BP_exponents,AL_eigs)]):
            print("Some bad AL-eigenvalues found")
        # NB the following will put 0 for the eigenvalue for primes
        # whose quare divides the level; this will need fixing later.
        data['AL_eigenvalues'] = [[F.primes[k],data['hecke_eigenvalues'][k]] for k in BP_indices]

        data['is_CM'] = '?'
        data['is_base_change'] = '?'
Пример #23
0
def render_hmf_webpage(**args):
    C = getDBConnection()
    data = None
    if 'label' in args:
        label = str(args['label'])
        data = C.hmfs.forms.find_one({'label': label})
    if data is None:
        return "No such field"
    info = {}
    try:
        info['count'] = args['count']
    except KeyError:
        info['count'] = 10

    try:
        numeigs = request.args['numeigs']
        numeigs = int(numeigs)
    except:
        numeigs = 20

    hmf_field = C.hmfs.fields.find_one({'label': data['field_label']})
    nf = WebNumberField(data['field_label'])
    info['base_galois_group'] = nf.galois_string()
    info['field_degree'] = nf.degree()
    info['field_disc'] = str(nf.disc())
    info['field_poly'] = teXify_pol(str(nf.poly()))

    info.update(data)

    info['downloads'] = [('Download to Magma',
                          url_for(".render_hmf_webpage_download",
                                  field_label=info['field_label'],
                                  label=info['label'],
                                  download_type='magma')),
                         ('Download to Sage',
                          url_for(".render_hmf_webpage_download",
                                  field_label=info['field_label'],
                                  label=info['label'],
                                  download_type='sage'))]
    info['friends'] = []
    info['friends'] = [('L-function',
                        url_for("l_functions.l_function_hmf_page",
                                field=info['field_label'],
                                label=info['label'],
                                character='0',
                                number='0'))]

    # info['learnmore'] = [('Number Field labels',
    # url_for("render_labels_page")), ('Galois group
    # labels',url_for("render_groups_page")), ('Discriminant
    # ranges',url_for("render_discriminants_page"))]

    bread = [('Hilbert Modular Forms',
              url_for(".hilbert_modular_form_render_webpage")),
             ('%s' % data['label'], ' ')]

    t = "Hilbert Cusp Form %s" % info['label']
    credit = 'Lassina Dembele, Steve Donnelly and <A HREF="http://www.cems.uvm.edu/~voight/">John Voight</A>'

    forms_space = C.hmfs.forms.find({
        'field_label': data['field_label'],
        'level_ideal': data['level_ideal']
    })
    dim_space = 0
    for v in forms_space:
        dim_space += v['dimension']

    info['newspace_dimension'] = dim_space

    w = polygen(QQ, 'w')
    e = polygen(QQ, 'e')
    eigs = data['hecke_eigenvalues']
    eigs = eigs[:min(len(eigs), numeigs)]

    primes = hmf_field['primes']
    n = min(len(eigs), len(primes))
    info['eigs'] = [{
        'eigenvalue': teXify_pol(eigs[i]),
        'prime_ideal': teXify_pol(primes[i]),
        'prime_norm': primes[i][1:primes[i].index(',')]
    } for i in range(n)]

    try:
        display_eigs = request.args['display_eigs']
        if display_eigs in ['True', 'true', '1', 'yes']:
            display_eigs = True
        else:
            display_eigs = False
    except KeyError:
        display_eigs = False

    if 'numeigs' in request.args:
        display_eigs = True

    info['hecke_polynomial'] = teXify_pol(info['hecke_polynomial'])

    if 'AL_eigenvalues_fixed' in data:
        if data['AL_eigenvalues_fixed'] == 'done':
            info['AL_eigs'] = [{
                'eigenvalue': teXify_pol(al[1]),
                'prime_ideal': teXify_pol(al[0]),
                'prime_norm': al[0][1:al[0].index(',')]
            } for al in data['AL_eigenvalues']]
        else:
            info['AL_eigs'] = [{'eigenvalue': '?', 'prime_ideal': '?'}]
    else:
        info['AL_eigs'] = [{'eigenvalue': '?', 'prime_ideal': '?'}]
    info['AL_eigs_count'] = len(info['AL_eigs']) != 0

    if not display_eigs:
        for eig in info['eigs']:
            if len(eig['eigenvalue']) > 300:
                eig['eigenvalue'] = '...'
        for eig in info['AL_eigs']:
            if len(eig['eigenvalue']) > 300:
                eig['eigenvalue'] = '...'

    info['level_ideal'] = teXify_pol(info['level_ideal'])

    if 'is_CM' in data:
        is_CM = data['is_CM']
    else:
        is_CM = '?'
    info['is_CM'] = is_CM

    if 'is_base_change' in data:
        is_base_change = data['is_base_change']
    else:
        is_base_change = '?'
    info['is_base_change'] = is_base_change

    if 'q_expansions' in data:
        info['q_expansions'] = data['q_expansions']

    properties2 = [('Field', '%s' % data['field_label']),
                   ('Weight', '%s' % data['weight']),
                   ('Level Norm', '%s' % data['level_norm']),
                   ('Level', '$' + teXify_pol(data['level_ideal']) + '$'),
                   ('Label', '%s' % data['label_suffix']),
                   ('Dimension', '%s' % data['dimension']), ('CM?', is_CM),
                   ('Base Change?', is_base_change)]

    return render_template("hilbert_modular_form.html",
                           downloads=info["downloads"],
                           info=info,
                           properties2=properties2,
                           credit=credit,
                           title=t,
                           bread=bread,
                           friends=info['friends'])
Пример #24
0
def render_hmf_webpage(**args):
    C = getDBConnection()
    if 'data' in args:
        data = args['data']
        label = data['label']
    else:
        label = str(args['label'])
        data = C.hmfs.forms.find_one({'label': label})
    if data is None:
        return "No such form"
    info = {}
    try:
        info['count'] = args['count']
    except KeyError:
        info['count'] = 10

    try:
        numeigs = request.args['numeigs']
        numeigs = int(numeigs)
    except:
        numeigs = 20

    hmf_field = C.hmfs.fields.find_one({'label': data['field_label']})
    gen_name = findvar(hmf_field['ideals'])
    nf = WebNumberField(data['field_label'], gen_name=gen_name)
    info['field'] = nf
    info['base_galois_group'] = nf.galois_string()
    info['field_degree'] = nf.degree()
    info['field_disc'] = str(nf.disc())
    info['field_poly'] = teXify_pol(str(nf.poly()))

    info.update(data)

    info['downloads'] = [
        ('Download to Magma', url_for(".render_hmf_webpage_download", field_label=info['field_label'], label=info['label'], download_type='magma')),
        ('Download to Sage', url_for(".render_hmf_webpage_download", field_label=info['field_label'], label=info['label'], download_type='sage'))
        ]
    if hmf_field['narrow_class_no'] == 1:
        info['friends'] = [('L-function',
                            url_for("l_functions.l_function_hmf_page", field=info['field_label'], label=info['label'], character='0', number='0'))]
    else:
        info['friends'] = [('L-function not available', "")]
    if data['dimension'] == 1:   # Try to attach associated elliptic curve
        lab = split_class_label(info['label'])
        ec_from_hmf = db_ecnf().find_one({"label": label + '1'})
        if ec_from_hmf == None:
            info['friends'] += [('Elliptic curve not available', "")]
        else:
            info['friends'] += [('Isogeny class ' + info['label'], url_for("ecnf.show_ecnf_isoclass", nf=lab[0], conductor_label=lab[1], class_label=lab[2]))]

    bread = [('Hilbert Modular Forms', url_for(".hilbert_modular_form_render_webpage")), ('%s' % data[
                                                                                         'label'], ' ')]

    t = "Hilbert Cusp Form %s" % info['label']

    forms_space = C.hmfs.forms.find(
        {'field_label': data['field_label'], 'level_ideal': data['level_ideal']})
    dim_space = 0
    for v in forms_space:
        dim_space += v['dimension']

    info['newspace_dimension'] = dim_space

    w = polygen(QQ, 'w')
    e = polygen(QQ, 'e')
    eigs = data['hecke_eigenvalues']
    eigs = eigs[:min(len(eigs), numeigs)]

    primes = hmf_field['primes']
    n = min(len(eigs), len(primes))
    info['eigs'] = [{'eigenvalue': teXify_pol(eigs[i]),
                     'prime_ideal': teXify_pol(primes[i]),
                     'prime_norm': primes[i][1:primes[i].index(',')]} for i in range(n)]

    try:
        display_eigs = request.args['display_eigs']
        if display_eigs in ['True', 'true', '1', 'yes']:
            display_eigs = True
        else:
            display_eigs = False
    except KeyError:
        display_eigs = False

    if 'numeigs' in request.args:
        display_eigs = True

    info['hecke_polynomial'] = teXify_pol(info['hecke_polynomial'])

    if 'AL_eigenvalues_fixed' in data:
        if data['AL_eigenvalues_fixed'] == 'done':
            info['AL_eigs'] = [{'eigenvalue': teXify_pol(al[1]),
                                'prime_ideal': teXify_pol(al[0]),
                                'prime_norm': al[0][1:al[0].index(',')]} for al in data['AL_eigenvalues']]
        else:
            info['AL_eigs'] = [{'eigenvalue': '?', 'prime_ideal': '?'}]
    else:
        info['AL_eigs'] = [{'eigenvalue': '?', 'prime_ideal': '?'}]
    info['AL_eigs_count'] = len(info['AL_eigs']) != 0

    max_eig_len = max([len(eig['eigenvalue']) for eig in info['eigs']])
    display_eigs = display_eigs or (max_eig_len<=300)
    if not display_eigs:
        for eig in info['eigs']:
            if len(eig['eigenvalue']) > 300:
                eig['eigenvalue'] = '...'
        for eig in info['AL_eigs']:
            if len(eig['eigenvalue']) > 300:
                eig['eigenvalue'] = '...'

    info['level_ideal'] = teXify_pol(info['level_ideal'])

    if 'is_CM' in data:
        is_CM = data['is_CM']
    else:
        is_CM = '?'
    info['is_CM'] = is_CM

    if 'is_base_change' in data:
        is_base_change = data['is_base_change']
    else:
        is_base_change = '?'
    info['is_base_change'] = is_base_change

    if 'q_expansions' in data:
        info['q_expansions'] = data['q_expansions']

    properties2 = [('Base field', '%s' % info['field'].field_pretty()),
                   ('Weight', '%s' % data['weight']),
                   ('Level norm', '%s' % data['level_norm']),
                   ('Level', '$' + teXify_pol(data['level_ideal']) + '$'),
                   ('Label', '%s' % data['label_suffix']),
                   ('Dimension', '%s' % data['dimension']),
                   ('CM', is_CM),
                   ('Base change', is_base_change)
                   ]

    return render_template("hilbert_modular_form.html", downloads=info["downloads"], info=info, properties2=properties2, credit=hmf_credit, title=t, bread=bread, friends=info['friends'], learnmore=learnmore_list())
Пример #25
0
    def create_from_data_string(self, label_or_field, L):
        """Takes an input line L from a raw data file and constructs the
        associated HMF object with given base field.

        String sample:
        <[31, 31, w + 12], "a", [-3, -2, 2, 4, -4, ...]>,
        """
        data = self.dbdata = {}
        if isinstance(label_or_field, str):
            label = label_or_field
            data['field_label'] = label
            F = HilbertNumberField(label)
            if not F:
                raise ValueError(
                    "No Hilbert number field with label %s is in the database"
                    % label)
        elif label_or_field is None:
            raise ValueError("Must specify a valid field label")
        else:  # we were passed a HilbertNumberField already
            F = label_or_field
            data['field_label'] = F.label
        #print("data['field_label'] = %s" % data['field_label'])

        # The level

        i = L.find('[')
        j = L.find(']')
        data['level_ideal'] = L[i:j + 1]
        #print("data['level_ideal'] = %s" % data['level_ideal'])
        N, n, alpha = data['level_ideal'][1:-1].split(',')
        data['level_norm'] = int(N)
        #print("data['level_norm'] = %s" % data['level_norm'])
        level = F.ideal_from_str(data['level_ideal'])[2]
        #print("level = %s" % level)
        data['level_label'] = F.ideal_label(level)
        #print("data['level_label'] = %s" % data['level_label'])

        # The weight

        data['parallel_weight'] = int(2)
        data['weight'] = str([data['parallel_weight']] * F.degree())
        weight = [2] * F.degree()

        # The label

        i = L.find('"')
        j = L.find('"', i + 1)
        data['label_suffix'] = L[i + 1:j].replace(" ", "")

        data['label'] = construct_full_label(data['field_label'], weight,
                                             data['level_label'],
                                             data['label_suffix'])
        data['short_label'] = '-'.join(
            [data['level_label'], data['label_suffix']])
        #print("data['label'] = %s" % data['label'] )
        #print("data['short_label'] = %s" % data['short_label'] )

        # The hecke polynomial and degree

        if 'x' in L:
            # non-rational
            i = L.find("x")
            j = L.find(i + 1, ",")
            data['hecke_polynomial'] = pol = L[i:j]
            data['dimension'] = int(1)
            x = polygen(QQ)
            hpol = x.parent()(str(pol))
            data['dimension'] = int(hpol.degree())
        else:
            # rational
            data['hecke_polynomial'] = 'x'
            data['dimension'] = int(1)

        i = L.rfind("[")
        j = L.rfind("]")
        data['hecke_eigenvalues'] = L[i + 1:j].replace(" ", "").split(",")
        data['hecke_eigenvalues'] = [
            text_type(s) for s in data['hecke_eigenvalues']
        ]
        #print("hecke_eigenvalues = %s..." % data['hecke_eigenvalues'][:20])

        # Find (some of the) AL-eigenvalues

        BP = level.prime_factors()
        BP_indices = [F.prime_index(P) for P in BP]
        print("BP_indices = %s" % BP_indices)
        BP_exponents = [level.valuation(P) for P in BP]
        #print("BP_exponents = %s" % BP_exponents)
        AL_eigs = [int(data['hecke_eigenvalues'][k]) for k in BP_indices]
        #print("AL_eigs      = %s" % AL_eigs)
        if not all([(e == 1 and eig in [-1, 1]) or (eig == 0)
                    for e, eig in zip(BP_exponents, AL_eigs)]):
            print("Some bad AL-eigenvalues found")
        # NB the following will put 0 for the eigenvalue for primes
        # whose quare divides the level; this will need fixing later.
        data['AL_eigenvalues'] = [[F.primes[k], data['hecke_eigenvalues'][k]]
                                  for k in BP_indices]

        data['is_CM'] = '?'
        data['is_base_change'] = '?'
Пример #26
0
def render_hmf_webpage(**args):
    C = getDBConnection()
    data = None
    if "label" in args:
        label = str(args["label"])
        data = C.hmfs.forms.find_one({"label": label})
    if data is None:
        return "No such field"
    info = {}
    try:
        info["count"] = args["count"]
    except KeyError:
        info["count"] = 10

    try:
        numeigs = request.args["numeigs"]
        numeigs = int(numeigs)
    except:
        numeigs = 20

    hmf_field = C.hmfs.fields.find_one({"label": data["field_label"]})
    nf = WebNumberField(data["field_label"])
    info["base_galois_group"] = nf.galois_string()
    info["field_degree"] = nf.degree()
    info["field_disc"] = str(nf.disc())
    info["field_poly"] = teXify_pol(str(nf.poly()))

    info.update(data)

    info["downloads"] = [
        (
            "Download to Magma",
            url_for(
                ".render_hmf_webpage_download",
                field_label=info["field_label"],
                label=info["label"],
                download_type="magma",
            ),
        ),
        (
            "Download to Sage",
            url_for(
                ".render_hmf_webpage_download",
                field_label=info["field_label"],
                label=info["label"],
                download_type="sage",
            ),
        ),
    ]
    info["friends"] = []
    info["friends"] = [
        (
            "L-function",
            url_for(
                "l_functions.l_function_hmf_page",
                field=info["field_label"],
                label=info["label"],
                character="0",
                number="0",
            ),
        )
    ]

    # info['learnmore'] = [('Number Field labels',
    # url_for("render_labels_page")), ('Galois group
    # labels',url_for("render_groups_page")), ('Discriminant
    # ranges',url_for("render_discriminants_page"))]

    bread = [("Hilbert Modular Forms", url_for(".hilbert_modular_form_render_webpage")), ("%s" % data["label"], " ")]

    t = "Hilbert Cusp Form %s" % info["label"]
    credit = 'Lassina Dembele, Steve Donnelly and <A HREF="http://www.cems.uvm.edu/~voight/">John Voight</A>'

    forms_space = C.hmfs.forms.find({"field_label": data["field_label"], "level_ideal": data["level_ideal"]})
    dim_space = 0
    for v in forms_space:
        dim_space += v["dimension"]

    info["newspace_dimension"] = dim_space

    w = polygen(QQ, "w")
    e = polygen(QQ, "e")
    eigs = data["hecke_eigenvalues"]
    eigs = eigs[: min(len(eigs), numeigs)]

    primes = hmf_field["primes"]
    n = min(len(eigs), len(primes))
    info["eigs"] = [
        {
            "eigenvalue": teXify_pol(eigs[i]),
            "prime_ideal": teXify_pol(primes[i]),
            "prime_norm": primes[i][1 : primes[i].index(",")],
        }
        for i in range(n)
    ]

    try:
        display_eigs = request.args["display_eigs"]
        if display_eigs in ["True", "true", "1", "yes"]:
            display_eigs = True
        else:
            display_eigs = False
    except KeyError:
        display_eigs = False

    if "numeigs" in request.args:
        display_eigs = True

    info["hecke_polynomial"] = teXify_pol(info["hecke_polynomial"])

    if "AL_eigenvalues_fixed" in data:
        if data["AL_eigenvalues_fixed"] == "done":
            info["AL_eigs"] = [
                {
                    "eigenvalue": teXify_pol(al[1]),
                    "prime_ideal": teXify_pol(al[0]),
                    "prime_norm": al[0][1 : al[0].index(",")],
                }
                for al in data["AL_eigenvalues"]
            ]
        else:
            info["AL_eigs"] = [{"eigenvalue": "?", "prime_ideal": "?"}]
    else:
        info["AL_eigs"] = [{"eigenvalue": "?", "prime_ideal": "?"}]
    info["AL_eigs_count"] = len(info["AL_eigs"]) != 0

    if not display_eigs:
        for eig in info["eigs"]:
            if len(eig["eigenvalue"]) > 300:
                eig["eigenvalue"] = "..."
        for eig in info["AL_eigs"]:
            if len(eig["eigenvalue"]) > 300:
                eig["eigenvalue"] = "..."

    info["level_ideal"] = teXify_pol(info["level_ideal"])

    if "is_CM" in data:
        is_CM = data["is_CM"]
    else:
        is_CM = "?"
    info["is_CM"] = is_CM

    if "is_base_change" in data:
        is_base_change = data["is_base_change"]
    else:
        is_base_change = "?"
    info["is_base_change"] = is_base_change

    if "q_expansions" in data:
        info["q_expansions"] = data["q_expansions"]

    properties2 = [
        ("Field", "%s" % data["field_label"]),
        ("Weight", "%s" % data["weight"]),
        ("Level Norm", "%s" % data["level_norm"]),
        ("Level", "$" + teXify_pol(data["level_ideal"]) + "$"),
        ("Label", "%s" % data["label_suffix"]),
        ("Dimension", "%s" % data["dimension"]),
        ("CM", is_CM),
        ("Base Change", is_base_change),
    ]

    return render_template(
        "hilbert_modular_form.html",
        downloads=info["downloads"],
        info=info,
        properties2=properties2,
        credit=credit,
        title=t,
        bread=bread,
        friends=info["friends"],
    )
Пример #27
0
def session():
    from sqlalchemy.orm import sessionmaker
    Session = sessionmaker(bind=engine)
    return Session()

########################################################
# Convenience functions to use the database
########################################################
from sage.all import (QQ, ZZ, NumberField, polygen, dumps, gcd, parallel, divisors,
                      cartesian_product_iterator)
from sage.rings.all import is_Ideal
from psage.modform.hilbert.sqrt5.hmf import primes_of_bounded_norm
from psage.number_fields.sqrt5.prime import Prime

x = polygen(QQ, 'x')
F = NumberField(x**2 - x - 1, 'a')
a = F.gen()

def ideal_to_tuple(N):
    v = N.free_module().echelonized_basis_matrix().list()
    return int(v[0]), int(v[1]), int(v[3])

def tuple_to_ideal(t):
    return F.ideal([t[0] + a*t[1], t[2] + a*t[2]])

def fast_ideal(P):
    return Prime(P) if is_Ideal(P) else P
    
def store_space(s, H):
    """
Пример #28
0
def render_hmf_webpage(**args):
    C = getDBConnection()
    data = None
    if 'label' in args:
        label = str(args['label'])
        data = C.hmfs.forms.find_one({'label': label})
    if data is None:
        return "No such field"
    info = {}
    try:
        info['count'] = args['count']
    except KeyError:
        info['count'] = 10

    try:
        numeigs = request.args['numeigs']
        numeigs = int(numeigs)
    except:
        numeigs = 20

    hmf_field = C.hmfs.fields.find_one({'label': data['field_label']})
    nf = WebNumberField(data['field_label'])
    info['base_galois_group'] = nf.galois_string()
    info['field_degree'] = nf.degree()
    info['field_disc'] = str(nf.disc())
    info['field_poly'] = teXify_pol(str(nf.poly()))

    info.update(data)

    downloadslabel = '/ModularForm/GL2/' + info['field_label'] + '/holomorphic/' + info['label']
    info['downloads'] = [('Download to Magma', downloadslabel + '/download/magma'), (
        'Download to Sage', downloadslabel + '/download/sage')]
    info['friends'] = []
    info['friends'] = [('L-function', '/L/ModularForm/GL2/' + data['field_label'] + '/holomorphic/' +
                        info['label'] + '/0/0')]
# info['learnmore'] = [('Number Field labels',
# url_for("render_labels_page")), ('Galois group
# labels',url_for("render_groups_page")), ('Discriminant
# ranges',url_for("render_discriminants_page"))]
    bread = [('Hilbert Modular Forms', url_for("hilbert_modular_form_render_webpage")), ('%s' % data[
                                                                                         'label'], ' ')]

    t = "Hilbert Cusp Form %s" % info['label']
    credit = 'Lassina Dembele, Steve Donnelly and <A HREF="http://www.cems.uvm.edu/~voight/">John Voight</A>'

    forms_space = C.hmfs.forms.find(
        {'field_label': data['field_label'], 'level_ideal': data['level_ideal']})
    dim_space = 0
    for v in forms_space:
        dim_space += v['dimension']

    info['newspace_dimension'] = dim_space

    w = polygen(QQ, 'w')
    e = polygen(QQ, 'e')
    eigs = data['hecke_eigenvalues']
    eigs = eigs[:min(len(eigs), numeigs)]

    primes = hmf_field['primes']
    n = min(len(eigs), len(primes))
    info['eigs'] = [{'eigenvalue': teXify_pol(eigs[i]),
                     'prime_ideal': teXify_pol(primes[i]),
                     'prime_norm': primes[i][1:primes[i].index(',')]} for i in range(n)]

    try:
        display_eigs = request.args['display_eigs']
        if display_eigs in ['True', 'true', '1', 'yes']:
            display_eigs = True
        else:
            display_eigs = False
    except KeyError:
        display_eigs = False

    if 'numeigs' in request.args:
        display_eigs = True

    info['hecke_polynomial'] = teXify_pol(info['hecke_polynomial'])

    if 'AL_eigenvalues_fixed' in data:
        if data['AL_eigenvalues_fixed'] == 'done':
            info['AL_eigs'] = [{'eigenvalue': teXify_pol(al[1]),
                                'prime_ideal': teXify_pol(al[0]),
                                'prime_norm': al[0][1:al[0].index(',')]} for al in data['AL_eigenvalues']]
        else:
            info['AL_eigs'] = [{'eigenvalue': '?', 'prime_ideal': '?'}]
    else:
        info['AL_eigs'] = [{'eigenvalue': '?', 'prime_ideal': '?'}]
    info['AL_eigs_count'] = len(info['AL_eigs']) != 0

    if not display_eigs:
        for eig in info['eigs']:
            if len(eig['eigenvalue']) > 300:
                eig['eigenvalue'] = '...'
        for eig in info['AL_eigs']:
            if len(eig['eigenvalue']) > 300:
                eig['eigenvalue'] = '...'

    info['level_ideal'] = teXify_pol(info['level_ideal'])

    if 'is_CM' in data:
        is_CM = data['is_CM']
    else:
        is_CM = '?'
    info['is_CM'] = is_CM

    if 'is_base_change' in data:
        is_base_change = data['is_base_change']
    else:
        is_base_change = '?'
    info['is_base_change'] = is_base_change

    if 'q_expansions' in data:
        info['q_expansions'] = data['q_expansions']

    properties2 = [('Field', '%s' % data['field_label']),
                   ('Weight', '%s' % data['weight']),
                   ('Level Norm', '%s' % data['level_norm']),
                   ('Level', '$' + teXify_pol(data['level_ideal']) + '$'),
                   ('Label', '%s' % data['label_suffix']),
                   ('Dimension', '%s' % data['dimension']),
                   ('CM?', is_CM),
                   ('Base Change?', is_base_change)
                   ]

    return render_template("hilbert_modular_form/hilbert_modular_form.html", downloads=info["downloads"], info=info, properties2=properties2, credit=credit, title=t, bread=bread, friends=info['friends'])