class MaassStats(StatsDisplay):
table = db.maass_newforms
baseurl_func = ".index"
stat_list = [
{
'cols': ['level', 'spectral_parameter'],
'totaler': totaler(),
'proportioner': proportioners.per_row_total
},
{
'cols': ['symmetry', 'level'],
'totaler': totaler(),
'proportioner': proportioners.per_col_total
},
{
'cols': ['symmetry', 'spectral_parameter'],
'totaler': totaler(),
'proportioner': proportioners.per_col_total
},
]
top_titles = {'symmetry': 'symmetries'}
buckets = {
'level': ['1', '2-13', '14-20', '21-30', '31-100', '101-997'],
'spectral_parameter':
['0-1', '1-2', '2-3', '3-4', '4-6', '6-10', '10-20', '20-32', '32-50']
}
knowls = {
'level': 'mf.maass.mwf.level',
'spectral_parameter': 'mf.maass.mwf.spectralparameter',
'symmetry': 'mf.maass.mwf.symmetry'
}
formatters = {'symmetry': (lambda t: 'odd' if t in [-1, '-1'] else 'even')}
query_formatters = {
'symmetry': (lambda t: 'symmetry=%s' %
(1 if t in [1, '1', 'even'] else -1))
}
def __init__(self):
self.nforms = db.maass_newforms.count()
self.max_level = db.maass_newforms.max('level')
@property
def short_summary(self):
return self.summary + ' Here are some <a href="%s">further statistics</a>.' % (
url_for(".statistics"))
@property
def summary(self):
return r"The database currently contains %s %s of %s 0 on $\Gamma_0(N)$ for $N$ in the range from 1 to %s." % (
comma(self.nforms), display_knowl('mf.maass.mwf', 'Maass forms'),
display_knowl('mf.maass.mwf.weight', 'weight'), self.max_level)
class ArtinStats(StatsDisplay):
table = db.artin_reps
baseurl_func = ".index"
stat_list = [
{"cols": ["Dim", "Conductor"],
"constraint": {"Hide": 0},
"totaler": totaler(),
"proportioner": proportioners.per_row_total},
{"cols": ["Dim", "NumBadPrimes"],
"constraint": {"Hide": 0},
"totaler": totaler(),
"proportioner": proportioners.per_row_total},
{"cols": ["Indicator", "Dim"],
"constraint": {"Hide": 0}},
{"cols": ["Is_Even", "Dim"],
"constraint": {"Hide": 0}},
{"cols": ["GaloisLabel"],
"constraint": {"Hide": 0}},
{"cols": ["Proj_nTj"],
"constraint": {"Hide": 0}},
{"cols": ["Container"],
"constraint": {"Hide": 0}}
]
knowls = {"Dim": "artin.dimension",
"Conductor": "artin.conductor",
"GaloisLabel": "artin.gg_quotient",
"Is_Even": "artin.parity",
"Proj_nTj": "artin.projective_image",
"NumBadPrimes": "artin.ramified_primes",
"Container": "artin.permutation_container",
"Indicator": "artin.frobenius_schur_indicator"}
top_titles = {"Indicator": "Frobenius-Schur indicators",
"Container": "smallest permutation containers",
"Is_Even": "parities"}
short_display = {"Dim": "dimension",
"Conductor": "conductor",
"GaloisLabel": "Galois group",
"Is_Even": "parity",
"Proj_nTj": "projective image",
"Container": "container",
"NumBadPrimes": "number of ramified primes",
"Indicator": "indicator"}
sort_keys = {"GaloisLabel": galdata,
"Proj_nTj": galdata,
"Container": galdata}
formatters = {"Conductor": lambda N: scinot(range_formatter(N)),
"Is_Even": lambda x: "even" if x in ["even", True] else "odd",
"GaloisLabel": galformatter,
"Container": contformatter,
"Proj_nTj": projformatter}
query_formatters = {
"Dim": (lambda d: "dimension=%s" % range_formatter(d)),
"Conductor": (lambda N: "conductor=%s" % (unsci(range_formatter(N)))),
"NumBadPrimes": (lambda N: "num_ram=%s" % range_formatter(N)),
"GaloisLabel": (lambda gal: r"group=%s" % (galunformatter(gal))),
"Proj_nTj": (lambda proj: r"projective_image=%s" % (galunformatter(proj))),
"Container": (lambda cont: r"container=%s" % (galunformatter(cont))),
"Is_Even": (lambda x: r"parity=%s" % ("even" if x in ["even", True] else "odd")),
"Indicator": (lambda ind: r"frobenius_schur_indicator=%s" % ind),
}
buckets = {
"Conductor": [trange(a, b) for (a,b) in intervals(0,8,2) + intervals(8,24,4) + intervals(24,56,8) + intervals(56,88,16)] + [trange(88,None)],
"Dim": [str(x) for x in range(1,13)] + ["14-21", "24-30", "35", "40-70"]
}
def __init__(self):
hide = {"Hide": 0}
self.nreps = db.artin_reps.count(hide)
self.nfields = db.artin_reps.count_distinct("NFGal", hide)
self.ngroups = db.artin_reps.count_distinct("GaloisLabel", hide)
self.maxdim = db.artin_reps.max("Dim")
maxcond = ZZ(db.artin_reps.max("Conductor"))
self.maxcond = maxcond.factor()._latex_()
self.amaxcond = maxcond.n(digits=2)._latex_()
@property
def summary(self):
return r"The database currently contains {nreps} Galois conjugacy classes of {repknowl}, for a total of {nfields} {nfknowl} with {ngroups} {gpknowl}. The largest {dimknowl} is ${mdim}$ and the largest {condknowl} is ${mcond} \approx {amcond}$.".format(
nreps=comma(self.nreps),
repknowl=display_knowl("artin", "Artin representations"),
nfields=comma(self.nfields),
nfknowl=display_knowl("artin.number_field", "number fields"),
ngroups=self.ngroups,
gpknowl=display_knowl("artin.gg_quotient", "Galois groups"),
dimknowl=display_knowl("artin.dimension", "dimension"),
mdim=self.maxdim,
condknowl=display_knowl("artin.conductor", "conductor"),
mcond=self.maxcond,
amcond=self.amaxcond)
@property
def short_summary(self):
return r'The database currently contains {nreps} Galois conjugacy classes of {repknowl}, for a total of {nfields} {nfknowl}. Here are some <a href="{url}">further statistics</a>.'.format(
nreps=comma(self.nreps),
repknowl=display_knowl("artin", "Artin representations"),
nfields=comma(self.nfields),
nfknowl=display_knowl("artin.number_field", "number fields"),
url=url_for(".statistics"))
class BianchiStats(StatsDisplay):
table = db.bmf_forms
baseurl_func = ".index"
stat_list = [
{'cols': ['field_label', 'level_norm'],
'top_title': '%s by %s and %s' % (
display_knowl("mf.bianchi.bianchimodularforms",
"Bianchi modular forms"),
display_knowl('nf', 'base field'),
display_knowl('mf.bianchi.level', 'level norm')),
'totaler': totaler(),
'proportioner': proportioners.per_row_total},
{'cols': ['field_label', 'level_norm'],
'top_title': 'computed %s by %s and %s' % (
display_knowl("mf.bianchi.spaces",
r"$\operatorname{GL}_2$ levels"),
display_knowl('nf', 'base field'),
display_knowl('mf.bianchi.level', 'level norm')),
'intro': ["The set of %s computed for each level varies." % display_knowl("mf.bianchi.weight", "weights")],
'constraint': {"gl2_cusp_totaldim": {"$gt": 0}},
'baseurl_func': ".gl2dims",
'table': db.bmf_dims,
'totaler': totaler(col_counts=False),
'proportioner': proportioners.per_row_total},
{'cols': ['field_label', 'level_norm'],
'top_title': 'computed %s by %s and %s' % (
display_knowl("mf.bianchi.spaces",
r"$\operatorname{SL}_2$ levels"),
display_knowl('nf', 'base field'),
display_knowl('mf.bianchi.level', 'level norm')),
'intro': ["The set of %s computed for each level varies." % display_knowl("mf.bianchi.weight", "weights")],
'constraint': {"sl2_cusp_totaldim": {"$gt": 0}},
'baseurl_func': ".sl2dims",
'buckets': {'level_norm': ['1-100', '101-200', '201-400', '401-800', '801-1600', '1601-3200', '3201-6400']},
'table': db.bmf_dims,
'totaler': totaler(col_counts=False),
'proportioner': proportioners.per_row_total},
{'cols': ['dimension', 'level_norm'],
'totaler': totaler(),
'proportioner': proportioners.per_col_total},
{'cols': ['dimension', 'field_label'],
'totaler': totaler(),
'proportioner': proportioners.per_col_total},
]
buckets = {'level_norm': ['1-100', '101-1000', '1001-10000', '10001-50000', '50001-100000', '100001-150000']}
knowls = {'level_norm': 'mf.bianchi.level',
'dimension': 'mf.bianchi.spaces',
'field_label': 'nf'}
formatters = {'field_label': field_formatter}
query_formatters = {'field_label': (lambda x: 'field_label=%s' % (field_unformatter(x)))}
sort_keys = {'field_label': field_sortkey}
top_titles = {'dimension': 'newform dimensions'}
short_display = {'field_label': 'base field'}
def __init__(self):
self.nforms = db.bmf_forms.count()
self.ndims = db.bmf_dims.count()
self.nformfields = len(db.bmf_forms.distinct('field_label'))
self.ndimfields = len(db.bmf_dims.distinct('field_label'))
@property
def summary(self):
return r"The database currently contains %s %s of weight 2 over %s imaginary quadratic fields, and %s %s over %s imaginary quadratic fields, including all with class number one." % (
comma(self.nforms),
display_knowl("mf.bianchi.bianchimodularforms",
"Bianchi modular forms"),
self.nformfields,
comma(self.ndims),
display_knowl("mf.bianchi.spaces",
"spaces of cusp forms"),
self.ndimfields)
@property
def short_summary(self):
return r'The database currently contains %s %s of weight 2 over the nine imaginary quadratic fields of class number one. Here are some <a href="%s">further statistics</a>.' % (comma(self.nforms), display_knowl("mf.bianchi.bianchimodularforms", "Bianchi modular forms"), url_for(".statistics"))
class HMFstats(StatsDisplay):
"""
Class for creating and displaying statistics for Hilbert modular forms
"""
def __init__(self):
self.nforms = db.hmf_forms.count()
table = db.hmf_forms
baseurl_func = ".hilbert_modular_form_render_webpage"
stat_list = [
{
'cols': ['level_norm', 'deg'],
'totaler': totaler(),
'proportioner': proportioners.per_col_total
},
{
'cols': ['level_norm', 'dimension'],
'totaler': totaler(),
'proportioner': proportioners.per_col_total
},
]
buckets = {
'level_norm': ['1', '2-10', '11-100', '101-1000', '1001-10000'],
'dimension':
['1', '2', '3', '4', '5-10', '11-20', '21-100', '101-1000']
}
knowls = {
'level_norm': 'mf.hilbert.level_norm',
'dimension': 'mf.hilbert.dimension',
'deg': 'nf.degree'
}
short_display = {'deg': 'degree'}
@property
def short_summary(self):
return self.summary + " Here are some <a href='%s'>further statistics</a>." % (
url_for(".statistics"), )
@property
def summary(self):
hmf_knowl = '<a knowl="mf.hilbert">Hilbert modular forms</a>'
nf_knowl = '<a knowl="nf.totally_real">totally real number fields</a>'
deg_knowl = '<a knowl="nf.degree">degree</a>'
return "The database currently contains %s %s over %s %s of %s 2 to %s." % (
comma(self.nforms), hmf_knowl, self.counts()["nfields"], nf_knowl,
deg_knowl, self.counts()["maxdeg"])
def degree_summary(self, d):
stats = self.statistics(d)
hmf_knowl = '<a knowl="mf.hilbert">Hilbert modular forms</a>'
nf_knowl = '<a knowl="nf.totally_real">totally real number fields</a>'
deg_knowl = '<a knowl="nf.degree">degree</a>'
level_knowl = '<a knowl="mf.hilbert.level_norm">level norm</a>'
return ''.join([
r'The database currently contains %s ' % stats['nforms'],
hmf_knowl,
r' defined over %s ' % stats['nfields'], nf_knowl,
r' of %s %s, with ' % (deg_knowl, d), level_knowl,
r' up to %s.' % stats['maxnorm']
])
@cached_method
def counts(self):
counts = {}
counts['nforms'] = self.nforms
counts['nforms_c'] = comma(self.nforms)
attrs = ["degree", "discriminant", "label"]
fields = list(db.hmf_fields.search({}, attrs, sort=attrs))
degrees = sorted(set(F["degree"] for F in fields))
by_deg = {d: [F for F in fields if F["degree"] == d] for d in degrees}
counts["degrees"] = degrees
counts["nfields"] = len(fields)
counts["nfields_c"] = comma(len(fields))
counts["maxdeg"] = max(degrees)
counts["max_deg_c"] = comma(max(degrees))
counts["fields_by_degree"] = {
d: [F["label"] for F in by_deg[d]]
for d in degrees
}
counts["nfields_by_degree"] = {d: len(by_deg[d]) for d in degrees}
counts["max_disc_by_degree"] = {
d: max(F["discriminant"] for F in by_deg[d])
for d in degrees
}
return counts
@cached_method
def statistics(self, d=None):
if d is not None:
return self.statistics()[int(d)]
nstats = db.hmf_forms.stats.numstats("level_norm", "field_label")
counts = db.hmf_forms.stats.column_counts("field_label")
nstats_by_deg = db.hmf_forms.stats.numstats("level_norm", "deg")
counts_by_deg = db.hmf_forms.stats.column_counts("deg")
C = self.counts()
stats = {
d: {
"fields": C["fields_by_degree"][d],
"nfields": C["nfields_by_degree"][d],
"nforms": counts_by_deg[d],
"maxnorm": nstats_by_deg[d]["max"],
"counts": {
F: {
"nforms":
counts[F],
"maxnorm":
nstats[F]["max"],
"field_knowl":
nf_display_knowl(F, F),
"forms":
lambda label: url_for(
'hmf.hilbert_modular_form_render_webpage',
field_label=label)
}
for F in C["fields_by_degree"][d]
}
}
for d in C["degrees"]
}
return stats
def setup(self, attributes=None, delete=False):
if attributes is None:
# Per-degree statistics aren't updated by the normal setup function
# The assert is for pyflakes
assert self.statistics()
super().setup(attributes, delete)
