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)
