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)