def _should_be_ignored(name, base_name): if isinstance(base_name, str): base_ob = ip.ev(preparse(base_name)) if any((isinstance(base_ob, cls) for cls in ignore_classes)): return None else: base_ob = None name_ob = ip.ev(preparse(name)) if any((isinstance(name_ob, cls) for cls in ignore_classes)): return None else: return True
def _sage_getdef(name, base_name=None): try: if _is_safe_str(name) and (_should_be_ignored(name, base_name) is not None): gd_name = "sage.misc.sageinspect.sage_getdef" name_ob = ip.ev(preparse(name)) if inspect.isclass(name_ob): df = ip.ev("%s(%s.__init__)" % (gd_name, name)) else: df = ip.ev("%s(%s)" % (gd_name, preparse(name))) return df except NameError: pass
def all_attributes(compl_dct): varname = compl_dct["var-base-name"] try: regexp = re.compile("^[ a-zA-Z0-9._\\[\\]]+$") if regexp.match(varname) is None: return [] if varname in interfaces: ls = ip.ev('dir(%s)' % (varname, )) else: ls = _completions_attributes(preparse(varname)) ls.extend(ip.ev('dir(%s)' % (preparse(varname), ))) ls = list(sorted(uniq(ls))) return ls except: return []
def all_attributes(compl_dct): varname = compl_dct["var-base-name"] try: regexp = re.compile("^[ a-zA-Z0-9._\\[\\]]+$") if regexp.match(varname) is None: return [] if varname in interfaces: ls = ip.ev('dir(%s)' % (varname,)) else: ls = _completions_attributes(preparse(varname)) ls.extend(ip.ev('dir(%s)' % (preparse(varname),))) ls = list(sorted(uniq(ls))) return ls except: return []
def get_number_field_integral_basis(c_string): r"""Get the integral basis for the field specified by the string. INPUT: c_string -- string, a string of comma-separated coefficients with no spaces: the coefficients of the normalized (using gp.polredabs) defining polynomial OUTPUT: fld_bool -- bool, True if the number field has a page in the LMFDB, False otherwise K_new -- number field, the number field with defining polynomial that is the normalized version (given by gp.polredabs) of the one with coefficients specified by c_string a -- number field element, generator for K_new the integral basis for K_new recorded on its LMFDB page """ C = getDBconnection() c_hash = field_coeffs_string_to_hash(c_string) field = C.numberfields.fields.find_one({'coeffhash': c_hash}) fld_bool = True try: field['degree'] except TypeError: fld_bool = False if fld_bool: field_str = field['coeffs'] int_basis_str = field['zk'] poly = coeffs_to_poly(field_str) K_new = NumberField(poly, names=('a', )) (a, ) = K_new._first_ngens(1) return fld_bool, K_new, a, [ K_new(eval(preparse(el))) for el in int_basis_str ] else: # could add polynomial to list of number fields missing from LMFDB here return fld_bool, None, None, None
def get_number_field_integral_basis(c_string): r"""Get the integral basis for the field specified by the string. INPUT: c_string -- string, a string of comma-separated coefficients with no spaces: the coefficients of the normalized (using gp.polredabs) defining polynomial OUTPUT: fld_bool -- bool, True if the number field has a page in the LMFDB, False otherwise K_new -- number field, the number field with defining polynomial that is the normalized version (given by gp.polredabs) of the one with coefficients specified by c_string a -- number field element, generator for K_new the integral basis for K_new recorded on its LMFDB page """ C = getDBconnection() c_hash = field_coeffs_string_to_hash(c_string) field = C.numberfields.fields.find_one({'coeffhash':c_hash}) fld_bool = True try: field['degree'] except TypeError: fld_bool = False if fld_bool: field_str = field['coeffs'] int_basis_str = field['zk'] poly = coeffs_to_poly(field_str) K_new = NumberField(poly, names=('a',)) (a,) = K_new._first_ngens(1) return fld_bool, K_new, a, [K_new(eval(preparse(el))) for el in int_basis_str] else: # could add polynomial to list of number fields missing from LMFDB here return fld_bool, None, None, None
def evaluate(input): if not E.is_started(): E.execute('from sage.all import *') from sage.all import preparse E.execute(preparse(input)) n = 0 while True: status = E.output_status() if len(status.output) > n: yield status.output[n:-1].lstrip() n = len(status.output) if status.done: return time.sleep(0.2)
def short_doc(name, base_name=None): ''' If name or base_name is an instance of one of ignore_classes, then this function returns None. ''' sd_name = "sage.misc.sageinspect.sage_getdoc" if _is_safe_str(name) and (_should_be_ignored(name, base_name) is not None): dc = ip.ev("%s(%s)" % (sd_name, preparse(name))) m = _doc_delim_regexp.search(dc) if m is not None: res = dc[:m.start()] else: res = dc return res.strip()
def get_hmfs_hecke_field_and_eigenvals(label): """Get the Hecke field and eigenvalues for the Hilbert modular form with given label. INPUT: label -- string, the label of the Hilbert modular form OUTPUT: K_old -- number field, the field containing the Hecke eigenvalues e -- number field element, a generator for K_old over QQ eigenvals -- list, a list of the Hecke eigenvalues """ C = getDBconnection() # Should I use find_one, or something else? R = PolynomialRing(QQ, names=('x')) form = C.hmfs.forms.find_one({'label': label}) poly = R(str(form['hecke_polynomial'])) K_old = NumberField(poly, names=('e', )) (e, ) = K_old._first_ngens(1) eigenvals_str = form['hecke_eigenvalues'] eigenvals = [K_old(eval(preparse(el))) for el in eigenvals_str] return K_old, e, eigenvals
def get_hmfs_hecke_field_and_eigenvals(label): """Get the Hecke field and eigenvalues for the Hilbert modular form with given label. INPUT: label -- string, the label of the Hilbert modular form OUTPUT: K_old -- number field, the field containing the Hecke eigenvalues e -- number field element, a generator for K_old over QQ eigenvals -- list, a list of the Hecke eigenvalues """ C = getDBconnection() # Should I use find_one, or something else? R = PolynomialRing(QQ,names=('x')) form = C.hmfs.forms.find_one({'label':label}) poly = R(str(form['hecke_polynomial'])) K_old = NumberField(poly, names=('e',)) (e,) = K_old._first_ngens(1) eigenvals_str = form['hecke_eigenvalues'] eigenvals = [K_old(eval(preparse(el))) for el in eigenvals_str] return K_old, e, eigenvals
def all_attributes(compl_dct): varname = compl_dct["var-base-name"] try: regexp = re.compile("^[ a-zA-Z0-9._\\[\\]]+$") if regexp.match(varname) is None: return [] var = ip.ev(preparse(varname)) if varname in interfaces: ls = ip.ev('dir(%s)' % (varname)) elif hasattr(var, 'trait_names'): try: ls = var.trait_names(verbose=False) + dir(var) except TypeError: ls = var.trait_names() + dir(var) except: ls = dir(var) else: ls = dir(var) return ls except: return []
def evaluate(input): from sage.all import preparse try: return [execute_code(preparse(input), G)[0]] except Exception, msg: return "Error: '%s'"%msg
def import_data(hmf_filename, fileprefix=None, ferrors=None, test=True): if fileprefix==None: fileprefix="." hmff = file(os.path.join(fileprefix,hmf_filename)) if ferrors==None: if Dan_test: ferrors = file('/Users/d_yasaki/repos/lmfdb/lmfdb/scripts/hmf/fixing-permuted-primes/import_data.err', 'a') else: ferrors = file('/home/jvoight/lmfdb/backups/import_data.err', 'a') # Parse field data v = hmff.readline() assert v[:9] == 'COEFFS :=' coeffs = eval(v[10:][:-2]) v = hmff.readline() assert v[:4] == 'n :=' n = int(v[4:][:-2]) v = hmff.readline() assert v[:4] == 'd :=' d = int(v[4:][:-2]) magma.eval('F<w> := NumberField(Polynomial(' + str(coeffs) + '));') magma.eval('ZF := Integers(F);') # Find the corresponding field in the database of number fields dkey = make_disc_key(ZZ(d))[1] sig = "%s,%s" % (n,0) print("Finding field with signature %s and disc_key %s ..." % (sig,dkey)) fields_matching = fields.find({"disc_abs_key": dkey, "signature": sig}) cnt = fields_matching.count() print("Found %s fields" % cnt) assert cnt >= 1 field_label = None co = str(coeffs)[1:-1].replace(" ","") for i in range(cnt): nf = fields_matching.next() print("Comparing coeffs %s with %s" % (nf['coeffs'], co)) if nf['coeffs'] == co: field_label = nf['label'] assert field_label is not None print "...found!" # Find the field in the HMF database print("Finding field %s in HMF..." % field_label) F_hmf = hmf_fields.find_one({"label": field_label}) if Dan_test: assert F_hmf is not None # Assuming the hmf field is already there! if F_hmf is None: # Create list of ideals print "...adding!" ideals = eval(preparse(magma.eval('nice_idealstr(F);'))) ideals_str = [str(c) for c in ideals] if test: print("Would now insert data for %s into hmf_fields" % field_label) else: hmf_fields.insert_one({"label": field_label, "degree": n, "discriminant": d, "ideals": ideals_str}) F_hmf = hmf_fields.find_one({"label": field_label}) else: print "...found!" print "Computing ideals..." ideals_str = F_hmf['ideals'] ideals = [eval(preparse(c)) for c in ideals_str] ideals_norms = [c[0] for c in ideals] magma.eval('ideals_str := [' + ''.join(F_hmf['ideals']).replace('][', '], [') + ']') magma.eval('ideals := [ideal<ZF | {F!x : x in I}> : I in ideals_str];') # Add the list of primes print "Computing primes..." v = hmff.readline() # Skip line v = hmff.readline() assert v[:9] == 'PRIMES :=' primes_str = v[10:][:-2] primes_array = [str(t) for t in eval(preparse(primes_str))] magma.eval('primes_array := ' + primes_str) magma.eval('primes := [ideal<ZF | {F!x : x in I}> : I in primes_array];') magma.eval('primes_indices := [Index(ideals, pp) : pp in primes];') try: assert magma('&and[primes_indices[j] gt primes_indices[j-1] : j in [2..#primes_indices]]') resort = False except AssertionError: print "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! Primes reordered!" resort = True magma.eval('_, sigma := Sort(primes_indices, func<x,y | x-y>);') magma.eval('perm := [[xx : xx in x] : x in CycleDecomposition(sigma) | #x gt 1]') # Check at least they have the same norm magma.eval('for tau in perm do assert #{Norm(ideals[primes_indices[t]]) : t in tau} eq 1; end for;') primes_resort = eval(magma.eval('Eltseq(sigma)')) primes_resort = [c - 1 for c in primes_resort] primes_indices = eval(magma.eval('primes_indices')) primes_str = [ideals_str[j - 1] for j in primes_indices] assert len(primes_array) == len(primes_str) print "...comparing..." for i in range(len(primes_array)): assert magma('ideal<ZF | {F!x : x in ' + primes_array[i] + '}> eq ' + 'ideal<ZF | {F!x : x in ' + primes_str[i] + '}>;') if resort: # Important also to resort the list of primes themselves! # not just the a_pp's primes_str = [primes_str[i] for i in primes_resort] if Dan_test: assert 'primes' in F_hmf # DY: want to make sure the fields are not touched! if 'primes' in F_hmf: # Nothing smart: make sure it is the same assert F_hmf['primes'] == primes_str else: F_hmf['primes'] = primes_str if test: print("Would now save primes string %s... into hmf_fields" % primes_str[:100]) else: hmf_fields.replace_one(F_hmf) print "...saved!" # Collect levels v = hmff.readline() if v[:9] == 'LEVELS :=': # Skip this line since we do not use the list of levels v = hmff.readline() for i in range(3): if v[:11] != 'NEWFORMS :=': v = hmff.readline() else: break # Finally, newforms! print "Starting newforms!" while v != '': v = hmff.readline()[1:-3] if len(v) == 0: break data = eval(preparse(v)) level_ideal = data[0] level_norm = data[0][0] label_suffix = fix_one_label(data[1]) weight = [2 for i in range(n)] label_nsuffix = class_to_int(label_suffix) level_ind = int(magma('Index(ideals, ideal<ZF | {F!x : x in ' + str(level_ideal) + '}>)') ) - 1 # Magma counts starting at 1 level_ideal = ideals_str[level_ind] assert magma('ideal<ZF | {F!x : x in ' + str(level_ideal) + '}> eq ' + 'ideal<ZF | {F!x : x in ' + str(data[0]) + '}>;') level_dotlabel = level_ind - ideals_norms.index(level_norm) + 1 # Start counting at 1 assert level_dotlabel > 0 level_label = str(level_norm) + '.' + str(level_dotlabel) label = construct_full_label(field_label, weight, level_label, label_suffix) short_label = level_label + '-' + label_suffix if len(data) == 3: hecke_polynomial = x hecke_eigenvalues = data[2] else: hecke_polynomial = data[2] hecke_eigenvalues = data[3] if resort: hecke_eigenvalues = [hecke_eigenvalues[i] for i in primes_resort] # Constrain eigenvalues to size 2MB hecke_eigenvalues = [str(c) for c in hecke_eigenvalues] leftout = 0 while sum([len(s) for s in hecke_eigenvalues]) > 2000000: hecke_eigenvalues = hecke_eigenvalues[:-1] leftout += 1 # commented code below throws an error. use above. # just be safe and remove one eigenvalue at a time. # Aurel's code will adjust and remove extra when needed. #q = primes_resort[len(hecke_eigenvalues)] #while primes_resort[len(hecke_eigenvalues)] == q: # # Remove all with same norm # leftout += 1 # hecke_eigenvalues = hecke_eigenvalues[:-1] if leftout > 0: print "Left out", leftout info = {"label": label, "short_label": short_label, "field_label": field_label, "level_norm": int(level_norm), "level_ideal": str(level_ideal), "level_label": level_label, "weight": str(weight), "label_suffix": label_suffix, "label_nsuffix" : label_nsuffix, "dimension": hecke_polynomial.degree(), "hecke_polynomial": str(hecke_polynomial), "hecke_eigenvalues": hecke_eigenvalues} # DY: don't deal with AL right now. #, #"AL_eigenvalues": [[str(a[0]), str(a[1])] for a in AL_eigenvalues]} print info['label'] existing_forms = hmf_forms.find({"label": label}) assert existing_forms.count() <= 1 if existing_forms.count() == 0: if test: print("Would now insert form data %s into hmf_forms" % info) else: hmf_forms.insert_one(info) else: existing_form = existing_forms.next() assert info['hecke_polynomial'] == existing_form['hecke_polynomial'] try: assert info['hecke_eigenvalues'] == existing_form['hecke_eigenvalues'] print "...duplicate" except AssertionError: print "...Hecke eigenvalues do not match! Checking for permutation" assert set(info['hecke_eigenvalues'] + ['0','1','-1']) == set(existing_form['hecke_eigenvalues'] + [u'0',u'1',u'-1']) # Add 0,1,-1 to allow for Atkin-Lehner eigenvalues, if not computed print "As sets, ignoring 0,1,-1, the eigenvalues match!" if test: print("Would now replace permuted form data %s with %s" % (existing_form, info)) else: existing_form['hecke_eigenvalues'] = info['hecke_eigenvalues'] hmf_forms.save(existing_form)