def abelian_variety_count(info, query): common_parse(info, query) urlgen_info = dict(info) urlgen_info.pop("hst", None) def url_generator(g, q): info_copy = dict(urlgen_info) info_copy.pop("search_array", None) info_copy["search_type"] = "List" info_copy["g"] = g info_copy["q"] = q return url_for("abvarfq.abelian_varieties", **info_copy) av_stats = AbvarFqStats() if "g" in info: info["row_heads"] = integer_options(info["g"], contained_in=av_stats.gs) else: info["row_heads"] = av_stats.gs if "q" in info: info["col_heads"] = integer_options(info["q"], contained_in=av_stats.qs) else: info["col_heads"] = av_stats.qs if "p" in query: ps = integer_options(info["p"], contained_in=av_stats.qs) info["col_heads"] = [q for q in info["col_heads"] if any(q % p == 0 for p in ps)] if not info["col_heads"]: raise ValueError("Must include at least one base field") info["na_msg"] = '"n/a" means that the isogeny classes of abelian varieties of this dimension over this field are not in the database yet.' info["row_label"] = "Dimension" info["col_label"] = r"Cardinality of base field \(q\)" info["url_func"] = url_generator
def parse_pandt(info, family): errs = [] if family.euler_factors.keys(): try: info['ps'] = [ elt for elt in integer_options( info.get('p', family.default_prange), family.maxp) if elt <= family.maxp and is_prime(elt) and elt not in family.wild_primes ] except (ValueError, TypeError) as err: info['ps'] = family.defaultp if err.args and err.args[0] == 'Too many options': errs.append(r"Only p up to %s are available" % (family.maxp)) else: errs.append( "<span style='color:black'>p</span> must be an integer, range of integers or comma separated list of integers" ) try: if info.get('t'): info['ts'] = sorted( list(set(map(QQ, info.get('t').split(","))))) info['t'] = ",".join(map(str, info['ts'])) else: info['ts'] = None except (ValueError, TypeError): info['ts'] = None errs.append( "<span style='color:black'>t</span> must be a rational or comma separated list of rationals" ) return errs
def setup_cc_data(self, info): """ INPUT: - ``info`` -- a dictionary with keys - ``m`` -- a string describing the embedding indexes desired - ``n`` -- a string describing the a_n desired - ``CC_m`` -- a list of embedding indexes - ``CC_n`` -- a list of desired a_n - ``format`` -- one of 'embed', 'analytic_embed', 'satake', or 'satake_angle' """ an_formats = ['embed','analytic_embed', None] angles_formats = ['satake','satake_angle', None] analytic_shift_formats = ['embed', None] cc_proj = ['conrey_index','embedding_index','embedding_m','embedding_root_real','embedding_root_imag'] format = info.get('format') query = {'hecke_orbit_code':self.hecke_orbit_code} # deal with m if self.embedding_label is None: m = info.get('m','1-%s'%(min(self.dim,20))) if '.' in m: m = re.sub(r'\d+\.\d+', self.embedding_from_embedding_label, m) CC_m = info['CC_m'] if 'CC_m' in info else integer_options(m) CC_m = sorted(set(CC_m)) # if it is a range if len(CC_m) - 1 == CC_m[-1] - CC_m[0]: query['embedding_m'] = {'$gte':CC_m[0], '$lte':CC_m[-1]} else: query['embedding_m'] = {'$in': CC_m} self.embedding_m = None else: self.embedding_m = int(info['CC_m'][0]) cc_proj.extend(['dual_conrey_index', 'dual_embedding_index']) query = {'label' : self.label + '.' + self.embedding_label} if format is None and 'CC_n' not in info: # for download CC_n = (1, self.an_cc_bound) else: n = info.get('n','1-10') CC_n = info['CC_n'] if 'CC_n' in info else integer_options(n) # convert CC_n to an interval in [1,an_bound] CC_n = ( max(1, min(CC_n)), min(self.an_cc_bound, max(CC_n)) ) an_keys = (CC_n[0]-1, CC_n[1]) # extra 5 primes in case we hit too many bad primes angles_keys = ( bisect.bisect_left(primes_for_angles, CC_n[0]), min(bisect.bisect_right(primes_for_angles, CC_n[1]) + 5, self.primes_cc_bound) ) an_projection = 'an_normalized[%d:%d]' % an_keys angles_projection = 'angles[%d:%d]' % angles_keys if format in an_formats: cc_proj.append(an_projection) if format in angles_formats: cc_proj.append(angles_projection) cc_data= list(db.mf_hecke_cc.search(query, projection = cc_proj)) if not cc_data: self.has_complex_qexp = False else: self.has_complex_qexp = True self.cc_data = {} for embedded_mf in cc_data: if format in an_formats: an_normalized = embedded_mf.pop(an_projection) # we don't store a_0, thus the +1 embedded_mf['an_normalized'] = {i: [float(x), float(y)] for i, (x, y) in enumerate(an_normalized, an_keys[0] + 1)} if format in angles_formats: embedded_mf['angles'] = {primes_for_angles[i]: theta for i, theta in enumerate(embedded_mf.pop(angles_projection), angles_keys[0])} self.cc_data[embedded_mf.pop('embedding_m')] = embedded_mf if format in analytic_shift_formats: self.analytic_shift = {i : RR(i)**((ZZ(self.weight)-1)/2) for i in self.cc_data.values()[0]['an_normalized'].keys()} if format in angles_formats: self.character_values = defaultdict(list) G = DirichletGroup_conrey(self.level) chars = [DirichletCharacter_conrey(G, char) for char in self.conrey_indexes] for p in self.cc_data.values()[0]['angles'].keys(): if p.divides(self.level): self.character_values[p] = None continue for chi in chars: c = chi.logvalue(p) * self.char_order angle = float(c / self.char_order) value = CDF(0,2*CDF.pi()*angle).exp() self.character_values[p].append((angle, value)) if self.embedding_m is not None: m = self.embedding_m dci = self.cc_data[m].get('dual_conrey_index') dei = self.cc_data[m].get('dual_embedding_index') self.dual_label = "%s.%s" % (dci, dei) x = self.cc_data[m].get('embedding_root_real') y = self.cc_data[m].get('embedding_root_imag') if x is None or y is None: self.embedding_root = None else: self.embedding_root = display_complex(x, y, 6, method='round', try_halfinteger=False)