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_floats(info, query, 'rd') parse_floats(info, query, 'regulator') parse_ints(info,query,'class_number') parse_ints(info,query,'num_ram') parse_bool(info,query,'cm_field',qfield='cm') 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 info['gg_display'] = group_pretty_and_nTj
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_floats(info, query, 'rd') parse_ints(info,query,'class_number') parse_bool(info,query,'cm_field',qfield='cm') 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 info['gg_display'] = group_pretty_and_nTj
def abelian_variety_search(info, query): parse_ints(info,query,'q',name='base field') parse_ints(info,query,'g',name='dimension') parse_bool(info,query,'simple',qfield='is_simp') parse_bool(info,query,'primitive',qfield='is_prim') parse_bool_unknown(info, query, 'jacobian', qfield='is_jac') parse_bool_unknown(info, query, 'polarizable', qfield='is_pp') parse_ints(info,query,'p_rank') parse_ints(info,query,'ang_rank') parse_newton_polygon(info,query,'newton_polygon',qfield='slps') parse_string_start(info,query,'initial_coefficients',qfield='poly_str',initial_segment=["1"]) parse_string_start(info,query,'abvar_point_count',qfield='A_cnts_str') parse_string_start(info,query,'curve_point_count',qfield='C_cnts_str',first_field='pt_cnt') if info.get('simple_quantifier') == 'contained': parse_subset(info,query,'simple_factors',qfield='simple_distinct',mode='subsets') elif info.get('simple_quantifier') == 'exactly': parse_subset(info,query,'simple_factors',qfield='simple_distinct',mode='exact') elif info.get('simple_quantifier') == 'include': parse_submultiset(info,query,'simple_factors',mode='append') for n in range(1,6): parse_ints(info,query,'dim%s_factors'%n) for n in range(1,4): parse_ints(info,query,'dim%s_distinct'%n) parse_nf_string(info,query,'number_field',qfield='nf') parse_galgrp(info,query,qfield=('galois_n','galois_t'))
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_ints(info,query,'nilpotency') 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_short info['yesno'] = yesno info['wgg'] = WebGaloisGroup.from_data
def artin_representation_search(info, query): query['Hide'] = 0 info['sign_code'] = 0 parse_primes(info, query, "unramified", name="Unramified primes", qfield="BadPrimes", mode="complement") parse_primes(info, query, "ramified", name="Ramified primes", qfield="BadPrimes", mode="append") parse_element_of(info, query, "root_number", qfield="GalConjSigns") parse_restricted(info, query, "frobenius_schur_indicator", qfield="Indicator", allowed=[1, 0, -1], process=int) parse_container(info, query, 'container', qfield='Container', name="Smallest permutation representation") parse_galgrp(info, query, "group", name="Group", qfield=("Galn", "Galt")) parse_ints(info, query, 'dimension', qfield='Dim') parse_ints(info, query, 'conductor', qfield='Conductor') parse_bool(info, query, 'Is_Even')
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 belyi_search(info, query): 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") parse_ints(info, query, "pass_size", "pass_size") parse_nf_string(info, query, 'field', name="base number field", qfield='base_field_label') # 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] parse_bool(info, query, "is_primitive", name="is_primitive") if info.get("primitivization"): primitivization = info["primitivization"] if re.match(GALMAP_RE, primitivization): # 7T6-7_4.2.1_4.2.1-b query["primitivization"] = primitivization else: raise ValueError("%s is not a valid Belyi map label", primitivization)
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 number_field_search(info, query): parse_ints(info, query, 'degree') parse_galgrp(info, query, qfield=('galois_label', 'degree')) parse_bracketed_posints(info, query, 'signature', qfield=('degree', 'r2'), exactlength=2, allow0=True, extractor=lambda L: (L[0] + 2 * L[1], L[1])) parse_signed_ints(info, query, 'discriminant', qfield=('disc_sign', 'disc_abs')) parse_floats(info, query, 'rd') parse_floats(info, query, 'regulator') parse_ints(info, query, 'class_number') parse_ints(info, query, 'num_ram') parse_bool(info, query, 'cm_field', qfield='cm') parse_bool(info, query, 'is_galois') parse_bracketed_posints(info, query, 'class_group', check_divisibility='increasing', process=int) parse_primes(info, query, 'ur_primes', name='Unramified primes', qfield='ramps', mode='exclude') parse_primes(info, query, 'ram_primes', name='Ramified primes', qfield='ramps', mode=info.get('ram_quantifier'), radical='disc_rad') parse_subfield(info, query, 'subfield', qfield='subfields', name='Intermediate field') parse_padicfields(info, query, 'completions', qfield='local_algs', name='$p$-adic completions') info['wnf'] = WebNumberField.from_data info['gg_display'] = group_pretty_and_nTj
def artin_representation_search(info, query): query['Hide'] = 0 info['sign_code'] = 0 parse_primes(info, query, "unramified", name="Unramified primes", qfield="BadPrimes", mode="exclude") parse_primes(info, query, "ramified", name="Ramified primes", qfield="BadPrimes", mode=info.get("ram_quantifier")) parse_restricted(info, query, "root_number", qfield="GalConjSigns", allowed=[-1, 1], process=lambda x: {"$contains": [int(x)]}) parse_restricted(info, query, "frobenius_schur_indicator", qfield="Indicator", allowed=[1, 0, -1], process=int) parse_container(info, query, 'container', qfield='Container', name="Smallest permutation representation") parse_galgrp(info, query, "group", name="Group", qfield=("GaloisLabel", None)) parse_ints(info, query, 'dimension', qfield='Dim') parse_ints(info, query, 'conductor', qfield='Conductor') parse_ints(info, query, 'num_ram', qfield='NumBadPrimes') parse_projective_group(info, query, 'projective_image', qfield='Proj_GAP') parse_projective_type(info, query, 'projective_image_type', qfield='Proj_GAP') # Backward support for old URLs if 'Is_Even' in info: info['parity'] = info.pop('Is_Even') parse_bool(info, query, 'parity', qfield='Is_Even')
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_ints(info,query,'num_int_pts','num_int_pts') parse_floats(info,query,'regulator','regulator') parse_bool(info,query,'semistable','semistable') 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_ints(info,query,field='cm_disc',qfield='cm') if 'cm_disc' in info: query['cm'] = info['cm_disc'] 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='exclude') parse_primes(info, query, 'nonsurj_primes', name='non-maximal primes', qfield='nonmax_primes',mode=info.get('surj_quantifier'), radical='nonmax_rad') parse_primes(info, query, 'bad_primes', name='bad primes', qfield='bad_primes',mode=info.get('bad_quantifier')) # The button which used to be labelled Optimal only no/yes" # (default no) has been renamed "Curves per isogeny class all/one" # (default one) but the only change in behavious is that we no # longer treat class 990h (where the optial curve is #3 not #1) as # special: the "one" option just restricts to curves whose # 'number' is 1. if 'optimal' in info and info['optimal'] == 'on': query.update({'number':1}) # Old behaviour was as follows: # For all isogeny classes except 990h the optimal curve is number 1, while for class 990h it is number 3. # So setting query['number'] = 1 is nearly correct, but fails on 990h3. # Instead, we use this more complicated query: # query.update({"$or":[{'iso':'990h', 'number':3}, {'iso':{'$ne':'990h'},'number':1}]}) info['curve_ainvs'] = lambda dbc: str([ZZ(ai) for ai in dbc['ainvs']]) info['curve_url_LMFDB'] = 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_LMFDB'] = lambda dbc: url_for(".by_double_iso_label", conductor=dbc['conductor'], iso_label=split_lmfdb_label(dbc['lmfdb_iso'])[1]) info['curve_url_Cremona'] = lambda dbc: url_for(".by_ec_label", label=dbc['label']) info['iso_url_Cremona'] = lambda dbc: url_for(".by_ec_label", label=dbc['iso'])
def belyi_search(info, query): info["geometry_types_list"] = geometry_types_list info["geometry_types_dict"] = geometry_types_dict info["belyi_galmap_url"] = url_for_belyi_galmap_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") parse_ints(info, query, "pass_size", "pass_size") parse_nf_string(info, query, 'field', name="base number field", qfield='base_field_label') # 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] info["nf_link"] = lambda elt: field_display_gen( elt.get('base_field_label'), elt.get('base_field'), truncate=16) parse_bool(info, query, "is_primitive", name="is_primitive")
def elliptic_curve_search(info, query): parse_rational_to_list(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_ints(info,query,'num_int_pts','num_int_pts') parse_ints(info,query,'class_size','class_size') parse_ints(info,query,'class_deg','class_deg') parse_floats(info,query,'regulator','regulator') parse_bool(info,query,'semistable','semistable') parse_bool(info,query,'potential_good_reduction','potential_good_reduction') 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_ints(info,query,field='cm_disc',qfield='cm') parse_element_of(info,query,'isogeny_degrees',split_interval=1000,contained_in=get_stats().isogeny_degrees) parse_primes(info, query, 'surj_primes', name='maximal primes', qfield='nonmax_primes', mode='exclude') parse_primes(info, query, 'nonsurj_primes', name='non-maximal primes', qfield='nonmax_primes',mode=info.get('surj_quantifier'), radical='nonmax_rad') parse_primes(info, query, 'bad_primes', name='bad primes', qfield='bad_primes',mode=info.get('bad_quantifier')) parse_primes(info, query, 'sha_primes', name='sha primes', qfield='sha_primes',mode=info.get('sha_quantifier')) # The button which used to be labelled Optimal only no/yes" # (default: no) has been renamed "Curves per isogeny class # all/one" (default: all). When this option is "one" we only list # one curve in each class, currently choosing the curve with # minimal Faltings heights, which is conjecturally the # Gamma_1(N)-optimal curve. if 'optimal' in info and info['optimal'] == 'on': query.update({'lmfdb_number':1}) info['curve_ainvs'] = lambda dbc: str([ZZ(ai) for ai in dbc['ainvs']]) info['curve_url_LMFDB'] = 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_LMFDB'] = lambda dbc: url_for(".by_double_iso_label", conductor=dbc['conductor'], iso_label=split_lmfdb_label(dbc['lmfdb_iso'])[1]) info['cremona_bound'] = CREMONA_BOUND info['curve_url_Cremona'] = lambda dbc: url_for(".by_ec_label", label=dbc['Clabel']) info['iso_url_Cremona'] = lambda dbc: url_for(".by_ec_label", label=dbc['Ciso'])
def common_parse(info, query): parse_ints(info, query, "q", name="base field") parse_ints(info, query, "p", name="base cardinality") parse_ints(info, query, "g", name="dimension") parse_ints(info, query, "geom_deg", qfield="geometric_extension_degree") parse_bool(info, query, "simple", qfield="is_simple") parse_bool(info, query, "geom_simple", qfield="is_geometrically_simple") parse_bool(info, query, "primitive", qfield="is_primitive") parse_bool_unknown(info, query, "jacobian", qfield="has_jacobian") parse_bool_unknown(info, query, "polarizable", qfield="has_principal_polarization") parse_ints(info, query, "p_rank") parse_ints(info, query, "p_rank_deficit") parse_ints(info, query, "angle_rank") parse_ints(info, query, "jac_cnt", qfield="jacobian_count", name="Number of Jacobians") parse_ints(info, query, "hyp_cnt", qfield="hyp_count", name="Number of Hyperelliptic Jacobians") parse_ints(info, query, "twist_count") parse_ints(info, query, "max_twist_degree") parse_ints(info, query, "size") parse_newton_polygon(info, query, "newton_polygon", qfield="slopes") parse_string_start(info, query, "initial_coefficients", qfield="poly_str", initial_segment=["1"]) parse_string_start(info, query, "abvar_point_count", qfield="abvar_counts_str", first_field="abvar_count") parse_string_start(info, query, "curve_point_count", qfield="curve_counts_str", first_field="curve_count") if info.get("simple_quantifier") in ["subset", "exactly"]: parse_subset(info, query, "simple_factors", qfield="simple_distinct", mode=info.get("simple_quantifier")) else: parse_submultiset(info, query, "simple_factors") if info.get("use_geom_decomp") == "on": dimstr = "geom_dim" nf_qfield = "geometric_number_fields" gal_qfield = "geometric_galois_groups" else: dimstr = "dim" nf_qfield = "number_fields" gal_qfield = "galois_groups" for n in range(1, 6): parse_ints(info, query, "dim%s_factors" % n, qfield="%s%s_factors" % (dimstr, n)) for n in range(1, 4): parse_ints(info, query, "dim%s_distinct" % n, qfield="%s%s_distinct" % (dimstr, n)) parse_nf_string(info, query, "number_field", qfield=nf_qfield) parse_galgrp(info, query, "galois_group", qfield=gal_qfield) if 'geom_squarefree' in info: if info['geom_squarefree'] == 'Yes': query['is_squarefree'] = True elif info['geom_squarefree'] == 'YesAndGeom': query['is_squarefree'] = True query['is_geometrically_squarefree'] = True elif info['geom_squarefree'] == 'YesNotGeom': query['is_squarefree'] = True query['is_geometrically_squarefree'] = False elif info['geom_squarefree'] == 'No': query['is_squarefree'] = False elif info['geom_squarefree'] == 'NotGeom': query['is_geometrically_squarefree'] = False
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 info["geom_end_alg_list"] = geom_end_alg_list info["geom_end_alg_dict"] = geom_end_alg_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', 'geom_end_alg'): 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 common_parse(info, query): parse_ints(info, query, "modulus", name="modulus") parse_ints(info, query, "conductor", name="conductor") parse_ints(info, query, "order", name="order") if 'parity' in info: parity = info['parity'] if parity == 'even': query['parity'] = 1 elif parity == 'odd': query['parity'] = -1 parse_bool(info, query, "is_primitive", name="is_primitive") parse_bool(info, query, "is_real", name="is_real") parse_bool(info, query, "is_minimal", name="is_minimal")
def search(info): """ query processing for Sato-Tate groups -- returns rendered results page """ if 'jump' in info: return redirect(url_for('.by_label', label=info['jump']), 301) if 'label' in info: return redirect(url_for('.by_label', label=info['label']), 301) search_type = info.get("search_type", info.get("hst", "List")) template_kwds = { 'bread': get_bread("Search results"), 'credit': credit_string, 'learnmore': learnmore_list() } title = 'Sato-Tate group search results' err_title = 'Sato-Tate group search input error' count = parse_count(info, 50) start = parse_start(info) # if user clicked refine search always restart at 0 if 'refine' in info: start = 0 ratonly = (info.get('include_irrational', 'no').strip().lower() == 'no') if search_type == "Random" and not ratonly: info['err'] = err = 'Cannot select random irrational Sato-Tate group' flash_error(err) return render_template('st_results.html', info=info, title=err_title, **template_kwds) query = {'rational': True} if ratonly else {} try: parse_ints(info, query, 'weight', 'weight') if 'weight' in query: weight_list = parse_ints_to_list_flash(info.get('weight'), 'weight') parse_ints(info, query, 'degree', 'degree') if 'degree' in query: degree_list = parse_ints_to_list_flash(info.get('degree'), 'degree') if info.get('identity_component'): query['identity_component'] = info['identity_component'] parse_ints(info, query, 'components', 'components') def refine_components(current, condition): if current is None: return condition return [x for x in condition if x in current] # The following are used to constraint which mu(n) will show up in search results components_list = None ommitted = set() if 'components' in query: components_list = parse_ints_to_list_flash(info.get('components'), 'components') parse_component_group(info, query) gps = query.get("component_group") if gps: if isinstance(gps, dict): gps = gps["$in"] else: gps = [gps] if not ratonly: cyclic_labels = set( db.gps_small.search({"cyclic": True}, "label")) irrat = [] for code in gps: if code in cyclics: irrat.append(cyclics[code]) elif re.match(cyclicre, code): irrat.append(int(code[1:])) elif not ratonly and code in cyclic_labels: irrat.append(int(code.split(".")[0])) components_list = refine_components(components_list, irrat) parse_rational(info, query, 'trace_zero_density', 'trace zero density') parse_ints(info, query, 'second_trace_moment') parse_ints(info, query, 'fourth_trace_moment') for name, ones in [('second_trace_moment', [1, 2]), ('fourth_trace_moment', [1, 2, 4])]: if name in query: # E(x^2) for mu(1) and mu(2) are 1; others are 0 # E(x^4) for mu(1), mu(2) and mu(4) are 1; others are 0 E = parse_ints_to_list_flash(info.get(name), name.replace("_", " ")) if 0 not in E: components_list = refine_components(components_list, ones) if 1 not in E: ommitted.update(ones) parse_ints(info, query, 'first_a2_moment') parse_bool(info, query, 'maximal') if "first_a2_moment" in query or query.get("maximal"): # mu(n) do not have a2 moments and none are maximal components_list = [] except ValueError as err: info['err'] = str(err) return render_template('st_results.html', info=info, title=err_title, **template_kwds) # Check mu(n) groups first (these are not stored in the database) results = [] if ((not 'weight' in query or 0 in weight_list) and (not 'degree' in query or 1 in degree_list) and (not 'identity_component' in query or query['identity_component'] == 'SO(1)') and (not 'trace_zero_density' in query or query['trace_zero_density'] == '0')): nres = None if components_list is None: components_list = range( 1, 3 if ratonly else (start + count + 1 + len(ommitted))) nres = None if ratonly else INFINITY elif ratonly: components_list = [n for n in range(1, 3) if n in components_list] components_list = [n for n in components_list if n not in ommitted] if nres is None: nres = len(components_list) if search_type == "Random" and nres > 0: # Need to return mu(1), mu(2) or mu(4) sometimes otherlen = db.gps_sato_tate.count(query) r = ZZ.random_element(nres + otherlen) if r < nres: return redirect( url_for(".by_label", label="0.1.%d" % components_list[r]), 307) for n in itertools.islice(components_list, start, start + count): results.append(mu_info(n)) else: nres = 0 if 'result_count' in info: nres += db.gps_sato_tate.count(query) return jsonify({"nres": str(nres)}) if search_type == "Random": label = db.gps_sato_tate.random(query, "label") if label is not None: return redirect(url_for(".by_label", label=label), 307) # Now lookup other (rational) ST groups in database if nres != INFINITY: start2 = start - nres if start > nres else 0 proj = [ 'label', 'weight', 'degree', 'real_dimension', 'identity_component', 'name', 'pretty', 'components', 'component_group', 'trace_zero_density', 'moments' ] try: res = db.gps_sato_tate.search(query, proj, limit=max(count - len(results), 0), offset=start2, info=info) except QueryCanceledError as err: ctx = ctx_proc_userdata() flash_error( 'The search query took longer than expected! Please help us improve by reporting this error <a href="%s" target=_blank>here</a>.' % ctx['feedbackpage']) info['err'] = str(err) return render_template('st_results.html', info=info, title=err_title, **template_kwds) info['number'] += nres if start < info['number'] and len(results) < count: for v in res: v['identity_component'] = st0_pretty(v['identity_component']) v['component_group'] = sg_pretty(v['component_group']) v['trace_moments'] = trace_moments(v['moments']) results.append(v) else: info['number'] = 'infinity' info['start'] = start info['count'] = count info['st0_list'] = st0_list info['st0_dict'] = st0_dict info['results'] = results info['stgroup_url'] = lambda dbc: url_for('.by_label', label=dbc['label']) return render_template('st_results.html', info=info, title=title, **template_kwds)
def genus2_curve_search(info, query): 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') if info.get('analytic_sha') == "None": query['analytic_sha'] = None else: parse_ints(info, query, 'analytic_sha', 'analytic order of sha') 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: t_o = 1 for n in query['torsion']: t_o *= int(n) query['torsion_order'] = t_o if 'torsion' in query: query['torsion_subgroup'] = str(query['torsion']).replace(" ", "") query.pop('torsion') # search using string key, not array of ints geom_inv_type = info.get('geometric_invariants_type', 'igusa_clebsch_inv') if geom_inv_type == 'igusa_clebsch_inv': invlength = 4 elif geom_inv_type == 'igusa_inv': invlength = 5 else: invlength = 3 parse_bracketed_rats(info, query, 'geometric_invariants', qfield=geom_inv_type, exactlength=invlength, split=False, keepbrackets=True) 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', 'end_alg', 'geom_end_alg'): if info.get(fld): query[fld] = info[fld] parse_primes(info, query, 'bad_primes', name='bad primes', qfield='bad_primes', mode=info.get('bad_quantifier')) info["curve_url"] = lambda label: url_for_curve_label(label) info["class_url"] = lambda label: url_for_isogeny_class_label(label)
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, 'rank') 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 'torsion_order' not in query: t_o = 1 for n in query['torsion_structure']: t_o *= int(n) query['torsion_order'] = t_o parse_element_of(info, query, 'isodeg', split_interval=1000, contained_in=ECNF_stats().isogeny_degrees) parse_bool(info, query, 'semistable', 'semistable') parse_bool(info, query, 'potential_good_reduction', 'potential_good_reduction') parse_ints(info, query, 'class_size', 'class_size') parse_ints(info, query, 'class_deg', 'class_deg') parse_ints(info, query, 'sha', 'analytic order of Ш') parse_floats(info, query, 'reg', 'regulator') parse_nf_jinv(info, query, 'jinv', 'j-invariant', field_label=query.get('field_label')) if info.get('one') == "yes": info['number'] = 1 query['number'] = 1 if 'include_base_change' in info: if info['include_base_change'] in [ 'exclude', 'off' ]: # off for backward compat with urls 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 parse_cm_list(info, query, field='cm_disc', qfield='cm', name="CM discriminant") if 'include_cm' in info: if info['include_cm'] == 'PCM': tmp = {'$ne': 0} if 'cm' in query: query['cm'] = {'$and': [tmp, query['cm']]} else: query['cm'] = tmp elif info['include_cm'] == 'PCMnoCM': tmp = {'$lt': 0} if 'cm' in query: query['cm'] = {'$and': [tmp, query['cm']]} else: query['cm'] = tmp elif info['include_cm'] == 'CM': tmp = {'$gt': 0} if 'cm' in query: query['cm'] = {'$and': [tmp, query['cm']]} else: query['cm'] = tmp elif info['include_cm'] == 'noPCM': tmp = 0 if 'cm' in query: query['cm'] = {'$and': [tmp, query['cm']]} else: query['cm'] = tmp parse_primes(info, query, 'conductor_norm_factors', name='bad primes', qfield='conductor_norm_factors', mode=info.get('bad_quantifier')) info['field_pretty'] = field_pretty parse_ints(info, query, 'bf_deg', name='Base field degree', qfield='degree')
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,'rank') 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: t_o = 1 for n in query['torsion_structure']: t_o *= int(n) query['torsion_order'] = t_o parse_element_of(info,query,'isodeg',split_interval=1000,contained_in=ECNF_stats().isogeny_degrees) parse_bool(info,query,'semistable','semistable') parse_bool(info,query,'potential_good_reduction','potential_good_reduction') parse_ints(info,query,'class_size','class_size') parse_ints(info,query,'class_deg','class_deg') parse_ints(info,query,'sha','analytic order of Ш') parse_floats(info,query,'reg','regulator') 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') if not 'a' in info['jinv'] and not info.get('field'): # rational j-invariant allowed for any field parse_rational(info, query, 'jinv', name='j-invariant') if query.get('jinv'): query['jinv'] = {'$regex': '^' + query['jinv'] + '(,0)*$'} # nf elements like j,0,0,0 else: # j-invariant is a number field element parse_nf_elt(info, query, 'jinv', name='j-invariant') if query.get('jinv'): query['jinv'] = ','.join(query['jinv']) if info.get('one') == "yes": info['number'] = 1 query['number'] = 1 if 'include_base_change' in info: if info['include_base_change'] in ['exclude', 'off']: # off for backward compat with urls 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'] == 'PCM': query['cm'] = {'$ne' : 0} elif info['include_cm'] == 'PCMnoCM': query['cm'] = {'$lt' : 0} elif info['include_cm'] == 'CM': query['cm'] = {'$gt' : 0} elif info['include_cm'] == 'noPCM': query['cm'] = 0 parse_ints(info,query,field='cm_disc',qfield='cm') parse_primes(info, query, 'conductor_norm_factors', name='bad primes', qfield='conductor_norm_factors',mode=info.get('bad_quantifier')) info['field_pretty'] = field_pretty info['web_ainvs'] = web_ainvs parse_ints(info,query,'bf_deg',name='Base field degree',qfield='degree')
def group_search(info, query): info['group_url'] = get_url parse_ints(info, query, 'order', 'order') parse_ints(info, query, 'dim', 'dim') parse_bool(info, query, 'irreducible', 'irreducible')
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 if info.get('jump', '').strip(): jump_list = [ "1T1", "2T1", "3T1", "4T1", "4T2", "5T1", "6T1", "7T1", "8T1", "8T2", "8T3", "8T5", "9T1", "9T2", "10T1", "11T1", "12T1", "12T2", "12T5", "13T1", "14T1", "15T1", "16T1", "16T2", "16T3", "16T4", "16T5", "16T7", "16T8", "16T14", "17T1", "18T1", "18T2", "19T1", "20T1", "20T2", "20T3", "21T1", "22T1", "23T1", "24T1", "24T2", "24T3", "24T4", "24T5", "24T6", "24T8", "25T1", "25T2", "26T1", "27T1", "27T2", "27T4", "28T1", "28T2", "28T3", "29T1", "30T1", "31T1", "32T32", "32T33", "32T34", "32T35", "32T36", "32T37", "32T38", "32T39", "32T40", "32T41", "32T42", "32T43", "32T44", "32T45", "32T46", "32T47", "32T48", "32T49", "32T50", "32T51", "33T1", "34T1", "35T1", "36T1", "36T2", "36T3", "36T4", "36T7", "36T9", "37T1", "38T1", "39T1", "40T1", "40T2", "40T3", "40T4", "40T5", "40T7", "40T8", "40T13", "41T1", "42T1", "43T1", "44T1", "44T2", "44T3", "45T1", "45T2", "46T1", "47T1" ] strip_label = info.get('jump', '').strip().upper() # If the user entered a simple label if re.match(r'^\d+T\d+$', strip_label): return redirect(url_for('.by_label', label=strip_label), 301) try: parse_galgrp( info, query, qfield=['label', 'n'], name='a Galois group label', field='jump', list_ok=False, err_msg= "It needs to be a transitive group in nTj notation, such as 5T1, a GAP id, such as [4,1], or a <a title = 'Galois group labels' knowl='nf.galois_group.name'>group label</a>" ) except ValueError: return redirect(url_for('.index')) if query.get('label', '') in jump_list: return redirect(url_for('.by_label', label=query['label']), 301) else: # convert this to a regular search info['gal'] = info['jump'] parse_ints(info, query, 'n', 'degree') parse_ints(info, query, 't') parse_ints(info, query, 'order') parse_ints(info, query, 'arith_equiv') parse_ints(info, query, 'nilpotency') parse_galgrp(info, query, qfield=['label', 'n'], name='Galois group', field='gal') for param in ('cyc', 'solv', 'prim'): parse_bool(info, query, param, process=int, blank=['0', 'Any']) if info.get("parity") == "even": query["parity"] = 1 elif info.get("parity") == "odd": query["parity"] = -1 #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_short info['yesno'] = yesno info['wgg'] = WebGaloisGroup.from_data
def group_search(info, query): info['group_url'] = get_url info['getname'] = lambda xx: '$' + group_names_pretty(xx) + '$' parse_ints(info, query, 'order', 'order') parse_ints(info, query, 'dim', 'dim') parse_bool(info, query, 'irreducible', 'irreducible')
def genus2_curve_search(info, query): 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") if info.get("analytic_sha") == "None": query["analytic_sha"] = None else: parse_ints(info, query, "analytic_sha", "analytic order of sha") 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 "torsion_order" not in query: t_o = 1 for n in query["torsion"]: t_o *= int(n) query["torsion_order"] = t_o if "torsion" in query: query["torsion_subgroup"] = str(query["torsion"]).replace(" ", "") query.pop("torsion") # search using string key, not array of ints parse_bracketed_rats( info, query, "geometric_invariants", qfield="g2_inv", minlength=3, maxlength=5, listprocess=geom_inv_to_G2, split=False, keepbrackets=True, ) 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"] # Support legacy aut_grp_id if info.get("aut_grp_id"): info["aut_grp_label"] = ".".join( info.pop("aut_grp_id")[1:-1].split(",")) if info.get("geom_aut_grp_id"): info["geom_aut_grp_label"] = ".".join( info.pop("geom_aut_grp_id")[1:-1].split(",")) for fld in ( "st_group", "real_geom_end_alg", "aut_grp_label", "geom_aut_grp_label", "end_alg", "geom_end_alg", ): if info.get(fld): query[fld] = info[fld] parse_primes( info, query, "bad_primes", name="bad primes", qfield="bad_primes", mode=info.get("bad_quantifier"), ) parse_sort(info, query)