def higher_genus_w_automorphisms_search(info, query): if info.get('signature'): #allow for ; in signature info['signature'] = info['signature'].replace(';',',') parse_bracketed_posints(info,query,'signature',split=False,name='Signature',keepbrackets=True) if query.get('signature'): query['signature'] = info['signature'] = str(sort_sign(ast.literal_eval(query['signature']))).replace(' ','') parse_gap_id(info,query,'group',name='Group',qfield='group') parse_ints(info,query,'genus',name='Genus') parse_ints(info,query,'dim',name='Dimension of the family') if 'inc_hyper' in info: if info['inc_hyper'] == 'exclude': query['hyperelliptic'] = False elif info['inc_hyper'] == 'only': query['hyperelliptic'] = True if 'inc_cyc_trig' in info: if info['inc_cyc_trig'] == 'exclude': query['cyclic_trigonal'] = False elif info['inc_cyc_trig'] == 'only': query['cyclic_trigonal'] = True if 'inc_full' in info: if info['inc_full'] == 'exclude': query['full_auto'] = {'$exists': True} elif info['inc_full'] == 'only': query['full_auto'] = {'$exists': False} query['cc.1'] = 1 if info.get('groupsize'): err, result = add_group_order_range(query, info['groupsize']) if err is not None: flash_error('Parse error on group order field. <font face="Courier New"><br />Given: ' + err + '<br />-------' + result + '</font>') info['group_display'] = sg_pretty info['sign_display'] = sign_display
def elliptic_curve_search(info, query): parse_rational(info,query,'jinv','j-invariant') parse_ints(info,query,'conductor') parse_ints(info,query,'torsion','torsion order') parse_ints(info,query,'rank') parse_ints(info,query,'sha','analytic order of Ш') parse_bracketed_posints(info,query,'torsion_structure',maxlength=2,check_divisibility='increasing') # speed up slow torsion_structure searches by also setting torsion #if 'torsion_structure' in query and not 'torsion' in query: # query['torsion'] = reduce(mul,[int(n) for n in query['torsion_structure']],1) if 'include_cm' in info: if info['include_cm'] == 'exclude': query['cm'] = 0 elif info['include_cm'] == 'only': query['cm'] = {'$ne' : 0} parse_element_of(info,query,field='isodeg',qfield='isogeny_degrees',split_interval=1000) #parse_ints(info,query,field='isodeg',qfield='isogeny_degrees') parse_primes(info, query, 'surj_primes', name='maximal primes', qfield='nonmax_primes', mode='complement') if info.get('surj_quantifier') == 'exactly': mode = 'exact' else: mode = 'append' parse_primes(info, query, 'nonsurj_primes', name='non-maximal primes', qfield='nonmax_primes',mode=mode, radical='nonmax_rad') if 'optimal' in info and info['optimal'] == 'on': # fails on 990h3 query['number'] = 1 info['curve_url'] = lambda dbc: url_for(".by_triple_label", conductor=dbc['conductor'], iso_label=split_lmfdb_label(dbc['lmfdb_iso'])[1], number=dbc['lmfdb_number']) info['iso_url'] = lambda dbc: url_for(".by_double_iso_label", conductor=dbc['conductor'], iso_label=split_lmfdb_label(dbc['lmfdb_iso'])[1])
def genus2_curve_search(info, query): info["st_group_list"] = st_group_list info["st_group_dict"] = st_group_dict info["real_geom_end_alg_list"] = real_geom_end_alg_list info["real_geom_end_alg_to_ST0_dict"] = real_geom_end_alg_to_ST0_dict info["aut_grp_list"] = aut_grp_list info["aut_grp_dict"] = aut_grp_dict info["geom_aut_grp_list"] = geom_aut_grp_list info["geom_aut_grp_dict"] = geom_aut_grp_dict parse_ints(info,query,'abs_disc','absolute discriminant') parse_bool(info,query,'is_gl2_type','is of GL2-type') parse_bool(info,query,'has_square_sha','has square Sha') parse_bool(info,query,'locally_solvable','is locally solvable') parse_bool(info,query,'is_simple_geom','is geometrically simple') parse_ints(info,query,'cond','conductor') parse_ints(info,query,'num_rat_pts','rational points') parse_ints(info,query,'num_rat_wpts','rational Weierstrass points') parse_bracketed_posints(info, query, 'torsion', 'torsion structure', maxlength=4,check_divisibility="increasing") parse_ints(info,query,'torsion_order','torsion order') if 'torsion' in query and not 'torsion_order' in query: query['torsion_order'] = reduce(mul,[int(n) for n in query['torsion']],1) if 'torsion' in query: query['torsion_subgroup'] = str(query['torsion']).replace(" ","") query.pop('torsion') # search using string key, not array of ints parse_ints(info,query,'two_selmer_rank','2-Selmer rank') parse_ints(info,query,'analytic_rank','analytic rank') # G2 invariants and drop-list items don't require parsing -- they are all strings (supplied by us, not the user) if 'g20' in info and 'g21' in info and 'g22' in info: query['g2_inv'] = "['%s','%s','%s']"%(info['g20'], info['g21'], info['g22']) if 'class' in info: query['class'] = info['class'] for fld in ('st_group', 'real_geom_end_alg', 'aut_grp_id', 'geom_aut_grp_id'): if info.get(fld): query[fld] = info[fld] info["curve_url"] = lambda label: url_for_curve_label(label) info["class_url"] = lambda label: url_for_isogeny_class_label(label)
def galois_group_search(info, query): def includes_composite(s): s = s.replace(' ','').replace('..','-') for interval in s.split(','): if '-' in interval[1:]: ix = interval.index('-',1) a,b = int(interval[:ix]), int(interval[ix+1:]) if b == a: if a != 1 and not a.is_prime(): return True if b > a and b > 3: return True else: a = ZZ(interval) if a != 1 and not a.is_prime(): return True parse_ints(info,query,'n','degree') parse_ints(info,query,'t') parse_ints(info,query,'order') parse_bracketed_posints(info, query, qfield='gapidfull', split=False, exactlength=2, keepbrackets=True, name='GAP id', field='gapid') for param in ('cyc', 'solv', 'prim'): parse_bool(info, query, param, process=int, blank=['0','Any']) parse_restricted(info,query,'parity',allowed=[1,-1],process=int,blank=['0','Any']) if 'order' in query and 'n' not in query: query['__sort__'] = ['order', 'gapid', 'n', 't'] degree_str = prep_ranges(info.get('n')) info['show_subs'] = degree_str is None or (LIST_RE.match(degree_str) and includes_composite(degree_str)) info['group_display'] = group_display_pretty info['yesno'] = yesno info['wgg'] = WebGaloisGroup.from_data
def elliptic_curve_search(info, query): parse_nf_string(info, query, 'field', name="base number field", qfield='field_label') if query.get('field_label') == '1.1.1.1': return redirect(url_for("ec.rational_elliptic_curves", **request.args), 301) parse_ints(info, query, 'conductor_norm') parse_noop(info, query, 'conductor_label') parse_ints(info, query, 'torsion', name='Torsion order', qfield='torsion_order') parse_bracketed_posints(info, query, 'torsion_structure', maxlength=2) if 'torsion_structure' in query and not 'torsion_order' in query: query['torsion_order'] = reduce( mul, [int(n) for n in query['torsion_structure']], 1) parse_ints(info, query, field='isodeg', qfield='isogeny_degrees') if 'jinv' in info: if info.get('field', '').strip() == '2.2.5.1': info['jinv'] = info['jinv'].replace('phi', 'a') if info.get('field', '').strip() == '2.0.4.1': info['jinv'] = info['jinv'].replace('i', 'a') parse_nf_elt(info, query, 'jinv', name='j-invariant') if query.get('jinv'): query['jinv'] = ','.join(query['jinv']) if 'include_isogenous' in info and info['include_isogenous'] == 'off': info['number'] = 1 query['number'] = 1 if 'include_base_change' in info: if info['include_base_change'] == 'off': query['base_change'] = [] if info['include_base_change'] == 'only': query['base_change'] = {'$ne': []} else: info['include_base_change'] = "on" if 'include_Q_curves' in info: if info['include_Q_curves'] == 'exclude': query['q_curve'] = False elif info['include_Q_curves'] == 'only': query['q_curve'] = True if 'include_cm' in info: if info['include_cm'] == 'exclude': query['cm'] = 0 elif info['include_cm'] == 'only': query['cm'] = {'$ne': 0} info['field_pretty'] = field_pretty info['web_ainvs'] = web_ainvs
def elliptic_curve_search(info, query): parse_rational(info, query, 'jinv', 'j-invariant') parse_ints(info, query, 'conductor') parse_ints(info, query, 'torsion', 'torsion order') parse_ints(info, query, 'rank') parse_ints(info, query, 'sha', 'analytic order of Ш') parse_bracketed_posints(info, query, 'torsion_structure', maxlength=2, check_divisibility='increasing') # speed up slow torsion_structure searches by also setting torsion #if 'torsion_structure' in query and not 'torsion' in query: # query['torsion'] = reduce(mul,[int(n) for n in query['torsion_structure']],1) if 'include_cm' in info: if info['include_cm'] == 'exclude': query['cm'] = 0 elif info['include_cm'] == 'only': query['cm'] = {'$ne': 0} parse_element_of(info, query, field='isodeg', qfield='isogeny_degrees', split_interval=1000) #parse_ints(info,query,field='isodeg',qfield='isogeny_degrees') parse_primes(info, query, 'surj_primes', name='maximal primes', qfield='nonmax_primes', mode='complement') if info.get('surj_quantifier') == 'exactly': mode = 'exact' else: mode = 'append' parse_primes(info, query, 'nonsurj_primes', name='non-maximal primes', qfield='nonmax_primes', mode=mode, radical='nonmax_rad') if 'optimal' in info and info['optimal'] == 'on': # fails on 990h3 query['number'] = 1 info['curve_url'] = lambda dbc: url_for(".by_triple_label", conductor=dbc['conductor'], iso_label=split_lmfdb_label(dbc[ 'lmfdb_iso'])[1], number=dbc['lmfdb_number']) info['iso_url'] = lambda dbc: url_for(".by_double_iso_label", conductor=dbc['conductor'], iso_label=split_lmfdb_label(dbc[ 'lmfdb_iso'])[1])
def elliptic_curve_search(info, query): parse_nf_string(info,query,'field',name="base number field",qfield='field_label') if query.get('field_label') == '1.1.1.1': return redirect(url_for("ec.rational_elliptic_curves", **request.args), 301) parse_ints(info,query,'conductor_norm') parse_noop(info,query,'conductor_label') parse_ints(info,query,'torsion',name='Torsion order',qfield='torsion_order') parse_bracketed_posints(info,query,'torsion_structure',maxlength=2) if 'torsion_structure' in query and not 'torsion_order' in query: query['torsion_order'] = reduce(mul,[int(n) for n in query['torsion_structure']],1) parse_ints(info,query,field='isodeg',qfield='isogeny_degrees') if 'jinv' in info: if info.get('field','').strip() == '2.2.5.1': info['jinv'] = info['jinv'].replace('phi','a') if info.get('field','').strip() == '2.0.4.1': info['jinv'] = info['jinv'].replace('i','a') parse_nf_elt(info,query,'jinv',name='j-invariant') if query.get('jinv'): query['jinv'] =','.join(query['jinv']) if 'include_isogenous' in info and info['include_isogenous'] == 'off': info['number'] = 1 query['number'] = 1 if 'include_base_change' in info: if info['include_base_change'] == 'off': query['base_change'] = [] if info['include_base_change'] == 'only': query['base_change'] = {'$ne':[]} else: info['include_base_change'] = "on" if 'include_Q_curves' in info: if info['include_Q_curves'] == 'exclude': query['q_curve'] = False elif info['include_Q_curves'] == 'only': query['q_curve'] = True if 'include_cm' in info: if info['include_cm'] == 'exclude': query['cm'] = 0 elif info['include_cm'] == 'only': query['cm'] = {'$ne' : 0} info['field_pretty'] = field_pretty info['web_ainvs'] = web_ainvs
def number_field_search(info, query): parse_ints(info, query, 'degree') parse_galgrp(info, query, qfield=('degree', 'galt')) parse_bracketed_posints(info, query, 'signature', qfield=('degree', 'r2'), exactlength=2, extractor=lambda L: (L[0] + 2 * L[1], L[1])) parse_signed_ints(info, query, 'discriminant', qfield=('disc_sign', 'disc_abs')) parse_ints(info, query, 'class_number') parse_bracketed_posints(info, query, 'class_group', check_divisibility='increasing', process=int) parse_primes(info, query, 'ur_primes', name='Unramified primes', qfield='ramps', mode='complement') # modes are now contained (in), exactly, include if 'ram_quantifier' in info and str(info['ram_quantifier']) == 'include': mode = 'append' elif 'ram_quantifier' in info and str( info['ram_quantifier']) == 'contained': mode = 'subsets' else: mode = 'exact' parse_primes(info, query, 'ram_primes', name='Ramified primes', qfield='ramps', mode=mode, radical='disc_rad') ## This seems not to be used #if 'lucky' in info: # label = db.nf_fields.lucky(query, 0) # if label: # return redirect(url_for(".by_label", label=clean_input(label))) info['wnf'] = WebNumberField.from_data
def genus2_curve_search(info, query): info["st_group_list"] = st_group_list info["st_group_dict"] = st_group_dict info["real_geom_end_alg_list"] = real_geom_end_alg_list info["real_geom_end_alg_to_ST0_dict"] = real_geom_end_alg_to_ST0_dict info["aut_grp_list"] = aut_grp_list info["aut_grp_dict"] = aut_grp_dict info["geom_aut_grp_list"] = geom_aut_grp_list info["geom_aut_grp_dict"] = geom_aut_grp_dict parse_ints(info, query, 'abs_disc', 'absolute discriminant') parse_bool(info, query, 'is_gl2_type', 'is of GL2-type') parse_bool(info, query, 'has_square_sha', 'has square Sha') parse_bool(info, query, 'locally_solvable', 'is locally solvable') parse_bool(info, query, 'is_simple_geom', 'is geometrically simple') parse_ints(info, query, 'cond', 'conductor') parse_ints(info, query, 'num_rat_pts', 'rational points') parse_ints(info, query, 'num_rat_wpts', 'rational Weierstrass points') parse_bracketed_posints(info, query, 'torsion', 'torsion structure', maxlength=4, check_divisibility="increasing") parse_ints(info, query, 'torsion_order', 'torsion order') if 'torsion' in query and not 'torsion_order' in query: query['torsion_order'] = reduce(mul, [int(n) for n in query['torsion']], 1) if 'torsion' in query: query['torsion_subgroup'] = str(query['torsion']).replace(" ", "") query.pop('torsion') # search using string key, not array of ints parse_ints(info, query, 'two_selmer_rank', '2-Selmer rank') parse_ints(info, query, 'analytic_rank', 'analytic rank') # G2 invariants and drop-list items don't require parsing -- they are all strings (supplied by us, not the user) if 'g20' in info and 'g21' in info and 'g22' in info: query['g2_inv'] = "['%s','%s','%s']" % (info['g20'], info['g21'], info['g22']) if 'class' in info: query['class'] = info['class'] for fld in ('st_group', 'real_geom_end_alg', 'aut_grp_id', 'geom_aut_grp_id'): if info.get(fld): query[fld] = info[fld] info["curve_url"] = lambda label: url_for_curve_label(label) info["class_url"] = lambda label: url_for_isogeny_class_label(label)
def belyi_search(info, query): info['geometry_types_list'] = geometry_types_list info['geometry_types_dict'] = geometry_types_dict info["belyi_galmap_url"] = lambda label: url_for_belyi_galmap_label(label) if 'group' in query: info['group'] = query['group'] parse_bracketed_posints(info, query, 'abc_list', 'a, b, c', maxlength=3) if query.get('abc_list'): if len(query['abc_list']) == 3: a, b, c = sorted(query['abc_list']) query['a_s'] = a query['b_s'] = b query['c_s'] = c elif len(query['abc_list']) == 2: a, b = sorted(query['abc_list']) sub_query = [] sub_query.append( {'a_s': a, 'b_s': b} ) sub_query.append( {'b_s': a, 'c_s': b} ) query['$or'] = sub_query elif len(query['abc_list']) == 1: a = query['abc_list'][0] query['$or'] = [{'a_s': a}, {'b_s': a}, {'c_s': a}] query.pop('abc_list') # a naive hack if info.get('abc'): for elt in ['a_s', 'b_s', 'c_s']: info_hack = {} info_hack[elt] = info['abc'] parse_ints(info_hack, query, elt) parse_ints(info, query, 'g','g') parse_ints(info, query, 'deg', 'deg') parse_ints(info, query, 'orbit_size', 'orbit_size') # invariants and drop-list items don't require parsing -- they are all strings (supplied by us, not the user) for fld in ['geomtype','group']: if info.get(fld): query[fld] = info[fld]
def number_field_search(info, query): parse_ints(info,query,'degree') parse_galgrp(info,query, qfield=('degree', 'galt')) parse_bracketed_posints(info,query,'signature',qfield=('degree','r2'),exactlength=2,extractor=lambda L: (L[0]+2*L[1],L[1])) parse_signed_ints(info,query,'discriminant',qfield=('disc_sign','disc_abs')) parse_ints(info,query,'class_number') parse_bracketed_posints(info,query,'class_group',check_divisibility='increasing',process=int) parse_primes(info,query,'ur_primes',name='Unramified primes', qfield='ramps',mode='complement') # modes are now contained (in), exactly, include if 'ram_quantifier' in info and str(info['ram_quantifier']) == 'include': mode='append' elif 'ram_quantifier' in info and str(info['ram_quantifier']) == 'contained': mode='subsets' else: mode='exact' parse_primes(info,query,'ram_primes',name='Ramified primes', qfield='ramps',mode=mode,radical='disc_rad') ## This seems not to be used #if 'lucky' in info: # label = db.nf_fields.lucky(query, 0) # if label: # return redirect(url_for(".by_label", label=clean_input(label))) info['wnf'] = WebNumberField.from_data
def hgm_search(info, query): family_search = False if info.get('Submit Family') or info.get('family'): family_search = True query['__title__'] = r'Hypergeometric Family over $\Q$ Search Result' query[ '__err_title__'] = r'Hypergeometric Family over $\Q$ Search Input Error' query['__table__'] = db.hgm_families queryab = {} for param in [ 'A', 'B', 'A2', 'B2', 'A3', 'B3', 'A5', 'B5', 'A7', 'B7', 'Au2', 'Bu2', 'Au3', 'Bu3', 'Au5', 'Bu5', 'Au7', 'Bu7' ]: parse_bracketed_posints(info, queryab, param, split=False, listprocess=lambda a: sorted(a, reverse=True)) # Combine the parts of the query if there are A,B parts if queryab: queryabrev = {} for k in queryab.keys(): queryabrev[k + 'rev'] = queryab[k] query['$or'] = [queryab, queryabrev] # generic, irreducible not in DB yet parse_ints(info, query, 'degree') parse_ints(info, query, 'weight') parse_bracketed_posints(info, query, 'famhodge', 'family Hodge vector', split=False) parse_restricted(info, query, 'sign', allowed=['+1', 1, -1], process=int) # Make a version to search reversed way if not family_search: parse_ints(info, query, 'conductor', 'Conductor', 'cond') parse_rational(info, query, 't') parse_bracketed_posints(info, query, 'hodge', 'Hodge vector') info['make_label'] = make_abt_label info['make_t_label'] = make_t_label info['ab_label'] = ab_label info['display_t'] = display_t info['family'] = family_search info['factorint'] = factorint
def hgm_search(info, query): family_search = False if info.get('Submit Family') or info.get('family'): family_search = True query['__title__'] = r'Hypergeometric Family over $\Q$ Search Result' query['__err_title__'] = r'Hypergeometric Family over $\Q$ Search Input Error' query['__table__'] = db.hgm_families queryab = {} for param in ['A', 'B', 'A2', 'B2', 'A3', 'B3', 'A5', 'B5', 'A7', 'B7', 'Au2', 'Bu2', 'Au3', 'Bu3', 'Au5', 'Bu5', 'Au7', 'Bu7']: parse_bracketed_posints(info, queryab, param, split=False, listprocess=lambda a: sorted(a, reverse=True)) # Combine the parts of the query if there are A,B parts if queryab: queryabrev = {} for k in queryab.keys(): queryabrev[k+'rev'] = queryab[k] query['$or'] = [queryab, queryabrev] # generic, irreducible not in DB yet parse_ints(info, query, 'degree') parse_ints(info, query, 'weight') parse_bracketed_posints(info, query, 'famhodge', 'family Hodge vector',split=False) parse_restricted(info, query, 'sign', allowed=['+1',1,-1], process=int) # Make a version to search reversed way if not family_search: parse_ints(info, query, 'conductor', 'Conductor' , 'cond') parse_rational(info, query, 't') parse_bracketed_posints(info, query, 'hodge', 'Hodge vector') info['make_label'] = make_abt_label info['make_t_label'] = make_t_label info['ab_label'] = ab_label info['display_t'] = display_t info['family'] = family_search info['factorint'] = factorint
def higher_genus_w_automorphisms_search(**args): info = to_dict(args) bread = get_bread([("Search results", '')]) C = base.getDBConnection() query = {} if 'jump_to' in info: labs = info['jump_to'] if label_is_one_passport(labs): return render_passport({'passport_label': labs}) elif label_is_one_family(labs): return render_family({'label': labs}) else: flash_error( "The label %s is not a legitimate label for this data.", labs) return redirect(url_for(".index")) #allow for ; in signature if info.get('signature'): info['signature'] = info['signature'].replace(';', ',') try: parse_gap_id(info, query, 'group', 'Group') parse_ints(info, query, 'genus', name='Genus') parse_bracketed_posints(info, query, 'signature', split=False, name='Signature', keepbrackets=True) if query.get('signature'): query['signature'] = info['signature'] = str( sort_sign(ast.literal_eval(query['signature']))).replace( ' ', '') parse_ints(info, query, 'dim', name='Dimension of the family') if 'inc_hyper' in info: if info['inc_hyper'] == 'exclude': query['hyperelliptic'] = False elif info['inc_hyper'] == 'only': query['hyperelliptic'] = True if 'inc_cyc_trig' in info: if info['inc_cyc_trig'] == 'exclude': query['cyclic_trigonal'] = False elif info['inc_cyc_trig'] == 'only': query['cyclic_trigonal'] = True if 'inc_full' in info: if info['inc_full'] == 'exclude': query['full_auto'] = {'$exists': True} elif info['inc_full'] == 'only': query['full_auto'] = {'$exists': False} query['cc.1'] = 1 except ValueError: return search_input_error(info, bread) count = parse_count(info) start = parse_start(info) res = C.curve_automorphisms.passports.find(query).sort([ ('genus', pymongo.ASCENDING), ('dim', pymongo.ASCENDING), ('cc'[0], pymongo.ASCENDING) ]) nres = res.count() res = res.skip(start).limit(count) if (start >= nres): start -= (1 + (start - nres) / count) * count if (start < 0): start = 0 L = [] for field in res: field['signature'] = ast.literal_eval(field['signature']) L.append(field) info['fields'] = L info['number'] = nres info['group_display'] = sg_pretty info['sign_display'] = sign_display info['start'] = start if nres == 1: info['report'] = 'unique match' else: if nres > count or start != 0: info['report'] = 'displaying matches %s-%s of %s' % ( start + 1, min(nres, start + count), nres) else: info['report'] = 'displaying all %s matches' % nres return render_template( "hgcwa-search.html", info=info, title= "Families of Higher Genus Curves with Automorphisms Search Result", bread=bread)
def elliptic_curve_search(info): if info.get('download') == '1' and info.get('Submit') and info.get( 'query'): return download_search(info) if not 'query' in info: info['query'] = {} bread = info.get('bread', [('Elliptic Curves', url_for(".index")), ('Search Results', '.')]) if 'jump' in info: label = info.get('label', '').replace(" ", "") # This label should be a full isogeny class label or a full # curve label (including the field_label component) try: nf, cond_label, iso_label, number = split_full_label(label.strip()) except ValueError: info['err'] = '' return search_input_error(info, bread) return redirect( url_for(".show_ecnf", nf=nf, conductor_label=cond_label, class_label=iso_label, number=number), 301) query = {} if 'jinv' in info: if info.get('field', '').strip() == '2.2.5.1': info['jinv'] = info['jinv'].replace('phi', 'a') if info.get('field', '').strip() == '2.0.4.1': info['jinv'] = info['jinv'].replace('i', 'a') try: parse_ints(info, query, 'conductor_norm') parse_noop(info, query, 'conductor_label') parse_nf_string(info, query, 'field', name="base number field", qfield='field_label') parse_nf_elt(info, query, 'jinv', name='j-invariant') parse_ints(info, query, 'torsion', name='Torsion order', qfield='torsion_order') parse_bracketed_posints(info, query, 'torsion_structure', maxlength=2) if 'torsion_structure' in query and not 'torsion_order' in query: query['torsion_order'] = reduce( mul, [int(n) for n in query['torsion_structure']], 1) parse_ints(info, query, field='isodeg', qfield='isogeny_degrees') except (TypeError, ValueError): return search_input_error(info, bread) if query.get('jinv'): query['jinv'] = ','.join(query['jinv']) if query.get('field_label') == '1.1.1.1': return redirect(url_for("ec.rational_elliptic_curves", **request.args), 301) if 'include_isogenous' in info and info['include_isogenous'] == 'off': info['number'] = 1 query['number'] = 1 if 'include_base_change' in info and info['include_base_change'] == 'off': query['base_change'] = [] else: info['include_base_change'] = "on" if 'include_Q_curves' in info: if info['include_Q_curves'] == 'exclude': query['q_curve'] = False elif info['include_Q_curves'] == 'only': query['q_curve'] = True if 'include_cm' in info: if info['include_cm'] == 'exclude': query['cm'] = 0 elif info['include_cm'] == 'only': query['cm'] = {'$ne': 0} info['query'] = query count = parse_count(info, 50) start = parse_start(info) # make the query and trim results according to start/count: cursor = db_ecnf().find(query) nres = cursor.count() if (start >= nres): start -= (1 + (start - nres) / count) * count if (start < 0): start = 0 res = cursor.sort([('field_label', ASC), ('conductor_norm', ASC), ('conductor_label', ASC), ('iso_nlabel', ASC), ('number', ASC)]).skip(start).limit(count) res = list(res) for e in res: e['numb'] = str(e['number']) e['field_knowl'] = nf_display_knowl(e['field_label'], getDBConnection(), field_pretty(e['field_label'])) info['curves'] = res # [ECNF(e) for e in res] info['number'] = nres info['start'] = start info['count'] = count info['more'] = int(start + count < nres) info['field_pretty'] = field_pretty info['web_ainvs'] = web_ainvs if nres == 1: info['report'] = 'unique match' else: if nres > count or start != 0: info['report'] = 'displaying matches %s-%s of %s' % ( start + 1, min(nres, start + count), nres) else: info['report'] = 'displaying all %s matches' % nres t = info.get('title', 'Elliptic Curve search results') return render_template("ecnf-search-results.html", info=info, credit=ecnf_credit, bread=bread, title=t)
def elliptic_curve_search(info): if info.get('download') == '1' and info.get('Submit') and info.get('query'): return download_search(info) if 'SearchAgain' in info: return rational_elliptic_curves() query = {} bread = info.get('bread',[('Elliptic Curves', url_for("ecnf.index")), ('$\Q$', url_for(".rational_elliptic_curves")), ('Search Results', '.')]) if 'jump' in info: label = info.get('label', '').replace(" ", "") m = match_lmfdb_label(label) if m: try: return by_ec_label(label) except ValueError: return elliptic_curve_jump_error(label, info, wellformed_label=True) elif label.startswith("Cremona:"): label = label[8:] m = match_cremona_label(label) if m: try: return by_ec_label(label) except ValueError: return elliptic_curve_jump_error(label, info, wellformed_label=True) elif match_cremona_label(label): return elliptic_curve_jump_error(label, info, cremona_label=True) elif label: # Try to parse a string like [1,0,3,2,4] as valid # Weistrass coefficients: lab = re.sub(r'\s','',label) lab = re.sub(r'^\[','',lab) lab = re.sub(r']$','',lab) try: labvec = lab.split(',') labvec = [QQ(str(z)) for z in labvec] # Rationals allowed E = EllipticCurve(labvec) # Now we do have a valid curve over Q, but it might # not be in the database. ainvs = [str(c) for c in E.minimal_model().ainvs()] xainvs = ''.join(['[',','.join(ainvs),']']) data = db_ec().find_one({'xainvs': xainvs}) if data is None: data = db_ec().find_one({'ainvs': ainvs}) if data is None: info['conductor'] = E.conductor() return elliptic_curve_jump_error(label, info, missing_curve=True) return by_ec_label(data['lmfdb_label']) except (TypeError, ValueError, ArithmeticError): return elliptic_curve_jump_error(label, info) else: query['label'] = '' try: parse_rational(info,query,'jinv','j-invariant') parse_ints(info,query,'conductor') parse_ints(info,query,'torsion','torsion order') parse_ints(info,query,'rank') parse_ints(info,query,'sha','analytic order of Ш') parse_bracketed_posints(info,query,'torsion_structure',maxlength=2,process=str,check_divisibility='increasing') # speed up slow torsion_structure searches by also setting torsion if 'torsion_structure' in query and not 'torsion' in query: query['torsion'] = reduce(mul,[int(n) for n in query['torsion_structure']],1) if 'include_cm' in info: if info['include_cm'] == 'exclude': query['cm'] = 0 elif info['include_cm'] == 'only': query['cm'] = {'$ne' : 0} parse_ints(info,query,field='isodeg',qfield='isogeny_degrees') parse_primes(info, query, 'surj_primes', name='surjective primes', qfield='non-maximal_primes', mode='complement') if info.get('surj_quantifier') == 'exactly': mode = 'exact' else: mode = 'append' parse_primes(info, query, 'nonsurj_primes', name='non-surjective primes', qfield='non-maximal_primes',mode=mode) except ValueError as err: info['err'] = str(err) return search_input_error(info, bread) count = parse_count(info,100) start = parse_start(info) if 'optimal' in info and info['optimal'] == 'on': # fails on 990h3 query['number'] = 1 info['query'] = query cursor = db_ec().find(query) nres = cursor.count() if(start >= nres): start -= (1 + (start - nres) / count) * count if(start < 0): start = 0 res = cursor.sort([('conductor', ASCENDING), ('iso_nlabel', ASCENDING), ('lmfdb_number', ASCENDING)]).skip(start).limit(count) info['curves'] = res info['format_ainvs'] = format_ainvs info['curve_url'] = lambda dbc: url_for(".by_triple_label", conductor=dbc['conductor'], iso_label=split_lmfdb_label(dbc['lmfdb_iso'])[1], number=dbc['lmfdb_number']) info['iso_url'] = lambda dbc: url_for(".by_double_iso_label", conductor=dbc['conductor'], iso_label=split_lmfdb_label(dbc['lmfdb_iso'])[1]) info['number'] = nres info['start'] = start info['count'] = count info['more'] = int(start + count < nres) if nres == 1: info['report'] = 'unique match' elif nres == 2: info['report'] = 'displaying both matches' else: if nres > count or start != 0: info['report'] = 'displaying matches %s-%s of %s' % (start + 1, min(nres, start + count), nres) else: info['report'] = 'displaying all %s matches' % nres #credit = 'John Cremona' #if 'non-surjective_primes' in query or 'non-maximal_primes' in query: # credit += ' and Andrew Sutherland' t = info.get('title','Elliptic Curves search results') return render_template("ec-search-results.html", info=info, credit=ec_credit(), bread=bread, title=t)
def number_field_search(**args): info = to_dict(args) info["learnmore"] = [ ("Global number field labels", url_for(".render_labels_page")), ("Galois group labels", url_for(".render_groups_page")), (Completename, url_for(".render_discriminants_page")), ("Quadratic imaginary class groups", url_for(".render_class_group_data")), ] t = "Global Number Field search results" bread = [("Global Number Fields", url_for(".number_field_render_webpage")), ("Search results", " ")] # for k in info.keys(): # nf_logger.debug(str(k) + ' ---> ' + str(info[k])) # nf_logger.debug('******************* '+ str(info['search'])) if "natural" in info: query = {"label_orig": info["natural"]} try: parse_nf_string(info, query, "natural", name="Label", qfield="label") return redirect(url_for(".by_label", label=clean_input(query["label"]))) except ValueError: query["err"] = info["err"] return search_input_error(query, bread) query = {} try: parse_galgrp(info, query, qfield="galois") parse_ints(info, query, "degree") parse_bracketed_posints(info, query, "signature", split=False, exactlength=2) parse_signed_ints(info, query, "discriminant", qfield=("disc_sign", "disc_abs_key"), parse_one=make_disc_key) parse_ints(info, query, "class_number") parse_bracketed_posints(info, query, "class_group", split=False, check_divisibility="increasing") parse_primes( info, query, "ur_primes", name="Unramified primes", qfield="ramps", mode="complement", to_string=True ) if "ram_quantifier" in info and str(info["ram_quantifier"]) == "some": mode = "append" else: mode = "exact" parse_primes(info, query, "ram_primes", "ramified primes", "ramps", mode, to_string=True) except ValueError: return search_input_error(info, bread) count = parse_count(info) start = parse_start(info) if info.get("paging"): try: paging = int(info["paging"]) if paging == 0: start = 0 except: pass C = base.getDBConnection() # nf_logger.debug(query) info["query"] = dict(query) if "lucky" in args: one = C.numberfields.fields.find_one(query) if one: label = one["label"] return redirect(url_for(".by_label", clean_input(label))) fields = C.numberfields.fields res = fields.find(query) if "download" in info and info["download"] != "0": return download_search(info, res) res = res.sort([("degree", ASC), ("disc_abs_key", ASC), ("disc_sign", ASC)]) nres = res.count() res = res.skip(start).limit(count) if start >= nres: start -= (1 + (start - nres) / count) * count if start < 0: start = 0 info["fields"] = res info["number"] = nres info["start"] = start if nres == 1: info["report"] = "unique match" else: if nres > count or start != 0: info["report"] = "displaying matches %s-%s of %s" % (start + 1, min(nres, start + count), nres) else: info["report"] = "displaying all %s matches" % nres info["wnf"] = WebNumberField.from_data return render_template("number_field_search.html", info=info, title=t, bread=bread)
def number_field_search(info): info['learnmore'] = [ ('Global number field labels', url_for(".render_labels_page")), ('Galois group labels', url_for(".render_groups_page")), (Completename, url_for(".render_discriminants_page")), ('Quadratic imaginary class groups', url_for(".render_class_group_data")) ] t = 'Global Number Field search results' bread = [('Global Number Fields', url_for(".number_field_render_webpage")), ('Search results', ' ')] if 'natural' in info: query = {'label_orig': info['natural']} try: parse_nf_string(info, query, 'natural', name="Label", qfield='label') return redirect( url_for(".by_label", label=clean_input(query['label_orig']))) except ValueError: query['err'] = info['err'] return search_input_error(query, bread) if 'algebra' in info: fields = info['algebra'].split('_') fields2 = [WebNumberField.from_coeffs(a) for a in fields] for j in range(len(fields)): if fields2[j] is None: fields2[j] = WebNumberField.fakenf(fields[j]) t = 'Number field algebra' info = {} info = {'fields': fields2} return render_template("number_field_algebra.html", info=info, title=t, bread=bread) query = {} try: parse_galgrp(info, query, qfield='galois') parse_ints(info, query, 'degree') parse_bracketed_posints(info, query, 'signature', split=False, exactlength=2) parse_signed_ints(info, query, 'discriminant', qfield=('disc_sign', 'disc_abs_key'), parse_one=make_disc_key) parse_ints(info, query, 'class_number') parse_bracketed_posints(info, query, 'class_group', split=False, check_divisibility='increasing') parse_primes(info, query, 'ur_primes', name='Unramified primes', qfield='ramps', mode='complement', to_string=True) # modes are now contained (in), exactly, include if 'ram_quantifier' in info and str( info['ram_quantifier']) == 'include': mode = 'append' parse_primes(info, query, 'ram_primes', 'ramified primes', 'ramps', mode, to_string=True) elif 'ram_quantifier' in info and str( info['ram_quantifier']) == 'contained': parse_primes(info, query, 'ram_primes', 'ramified primes', 'ramps_all', 'subsets', to_string=False) pass # build list else: mode = 'liststring' parse_primes(info, query, 'ram_primes', 'ramified primes', 'ramps_all', mode) except ValueError: return search_input_error(info, bread) count = parse_count(info) start = parse_start(info) # nf_logger.debug(query) info['query'] = dict(query) if 'lucky' in info: one = nfdb().find_one(query) if one: label = one['label'] return redirect(url_for(".by_label", label=clean_input(label))) fields = nfdb() res = fields.find(query) res = res.sort([('degree', ASC), ('disc_abs_key', ASC), ('disc_sign', ASC)]) if 'download' in info and info['download'] != '0': return download_search(info, res) nres = res.count() res = res.skip(start).limit(count) if (start >= nres): start -= (1 + (start - nres) / count) * count if (start < 0): start = 0 info['fields'] = res info['number'] = nres info['start'] = start if nres == 1: info['report'] = 'unique match' else: if nres > count or start != 0: info['report'] = 'displaying matches %s-%s of %s' % ( start + 1, min(nres, start + count), nres) else: info['report'] = 'displaying all %s matches' % nres info['wnf'] = WebNumberField.from_data return render_template("number_field_search.html", info=info, title=t, bread=bread)
def elliptic_curve_search(**args): info = to_dict(args['data']) if 'download' in info and info['download'] != 0: return download_search(info) if not 'query' in info: info['query'] = {} bread = [('Elliptic Curves', url_for(".index")), ('Search Results', '.')] if 'jump' in info: label = info.get('label', '').replace(" ", "") # This label should be a full isogeny class label or a full # curve label (including the field_label component) try: nf, cond_label, iso_label, number = split_full_label(label.strip()) except ValueError: info['err'] = '' return search_input_error(info, bread) return show_ecnf(nf, cond_label, iso_label, number) query = {} try: parse_ints(info,query,'conductor_norm') parse_noop(info,query,'conductor_label') parse_nf_string(info,query,'field',name="base number field",qfield='field_label') parse_nf_elt(info,query,'jinv',name='j-invariant') parse_ints(info,query,'torsion',name='Torsion order',qfield='torsion_order') parse_bracketed_posints(info,query,'torsion_structure',maxlength=2) if 'torsion_structure' in query and not 'torsion_order' in query: query['torsion_order'] = reduce(mul,[int(n) for n in query['torsion_structure']],1) except ValueError: return search_input_error(info, bread) if 'include_isogenous' in info and info['include_isogenous'] == 'off': info['number'] = 1 query['number'] = 1 if 'include_base_change' in info and info['include_base_change'] == 'off': query['base_change'] = [] else: info['include_base_change'] = "on" if 'include_Q_curves' in info: if info['include_Q_curves'] == 'exclude': query['q_curve'] = False elif info['include_Q_curves'] == 'only': query['q_curve'] = True if 'include_cm' in info: if info['include_cm'] == 'exclude': query['cm'] = 0 elif info['include_cm'] == 'only': query['cm'] = {'$ne' : 0} info['query'] = query count = parse_count(info, 50) start = parse_start(info) # make the query and trim results according to start/count: cursor = db_ecnf().find(query) nres = cursor.count() if(start >= nres): start -= (1 + (start - nres) / count) * count if(start < 0): start = 0 res = cursor.sort([('field_label', ASC), ('conductor_norm', ASC), ('conductor_label', ASC), ('iso_nlabel', ASC), ('number', ASC)]).skip(start).limit(count) res = list(res) for e in res: e['numb'] = str(e['number']) e['field_knowl'] = nf_display_knowl(e['field_label'], getDBConnection(), field_pretty(e['field_label'])) info['curves'] = res # [ECNF(e) for e in res] info['number'] = nres info['start'] = start info['count'] = count info['more'] = int(start + count < nres) info['field_pretty'] = field_pretty info['web_ainvs'] = web_ainvs if nres == 1: info['report'] = 'unique match' else: if nres > count or start != 0: info['report'] = 'displaying matches %s-%s of %s' % (start + 1, min(nres, start + count), nres) else: info['report'] = 'displaying all %s matches' % nres t = 'Elliptic Curve search results' return render_template("ecnf-search-results.html", info=info, credit=ecnf_credit, bread=bread, title=t)
def elliptic_curve_search(info): if info.get('download') == '1' and info.get('Submit') and info.get('query'): return download_search(info) if 'SearchAgain' in info: return rational_elliptic_curves() query = {} bread = info.get('bread',[('Elliptic Curves', url_for("ecnf.index")), ('$\Q$', url_for(".rational_elliptic_curves")), ('Search Results', '.')]) if 'jump' in info: label = info.get('label', '').replace(" ", "") m = match_lmfdb_label(label) if m: try: return by_ec_label(label) except ValueError: return elliptic_curve_jump_error(label, info, wellformed_label=True) elif label.startswith("Cremona:"): label = label[8:] m = match_cremona_label(label) if m: try: return by_ec_label(label) except ValueError: return elliptic_curve_jump_error(label, info, wellformed_label=True) elif match_cremona_label(label): return elliptic_curve_jump_error(label, info, cremona_label=True) elif label: # Try to parse a string like [1,0,3,2,4] as valid # Weistrass coefficients: lab = re.sub(r'\s','',label) lab = re.sub(r'^\[','',lab) lab = re.sub(r']$','',lab) try: labvec = lab.split(',') labvec = [QQ(str(z)) for z in labvec] # Rationals allowed E = EllipticCurve(labvec).minimal_model() # Now we do have a valid curve over Q, but it might # not be in the database. data = db_ec().find_one({'xainvs': EC_ainvs(E)}) if data is None: info['conductor'] = E.conductor() return elliptic_curve_jump_error(label, info, missing_curve=True) return by_ec_label(data['lmfdb_label']) except (TypeError, ValueError, ArithmeticError): return elliptic_curve_jump_error(label, info) else: query['label'] = '' try: parse_rational(info,query,'jinv','j-invariant') parse_ints(info,query,'conductor') parse_ints(info,query,'torsion','torsion order') parse_ints(info,query,'rank') parse_ints(info,query,'sha','analytic order of Ш') parse_bracketed_posints(info,query,'torsion_structure',maxlength=2,process=str,check_divisibility='increasing') # speed up slow torsion_structure searches by also setting torsion if 'torsion_structure' in query and not 'torsion' in query: query['torsion'] = reduce(mul,[int(n) for n in query['torsion_structure']],1) if 'include_cm' in info: if info['include_cm'] == 'exclude': query['cm'] = 0 elif info['include_cm'] == 'only': query['cm'] = {'$ne' : 0} parse_ints(info,query,field='isodeg',qfield='isogeny_degrees') parse_primes(info, query, 'surj_primes', name='surjective primes', qfield='non-maximal_primes', mode='complement') if info.get('surj_quantifier') == 'exactly': mode = 'exact' else: mode = 'append' parse_primes(info, query, 'nonsurj_primes', name='non-surjective primes', qfield='non-maximal_primes',mode=mode) except ValueError as err: info['err'] = str(err) return search_input_error(info, bread) count = parse_count(info,100) start = parse_start(info) if 'optimal' in info and info['optimal'] == 'on': # fails on 990h3 query['number'] = 1 info['query'] = query cursor = db_ec().find(query); cursor = cursor.sort([('conductor', ASCENDING), ('iso_nlabel', ASCENDING), ('lmfdb_number', ASCENDING)]); # equivalent to # cursor = res # nres = res.count() # if(start >= nres): # start -= (1 + (start - nres) / count) * count # if(start < 0): # start = 0 # res = res.skip(start).limit(count) try: start, nres, res = search_cursor_timeout_decorator(cursor, start, count); except ValueError as err: info['err'] = err; return search_input_error(info, bread) info['curves'] = res info['curve_url'] = lambda dbc: url_for(".by_triple_label", conductor=dbc['conductor'], iso_label=split_lmfdb_label(dbc['lmfdb_iso'])[1], number=dbc['lmfdb_number']) info['iso_url'] = lambda dbc: url_for(".by_double_iso_label", conductor=dbc['conductor'], iso_label=split_lmfdb_label(dbc['lmfdb_iso'])[1]) info['number'] = nres info['start'] = start info['count'] = count info['more'] = int(start + count < nres) if nres == 1: info['report'] = 'unique match' elif nres == 2: info['report'] = 'displaying both matches' else: if nres > count or start != 0: info['report'] = 'displaying matches %s-%s of %s' % (start + 1, min(nres, start + count), nres) else: info['report'] = 'displaying all %s matches' % nres t = info.get('title','Elliptic Curves search results') return render_template("ec-search-results.html", info=info, credit=ec_credit(), bread=bread, title=t)
def genus2_curve_search(info): if 'jump' in info: jump = info["jump"].strip() if re.match(r'^\d+\.[a-z]+\.\d+\.\d+$',jump): return redirect(url_for_curve_label(jump), 301) else: if re.match(r'^\d+\.[a-z]+$', jump): return redirect(url_for_isogeny_class_label(jump), 301) else: # Handle direct Lhash input if re.match(r'^\#\d+$',jump) and ZZ(jump[1:]) < 2**61: c = g2c_db_curves().find_one({'Lhash': jump[1:].strip()}) if c: return redirect(url_for_isogeny_class_label(c["class"]), 301) else: errmsg = "hash %s not found" else: errmsg = "%s is not a valid genus 2 curve or isogeny class label" flash_error (errmsg, jump) return redirect(url_for(".index")) if info.get('download','').strip() == '1': return download_search(info) info["st_group_list"] = st_group_list info["st_group_dict"] = st_group_dict info["real_geom_end_alg_list"] = real_geom_end_alg_list info["real_geom_end_alg_to_ST0_dict"] = real_geom_end_alg_to_ST0_dict info["aut_grp_list"] = aut_grp_list info["aut_grp_dict"] = aut_grp_dict info["geom_aut_grp_list"] = geom_aut_grp_list info["geom_aut_grp_dict"] = geom_aut_grp_dict bread = info.get('bread',(('Genus 2 Curves', url_for(".index")), ('$\Q$', url_for(".index_Q")), ('Search Results', '.'))) query = {} try: parse_ints(info,query,'abs_disc','absolute discriminant') parse_bool(info,query,'is_gl2_type','is of GL2-type') parse_bool(info,query,'has_square_sha','has square Sha') parse_bool(info,query,'locally_solvable','is locally solvable') parse_bool(info,query,'is_simple_geom','is geometrically simple') parse_ints(info,query,'cond','conductor') parse_ints(info,query,'num_rat_wpts','rational Weierstrass points') parse_bracketed_posints(info, query, 'torsion', 'torsion structure', maxlength=4,check_divisibility="increasing") parse_ints(info,query,'torsion_order','torsion order') if 'torsion' in query and not 'torsion_order' in query: query['torsion_order'] = reduce(mul,[int(n) for n in query['torsion']],1) if 'torsion' in query: query['torsion_subgroup'] = str(query['torsion']).replace(" ","") query.pop('torsion') # search using string key, not array of ints parse_ints(info,query,'two_selmer_rank','2-Selmer rank') parse_ints(info,query,'analytic_rank','analytic rank') # G2 invariants and drop-list items don't require parsing -- they are all strings (supplied by us, not the user) if 'g20' in info and 'g21' in info and 'g22' in info: query['g2_inv'] = "['%s','%s','%s']"%(info['g20'], info['g21'], info['g22']) if 'class' in info: query['class'] = info['class'] for fld in ('st_group', 'real_geom_end_alg', 'aut_grp_id', 'geom_aut_grp_id'): if info.get(fld): query[fld] = info[fld] except ValueError as err: info['err'] = str(err) return render_template("g2c_search_results.html", info=info, title='Genus 2 Curves Search Input Error', bread=bread, credit=credit_string) # Database query happens here info["query"] = query # save query for reuse in download_search cursor = g2c_db_curves().find(query, {'_id':False, 'label':True, 'eqn':True, 'st_group':True, 'is_gl2_type':True, 'is_simple_geom':True, 'analytic_rank':True}) count = parse_count(info, 50) start = parse_start(info) nres = cursor.count() if(start >= nres): start -= (1 + (start - nres) / count) * count if(start < 0): start = 0 res = cursor.sort([("cond", ASCENDING), ("class", ASCENDING), ("disc_key", ASCENDING), ("label", ASCENDING)]).skip(start).limit(count) nres = res.count() if nres == 1: info["report"] = "unique match" else: if nres > count or start != 0: info['report'] = 'displaying matches %s-%s of %s' % (start + 1, min(nres, start + count), nres) else: info['report'] = 'displaying all %s matches' % nres res_clean = [] for v in res: v_clean = {} v_clean["label"] = v["label"] v_clean["class"] = class_from_curve_label(v["label"]) v_clean["is_gl2_type"] = v["is_gl2_type"] v_clean["is_simple_geom"] = v["is_simple_geom"] v_clean["equation_formatted"] = list_to_min_eqn(literal_eval(v["eqn"])) v_clean["st_group_link"] = st_link_by_name(1,4,v['st_group']) v_clean["analytic_rank"] = v["analytic_rank"] res_clean.append(v_clean) info["curves"] = res_clean info["curve_url"] = lambda label: url_for_curve_label(label) info["class_url"] = lambda label: url_for_isogeny_class_label(label) info["start"] = start info["count"] = count info["more"] = int(start+count<nres) title = info.get('title','Genus 2 Curve search results') credit = credit_string return render_template("g2c_search_results.html", info=info, credit=credit,learnmore=learnmore_list(), bread=bread, title=title)
def genus2_curve_search(**args): info = to_dict(args) print "info", info info["st_group_list"] = st_group_list info["st_group_dict"] = st_group_dict info["real_geom_end_alg_list"] = real_geom_end_alg_list info["real_geom_end_alg_to_ST0_dict"] = real_geom_end_alg_to_ST0_dict info["aut_grp_list"] = aut_grp_list info["aut_grp_dict"] = aut_grp_dict info["geom_aut_grp_list"] = geom_aut_grp_list info["geom_aut_grp_dict"] = geom_aut_grp_dict query = {} # database callable bread = [('Genus 2 Curves', url_for(".index")), ('$\Q$', url_for(".index_Q")), ('Search Results', '.')] #if 'SearchAgain' in args: # return rational_genus2_curves() if 'jump' in args: label_regex = re.compile(r'\d+\.[a-z]+.\d+.\d+') if label_regex.match(info["jump"].strip()): data = render_curve_webpage_by_label(info["jump"].strip()) else: data = "Invalid label" print data if data == "Invalid label": flash(Markup("The label <span style='color:black'>%s</span> is invalid."%(info["jump"])),"error") return redirect(url_for(".index")) if data == "Data for curve not found": flash(Markup("No genus 2 curve with label <span style='color:black'>%s</span> was found in the database."%(info["jump"])),"error") return redirect(url_for(".index")) return data try: parse_ints(info,query,'abs_disc','absolute discriminant') parse_bool(info,query,'is_gl2_type') parse_bool(info,query,'has_square_sha') parse_bool(info,query,'locally_solvable') for fld in ('st_group', 'real_geom_end_alg'): if info.get(fld): query[fld] = info[fld] for fld in ('aut_grp', 'geom_aut_grp'): #Encoded into a GAP ID. parse_bracketed_posints(info,query,fld,exactlength=2) # igusa and igusa_clebsch invariants not currently searchable parse_bracketed_posints(info, query, 'torsion', 'torsion structure', maxlength=4,check_divisibility="increasing") parse_ints(info,query,'cond','conductor') parse_ints(info,query,'num_rat_wpts','Weierstrass points') parse_ints(info,query,'torsion_order') parse_ints(info,query,'two_selmer_rank','2-Selmer rank') parse_ints(info,query,'analytic_rank','analytic rank') except ValueError as err: info['err'] = str(err) return render_template("search_results_g2.html", info=info, title='Genus 2 Curves Search Input Error', bread=bread, credit=credit_string) info["query"] = dict(query) print "query", info["query"] print "info", info count = parse_count(info, 50) start = parse_start(info) cursor = db_g2c().curves.find(query) nres = cursor.count() if(start >= nres): start -= (1 + (start - nres) / count) * count if(start < 0): start = 0 res = cursor.sort([("cond", pymongo.ASCENDING), ("class", pymongo.ASCENDING), ("disc_key", pymongo.ASCENDING), ("label", pymongo.ASCENDING)]).skip(start).limit(count) nres = res.count() if nres == 1: info["report"] = "unique match" else: if nres > count or start != 0: info['report'] = 'displaying matches %s-%s of %s' % (start + 1, min(nres, start + count), nres) else: info['report'] = 'displaying all %s matches' % nres res_clean = [] for v in res: v_clean = {} v_clean["label"] = v["label"] v_clean["isog_label"] = v["class"] isogeny_class = db_g2c().isogeny_classes.find_one({'label' : isog_label(v["label"])}) v_clean["is_gl2_type"] = isogeny_class["is_gl2_type"] if isogeny_class["is_gl2_type"] == True: v_clean["is_gl2_type_display"] = '✔' #checkmark else: v_clean["is_gl2_type_display"] = '' v_clean["equation_formatted"] = list_to_min_eqn(v["min_eqn"]) v_clean["st_group_name"] = st_group_name(isogeny_class['st_group']) v_clean["analytic_rank"] = v["analytic_rank"] res_clean.append(v_clean) info["curves"] = res_clean info["curve_url"] = lambda dbc: url_for_label(dbc['label']) info["isog_url"] = lambda dbc: isog_url_for_label(dbc['label']) info["start"] = start info["count"] = count info["more"] = int(start+count<nres) credit = credit_string title = 'Genus 2 Curves search results' return render_template("search_results_g2.html", info=info, credit=credit,learnmore=learnmore_list(), bread=bread, title=title) credit = credit_string title = 'Genus 2 curves over $\Q$' bread = [('Genus 2 Curves', url_for(".index")), ('$\Q$', ' ')]
def number_field_search(**args): info = to_dict(args) info['learnmore'] = [('Global number field labels', url_for(".render_labels_page")), ('Galois group labels', url_for(".render_groups_page")), (Completename, url_for(".render_discriminants_page")), ('Quadratic imaginary class groups', url_for(".render_class_group_data"))] t = 'Global Number Field search results' bread = [('Global Number Fields', url_for(".number_field_render_webpage")), ('Search results', ' ')] # for k in info.keys(): # nf_logger.debug(str(k) + ' ---> ' + str(info[k])) # nf_logger.debug('******************* '+ str(info['search'])) if 'natural' in info: query = {'label_orig': info['natural']} try: parse_nf_string(info,query,'natural',name="Label",qfield='label') return redirect(url_for(".by_label", label= clean_input(query['label']))) except ValueError: query['err'] = info['err'] return search_input_error(query, bread) query = {} try: parse_galgrp(info,query, qfield='galois') parse_ints(info,query,'degree') parse_bracketed_posints(info,query,'signature',split=False,exactlength=2) parse_signed_ints(info,query,'discriminant',qfield=('disc_sign','disc_abs_key'),parse_one=make_disc_key) parse_ints(info,query,'class_number') parse_bracketed_posints(info,query,'class_group',split=False,check_divisibility='increasing') parse_primes(info,query,'ur_primes',name='Unramified primes',qfield='ramps',mode='complement',to_string=True) if 'ram_quantifier' in info and str(info['ram_quantifier']) == 'some': mode = 'append' else: mode = 'exact' parse_primes(info,query,'ram_primes','ramified primes','ramps',mode,to_string=True) except ValueError: return search_input_error(info, bread) count = parse_count(info) start = parse_start(info) if info.get('paging'): try: paging = int(info['paging']) if paging == 0: start = 0 except: pass C = base.getDBConnection() # nf_logger.debug(query) info['query'] = dict(query) if 'lucky' in args: one = C.numberfields.fields.find_one(query) if one: label = one['label'] return redirect(url_for(".by_label", clean_input(label))) fields = C.numberfields.fields res = fields.find(query) if 'download' in info and info['download'] != '0': return download_search(info, res) res = res.sort([('degree', ASC), ('disc_abs_key', ASC),('disc_sign', ASC)]) nres = res.count() res = res.skip(start).limit(count) if(start >= nres): start -= (1 + (start - nres) / count) * count if(start < 0): start = 0 info['fields'] = res info['number'] = nres info['start'] = start if nres == 1: info['report'] = 'unique match' else: if nres > count or start != 0: info['report'] = 'displaying matches %s-%s of %s' % (start + 1, min(nres, start + count), nres) else: info['report'] = 'displaying all %s matches' % nres info['wnf'] = WebNumberField.from_data return render_template("number_field_search.html", info=info, title=t, bread=bread)
def number_field_search(info): info['learnmore'] = [('Global number field labels', url_for(".render_labels_page")), ('Galois group labels', url_for(".render_groups_page")), (Completename, url_for(".render_discriminants_page")), ('Quadratic imaginary class groups', url_for(".render_class_group_data"))] t = 'Global Number Field search results' bread = [('Global Number Fields', url_for(".number_field_render_webpage")), ('Search Results', ' ')] if 'natural' in info: query = {'label_orig': info['natural']} try: parse_nf_string(info,query,'natural',name="Label",qfield='label') return redirect(url_for(".by_label", label=query['label'])) except ValueError: query['err'] = info['err'] return search_input_error(query, bread) if 'algebra' in info: fields=info['algebra'].split('_') fields2=[WebNumberField.from_coeffs(a) for a in fields] for j in range(len(fields)): if fields2[j] is None: fields2[j] = WebNumberField.fakenf(fields[j]) t = 'Number field algebra' info = {} info = {'fields': fields2} return render_template("number_field_algebra.html", info=info, title=t, bread=bread) query = {} try: parse_galgrp(info,query, qfield='galois') parse_ints(info,query,'degree') parse_bracketed_posints(info,query,'signature',split=False,exactlength=2) parse_signed_ints(info,query,'discriminant',qfield=('disc_sign','disc_abs_key'),parse_one=make_disc_key) parse_ints(info,query,'class_number') parse_bracketed_posints(info,query,'class_group',split=False,check_divisibility='increasing') parse_primes(info,query,'ur_primes',name='Unramified primes',qfield='ramps',mode='complement',to_string=True) # modes are now contained (in), exactly, include if 'ram_quantifier' in info and str(info['ram_quantifier']) == 'include': mode = 'append' parse_primes(info,query,'ram_primes','ramified primes','ramps',mode,to_string=True) elif 'ram_quantifier' in info and str(info['ram_quantifier']) == 'contained': parse_primes(info,query,'ram_primes','ramified primes','ramps_all','subsets',to_string=False) pass # build list else: mode = 'liststring' parse_primes(info,query,'ram_primes','ramified primes','ramps_all',mode) except ValueError: return search_input_error(info, bread) count = parse_count(info) start = parse_start(info) # nf_logger.debug(query) info['query'] = dict(query) if 'lucky' in info: one = nfdb().find_one(query) if one: label = one['label'] return redirect(url_for(".by_label", label=clean_input(label))) fields = nfdb() res = fields.find(query) res = res.sort([('degree', ASC), ('disc_abs_key', ASC),('disc_sign', ASC)]) if 'download' in info and info['download'] != '0': return download_search(info, res) # equivalent to # nres = res.count() #if(start >= nres): # start -= (1 + (start - nres) / count) * count #if(start < 0): # start = 0 # res = res.skip(start).limit(count) try: start, nres, res = search_cursor_timeout_decorator(res, start, count); except ValueError as err: info['err'] = err; return search_input_error(info, bread) info['fields'] = res info['number'] = nres info['start'] = start if nres == 1: info['report'] = 'unique match' else: if nres > count or start != 0: info['report'] = 'displaying matches %s-%s of %s' % (start + 1, min(nres, start + count), nres) else: info['report'] = 'displaying all %s matches' % nres info['wnf'] = WebNumberField.from_data return render_template("number_field_search.html", info=info, title=t, bread=bread)
def higher_genus_w_automorphisms_search(**args): info = to_dict(args) bread = get_bread([("Search Results",'')]) C = base.getDBConnection() query = {} if 'jump_to' in info: labs = info['jump_to'] if label_is_one_passport(labs): return render_passport({'passport_label': labs}) elif label_is_one_family(labs): return render_family({'label': labs}) else: flash_error ("The label %s is not a legitimate label for this data.",labs) return redirect(url_for(".index")) #allow for ; in signature if info.get('signature'): info['signature'] = info['signature'].replace(';',',') try: parse_gap_id(info,query,'group','Group') parse_ints(info,query,'genus',name='Genus') parse_bracketed_posints(info,query,'signature',split=False,name='Signature',keepbrackets=True) if query.get('signature'): query['signature'] = info['signature'] = str(sort_sign(ast.literal_eval(query['signature']))).replace(' ','') parse_ints(info,query,'dim',name='Dimension of the family') if 'inc_hyper' in info: if info['inc_hyper'] == 'exclude': query['hyperelliptic'] = False elif info['inc_hyper'] == 'only': query['hyperelliptic'] = True if 'inc_cyc_trig' in info: if info['inc_cyc_trig'] == 'exclude': query['cyclic_trigonal'] = False elif info['inc_cyc_trig'] == 'only': query['cyclic_trigonal'] = True if 'inc_full' in info: if info['inc_full'] == 'exclude': query['full_auto'] = {'$exists': True} elif info['inc_full'] == 'only': query['full_auto'] = {'$exists': False} query['cc.1'] = 1 except ValueError: return search_input_error(info, bread) count = parse_count(info) start = parse_start(info) if 'groupsize' in info and info['groupsize'] != '': err, result = add_group_order_range(query, info['groupsize'], C) if err != None: flash_error('Parse error on group order field. <font face="Courier New"><br />Given: ' + err + '<br />-------' + result + '</font>') res = C.curve_automorphisms.passports.find(query).sort([( 'genus', pymongo.ASCENDING), ('dim', pymongo.ASCENDING), ('cc'[0],pymongo.ASCENDING)]) nres = res.count() res = res.skip(start).limit(count) if(start >= nres): start -= (1 + (start - nres) / count) * count if(start < 0): start = 0 L = [ ] for field in res: field['signature'] = ast.literal_eval(field['signature']) L.append(field) if 'download_magma' in info: return hgcwa_code_download_search(L,'magma') #OR RES?????? elif 'download_gap' in info: return hgcwa_code_download_search(L,'gap') #OR L?????? info['fields'] = L info['number'] = nres info['group_display'] = sg_pretty info['show_downloads'] = len(L) > 0 info['sign_display'] = sign_display info['start'] = start if nres == 1: info['report'] = 'unique match' else: if nres > count or start != 0: info['report'] = 'displaying matches %s-%s of %s' % (start + 1, min( nres, start + count), nres) else: info['report'] = 'displaying all %s matches' % nres return render_template("hgcwa-search.html", info=info, title="Families of Higher Genus Curves with Automorphisms Search Result", credit=credit, bread=bread)
def genus2_curve_search(**args): info = to_dict(args) if 'download' in info and info['download'] == '1': return download_search(info) info["st_group_list"] = st_group_list info["st_group_dict"] = st_group_dict info["real_geom_end_alg_list"] = real_geom_end_alg_list info["real_geom_end_alg_to_ST0_dict"] = real_geom_end_alg_to_ST0_dict info["aut_grp_list"] = aut_grp_list info["aut_grp_dict"] = aut_grp_dict info["geom_aut_grp_list"] = geom_aut_grp_list info["geom_aut_grp_dict"] = geom_aut_grp_dict query = {} # database callable bread = [('Genus 2 Curves', url_for(".index")), ('$\Q$', url_for(".index_Q")), ('Search Results', '.')] #if 'SearchAgain' in args: # return rational_genus2_curves() if 'jump' in args: label_regex = re.compile(r'\d+\.[a-z]+.\d+.\d+') if label_regex.match(info["jump"].strip()): data = render_curve_webpage_by_label(info["jump"].strip()) else: data = "Invalid label" if data == "Invalid label": flash( Markup( "The label <span style='color:black'>%s</span> is invalid." % (info["jump"])), "error") return redirect(url_for(".index")) if data == "Data for curve not found": flash( Markup( "No genus 2 curve with label <span style='color:black'>%s</span> was found in the database." % (info["jump"])), "error") return redirect(url_for(".index")) return data try: parse_ints(info, query, 'abs_disc', 'absolute discriminant') parse_bool(info, query, 'is_gl2_type') parse_bool(info, query, 'has_square_sha') parse_bool(info, query, 'locally_solvable') for fld in ('st_group', 'real_geom_end_alg'): if info.get(fld): query[fld] = info[fld] for fld in ('aut_grp', 'geom_aut_grp'): parse_bracketed_posints(info, query, fld, exactlength=2) #Encoded into a GAP ID. # igusa and igusa_clebsch invariants not currently searchable parse_bracketed_posints(info, query, 'torsion', 'torsion structure', maxlength=4, check_divisibility="increasing") parse_ints(info, query, 'cond', 'conductor') parse_ints(info, query, 'num_rat_wpts', 'Weierstrass points') parse_ints(info, query, 'torsion_order') parse_ints(info, query, 'two_selmer_rank', '2-Selmer rank') parse_ints(info, query, 'analytic_rank', 'analytic rank') except ValueError as err: info['err'] = str(err) return render_template("search_results_g2.html", info=info, title='Genus 2 Curves Search Input Error', bread=bread, credit=credit_string) info["query"] = dict(query) count = parse_count(info, 50) start = parse_start(info) cursor = db_g2c().curves.find(query) nres = cursor.count() if (start >= nres): start -= (1 + (start - nres) / count) * count if (start < 0): start = 0 res = cursor.sort([("cond", pymongo.ASCENDING), ("class", pymongo.ASCENDING), ("disc_key", pymongo.ASCENDING), ("label", pymongo.ASCENDING)]).skip(start).limit(count) nres = res.count() if nres == 1: info["report"] = "unique match" else: if nres > count or start != 0: info['report'] = 'displaying matches %s-%s of %s' % ( start + 1, min(nres, start + count), nres) else: info['report'] = 'displaying all %s matches' % nres res_clean = [] for v in res: v_clean = {} v_clean["label"] = v["label"] v_clean["isog_label"] = v["class"] isogeny_class = db_g2c().isogeny_classes.find_one( {'label': isog_label(v["label"])}) v_clean["is_gl2_type"] = isogeny_class["is_gl2_type"] if isogeny_class["is_gl2_type"] == True: v_clean["is_gl2_type_display"] = '✔' #checkmark else: v_clean["is_gl2_type_display"] = '' v_clean["equation_formatted"] = list_to_min_eqn(v["min_eqn"]) v_clean["st_group_name"] = st_group_name(isogeny_class['st_group']) v_clean["analytic_rank"] = v["analytic_rank"] res_clean.append(v_clean) info["curves"] = res_clean info["curve_url"] = lambda dbc: url_for_label(dbc['label']) info["isog_url"] = lambda dbc: isog_url_for_label(dbc['label']) info["start"] = start info["count"] = count info["more"] = int(start + count < nres) credit = credit_string title = 'Genus 2 Curves search results' return render_template("search_results_g2.html", info=info, credit=credit, learnmore=learnmore_list(), bread=bread, title=title)
def galois_group_search(**args): info = to_dict(args) if info.get('jump_to'): return redirect(url_for('.by_label', label=info['jump_to']).strip(), 301) bread = get_bread([("Search Results", ' ')]) C = base.getDBConnection() query = {} def includes_composite(s): s = s.replace(' ','').replace('..','-') for interval in s.split(','): if '-' in interval[1:]: ix = interval.index('-',1) a,b = int(interval[:ix]), int(interval[ix+1:]) if b == a: if a != 1 and not a.is_prime(): return True if b > a and b > 3: return True else: a = ZZ(interval) if a != 1 and not a.is_prime(): return True try: parse_ints(info,query,'n','degree') parse_ints(info,query,'t') parse_ints(info,query,'order', qfield='orderkey', parse_singleton=make_order_key) parse_bracketed_posints(info, query, qfield='gapidfull', split=False, exactlength=2, keepbrackets=True, name='GAP id', field='gapid') for param in ('cyc', 'solv', 'prim', 'parity'): parse_bool(info,query,param,minus_one_to_zero=(param != 'parity')) degree_str = prep_ranges(info.get('n')) info['show_subs'] = degree_str is None or (LIST_RE.match(degree_str) and includes_composite(degree_str)) except ValueError as err: info['err'] = str(err) return search_input_error(info, bread) count = parse_count(info, 50) start = parse_start(info) if 'orderkey' in query and not ('n' in query): res = C.transitivegroups.groups.find(query).sort([('orderkey', pymongo.ASCENDING), ('gapid', pymongo.ASCENDING), ('n', pymongo.ASCENDING), ('t', pymongo.ASCENDING)]) else: res = C.transitivegroups.groups.find(query).sort([('n', pymongo.ASCENDING), ('t', pymongo.ASCENDING)]) nres = res.count() res = res.skip(start).limit(count) if(start >= nres): start -= (1 + (start - nres) / count) * count if(start < 0): start = 0 info['groups'] = res info['group_display'] = group_display_prettyC(C) info['report'] = "found %s groups" % nres info['yesno'] = yesno info['wgg'] = WebGaloisGroup.from_data info['start'] = start info['number'] = nres if nres == 1: info['report'] = 'unique match' else: if nres > count or start != 0: info['report'] = 'displaying matches %s-%s of %s' % (start + 1, min(nres, start + count), nres) else: info['report'] = 'displaying all %s matches' % nres return render_template("gg-search.html", info=info, title="Galois Group Search Result", bread=bread, credit=GG_credit)
def elliptic_curve_search(**args): info = to_dict(args) if "download" in info and info["download"] != "0": return download_search(info) query = {} bread = [ ("Elliptic Curves", url_for("ecnf.index")), ("$\Q$", url_for(".rational_elliptic_curves")), ("Search Results", "."), ] if "SearchAgain" in args: return rational_elliptic_curves() if "jump" in args: label = info.get("label", "").replace(" ", "") m = match_lmfdb_label(label) if m: try: return by_ec_label(label) except ValueError: return elliptic_curve_jump_error(label, info, wellformed_label=True) elif label.startswith("Cremona:"): label = label[8:] m = match_cremona_label(label) if m: try: return by_ec_label(label) except ValueError: return elliptic_curve_jump_error(label, info, wellformed_label=True) elif match_cremona_label(label): return elliptic_curve_jump_error(label, info, cremona_label=True) elif label: # Try to parse a string like [1,0,3,2,4] as valid # Weistrass coefficients: lab = re.sub(r"\s", "", label) lab = re.sub(r"^\[", "", lab) lab = re.sub(r"]$", "", lab) try: labvec = lab.split(",") labvec = [QQ(str(z)) for z in labvec] # Rationals allowed E = EllipticCurve(labvec) # Now we do have a valid curve over Q, but it might # not be in the database. ainvs = [str(c) for c in E.minimal_model().ainvs()] data = db_ec().find_one({"ainvs": ainvs}) if data is None: info["conductor"] = E.conductor() return elliptic_curve_jump_error(label, info, missing_curve=True) return by_ec_label(data["lmfdb_label"]) except (TypeError, ValueError, ArithmeticError): return elliptic_curve_jump_error(label, info) else: query["label"] = "" try: parse_rational(info, query, "jinv", "j-invariant") parse_ints(info, query, "conductor") parse_ints(info, query, "torsion", "torsion order") parse_ints(info, query, "rank") parse_ints(info, query, "sha", "analytic order of Ш") parse_bracketed_posints( info, query, "torsion_structure", maxlength=2, process=str, check_divisibility="increasing" ) parse_primes( info, query, "surj_primes", name="surjective primes", qfield="non-surjective_primes", mode="complement" ) if info.get("surj_quantifier") == "exactly": mode = "exact" else: mode = "append" parse_primes( info, query, "nonsurj_primes", name="non-surjective primes", qfield="non-surjective_primes", mode=mode ) except ValueError as err: info["err"] = str(err) return search_input_error(info, bread) count = parse_count(info, 100) start = parse_start(info) if "optimal" in info and info["optimal"] == "on": # fails on 990h3 query["number"] = 1 info["query"] = query cursor = db_ec().find(query) nres = cursor.count() if start >= nres: start -= (1 + (start - nres) / count) * count if start < 0: start = 0 res = ( cursor.sort([("conductor", ASCENDING), ("iso_nlabel", ASCENDING), ("lmfdb_number", ASCENDING)]) .skip(start) .limit(count) ) info["curves"] = res info["format_ainvs"] = format_ainvs info["curve_url"] = lambda dbc: url_for( ".by_triple_label", conductor=dbc["conductor"], iso_label=split_lmfdb_label(dbc["lmfdb_iso"])[1], number=dbc["lmfdb_number"], ) info["iso_url"] = lambda dbc: url_for( ".by_double_iso_label", conductor=dbc["conductor"], iso_label=split_lmfdb_label(dbc["lmfdb_iso"])[1] ) info["number"] = nres info["start"] = start info["count"] = count info["more"] = int(start + count < nres) if nres == 1: info["report"] = "unique match" elif nres == 2: info["report"] = "displaying both matches" else: if nres > count or start != 0: info["report"] = "displaying matches %s-%s of %s" % (start + 1, min(nres, start + count), nres) else: info["report"] = "displaying all %s matches" % nres credit = "John Cremona" if "non-surjective_primes" in query: credit += "and Andrew Sutherland" t = "Elliptic Curves search results" return render_template("search_results.html", info=info, credit=credit, bread=bread, title=t)
def elliptic_curve_search(**args): info = to_dict(args) if 'download' in info and info['download'] != '0': return download_search(info) query = {} bread = [('Elliptic Curves', url_for("ecnf.index")), ('$\Q$', url_for(".rational_elliptic_curves")), ('Search Results', '.')] if 'SearchAgain' in args: return rational_elliptic_curves() if 'jump' in args: label = info.get('label', '').replace(" ", "") m = match_lmfdb_label(label) if m: try: return by_ec_label(label) except ValueError: return elliptic_curve_jump_error(label, info, wellformed_label=True) elif label.startswith("Cremona:"): label = label[8:] m = match_cremona_label(label) if m: try: return by_ec_label(label) except ValueError: return elliptic_curve_jump_error(label, info, wellformed_label=True) elif match_cremona_label(label): return elliptic_curve_jump_error(label, info, cremona_label=True) elif label: # Try to parse a string like [1,0,3,2,4] as valid # Weistrass coefficients: lab = re.sub(r'\s','',label) lab = re.sub(r'^\[','',lab) lab = re.sub(r']$','',lab) try: labvec = lab.split(',') labvec = [QQ(str(z)) for z in labvec] # Rationals allowed E = EllipticCurve(labvec) # Now we do have a valid curve over Q, but it might # not be in the database. ainvs = [str(c) for c in E.minimal_model().ainvs()] data = db_ec().find_one({'ainvs': ainvs}) if data is None: info['conductor'] = E.conductor() return elliptic_curve_jump_error(label, info, missing_curve=True) return by_ec_label(data['lmfdb_label']) except (TypeError, ValueError, ArithmeticError): return elliptic_curve_jump_error(label, info) else: query['label'] = '' try: parse_rational(info,query,'jinv','j-invariant') parse_ints(info,query,'conductor') parse_ints(info,query,'torsion','torsion order') parse_ints(info,query,'rank') parse_ints(info,query,'sha','analytic order of Ш') parse_bracketed_posints(info,query,'torsion_structure',maxlength=2,process=str,check_divisibility='increasing') if 'include_cm' in info: if info['include_cm'] == 'exclude': query['cm'] = 0 elif info['include_cm'] == 'only': query['cm'] = {'$ne' : 0} parse_primes(info, query, 'surj_primes', name='surjective primes', qfield='non-surjective_primes', mode='complement') if info.get('surj_quantifier') == 'exactly': mode = 'exact' else: mode = 'append' parse_primes(info, query, 'nonsurj_primes', name='non-surjective primes', qfield='non-surjective_primes',mode=mode) except ValueError as err: info['err'] = str(err) return search_input_error(info, bread) count = parse_count(info,100) start = parse_start(info) if 'optimal' in info and info['optimal'] == 'on': # fails on 990h3 query['number'] = 1 info['query'] = query cursor = db_ec().find(query) nres = cursor.count() if(start >= nres): start -= (1 + (start - nres) / count) * count if(start < 0): start = 0 res = cursor.sort([('conductor', ASCENDING), ('iso_nlabel', ASCENDING), ('lmfdb_number', ASCENDING)]).skip(start).limit(count) info['curves'] = res info['format_ainvs'] = format_ainvs info['curve_url'] = lambda dbc: url_for(".by_triple_label", conductor=dbc['conductor'], iso_label=split_lmfdb_label(dbc['lmfdb_iso'])[1], number=dbc['lmfdb_number']) info['iso_url'] = lambda dbc: url_for(".by_double_iso_label", conductor=dbc['conductor'], iso_label=split_lmfdb_label(dbc['lmfdb_iso'])[1]) info['number'] = nres info['start'] = start info['count'] = count info['more'] = int(start + count < nres) if nres == 1: info['report'] = 'unique match' elif nres == 2: info['report'] = 'displaying both matches' else: if nres > count or start != 0: info['report'] = 'displaying matches %s-%s of %s' % (start + 1, min(nres, start + count), nres) else: info['report'] = 'displaying all %s matches' % nres credit = 'John Cremona' if 'non-surjective_primes' in query: credit += 'and Andrew Sutherland' t = 'Elliptic Curves search results' return render_template("search_results.html", info=info, credit=credit, bread=bread, title=t)
def hgm_search(info): #info = to_dict(args) bread = get_bread([("Search Results", '')]) query = {} queryab = {} queryabrev = {} if 'jump_to' in info: label = clean_input(info['jump_to']) if HGM_LABEL_RE.match(label): return render_hgm_webpage(normalize_motive(label)) if HGM_FAMILY_LABEL_RE.match(label): return render_hgm_family_webpage(normalize_family(label)) flash_error('%s is not a valid label for a hypergeometric motive or family of hypergeometric motives', label) return redirect(url_for(".index")) family_search = False if info.get('Submit Family') or info.get('family'): family_search = True # generic, irreducible not in DB yet try: parse_ints(info, query, 'degree') parse_ints(info, query, 'weight') parse_bracketed_posints(info, query, 'famhodge', 'family Hodge vector',split=False) parse_restricted(info, query, 'sign', allowed=['+1',1,-1], process=int) for param in ['A', 'B', 'A2', 'B2', 'A3', 'B3', 'A5', 'B5', 'A7', 'B7', 'Au2', 'Bu2', 'Au3', 'Bu3', 'Au5', 'Bu5', 'Au7', 'Bu7']: parse_bracketed_posints(info, queryab, param, split=False, listprocess=lambda a: sorted(a, reverse=True)) # Make a version to search reversed way if not family_search: parse_ints(info, query, 'conductor', 'Conductor' , 'cond') parse_rational(info, query, 't') parse_bracketed_posints(info, query, 'hodge', 'Hodge vector') except ValueError: if family_search: return render_template("hgm-search.html", info=info, title="Hypergeometric Family over $\Q$ Search Result", bread=bread, credit=HGM_credit, learnmore=learnmore_list()) return render_template("hgm-search.html", info=info, title="Hypergeometric Motive over $\Q$ Search Result", bread=bread, credit=HGM_credit, learnmore=learnmore_list()) # Now combine the parts of the query if there are A,B parts if queryab != {}: for k in queryab.keys(): queryabrev[k+'rev'] = queryab[k] queryab.update(query) queryabrev.update(query) query = {'$or':[queryab, queryabrev]} 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): start += (1 - (start + 1) / count) * count except: start = start_default else: start = start_default if info.get('paging'): try: paging = int(info['paging']) if paging == 0: start = 0 except: pass # logger.debug(query) if family_search: #query['leader'] = '1' res = familydb().find(query).sort([('label', pymongo.ASCENDING)]) else: res = motivedb().find(query).sort([('cond', pymongo.ASCENDING), ('label', pymongo.ASCENDING)]) nres = res.count() res = res.skip(start).limit(count) if(start >= nres): start -= (1 + (start - nres) / count) * count if(start < 0): start = 0 info['motives'] = res info['number'] = nres info['start'] = start if nres == 1: info['report'] = 'unique match' else: if nres > count or start != 0: info['report'] = 'displaying matches %s-%s of %s' % (start + 1, min(nres, start + count), nres) else: info['report'] = 'displaying all %s matches' % nres info['make_label'] = make_abt_label info['make_t_label'] = make_t_label info['ab_label'] = ab_label info['display_t'] = display_t info['family'] = family_search info['factorint'] = factorint if family_search: return render_template("hgm-search.html", info=info, title="Hypergeometric Family over $\Q$ Search Result", bread=bread, credit=HGM_credit, learnmore=learnmore_list()) else: return render_template("hgm-search.html", info=info, title="Hypergeometric Motive over $\Q$ Search Result", bread=bread, credit=HGM_credit, learnmore=learnmore_list())
def elliptic_curve_search(**args): info = to_dict(args['data']) if 'download' in info and info['download'] != 0: return download_search(info) bread = [('Elliptic Curves', url_for(".index")), ('Search Results', '.')] if 'jump' in info: label = info.get('label', '').replace(" ", "") # This label should be a full isogeny class label or a full # curve label (including the field_label component) try: nf, cond_label, iso_label, number = split_full_label(label.strip()) except ValueError: if not 'query' in info: info['query'] = {} info['err'] = '' return search_input_error(info, bread) return show_ecnf(nf, cond_label, iso_label, number) query = {} try: parse_ints(info,query,'conductor_norm') parse_noop(info,query,'conductor_label') parse_nf_string(info,query,'field',name="base number field",qfield='field_label') parse_nf_elt(info,query,'jinv',name='j-invariant') parse_ints(info,query,'torsion',name='Torsion order',qfield='torsion_order') parse_bracketed_posints(info,query,'torsion_structure',maxlength=2) except ValueError: return search_input_error(info, bread) if 'include_isogenous' in info and info['include_isogenous'] == 'off': info['number'] = 1 query['number'] = 1 if 'include_base_change' in info and info['include_base_change'] == 'off': query['base_change'] = [] else: info['include_base_change'] = "on" info['query'] = query count = parse_count(info, 50) start = parse_start(info) # make the query and trim results according to start/count: cursor = db_ecnf().find(query) nres = cursor.count() if(start >= nres): start -= (1 + (start - nres) / count) * count if(start < 0): start = 0 res = cursor.sort([('field_label', ASC), ('conductor_norm', ASC), ('conductor_label', ASC), ('iso_nlabel', ASC), ('number', ASC)]).skip(start).limit(count) res = list(res) for e in res: e['numb'] = str(e['number']) e['field_knowl'] = nf_display_knowl(e['field_label'], getDBConnection(), field_pretty(e['field_label'])) info['curves'] = res # [ECNF(e) for e in res] info['number'] = nres info['start'] = start info['count'] = count info['more'] = int(start + count < nres) info['field_pretty'] = field_pretty info['web_ainvs'] = web_ainvs if nres == 1: info['report'] = 'unique match' else: if nres > count or start != 0: info['report'] = 'displaying matches %s-%s of %s' % (start + 1, min(nres, start + count), nres) else: info['report'] = 'displaying all %s matches' % nres t = 'Elliptic Curve search results' return render_template("ecnf-search-results.html", info=info, credit=ecnf_credit, bread=bread, title=t)
def number_field_search(**args): info = to_dict(args) info['learnmore'] = [('Global number field labels', url_for(".render_labels_page")), ('Galois group labels', url_for(".render_groups_page")), (Completename, url_for(".render_discriminants_page")), ('Quadratic imaginary class groups', url_for(".render_class_group_data"))] t = 'Global Number Field search results' bread = [('Global Number Fields', url_for(".number_field_render_webpage")), ('Search results', ' ')] # for k in info.keys(): # nf_logger.debug(str(k) + ' ---> ' + str(info[k])) # nf_logger.debug('******************* '+ str(info['search'])) if 'natural' in info: query = {'label_orig': info['natural']} try: parse_nf_string(info,query,'natural',name="Label",qfield='label') return redirect(url_for(".by_label", label= clean_input(query['label_orig']))) except ValueError: query['err'] = info['err'] return search_input_error(query, bread) query = {} try: parse_galgrp(info,query, qfield='galois') parse_ints(info,query,'degree') parse_bracketed_posints(info,query,'signature',split=False,exactlength=2) parse_signed_ints(info,query,'discriminant',qfield=('disc_sign','disc_abs_key'),parse_one=make_disc_key) parse_ints(info,query,'class_number') parse_bracketed_posints(info,query,'class_group',split=False,check_divisibility='increasing') parse_primes(info,query,'ur_primes',name='Unramified primes',qfield='ramps',mode='complement',to_string=True) # modes are now contained (in), exactly, include if 'ram_quantifier' in info and str(info['ram_quantifier']) == 'include': mode = 'append' parse_primes(info,query,'ram_primes','ramified primes','ramps',mode,to_string=True) elif 'ram_quantifier' in info and str(info['ram_quantifier']) == 'contained': parse_primes(info,query,'ram_primes','ramified primes','ramps_all','subsets',to_string=False) pass # build list else: mode = 'liststring' parse_primes(info,query,'ram_primes','ramified primes','ramps_all',mode) except ValueError: return search_input_error(info, bread) count = parse_count(info) start = parse_start(info) if info.get('paging'): try: paging = int(info['paging']) if paging == 0: start = 0 except: pass C = base.getDBConnection() # nf_logger.debug(query) info['query'] = dict(query) if 'lucky' in args: one = C.numberfields.fields.find_one(query) if one: label = one['label'] return redirect(url_for(".by_label", label=clean_input(label))) fields = C.numberfields.fields res = fields.find(query) res = res.sort([('degree', ASC), ('disc_abs_key', ASC),('disc_sign', ASC)]) if 'download' in info and info['download'] != '0': return download_search(info, res) nres = res.count() res = res.skip(start).limit(count) if(start >= nres): start -= (1 + (start - nres) / count) * count if(start < 0): start = 0 info['fields'] = res info['number'] = nres info['start'] = start if nres == 1: info['report'] = 'unique match' else: if nres > count or start != 0: info['report'] = 'displaying matches %s-%s of %s' % (start + 1, min(nres, start + count), nres) else: info['report'] = 'displaying all %s matches' % nres info['wnf'] = WebNumberField.from_data return render_template("number_field_search.html", info=info, title=t, bread=bread)
def genus2_curve_search(**args): info = to_dict(args['data']) if 'jump' in info: jump = info["jump"].strip() curve_label_regex = re.compile(r'\d+\.[a-z]+.\d+.\d+$') if curve_label_regex.match(jump): return redirect(url_for_curve_label(jump), 301) else: class_label_regex = re.compile(r'\d+\.[a-z]+$') if class_label_regex.match(jump): return redirect(url_for_isogeny_class_label(jump), 301) else: # Handle direct Lhash input class_label_regex = re.compile(r'#\d+$') if class_label_regex.match(jump) and ZZ(jump[1:]) < 2**61: c = g2cdb().isogeny_classes.find_one({'Lhash': jump[1:].strip()}) if c: return redirect(url_for_isogeny_class_label(c["label"]), 301) else: errmsg = "Hash not found" else: errmsg = "Invalid label" flash(Markup(errmsg + " <span style='color:black'>%s</span>"%(jump)),"error") return redirect(url_for(".index")) if 'download' in info and info['download'] == '1': return download_search(info) info["st_group_list"] = st_group_list info["st_group_dict"] = st_group_dict info["real_geom_end_alg_list"] = real_geom_end_alg_list info["real_geom_end_alg_to_ST0_dict"] = real_geom_end_alg_to_ST0_dict info["aut_grp_list"] = aut_grp_list info["aut_grp_dict"] = aut_grp_dict info["geom_aut_grp_list"] = geom_aut_grp_list info["geom_aut_grp_dict"] = geom_aut_grp_dict bread = info.get('bread',(('Genus 2 Curves', url_for(".index")), ('$\Q$', url_for(".index_Q")), ('Search Results', '.'))) query = {} try: parse_ints(info,query,'abs_disc','absolute discriminant') parse_bool(info,query,'is_gl2_type') parse_bool(info,query,'has_square_sha') parse_bool(info,query,'locally_solvable') parse_bool(info,query,'is_simple_geom') parse_bracketed_posints(info, query, 'torsion', 'torsion structure', maxlength=4,check_divisibility="increasing") parse_ints(info,query,'cond') parse_ints(info,query,'num_rat_wpts','Weierstrass points') parse_ints(info,query,'torsion_order') if 'torsion' in query and not 'torsion_order' in query: query['torsion_order'] = reduce(mul,[int(n) for n in query['torsion']],1) parse_ints(info,query,'two_selmer_rank','2-Selmer rank') parse_ints(info,query,'analytic_rank','analytic rank') # G2 invariants and drop-list items don't require parsing -- they are all strings (supplied by us, not the user) if 'g20' in info and 'g21' in info and 'g22' in info: query['g2inv'] = [ info['g20'], info['g21'], info['g22'] ] if 'class' in info: query['class'] = info['class'] for fld in ('st_group', 'real_geom_end_alg', 'aut_grp_id', 'geom_aut_grp_id'): if info.get(fld): query[fld] = info[fld] except ValueError as err: info['err'] = str(err) return render_template("search_results_g2.html", info=info, title='Genus 2 Curves Search Input Error', bread=bread, credit=credit_string) info["query"] = dict(query) # Database query happens here cursor = g2cdb().curves.find(query,{'_id':int(0),'label':int(1),'min_eqn':int(1),'st_group':int(1),'is_gl2_type':int(1),'analytic_rank':int(1)}) count = parse_count(info, 50) start = parse_start(info) nres = cursor.count() if(start >= nres): start -= (1 + (start - nres) / count) * count if(start < 0): start = 0 res = cursor.sort([("cond", ASCENDING), ("class", ASCENDING), ("disc_key", ASCENDING), ("label", ASCENDING)]).skip(start).limit(count) nres = res.count() if nres == 1: info["report"] = "unique match" else: if nres > count or start != 0: info['report'] = 'displaying matches %s-%s of %s' % (start + 1, min(nres, start + count), nres) else: info['report'] = 'displaying all %s matches' % nres res_clean = [] for v in res: v_clean = {} v_clean["label"] = v["label"] v_clean["class"] = class_from_curve_label(v["label"]) v_clean["is_gl2_type"] = v["is_gl2_type"] v_clean["is_gl2_type_display"] = '✔' if v["is_gl2_type"] else '' # display checkmark if true, blank otherwise v_clean["equation_formatted"] = list_to_min_eqn(v["min_eqn"]) v_clean["st_group_name"] = st_group_name(v['st_group']) v_clean["st_group_href"] = st_group_href(v['st_group']) v_clean["analytic_rank"] = v["analytic_rank"] res_clean.append(v_clean) info["curves"] = res_clean info["curve_url"] = lambda label: url_for_curve_label(label) info["class_url"] = lambda label: url_for_isogeny_class_label(label) info["start"] = start info["count"] = count info["more"] = int(start+count<nres) title = info.get('title','Genus 2 Curve search results') credit = credit_string return render_template("search_results_g2.html", info=info, credit=credit,learnmore=learnmore_list(), bread=bread, title=title)
def genus2_curve_search(**args): info = to_dict(args['data']) if 'jump' in info: jump = info["jump"].strip() curve_label_regex = re.compile(r'\d+\.[a-z]+.\d+.\d+$') if curve_label_regex.match(jump): return redirect(url_for_curve_label(jump), 301) else: class_label_regex = re.compile(r'\d+\.[a-z]+$') if class_label_regex.match(jump): return redirect(url_for_isogeny_class_label(jump), 301) else: # Handle direct Lhash input class_label_regex = re.compile(r'#\d+$') if class_label_regex.match(jump) and ZZ(jump[1:]) < 2**61: c = g2cdb().isogeny_classes.find_one( {'Lhash': jump[1:].strip()}) if c: return redirect( url_for_isogeny_class_label(c["label"]), 301) else: errmsg = "Hash not found" else: errmsg = "Invalid label" flash(Markup(errmsg + " <span style='color:black'>%s</span>" % (jump)), "error") return redirect(url_for(".index")) if 'download' in info and info['download'] == '1': return download_search(info) info["st_group_list"] = st_group_list info["st_group_dict"] = st_group_dict info["real_geom_end_alg_list"] = real_geom_end_alg_list info["real_geom_end_alg_to_ST0_dict"] = real_geom_end_alg_to_ST0_dict info["aut_grp_list"] = aut_grp_list info["aut_grp_dict"] = aut_grp_dict info["geom_aut_grp_list"] = geom_aut_grp_list info["geom_aut_grp_dict"] = geom_aut_grp_dict bread = info.get('bread', (('Genus 2 Curves', url_for(".index")), ('$\Q$', url_for(".index_Q")), ('Search Results', '.'))) query = {} try: parse_ints(info, query, 'abs_disc', 'absolute discriminant') parse_bool(info, query, 'is_gl2_type') parse_bool(info, query, 'has_square_sha') parse_bool(info, query, 'locally_solvable') parse_bool(info, query, 'is_simple_geom') parse_bracketed_posints(info, query, 'torsion', 'torsion structure', maxlength=4, check_divisibility="increasing") parse_ints(info, query, 'cond') parse_ints(info, query, 'num_rat_wpts', 'Weierstrass points') parse_ints(info, query, 'torsion_order') if 'torsion' in query and not 'torsion_order' in query: query['torsion_order'] = reduce(mul, [int(n) for n in query['torsion']], 1) parse_ints(info, query, 'two_selmer_rank', '2-Selmer rank') parse_ints(info, query, 'analytic_rank', 'analytic rank') # G2 invariants and drop-list items don't require parsing -- they are all strings (supplied by us, not the user) if 'g20' in info and 'g21' in info and 'g22' in info: query['g2inv'] = [info['g20'], info['g21'], info['g22']] if 'class' in info: query['class'] = info['class'] for fld in ('st_group', 'real_geom_end_alg', 'aut_grp_id', 'geom_aut_grp_id'): if info.get(fld): query[fld] = info[fld] except ValueError as err: info['err'] = str(err) return render_template("search_results_g2.html", info=info, title='Genus 2 Curves Search Input Error', bread=bread, credit=credit_string) info["query"] = dict(query) # Database query happens here cursor = g2cdb().curves.find( query, { '_id': int(0), 'label': int(1), 'min_eqn': int(1), 'st_group': int(1), 'is_gl2_type': int(1), 'analytic_rank': int(1) }) count = parse_count(info, 50) start = parse_start(info) nres = cursor.count() if (start >= nres): start -= (1 + (start - nres) / count) * count if (start < 0): start = 0 res = cursor.sort([("cond", ASCENDING), ("class", ASCENDING), ("disc_key", ASCENDING), ("label", ASCENDING)]).skip(start).limit(count) nres = res.count() if nres == 1: info["report"] = "unique match" else: if nres > count or start != 0: info['report'] = 'displaying matches %s-%s of %s' % ( start + 1, min(nres, start + count), nres) else: info['report'] = 'displaying all %s matches' % nres res_clean = [] for v in res: v_clean = {} v_clean["label"] = v["label"] v_clean["class"] = class_from_curve_label(v["label"]) v_clean["is_gl2_type"] = v["is_gl2_type"] v_clean["is_gl2_type_display"] = '✔' if v[ "is_gl2_type"] else '' # display checkmark if true, blank otherwise v_clean["equation_formatted"] = list_to_min_eqn(v["min_eqn"]) v_clean["st_group_name"] = st_group_name(v['st_group']) v_clean["st_group_href"] = st_group_href(v['st_group']) v_clean["analytic_rank"] = v["analytic_rank"] res_clean.append(v_clean) info["curves"] = res_clean info["curve_url"] = lambda label: url_for_curve_label(label) info["class_url"] = lambda label: url_for_isogeny_class_label(label) info["start"] = start info["count"] = count info["more"] = int(start + count < nres) title = info.get('title', 'Genus 2 Curve search results') credit = credit_string return render_template("search_results_g2.html", info=info, credit=credit, learnmore=learnmore_list(), bread=bread, title=title)
def genus2_curve_search(**args): info = to_dict(args) if 'download' in info and info['download'] == '1': return download_search(info) info["st_group_list"] = st_group_list info["st_group_dict"] = st_group_dict info["real_geom_end_alg_list"] = real_geom_end_alg_list info["real_geom_end_alg_to_ST0_dict"] = real_geom_end_alg_to_ST0_dict info["aut_grp_list"] = aut_grp_list info["aut_grp_dict"] = aut_grp_dict info["geom_aut_grp_list"] = geom_aut_grp_list info["geom_aut_grp_dict"] = geom_aut_grp_dict query = {} # database callable bread = [('Genus 2 Curves', url_for(".index")), ('$\Q$', url_for(".index_Q")), ('Search Results', '.')] #if 'SearchAgain' in args: # return rational_genus2_curves() if 'jump' in args: curve_label_regex = re.compile(r'\d+\.[a-z]+.\d+.\d+$') if curve_label_regex.match(info["jump"].strip()): data = render_curve_webpage_by_label(info["jump"].strip()) else: class_label_regex = re.compile(r'\d+\.[a-z]+$') if class_label_regex.match(info["jump"].strip()): data = render_isogeny_class(info["jump"].strip()) else: class_label_regex = re.compile(r'#\d+$') if class_label_regex.match(info["jump"].strip()) and ZZ(info["jump"][1:]) < 2**61: c = g2cdb().isogeny_classes.find_one({'hash':int(info["jump"][1:])}) if c: data = render_isogeny_class(c["label"]) else: data = "Hash not found" else: data = "Invalid label" if isinstance(data,str): flash(Markup(data + " <span style='color:black'>%s</span>"%(info["jump"])),"error") return redirect(url_for(".index")) return data try: parse_ints(info,query,'abs_disc','absolute discriminant') parse_bool(info,query,'is_gl2_type') parse_bool(info,query,'has_square_sha') parse_bool(info,query,'locally_solvable') parse_bracketed_posints(info, query, 'torsion', 'torsion structure', maxlength=4,check_divisibility="increasing") parse_ints(info,query,'cond','conductor') parse_ints(info,query,'num_rat_wpts','Weierstrass points') parse_ints(info,query,'torsion_order') parse_ints(info,query,'two_selmer_rank','2-Selmer rank') parse_ints(info,query,'analytic_rank','analytic rank') # G2 invariants and drop-list items don't require parsing -- they are all strings (supplied by us, not the user) if info.get('g20') and info.get('g21') and info.get('g22'): query['g2inv'] = [ info['g20'], info['g21'], info['g22'] ] for fld in ('st_group', 'real_geom_end_alg', 'aut_grp_id', 'geom_aut_grp_id'): if info.get(fld): query[fld] = info[fld] except ValueError as err: info['err'] = str(err) return render_template("search_results_g2.html", info=info, title='Genus 2 Curves Search Input Error', bread=bread, credit=credit_string) info["query"] = dict(query) count = parse_count(info, 50) start = parse_start(info) cursor = g2cdb().curves.find(query) nres = cursor.count() if(start >= nres): start -= (1 + (start - nres) / count) * count if(start < 0): start = 0 res = cursor.sort([("cond", pymongo.ASCENDING), ("class", pymongo.ASCENDING), ("disc_key", pymongo.ASCENDING), ("label", pymongo.ASCENDING)]).skip(start).limit(count) nres = res.count() if nres == 1: info["report"] = "unique match" else: if nres > count or start != 0: info['report'] = 'displaying matches %s-%s of %s' % (start + 1, min(nres, start + count), nres) else: info['report'] = 'displaying all %s matches' % nres res_clean = [] for v in res: v_clean = {} v_clean["label"] = v["label"] v_clean["isog_label"] = v["class"] isogeny_class = g2cdb().isogeny_classes.find_one({'label' : isog_label(v["label"])}) v_clean["is_gl2_type"] = isogeny_class["is_gl2_type"] if isogeny_class["is_gl2_type"] == True: v_clean["is_gl2_type_display"] = '✔' #checkmark else: v_clean["is_gl2_type_display"] = '' v_clean["equation_formatted"] = list_to_min_eqn(v["min_eqn"]) v_clean["st_group_name"] = st_group_name(isogeny_class['st_group']) v_clean["st_group_href"] = st_group_href(isogeny_class['st_group']) v_clean["analytic_rank"] = v["analytic_rank"] res_clean.append(v_clean) info["curves"] = res_clean info["curve_url"] = lambda dbc: url_for_label(dbc['label']) info["isog_url"] = lambda dbc: isog_url_for_label(dbc['label']) info["start"] = start info["count"] = count info["more"] = int(start+count<nres) credit = credit_string title = 'Genus 2 Curves search results' return render_template("search_results_g2.html", info=info, credit=credit,learnmore=learnmore_list(), bread=bread, title=title)
def belyi_search(info): if 'jump' in info: jump = info["jump"].strip() if re.match(r'^\d+T\d+-\[\d+,\d+,\d+\]-\d+-\d+-\d+-g\d+-[a-z]+$', jump): return redirect(url_for_belyi_galmap_label(jump), 301) else: if re.match(r'^\d+T\d+-\[\d+,\d+,\d+\]-\d+-\d+-\d+-g\d+$', jump): return redirect(url_for_belyi_passport_label(jump), 301) else: errmsg = "%s is not a valid Belyi map or passport label" flash_error(errmsg, jump) return redirect(url_for(".index")) if info.get('download', '').strip(): return download_search(info) #search options info['geometry_types_list'] = geometry_types_list info['geometry_types_dict'] = geometry_types_dict bread = info.get('bread', (('Belyi Maps', url_for(".index")), ('Search Results', '.'))) query = {} try: if 'group' in query: info['group'] = query['group'] parse_bracketed_posints(info, query, 'abc_list', 'a, b, c', maxlength=3) if query.get('abc_list'): if len(query['abc_list']) == 3: a, b, c = sorted(query['abc_list']) query['a_s'] = a query['b_s'] = b query['c_s'] = c elif len(query['abc_list']) == 2: a, b = sorted(query['abc_list']) sub_query = [] sub_query.append({ 'a_s': a, 'b_s': b }) sub_query.append({ 'b_s': a, 'c_s': b }) query['$or'] = sub_query elif len(query['abc_list']) == 1: a = query['abc_list'][0] query['$or'] = [{ 'a_s': a }, { 'b_s': a }, { 'c_s': a }] query.pop('abc_list') # a naive hack if info.get('abc'): for elt in ['a_s', 'b_s', 'c_s']: info_hack = {} info_hack[elt] = info['abc'] parse_ints(info_hack, query, elt) parse_ints(info, query, 'g', 'g') parse_ints(info, query, 'deg', 'deg') parse_ints(info, query, 'orbit_size', 'orbit_size') # invariants and drop-list items don't require parsing -- they are all strings (supplied by us, not the user) for fld in ['geomtype', 'group']: if info.get(fld): query[fld] = info[fld] except ValueError as err: info['err'] = str(err) return render_template("belyi_search_results.html", info=info, title='Belyi Maps Search Input Error', bread=bread, credit=credit_string) # Database query happens here info["query"] = query # save query for reuse in download_search cursor = belyi_db_galmaps().find( query, { '_id': False, 'label': True, 'group': True, 'abc': True, 'g': True, 'deg': True, 'geomtype': True, 'orbit_size': True }) count = parse_count(info, 50) start = parse_start(info) nres = cursor.count() if (start >= nres): start -= (1 + (start - nres) / count) * count if (start < 0): start = 0 res = cursor.sort([("deg", ASCENDING), ("group_num", ASCENDING), ("g", ASCENDING), ("label", ASCENDING)]).skip(start).limit(count) nres = res.count() if nres == 1: info["report"] = "unique match" else: if nres > count or start != 0: info['report'] = 'displaying matches %s-%s of %s' % ( start + 1, min(nres, start + count), nres) else: info['report'] = 'displaying all %s matches' % nres res_clean = [] for v in res: v_clean = {} for key in ('label', 'group', 'deg', 'g', 'orbit_size'): v_clean[key] = v[key] v_clean['geomtype'] = geometry_types_dict[v['geomtype']] res_clean.append(v_clean) info["belyi_galmaps"] = res_clean info["belyi_galmap_url"] = lambda label: url_for_belyi_galmap_label(label) info["start"] = start info["count"] = count info["more"] = int(start + count < nres) title = info.get('title', 'Belyi map search results') credit = credit_string return render_template("belyi_search_results.html", info=info, credit=credit, learnmore=learnmore_list(), bread=bread, title=title)
def higher_genus_w_automorphisms_search(**args): info = to_dict(args) bread = get_bread([("Search results", '')]) C = base.getDBConnection() query = {} if 'jump_to' in info: labs = info['jump_to'] if label_is_one_passport(labs): return render_passport({'passport_label': labs}) elif label_is_one_family(labs): return render_family({'label': labs}) else: flash_error( "The label %s is not a legitimate label for this data.", labs) return redirect(url_for(".index")) #allow for ; in signature if info.get('signature'): info['signature'] = info['signature'].replace(';', ',') try: parse_gap_id(info, query, 'group', 'Group') parse_ints(info, query, 'genus', name='Genus') parse_bracketed_posints(info, query, 'signature', split=False, name='Signature', keepbrackets=True) if query.get('signature'): query['signature'] = info['signature'] = str( sort_sign(ast.literal_eval(query['signature']))).replace( ' ', '') parse_ints(info, query, 'dim', name='Dimension of the family') if 'inc_hyper' in info: if info['inc_hyper'] == 'exclude': query['hyperelliptic'] = False elif info['inc_hyper'] == 'only': query['hyperelliptic'] = True if 'inc_cyc_trig' in info: if info['inc_cyc_trig'] == 'exclude': query['cyclic_trigonal'] = False elif info['inc_cyc_trig'] == 'only': query['cyclic_trigonal'] = True if 'inc_full' in info: if info['inc_full'] == 'exclude': query['full_auto'] = {'$exists': True} elif info['inc_full'] == 'only': query['full_auto'] = {'$exists': False} query['cc.1'] = 1 except ValueError: return search_input_error(info, bread) count = parse_count(info) start = parse_start(info) if 'groupsize' in info and info['groupsize'] != '': err, result = add_group_order_range(query, info['groupsize'], C) if err != None: flash_error( 'Parse error on group order field. <font face="Courier New"><br />Given: ' + err + '<br />-------' + result + '</font>') """ res = C.curve_automorphisms.passports.find(query).sort([( 'genus', pymongo.ASCENDING), ('dim', pymongo.ASCENDING), ('cc'[0],pymongo.ASCENDING)]) nres = res.count() res = res.skip(start).limit(count) if(start >= nres): start -= (1 + (start - nres) / count) * count if(start < 0): start = 0 L = [ ] for field in res: field['signature'] = ast.literal_eval(field['signature']) L.append(field) code = "" download_code = 'download' in info first_download_entry = True for field in L: field['signature'] = ast.literal_eval(field['signature']) if download_code: if first_download_entry: code += '\n'.join(hgcwa_code(label=field['passport_label'], download_type='magma').split('\n')[1:]) else: code += hgcwa_code(label=field['passport_label'], download_type='magma').split('result_record:=[];')[1] first_download_entry = False if 'download' in info: response = make_response(code) response.headers['Content-type'] = 'text/plain' return response """ res = C.curve_automorphisms.passports.find(query).sort([ ('genus', pymongo.ASCENDING), ('dim', pymongo.ASCENDING), ('cc'[0], pymongo.ASCENDING) ]) nres = res.count() res = res.skip(start).limit(count) if (start >= nres): start -= (1 + (start - nres) / count) * count if (start < 0): start = 0 L = [] for field in res: field['signature'] = ast.literal_eval(field['signature']) L.append(field) if 'download_magma' in info: code = "// MAGMA CODE FOR SEACH RESULTS\n\n" first_download_entry = True for field in L: #print field if first_download_entry: code += ('\n'.join( hgcwa_code(label=field['passport_label'], download_type='magma').split('\n')[1:] )).replace( ", and generate data which is the same for all entries", "") else: code += hgcwa_code( label=field['passport_label'], download_type='magma').split('result_record:=[];')[1] first_download_entry = False response = make_response(code) response.headers['Content-type'] = 'text/plain' return response elif 'download_gap' in info: code = "# GAP CODE FOR SEARCH RESULTS\n\n" first_download_entry = True for field in L: print field['group'] if first_download_entry: code += ('\n'.join( hgcwa_code(label=field['passport_label'], download_type='gap').split('\n') [1:])).replace( "# Generate data which is the same for all entries.\n", "") else: code += hgcwa_code( label=field['passport_label'], download_type='gap').split('result_record:=[];')[1] first_download_entry = False response = make_response(code) response.headers['Content-type'] = 'text/plain' return response info['fields'] = L info['number'] = nres info['group_display'] = sg_pretty info['show_downloads'] = len(L) > 0 info['sign_display'] = sign_display info['start'] = start if nres == 1: info['report'] = 'unique match' else: if nres > count or start != 0: info['report'] = 'displaying matches %s-%s of %s' % ( start + 1, min(nres, start + count), nres) else: info['report'] = 'displaying all %s matches' % nres return render_template( "hgcwa-search.html", info=info, title= "Families of Higher Genus Curves with Automorphisms Search Result", credit=credit, bread=bread)
def elliptic_curve_search(**args): info = to_dict(args["data"]) if "download" in info and info["download"] != 0: return download_search(info) if not "query" in info: info["query"] = {} bread = [("Elliptic Curves", url_for(".index")), ("Search Results", ".")] if "jump" in info: label = info.get("label", "").replace(" ", "") # This label should be a full isogeny class label or a full # curve label (including the field_label component) try: nf, cond_label, iso_label, number = split_full_label(label.strip()) except ValueError: info["err"] = "" return search_input_error(info, bread) return show_ecnf(nf, cond_label, iso_label, number) query = {} try: parse_ints(info, query, "conductor_norm") parse_noop(info, query, "conductor_label") parse_nf_string(info, query, "field", name="base number field", qfield="field_label") parse_nf_elt(info, query, "jinv", name="j-invariant") parse_ints(info, query, "torsion", name="Torsion order", qfield="torsion_order") parse_bracketed_posints(info, query, "torsion_structure", maxlength=2) if "torsion_structure" in query and not "torsion_order" in query: query["torsion_order"] = reduce(mul, [int(n) for n in query["torsion_structure"]], 1) except ValueError: return search_input_error(info, bread) if "include_isogenous" in info and info["include_isogenous"] == "off": info["number"] = 1 query["number"] = 1 if "include_base_change" in info and info["include_base_change"] == "off": query["base_change"] = [] else: info["include_base_change"] = "on" if "include_Q_curves" in info: if info["include_Q_curves"] == "exclude": query["q_curve"] = False elif info["include_Q_curves"] == "only": query["q_curve"] = True if "include_cm" in info: if info["include_cm"] == "exclude": query["cm"] = 0 elif info["include_cm"] == "only": query["cm"] = {"$ne": 0} info["query"] = query count = parse_count(info, 50) start = parse_start(info) # make the query and trim results according to start/count: cursor = db_ecnf().find(query) nres = cursor.count() if start >= nres: start -= (1 + (start - nres) / count) * count if start < 0: start = 0 res = ( cursor.sort( [ ("field_label", ASC), ("conductor_norm", ASC), ("conductor_label", ASC), ("iso_nlabel", ASC), ("number", ASC), ] ) .skip(start) .limit(count) ) res = list(res) for e in res: e["numb"] = str(e["number"]) e["field_knowl"] = nf_display_knowl(e["field_label"], getDBConnection(), field_pretty(e["field_label"])) info["curves"] = res # [ECNF(e) for e in res] info["number"] = nres info["start"] = start info["count"] = count info["more"] = int(start + count < nres) info["field_pretty"] = field_pretty info["web_ainvs"] = web_ainvs if nres == 1: info["report"] = "unique match" else: if nres > count or start != 0: info["report"] = "displaying matches %s-%s of %s" % (start + 1, min(nres, start + count), nres) else: info["report"] = "displaying all %s matches" % nres t = "Elliptic Curve search results" return render_template("ecnf-search-results.html", info=info, credit=ecnf_credit, bread=bread, title=t)
def genus2_curve_search(info): if 'jump' in info: jump = info["jump"].strip() if re.match(r'^\d+\.[a-z]+\.\d+\.\d+$', jump): return redirect(url_for_curve_label(jump), 301) else: if re.match(r'^\d+\.[a-z]+$', jump): return redirect(url_for_isogeny_class_label(jump), 301) else: # Handle direct Lhash input if re.match(r'^\#\d+$', jump) and ZZ(jump[1:]) < 2**61: c = g2c_db_curves().find_one({'Lhash': jump[1:].strip()}) if c: return redirect( url_for_isogeny_class_label(c["class"]), 301) else: errmsg = "hash %s not found" else: errmsg = "%s is not a valid genus 2 curve or isogeny class label" flash_error(errmsg, jump) return redirect(url_for(".index")) if info.get('download', '').strip() == '1': return download_search(info) info["st_group_list"] = st_group_list info["st_group_dict"] = st_group_dict info["real_geom_end_alg_list"] = real_geom_end_alg_list info["real_geom_end_alg_to_ST0_dict"] = real_geom_end_alg_to_ST0_dict info["aut_grp_list"] = aut_grp_list info["aut_grp_dict"] = aut_grp_dict info["geom_aut_grp_list"] = geom_aut_grp_list info["geom_aut_grp_dict"] = geom_aut_grp_dict bread = info.get('bread', (('Genus 2 Curves', url_for(".index")), ('$\Q$', url_for(".index_Q")), ('Search Results', '.'))) query = {} try: parse_ints(info, query, 'abs_disc', 'absolute discriminant') parse_bool(info, query, 'is_gl2_type', 'is of GL2-type') parse_bool(info, query, 'has_square_sha', 'has square Sha') parse_bool(info, query, 'locally_solvable', 'is locally solvable') parse_bool(info, query, 'is_simple_geom', 'is geometrically simple') parse_ints(info, query, 'cond', 'conductor') parse_ints(info, query, 'num_rat_wpts', 'rational Weierstrass points') parse_bracketed_posints(info, query, 'torsion', 'torsion structure', maxlength=4, check_divisibility="increasing") parse_ints(info, query, 'torsion_order', 'torsion order') if 'torsion' in query and not 'torsion_order' in query: query['torsion_order'] = reduce(mul, [int(n) for n in query['torsion']], 1) if 'torsion' in query: query['torsion_subgroup'] = str(query['torsion']).replace(" ", "") query.pop('torsion') # search using string key, not array of ints parse_ints(info, query, 'two_selmer_rank', '2-Selmer rank') parse_ints(info, query, 'analytic_rank', 'analytic rank') # G2 invariants and drop-list items don't require parsing -- they are all strings (supplied by us, not the user) if 'g20' in info and 'g21' in info and 'g22' in info: query['g2_inv'] = "['%s','%s','%s']" % (info['g20'], info['g21'], info['g22']) if 'class' in info: query['class'] = info['class'] for fld in ('st_group', 'real_geom_end_alg', 'aut_grp_id', 'geom_aut_grp_id'): if info.get(fld): query[fld] = info[fld] except ValueError as err: info['err'] = str(err) return render_template("g2c_search_results.html", info=info, title='Genus 2 Curves Search Input Error', bread=bread, credit=credit_string) # Database query happens here info["query"] = query # save query for reuse in download_search cursor = g2c_db_curves().find( query, { '_id': False, 'label': True, 'eqn': True, 'st_group': True, 'is_gl2_type': True, 'is_simple_geom': True, 'analytic_rank': True }) count = parse_count(info, 50) start = parse_start(info) nres = cursor.count() if (start >= nres): start -= (1 + (start - nres) / count) * count if (start < 0): start = 0 res = cursor.sort([("cond", ASCENDING), ("class", ASCENDING), ("disc_key", ASCENDING), ("label", ASCENDING)]).skip(start).limit(count) nres = res.count() if nres == 1: info["report"] = "unique match" else: if nres > count or start != 0: info['report'] = 'displaying matches %s-%s of %s' % ( start + 1, min(nres, start + count), nres) else: info['report'] = 'displaying all %s matches' % nres res_clean = [] for v in res: v_clean = {} v_clean["label"] = v["label"] v_clean["class"] = class_from_curve_label(v["label"]) v_clean["is_gl2_type"] = v["is_gl2_type"] v_clean["is_simple_geom"] = v["is_simple_geom"] v_clean["equation_formatted"] = list_to_min_eqn(literal_eval(v["eqn"])) v_clean["st_group_link"] = st_link_by_name(1, 4, v['st_group']) v_clean["analytic_rank"] = v["analytic_rank"] res_clean.append(v_clean) info["curves"] = res_clean info["curve_url"] = lambda label: url_for_curve_label(label) info["class_url"] = lambda label: url_for_isogeny_class_label(label) info["start"] = start info["count"] = count info["more"] = int(start + count < nres) title = info.get('title', 'Genus 2 Curve search results') credit = credit_string return render_template("g2c_search_results.html", info=info, credit=credit, learnmore=learnmore_list(), bread=bread, title=title)
def hgm_search(**args): info = to_dict(args) bread = get_bread([("Search results", '')]) 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 try: parse_ints(info, query, 'degree') parse_ints(info, query, 'weight') parse_bracketed_posints(info, query, 'famhodge', 'family Hodge vector',split=False) parse_restricted(info, query, 'sign', allowed=['+1',1,-1], process=int) for param in ['A', 'B', 'A2', 'B2', 'A3', 'B3', 'A5', 'B5', 'A7', 'B7', 'Au2', 'Bu2', 'Au3', 'Bu3', 'Au5', 'Bu5', 'Au7', 'Bu7']: parse_bracketed_posints(info, query, param, split=False, listprocess=lambda a: sorted(a, reverse=True)) if not family_search: parse_ints(info, query, 'conductor') parse_rational(info, query, 't') parse_bracketed_posints(info, query, 'hodge', 'Hodge vector') except ValueError: return search_input_error(info, bread) #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): start += (1 - (start + 1) / count) * count except: start = start_default else: start = start_default if info.get('paging'): try: paging = int(info['paging']) if paging == 0: start = 0 except: pass # logger.debug(query) if family_search: #query['leader'] = '1' res = familydb().find(query).sort([('label', pymongo.ASCENDING)]) else: res = motivedb().find(query).sort([('cond', pymongo.ASCENDING), ('label', pymongo.ASCENDING)]) nres = res.count() res = res.skip(start).limit(count) if(start >= nres): start -= (1 + (start - nres) / count) * count if(start < 0): start = 0 info['motives'] = res info['number'] = nres info['start'] = start if nres == 1: info['report'] = 'unique match' else: if nres > count or start != 0: info['report'] = 'displaying matches %s-%s of %s' % (start + 1, min(nres, start + count), nres) else: info['report'] = 'displaying all %s matches' % nres info['make_label'] = make_abt_label info['make_t_label'] = make_t_label info['ab_label'] = ab_label info['display_t'] = display_t info['family'] = family_search info['factorint'] = factorint if family_search: return render_template("hgm-search.html", info=info, title="Hypergeometric Family over $\Q$ Search Result", bread=bread, credit=HGM_credit, learnmore=learnmore_list()) else: return render_template("hgm-search.html", info=info, title="Hypergeometric Motive over $\Q$ Search Result", bread=bread, credit=HGM_credit, learnmore=learnmore_list())
def galois_group_search(**args): info = to_dict(args) if info.get('jump_to'): return redirect(url_for('.by_label', label=info['jump_to']).strip(), 301) bread = get_bread([("Search Results", ' ')]) C = base.getDBConnection() query = {} def includes_composite(s): s = s.replace(' ','').replace('..','-') for interval in s.split(','): if '-' in interval[1:]: ix = interval.index('-',1) a,b = int(interval[:ix]), int(interval[ix+1:]) if b == a: if a != 1 and not a.is_prime(): return True if b > a and b > 3: return True else: a = ZZ(interval) if a != 1 and not a.is_prime(): return True try: parse_ints(info,query,'n','degree') parse_ints(info,query,'t') parse_ints(info,query,'order', qfield='orderkey', parse_singleton=make_order_key) parse_bracketed_posints(info, query, qfield='gapidfull', split=False, exactlength=2, keepbrackets=True, name='Gap id', field='gapid') for param in ('cyc', 'solv', 'prim', 'parity'): parse_bool(info,query,param,minus_one_to_zero=(param != 'parity')) degree_str = prep_ranges(info.get('n')) info['show_subs'] = degree_str is None or (LIST_RE.match(degree_str) and includes_composite(degree_str)) except ValueError as err: info['err'] = str(err) return search_input_error(info, bread) count = parse_count(info, 50) start = parse_start(info) if 'orderkey' in query and not ('n' in query): res = C.transitivegroups.groups.find(query).sort([('orderkey', pymongo.ASCENDING), ('gapid', pymongo.ASCENDING), ('n', pymongo.ASCENDING), ('t', pymongo.ASCENDING)]) else: res = C.transitivegroups.groups.find(query).sort([('n', pymongo.ASCENDING), ('t', pymongo.ASCENDING)]) nres = res.count() res = res.skip(start).limit(count) if(start >= nres): start -= (1 + (start - nres) / count) * count if(start < 0): start = 0 info['groups'] = res info['group_display'] = group_display_prettyC(C) info['report'] = "found %s groups" % nres info['yesno'] = yesno info['wgg'] = WebGaloisGroup.from_data info['start'] = start info['number'] = nres if nres == 1: info['report'] = 'unique match' else: if nres > count or start != 0: info['report'] = 'displaying matches %s-%s of %s' % (start + 1, min(nres, start + count), nres) else: info['report'] = 'displaying all %s matches' % nres return render_template("gg-search.html", info=info, title="Galois Group Search Result", bread=bread, credit=GG_credit)
def hgm_search(info): #info = to_dict(args) bread = get_bread([("Search Results", '')]) query = {} queryab = {} queryabrev = {} if 'jump_to' in info: label = clean_input(info['jump_to']) if HGM_LABEL_RE.match(label): return render_hgm_webpage(normalize_motive(label)) if HGM_FAMILY_LABEL_RE.match(label): return render_hgm_family_webpage(normalize_family(label)) flash_error( '%s is not a valid label for a hypergeometric motive or family of hypergeometric motives', label) return redirect(url_for(".index")) family_search = False if info.get('Submit Family') or info.get('family'): family_search = True # generic, irreducible not in DB yet try: parse_ints(info, query, 'degree') parse_ints(info, query, 'weight') parse_bracketed_posints(info, query, 'famhodge', 'family Hodge vector', split=False) parse_restricted(info, query, 'sign', allowed=['+1', 1, -1], process=int) for param in [ 'A', 'B', 'A2', 'B2', 'A3', 'B3', 'A5', 'B5', 'A7', 'B7', 'Au2', 'Bu2', 'Au3', 'Bu3', 'Au5', 'Bu5', 'Au7', 'Bu7' ]: parse_bracketed_posints( info, queryab, param, split=False, listprocess=lambda a: sorted(a, reverse=True)) # Make a version to search reversed way if not family_search: parse_ints(info, query, 'conductor', 'Conductor', 'cond') parse_rational(info, query, 't') parse_bracketed_posints(info, query, 'hodge', 'Hodge vector') except ValueError: if family_search: return render_template( "hgm-search.html", info=info, title="Hypergeometric Family over $\Q$ Search Result", bread=bread, credit=HGM_credit, learnmore=learnmore_list()) return render_template( "hgm-search.html", info=info, title="Hypergeometric Motive over $\Q$ Search Result", bread=bread, credit=HGM_credit, learnmore=learnmore_list()) # Now combine the parts of the query if there are A,B parts if queryab != {}: for k in queryab.keys(): queryabrev[k + 'rev'] = queryab[k] queryab.update(query) queryabrev.update(query) query = {'$or': [queryab, queryabrev]} 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): start += (1 - (start + 1) / count) * count except: start = start_default else: start = start_default if info.get('paging'): try: paging = int(info['paging']) if paging == 0: start = 0 except: pass # logger.debug(query) if family_search: #query['leader'] = '1' res = familydb().find(query).sort([('label', pymongo.ASCENDING)]) else: res = motivedb().find(query).sort([('cond', pymongo.ASCENDING), ('label', pymongo.ASCENDING)]) nres = res.count() res = res.skip(start).limit(count) if (start >= nres): start -= (1 + (start - nres) / count) * count if (start < 0): start = 0 info['motives'] = res info['number'] = nres info['start'] = start if nres == 1: info['report'] = 'unique match' else: if nres > count or start != 0: info['report'] = 'displaying matches %s-%s of %s' % ( start + 1, min(nres, start + count), nres) else: info['report'] = 'displaying all %s matches' % nres info['make_label'] = make_abt_label info['make_t_label'] = make_t_label info['ab_label'] = ab_label info['display_t'] = display_t info['family'] = family_search info['factorint'] = factorint if family_search: return render_template( "hgm-search.html", info=info, title="Hypergeometric Family over $\Q$ Search Result", bread=bread, credit=HGM_credit, learnmore=learnmore_list()) else: return render_template( "hgm-search.html", info=info, title="Hypergeometric Motive over $\Q$ Search Result", bread=bread, credit=HGM_credit, learnmore=learnmore_list())