def __init__(self, loggername, db):
# Have to record this object in the db so that we can reset the connection if necessary.
# This function also sets self.conn
db.register_object(self)
self._db = db
from lmfdb.utils.config import Configuration
logging_options = Configuration().get_logging()
self.slow_cutoff = logging_options["slowcutoff"]
handler = logging.FileHandler(logging_options["slowlogfile"])
formatter = logging.Formatter("%(asctime)s - %(message)s")
filt = QueryLogFilter()
handler.setFormatter(formatter)
handler.addFilter(filt)
self.logger = make_logger(loggername,
hl=False,
extraHandlers=[handler])
# -*- coding: utf-8 -*-
from lmfdb.app import app
from lmfdb.logger import make_logger
from flask import Blueprint
abvarfq_page = Blueprint("abvarfq", __name__, template_folder='templates', static_folder="static")
abvarfq_logger = make_logger(abvarfq_page)
@abvarfq_page.context_processor
def body_class():
return {'body_class': 'abvarfq'}
import main
assert main
app.register_blueprint(abvarfq_page, url_prefix="/Variety/Abelian/Fq")
# -*- coding: utf-8 -*-
from collections import Counter
import os, yaml
from flask import url_for
from sage.all import (
gcd, Set, ZZ, is_even, is_odd, euler_phi, CyclotomicField, gap, RealField,
AbelianGroup, QQ, gp, NumberField, PolynomialRing, latex, pari, cached_function)
from lmfdb import db
from lmfdb.utils import (web_latex, coeff_to_poly, pol_to_html,
display_multiset, factor_base_factor, factor_base_factorization_latex)
from lmfdb.logger import make_logger
from lmfdb.galois_groups.transitive_group import WebGaloisGroup, group_display_knowl, galois_module_knowl, group_pretty_and_nTj
wnflog = make_logger("WNF")
dir_group_size_bound = 10000
dnc = 'data not computed'
# Dictionary of field label: n for abs(disc(Q(zeta_n)))
# Does all cyclotomic fields of degree n s.t. 2<n<24
cycloinfo = {'4.0.125.1': 5, '6.0.16807.1': 7, '4.0.256.1': 8,
'6.0.19683.1': 9, '10.0.2357947691.1': 11, '4.0.144.1': 12,
'12.0.1792160394037.1': 13, '8.0.1265625.1': 15, '8.0.16777216.1': 16,
'16.0.2862423051509815793.1': 17, '18.0.5480386857784802185939.1': 19,
'8.0.4000000.1': 20, '12.0.205924456521.1': 21,
'22.0.39471584120695485887249589623.1': 23, '8.0.5308416.1': 24,
'20.0.2910383045673370361328125.1': 25,
'18.0.2954312706550833698643.1': 27, '12.0.1157018619904.1': 28,
'16.0.18446744073709551616.1': 32, '20.0.328307557444402776721569.1': 33,
'24.0.304383340063522342681884765625.1': 35,
from seminars.utils import (
format_errmsg,
ics_file,
show_input_errors,
timestamp,
timezones,
topdomain,
validate_url,
)
from seminars.tokens import generate_timed_token, read_timed_token, read_token
from datetime import datetime
login_page = Blueprint("user", __name__, template_folder="templates")
logger = make_logger(login_page)
login_manager = LoginManager()
from .pwdmanager import userdb, SeminarsUser, SeminarsAnonymousUser
@login_manager.user_loader
def load_user(uid):
return SeminarsUser(uid)
login_manager.login_view = "user.info"
login_manager.anonymous_user = SeminarsAnonymousUser
# -*- coding: utf-8 -*-
from __future__ import absolute_import
from .main import login_page, login_manager, admin_required, housekeeping
assert admin_required # silence pyflakes
assert housekeeping # silence pyflakes
from flask_login import __version__ as FLASK_LOGIN_VERSION
from seminars.app import app
from lmfdb.logger import make_logger
from distutils.version import StrictVersion
# secret key, necessary for sessions, and sessions are
# in turn necessary for users to login
app.secret_key = "vVjYyCM99DtirZqMaGMrle"
login_manager.init_app(app)
app.register_blueprint(login_page, url_prefix="/user")
users_logger = make_logger("user", hl=True)
FLASK_LOGIN_LIMIT = "0.3.0"
if StrictVersion(FLASK_LOGIN_VERSION) < StrictVersion(FLASK_LOGIN_LIMIT):
raise RuntimeError(
"flask-login is older than version {version} and must be updated, perhaps through `sage -pip install flask-login`"
.format(version=FLASK_LOGIN_LIMIT))
# -*- coding: utf-8 -*-
from lmfdb.app import app
from lmfdb.logger import make_logger
from flask import Blueprint
higher_genus_w_automorphisms_page = Blueprint("higher_genus_w_automorphisms",
__name__, template_folder='templates',
static_folder="static")
logger = make_logger(higher_genus_w_automorphisms_page)
@higher_genus_w_automorphisms_page.context_processor
def body_class():
return {'body_class': 'higher_genus_w_automorphisms'}
import main
assert main # silence pyflakes
app.register_blueprint(higher_genus_w_automorphisms_page, url_prefix="/HigherGenus/C/Aut")
# -*- coding: utf-8 -*-
from lmfdb.app import app
from lmfdb.logger import make_logger
from flask import Blueprint
g2c_page = Blueprint("g2c", __name__, template_folder='templates',
static_folder="static")
g2c_logger = make_logger(g2c_page)
@g2c_page.context_processor
def body_class():
return {'body_class': 'g2c'}
import main
assert main # silence pyflakes
app.register_blueprint(g2c_page, url_prefix="/Genus2Curve")
# -*- coding: utf-8 -*-
from lmfdb.app import app
from lmfdb.logger import make_logger
from flask import Blueprint
from lmfdb.api2.searchers import register_search_function, register_singleton
import searchers
ec_page = Blueprint("ec", __name__, template_folder='templates', static_folder="static")
ec_logger = make_logger(ec_page)
#ec_logger.info("Initializing elliptic curves blueprint")
@ec_page.context_processor
def body_class():
return {'body_class': 'ec'}
import elliptic_curve
assert elliptic_curve # for pyflakes
app.register_blueprint(ec_page, url_prefix="/EllipticCurve/Q")
register_search_function("elliptic_curves_q", "Elliptic Curves over Rationals",
"Search over elliptic curves defined over rationals", auto_search = 'ec_curves')
register_singleton('EllipticCurve/Q', 'ec_curves',
simple_search = searchers.ec_simple_label_search)
# -*- coding: utf-8 -*-
from lmfdb.app import app
from lmfdb.logger import make_logger
from flask import Blueprint
artin_representations_page = Blueprint(
"artin_representations", __name__, template_folder='templates', static_folder="static")
artin_logger = make_logger("artin", hl=True)
# artin_logger.info("Initializing Artin representations blueprint")
@artin_representations_page.context_processor
def body_class():
return {'body_class': 'artin_representations'}
import main
assert main # silence pyflakes
app.register_blueprint(artin_representations_page, url_prefix="/ArtinRepresentation")
# -*- coding: utf-8 -*-
from lmfdb.app import app
from lmfdb.logger import make_logger
from flask import Blueprint
galois_groups_page = Blueprint("galois_groups", __name__, template_folder='templates', static_folder="static")
logger = make_logger(galois_groups_page)
@galois_groups_page.context_processor
def body_class():
return {'body_class': 'galois_groups'}
import main
assert main
app.register_blueprint(galois_groups_page, url_prefix="/GaloisGroup")
# -*- coding: utf-8 -*-
from lmfdb.app import app
from lmfdb.logger import make_logger
from flask import Blueprint
permutations_page = Blueprint("permutations", __name__, template_folder='templates', static_folder="static")
logger = make_logger(permutations_page)
@permutations_page.context_processor
def body_class():
return {'body_class': 'Permutations'}
import main
assert main
app.register_blueprint(permutations_page, url_prefix="/Permutations")
def field_data(s):
r"""
Returns full field data from field label.
"""
deg, r1, abs_disc, n = [int(c) for c in s.split(".")]
sig = [r1, (deg - r1) // 2]
return [s, deg, sig, abs_disc]
def sort_field(F):
r"""
Returns data to sort by, from field label.
"""
return [int(c) for c in F.split(".")]
logger = make_logger("ecnf")
class ECNF_stats(StatsDisplay):
ec_knowls = '<a knowl="ec">elliptic curves</a>'
ec_knowl = '<a knowl="ec">elliptic curve</a>'
iso_knowls = '<a knowl="ec.isogeny_class">isogeny classes</a>'
iso_knowl = '<a knowl="ec.isogeny_class">isogeny class</a>'
nf_knowls = '<a knowl="nf">number fields</a>'
nf_knowl = '<a knowl="nf">number field</a>'
deg_knowl = '<a knowl="nf.degree">degree</a>'
cond_knowls = '<a knowl="ec.conductor">conductors</a>'
cond_knowl = '<a knowl="ec.conductor">conductor</a>'
@lazy_attribute
def ncurves(self):
return db.ec_nfcurves.count()
@lazy_attribute
# -*- coding: utf-8 -*-
from lmfdb.app import app
from lmfdb.logger import make_logger
from flask import Blueprint
cmf_page = Blueprint("cmf", __name__, template_folder='templates', static_folder="static")
cmf = cmf_page
cmf_logger = make_logger(cmf_page)
import main
assert main # silence pyflakes
app.register_blueprint(cmf_page, url_prefix="/ModularForm/GL2/Q/holomorphic")
# -*- coding: utf-8 -*-
from lmfdb.app import app
from lmfdb.logger import make_logger
from flask import Blueprint
nf_page = Blueprint("number_fields", __name__, template_folder='templates', static_folder="static")
nf_logger = make_logger(nf_page)
@nf_page.context_processor
def body_class():
return {'body_class': 'nf'}
import number_field
assert number_field
app.register_blueprint(nf_page, url_prefix="/NumberField")
# -*- coding: utf-8 -*-
from lmfdb.app import app
from lmfdb.logger import make_logger
from flask import Blueprint
hiwf_page = Blueprint("hiwf", __name__, template_folder='templates', static_folder="static")
hiwf_logger = make_logger(hiwf_page)
@hiwf_page.context_processor
def body_class():
return {'body_class': 'hiwf'}
import half_integral_form
assert half_integral_form
app.register_blueprint(hiwf_page, url_prefix="/ModularForm/GL2/Q/holomorphic/half")
# -*- coding: utf-8 -*-
from flask import url_for
from lmfdb import db
from lmfdb.utils import encode_plot, names_and_urls, web_latex
from lmfdb.logger import make_logger
from lmfdb.ecnf.WebEllipticCurve import web_ainvs, FIELD
from lmfdb.number_fields.web_number_field import field_pretty, nf_display_knowl
from sage.all import latex, Matrix, ZZ, Infinity
from lmfdb.lfunctions.LfunctionDatabase import (get_lfunction_by_url,
get_instances_by_Lhash_and_trace_hash)
logger = make_logger("ecnf")
class ECNF_isoclass(object):
"""
Class for an isogeny class of elliptic curves over Q
"""
def __init__(self, dbdata):
"""
Arguments:
- dbdata: the data from the database
"""
#logger.info("Constructing an instance of ECNF_isoclass")
self.__dict__.update(dbdata)
self.make_class()
@staticmethod
# -*- coding: utf-8 -*-
from lmfdb.app import app
from lmfdb.logger import make_logger
from flask import Blueprint
hiwf_page = Blueprint("hiwf",
__name__,
template_folder='templates',
static_folder="static")
hiwf_logger = make_logger(hiwf_page)
@hiwf_page.context_processor
def body_class():
return {'body_class': 'hiwf'}
from . import half_integral_form
assert half_integral_form
app.register_blueprint(hiwf_page,
url_prefix="/ModularForm/GL2/Q/holomorphic/half")
# -*- coding: utf-8 -*-
from lmfdb.app import app
from lmfdb.utils import comma, format_percentage
from lmfdb.logger import make_logger
from lmfdb import db
from flask import url_for
logger = make_logger("ec")
the_ECstats = None
def get_stats():
global the_ECstats
if the_ECstats is None:
the_ECstats = ECstats()
return the_ECstats
def elliptic_curve_summary():
counts = get_stats().counts()
ecstaturl = url_for('ec.statistics')
return r'The database currently contains the Cremona database of all %s <a title="Elliptic curves [ec]" knowl="ec" kwargs="">elliptic curves</a> defined over $\Q$ with <a title="Conductor of an elliptic curve over $\Q$ [ec.q.conductor]" knowl="ec.q.conductor" kwargs="">conductor</a> at most %s, all of which have <a title="Rank of an elliptic curve over $\mathbb{Q}$ [ec.rank]" knowl="ec.rank" kwargs="">rank</a> $\leq %s$. Here are some <a href="%s">further statistics</a>.' % (str(counts['ncurves_c']), str(counts['max_N_c']), str(counts['max_rank']), ecstaturl)
@app.context_processor
def ctx_elliptic_curve_summary():
return {'elliptic_curve_summary': elliptic_curve_summary}
class ECstats(object):
"""
Class for creating and displaying statistics for elliptic curves over Q
"""
# -*- coding: utf-8 -*-
from lmfdb.app import app
from lmfdb.logger import make_logger
from flask import Blueprint
hecke_algebras_page = Blueprint("hecke_algebras",
__name__,
template_folder='templates',
static_folder="static")
hecke_algebras_logger = make_logger(hecke_algebras_page)
@hecke_algebras_page.context_processor
def body_class():
return {'body_class': 'hecke_algebras'}
import main
assert main
app.register_blueprint(hecke_algebras_page,
url_prefix="/ModularForm/GL2/Q/HeckeAlgebra")
# -*- coding: utf-8 -*- from lmfdb.logger import make_logger from flask import Blueprint MWF = "mwf" # Maass waveforms mwf = Blueprint(MWF, __name__, template_folder="views/templates", static_folder="views/static") mwf_logger = make_logger(mwf) import backend assert backend import views assert views
# -*- coding: utf-8 -*-
from lmfdb.app import app
from lmfdb.logger import make_logger
from flask import Blueprint
abvar_page = Blueprint("abvar", __name__, template_folder='templates', static_folder="static")
abvar_logger = make_logger(abvar_page)
@abvar_page.context_processor
def body_class():
return {'body_class': 'abvar'}
app.register_blueprint(abvar_page, url_prefix="/Variety/Abelian")
# -*- coding: utf-8 -*-
from lmfdb.app import app
from lmfdb.logger import make_logger
from flask import Blueprint
rep_galois_modl_page = Blueprint("rep_galois_modl", __name__, template_folder='templates', static_folder="static")
rep_galois_modl_logger = make_logger(rep_galois_modl_page)
@rep_galois_modl_page.context_processor
def body_class():
return {'body_class': 'rep_galois_modl'}
import main
assert main #silence pyflakes
app.register_blueprint(rep_galois_modl_page, url_prefix="/Representation/Galois/ModL")
from collections import Counter
import os, yaml
from flask import url_for
from sage.all import (gcd, Set, ZZ, is_even, is_odd, euler_phi,
CyclotomicField, gap, RealField, AbelianGroup, QQ, gp,
NumberField, PolynomialRing, latex, pari,
cached_function)
from lmfdb import db
from lmfdb.utils import (web_latex, coeff_to_poly, pol_to_html,
display_multiset, factor_base_factor,
factor_base_factorization_latex)
from lmfdb.logger import make_logger
from lmfdb.galois_groups.transitive_group import WebGaloisGroup, group_display_knowl, galois_module_knowl, group_pretty_and_nTj
wnflog = make_logger("WNF")
dir_group_size_bound = 10000
dnc = 'data not computed'
# Dictionary of field label: n for abs(disc(Q(zeta_n)))
# Does all cyclotomic fields of degree n s.t. 2<n<24
cycloinfo = {
'4.0.125.1':
5,
'6.0.16807.1':
7,
'4.0.256.1':
8,
'6.0.19683.1':
9,
from main import (login_page, login_manager, admin_required, knowl_reviewer_required,
housekeeping, FLASK_LOGIN_VERSION, FLASK_LOGIN_LIMIT)
assert admin_required # silence pyflakes
assert knowl_reviewer_required # silence pyflakes
assert housekeeping # silence pyflakes
from lmfdb.app import app
from lmfdb.logger import make_logger
from distutils.version import StrictVersion
# secret key, necessary for sessions, and sessions are
# in turn necessary for users to login
app.secret_key = '9af"]ßÄ!_°$2ha€42~µ…010'
login_manager.init_app(app)
app.register_blueprint(login_page, url_prefix="/users")
users_logger = make_logger("users", hl=True)
if StrictVersion(FLASK_LOGIN_VERSION) < StrictVersion(FLASK_LOGIN_LIMIT):
users_logger.warning(
"DEPRECATION-WARNING: "
"flask-login is older than version {version}. "
"Versions older than {version} have different functionality and may "
"stop working in the future. "
"Consider updating, perhaps through "
"`sage -pip install flask-login`.".format(version=FLASK_LOGIN_LIMIT))
# -*- coding: utf-8 -*-
from lmfdb.app import app
from lmfdb.logger import make_logger
from flask import Blueprint
maass_page = Blueprint("maass", __name__, template_folder='templates')
logger = make_logger(maass_page)
@maass_page.context_processor
def body_class():
return {'body_class': 'maass'}
from . import main
assert main # silence pyflakes
app.register_blueprint(maass_page, url_prefix="/ModularForm/GL2/Q/Maass")
# API2 has been disabled for now
#from lmfdb.api2.searchers import register_search_function
#register_search_function(
# "gl2_maass_forms",
# "GL2 Maass forms",
# "Search over GL2 Maass forms",
# auto_search = 'maass_newforms'
#)
# -*- coding: utf-8 -*-
from lmfdb.logger import make_logger
import os
from flask import Blueprint, Response, render_template, request, url_for
FirstZeros = Blueprint('first L-function zeros',
__name__, template_folder="templates")
logger = make_logger(FirstZeros)
import sqlite3
data_location = os.path.expanduser("~/data/zeros/")
@FirstZeros.route("/")
def firstzeros():
start = request.args.get('start', None, float)
end = request.args.get('end', None, float)
limit = request.args.get('limit', 100, int)
degree = request.args.get('degree', None, int)
# signature_r = request.arts.get("signature_r", None, int)
# signature_c = request.arts.get("signature_c", None, int)
if limit > 1000:
limit = 1000
if limit < 0:
limit = 100
# return render_template("first_zeros.html", start=start, end=end,
# limit=limit, degree=degree, signature_r=signature_r,
# signature_c=signature_c)
title = "Search for First Zeros of L-functions"
bread = [("L-functions", url_for("l_functions.l_function_top_page")),
# -*- coding: utf-8 -*-
# Class created to aid in uploading HMF data from the Magma output data files.
# Incomplete, and currently not used for real work.
#
# In particular this code assumes that all the data for one HMF is in
# a single collection, which is no longer the case.
from __future__ import print_function
from six import text_type
from sage.all import QQ, polygen
from lmfdb import db
from lmfdb.hilbert_modular_forms.hilbert_field import HilbertNumberField
from lmfdb.logger import make_logger
logger = make_logger("hmf")
def construct_full_label(field_label, weight, level_label, label_suffix):
if all([w==2 for w in weight]): # Parellel weight 2
weight_label = ''
elif all([w==weight[0] for w in weight]): # Parellel weight
weight_label = str(weight[0]) + '-'
else: # non-parallel weight
weight_label = str(weight) + '-'
return ''.join([field_label, '-', weight_label, level_label, '-', label_suffix])
class WebHMF(object):
"""
Class for an Hilbert Modular Newform
"""
# -*- coding: utf-8 -*-
from lmfdb.app import app
from lmfdb.logger import make_logger
from flask import Blueprint
smf_page = Blueprint('smf', __name__,
template_folder='templates', static_folder='static')
smf_logger = make_logger(smf_page)
@smf_page.context_processor
def body_class():
return {'body_class': 'smf'}
import siegel_modular_form
assert siegel_modular_form #silence pyflakes
app.register_blueprint(smf_page, url_prefix='/ModularForm/GSp/Q')
return "%s.%s%s" % (conductor, iso_class, number)
def curve_cremona_label(conductor, iso_class, number):
return "%s%s%s" % (conductor, iso_class, number)
def class_lmfdb_label(conductor, iso_class):
return "%s.%s" % (conductor, iso_class)
def class_cremona_label(conductor, iso_class):
return "%s%s" % (conductor, iso_class)
logger = make_logger("ec")
def split_galois_image_code(s):
"""Each code starts with a prime (1-3 digits but we allow for more)
followed by an image code or that prime. This function returns
two substrings, the prefix number and the rest.
"""
p = re.findall(r'\d+', s)[0]
return p, s[len(p):]
def trim_galois_image_code(s):
"""Return the image code with the prime prefix removed.
"""
return split_galois_image_code(s)[1]
# -*- coding: utf-8 -*-
from lmfdb.app import app
from lmfdb.logger import make_logger
from flask import Blueprint
tensor_products_page = Blueprint(
"tensor_products", __name__, template_folder='templates', static_folder="static")
tensor_products_logger = make_logger("tensor_products", hl=True)
@tensor_products_page.context_processor
def body_class():
return {'body_class': 'tensor_products'}
import main
assert main #silence pyflakes
app.register_blueprint(tensor_products_page, url_prefix="/TensorProducts")
import flask
from mpmath import nstr, inf
from sage.all import floor, log
from lmfdb.logger import make_logger
from flask import render_template, request, url_for
ZetaZeros = flask.Blueprint("zeta zeros", __name__, template_folder="templates")
logger = make_logger(ZetaZeros)
from platt_zeros import zeros_starting_at_N, zeros_starting_at_t
@ZetaZeros.route("/")
def zetazeros():
N = request.args.get("N", None, int)
t = request.args.get("t", 0, float)
limit = request.args.get("limit", 100, int)
if limit > 1000:
return list_zeros(N=N, t=t, limit=limit)
else:
title = "Zeros of $\zeta(s)$"
bread = [("L-functions", url_for("l_functions.l_function_top_page")),
('Zeros of $\zeta(s)$', ' ')]
learnmore = [("Completeness of this data",url_for(".extent") ),("How data was computed", url_for(".howcomputed"))]
return render_template('zeta.html', N=N, t=t, limit=limit, title=title, bread=bread, learnmore=learnmore)
@ZetaZeros.route("/Extent")
def extent ():
t = 'Extent of Data for Riemann Zeta Zeros'
bread = [("L-functions", url_for("l_functions.l_function_top_page")),
# -*- coding: utf-8 -*-
from lmfdb.app import app
from lmfdb.logger import make_logger
from flask import Blueprint
hmf_page = Blueprint("hmf", __name__, template_folder='templates', static_folder="static")
hmf_logger = make_logger(hmf_page)
@hmf_page.context_processor
def body_class():
return {'body_class': 'hmf'}
import hilbert_modular_form
assert hilbert_modular_form
app.register_blueprint(hmf_page, url_prefix="/ModularForm/GL2/TotallyReal")
# -*- coding: utf-8 -*-
from lmfdb.app import app
from lmfdb.logger import make_logger
from flask import Blueprint
belyi_page = Blueprint("belyi",
__name__,
template_folder='templates',
static_folder="static")
belyi_logger = make_logger(belyi_page)
@belyi_page.context_processor
def body_class():
return {'body_class': 'belyi'}
import main
assert main # silence pyflakes
app.register_blueprint(belyi_page, url_prefix="/Belyi")
# -*- coding: utf-8 -*-
from lmfdb.app import app
from lmfdb.logger import make_logger
from flask import Blueprint
lattice_page = Blueprint("lattice", __name__, template_folder='templates', static_folder="static")
lattice_logger = make_logger(lattice_page)
@lattice_page.context_processor
def body_class():
return {'body_class': 'lattice'}
import main
assert main
app.register_blueprint(lattice_page, url_prefix="/Lattice")
# -*- coding: utf-8 -*-
from __future__ import absolute_import
from seminars.app import app
from lmfdb.logger import make_logger
from flask import Blueprint
create_page = Blueprint("create",
__name__,
template_folder='templates',
static_folder="static")
create = create_page
create_logger = make_logger(create_page)
from . import main
assert main # silence pyflakes
app.register_blueprint(create_page, url_prefix="/create")
# -*- coding: utf-8 -*-
from flask import url_for
from lmfdb import db
from lmfdb.app import app
from lmfdb.utils import comma
from lmfdb.logger import make_logger
from lmfdb.number_fields.web_number_field import nf_display_knowl
from sage.misc.cachefunc import cached_method
def field_sort_key(F):
dsdn = F.split(".")
return (int(dsdn[0]), int(dsdn[2])) # by degree then discriminant
logger = make_logger("hmf")
the_HMFstats = None
def get_counts():
global the_HMFstats
if the_HMFstats is None:
the_HMFstats = HMFstats()
return the_HMFstats.counts()
def get_stats(d=None):
global the_HMFstats
if the_HMFstats is None:
the_HMFstats = HMFstats()
return the_HMFstats.stats(d)
def hmf_summary():
counts = get_stats().counts()
# -*- coding: utf-8 -*-
from lmfdb import db
from lmfdb.app import app
from lmfdb.utils import comma
from lmfdb.logger import make_logger
from sage.misc.cachefunc import cached_method
logger = make_logger("rep_galois_modls")
the_rep_galois_modlstats = None
def get_stats():
global the_rep_galois_modlstats
if the_rep_galois_modlstats is None:
the_rep_galois_modlstats = rep_galois_modlstats()
return the_rep_galois_modlstats
def rep_galois_modl_summary():
counts = get_stats().counts()
return r"<p>The database currently contains %s <a title='mod ℓ Galois representation'[rep_galois_modl.definition]' knowl='rep_galois_modl.definition' kwargs=''>mod ℓ Galois representations</a>.</p>" % (
str(counts['nrep_galois_modl_c']))
@app.context_processor
def ctx_rep_galois_modl_summary():
return {'rep_galois_modl_summary': rep_galois_modl_summary}
class rep_galois_modlstats(object):
# -*- coding: utf-8 -*-
from lmfdb.app import app
from lmfdb.logger import make_logger
from flask import Blueprint
l_function_page = Blueprint("l_functions", __name__, template_folder='templates', static_folder="static")
logger = make_logger("LF")
@l_function_page.context_processor
def body_class():
return {'body_class': 'l_functions'}
import main
assert main # silence pyflakes
app.register_blueprint(l_function_page, url_prefix="/L")
# -*- coding: utf-8 -*-
from lmfdb import db
from lmfdb.logger import make_logger
from lmfdb.number_fields.web_number_field import nf_display_knowl, field_pretty
from lmfdb.elliptic_curves.web_ec import split_lmfdb_label
from lmfdb.nfutils.psort import primes_iter, ideal_from_label, ideal_label
from lmfdb.utils import web_latex, names_and_urls
from lmfdb.lfunctions.LfunctionDatabase import (get_instances_by_Lhash,
get_instances_by_trace_hash, get_lfunction_by_url)
from flask import url_for
from sage.all import QQ, PolynomialRing, NumberField
logger = make_logger("bmf")
class WebBMF(object):
"""
Class for an Bianchi Newform
"""
def __init__(self, dbdata):
"""Arguments:
- dbdata: the data from the database
dbdata is expected to be a database entry from which the class
is initialised.
"""
logger.debug("Constructing an instance of WebBMF class from database")
self.__dict__.update(dbdata)
# All other fields are handled here
# -*- coding: utf-8 -*-
from lmfdb.app import app
from lmfdb.logger import make_logger
from flask import Blueprint
crystals_page = Blueprint("crystals", __name__, template_folder='templates', static_folder="static")
logger = make_logger(crystals_page)
@crystals_page.context_processor
def body_class():
return {'body_class': 'Crystals'}
import main
assert main # silence pyflakes
app.register_blueprint(crystals_page, url_prefix="/Crystals")
# -*- coding: utf-8 -*-
from lmfdb.app import app
from lmfdb.logger import make_logger
from flask import Blueprint
belyi_page = Blueprint("belyi", __name__, template_folder='templates',
static_folder="static")
belyi_logger = make_logger(belyi_page)
@belyi_page.context_processor
def body_class():
return {'body_class': 'belyi'}
import main
assert main # silence pyflakes
app.register_blueprint(belyi_page, url_prefix="/Belyi")
# -*- coding: utf-8 -*-
from lmfdb.app import app
from lmfdb.logger import make_logger
from flask import Blueprint
motive_page = Blueprint("motive",
__name__,
template_folder='templates',
static_folder="static")
motive_logger = make_logger(motive_page)
@motive_page.context_processor
def body_class():
return {'body_class': 'motive'}
import main
assert main # silence pyflakes
app.register_blueprint(motive_page, url_prefix="/Motive")
import flask
from mpmath import nstr, inf
from sage.all import floor, log
from lmfdb.logger import make_logger
from flask import render_template, request, url_for
ZetaZeros = flask.Blueprint("zeta zeros",
__name__,
template_folder="templates")
logger = make_logger(ZetaZeros)
from platt_zeros import zeros_starting_at_N, zeros_starting_at_t
credit_string = "David Platt"
def learnmore_list():
return [('Completeness of the data', url_for(".completeness")),
('Source of the data', url_for(".source")),
('Reliability of the data', url_for(".reliability"))]
# Return the learnmore list with the matchstring entry removed
def learnmore_list_remove(matchstring):
return filter(lambda t: t[0].find(matchstring) < 0, learnmore_list())
@ZetaZeros.route("/")
def zetazeros():
N = request.args.get("N", None, int)
t = request.args.get("t", 0, float)
# -*- coding: utf-8 -*-
from lmfdb.app import app
from lmfdb.logger import make_logger
from flask import Blueprint
api_page = Blueprint("API", __name__, template_folder='templates', static_folder="static")
api_logger = make_logger(api_page)
@api_page.context_processor
def body_class():
return {'body_class': 'api'}
import api
assert api # silence pyflakes
app.register_blueprint(api_page, url_prefix="/api")
# -*- coding: utf-8 -*-
from lmfdb.logger import make_logger
import os
from flask import Blueprint, Response, render_template, request, url_for
FirstZeros = Blueprint('first L-function zeros',
__name__,
template_folder="templates")
logger = make_logger(FirstZeros)
import sqlite3
data_location = os.path.expanduser("~/data/zeros/")
@FirstZeros.route("/")
def firstzeros():
start = request.args.get('start', None, float)
end = request.args.get('end', None, float)
limit = request.args.get('limit', 100, int)
degree = request.args.get('degree', None, int)
# signature_r = request.arts.get("signature_r", None, int)
# signature_c = request.arts.get("signature_c", None, int)
if limit > 1000:
limit = 1000
if limit < 0:
limit = 100
# return render_template("first_zeros.html", start=start, end=end,
# limit=limit, degree=degree, signature_r=signature_r,
# signature_c=signature_c)
# -*- coding: utf-8 -*-
from __future__ import absolute_import
from lmfdb.app import app
from lmfdb.logger import make_logger
from flask import Blueprint
from lmfdb.api2.searchers import register_search_function
nf_page = Blueprint("number_fields",
__name__,
template_folder='templates',
static_folder="static")
nf_logger = make_logger(nf_page)
@nf_page.context_processor
def body_class():
return {'body_class': 'nf'}
from . import number_field
assert number_field
app.register_blueprint(nf_page, url_prefix="/NumberField")
register_search_function("number_fields",
"Global number fields",
"Search over global number fields",
auto_search='nf_fields')
# -*- coding: utf-8 -*-
from __future__ import absolute_import
from beantheory.app import app
from lmfdb.logger import make_logger
from flask import Blueprint
knowledge_page = Blueprint("knowledge", __name__, template_folder='templates')
logger = make_logger(knowledge_page)
from . import main
assert main
app.register_blueprint(knowledge_page, url_prefix="/knowledge")
# -*- coding: utf-8 -*-
from lmfdb.app import app
from lmfdb.logger import make_logger
from flask import Blueprint
abvar_page = Blueprint("abvar",
__name__,
template_folder="templates",
static_folder="static")
abvar_logger = make_logger(abvar_page)
@abvar_page.context_processor
def body_class():
return {"body_class": "abvar"}
app.register_blueprint(abvar_page, url_prefix="/Variety/Abelian")
# API2 has been disabled for now
#from lmfdb.api2.searchers import register_search_function
#register_search_function(
# "abvar",
# "Abelian varieties",
# "Search over abelian varieties",
# auto_search="av_fqisog",
# inv=["av", "av_fqisog"],
#)
# -*- coding: utf-8 -*-
from lmfdb.app import app
from lmfdb.logger import make_logger
from flask import Blueprint
from lmfdb.api2.searchers import register_search_function
local_fields_page = Blueprint("local_fields",
__name__,
template_folder='templates',
static_folder="static")
logger = make_logger(local_fields_page)
@local_fields_page.context_processor
def body_class():
return {'body_class': 'local_fields'}
import main
assert main
app.register_blueprint(local_fields_page, url_prefix="/LocalNumberField")
register_search_function("local_fields",
"Local number fields",
"Search over local number fields",
auto_search='lf_fields')
# -*- coding: utf-8 -*-
from lmfdb.app import app
from lmfdb.logger import make_logger
from flask import Blueprint
tensor_products_page = Blueprint("tensor_products",
__name__,
template_folder='templates',
static_folder="static")
tensor_products_logger = make_logger("tensor_products", hl=True)
@tensor_products_page.context_processor
def body_class():
return {'body_class': 'tensor_products'}
import main
assert main #silence pyflakes
app.register_blueprint(tensor_products_page, url_prefix="/TensorProducts")
from flask import url_for
from collections import defaultdict
from sage.all import (gcd, ZZ, Rational, Integers, cached_method,
euler_phi, latex)
from sage.databases.cremona import cremona_letter_code
from sage.misc.lazy_attribute import lazy_attribute
from lmfdb import db
from lmfdb.utils import prop_int_pretty
from lmfdb.utils.utilities import num2letters
from lmfdb.logger import make_logger
from lmfdb.number_fields.web_number_field import WebNumberField, formatfield, nf_display_knowl
from lmfdb.characters.TinyConrey import (ConreyCharacter, kronecker_symbol,
symbol_numerator, PariConreyGroup, get_sage_genvalues)
from lmfdb.characters.utils import url_character, complex2str
from lmfdb.groups.abstract.main import abstract_group_display_knowl
logger = make_logger("DC")
def parity_string(n):
return "odd" if n == -1 else "even"
def bool_string(b):
return "yes" if b else "no"
#############################################################################
###
### Class for Web objects
###
#############################################################################
class WebCharObject(object):
""" class for all characters and character groups """
# -*- coding: utf-8 -*-
from lmfdb.app import app
from lmfdb.logger import make_logger
from flask import Blueprint
bmf_page = Blueprint("bmf",
__name__,
template_folder='templates',
static_folder="static")
bmf_logger = make_logger(bmf_page)
@bmf_page.context_processor
def body_class():
return {'body_class': 'bmf'}
from . import bianchi_modular_form
assert bianchi_modular_form
app.register_blueprint(bmf_page,
url_prefix="/ModularForm/GL2/ImaginaryQuadratic")
# -*- coding: utf-8 -*-
from __future__ import absolute_import
from lmfdb.app import app
from lmfdb.logger import make_logger
from flask import Blueprint
abvarfq_page = Blueprint("abvarfq",
__name__,
template_folder="templates",
static_folder="static")
abvarfq_logger = make_logger(abvarfq_page)
@abvarfq_page.context_processor
def body_class():
return {"body_class": "abvarfq"}
from . import main
assert main
app.register_blueprint(abvarfq_page, url_prefix="/Variety/Abelian/Fq")
# -*- coding: utf-8 -*-
from lmfdb.app import app
from lmfdb.utils import comma
from lmfdb.logger import make_logger
from lmfdb import db
logger = make_logger("hecke_algebras")
def hecke_algebras_summary():
heckestats = db.hecke_algebras.stats
hecke_knowl = '<a knowl="hecke_algebra.definition">Hecke algebras</a>'
level_knowl = '<a knowl="cmf.level">level</a>'
weight_knowl = '<a knowl="cmf.weight">weight</a>'
gamma0_knowl = '<a knowl="group.sl2z.subgroup.gamma0n">$\Gamma_0$</a>'
level_data = heckestats.get_oldstat('level')
number = level_data['total']
max_level = level_data['max']
weight_data = heckestats.get_oldstat('weight')
max_weight = weight_data['max']
return ''.join([r'The database currently contains {} '.format(comma(number)),
hecke_knowl,'. The largest ', level_knowl, ' for ' , gamma0_knowl , ' is {}, '.format(comma(max_level)),
'the largest ', weight_knowl, ' is {}.'.format(comma(max_weight))])
@app.context_processor
def ctx_hecke_algebras_summary():
return {'hecke_algebras_summary': hecke_algebras_summary}
# -*- coding: utf-8 -*-
from lmfdb.app import app
from lmfdb.logger import make_logger
from flask import Blueprint
modlmf_page = Blueprint("modlmf",
__name__,
template_folder='templates',
static_folder="static")
modlmf_logger = make_logger(modlmf_page)
@modlmf_page.context_processor
def body_class():
return {'body_class': 'modlmf'}
from . import main
assert main
app.register_blueprint(modlmf_page, url_prefix="/ModularForm/GL2/ModL")
from sage.rings.all import PolynomialRing, ZZ
from lmfdb import db
from lmfdb.app import app
from lmfdb.logger import make_logger
from lmfdb.utils import (
to_dict,
parse_ints, parse_string_start, parse_nf_string, parse_galgrp,
parse_subset, parse_submultiset, parse_bool, parse_bool_unknown,
search_wrap)
from . import abvarfq_page
from .search_parsing import parse_newton_polygon
from .isog_class import validate_label, AbvarFq_isoclass
from .stats import AbvarFqStats
logger = make_logger("abvarfq")
#########################
# Top level
#########################
def get_bread(*breads):
bc = [('Abelian Varieties', url_for(".abelian_varieties")),
('Fq', url_for(".abelian_varieties"))]
map(bc.append, breads)
return bc
abvarfq_credit = 'Taylor Dupuy, Kiran Kedlaya, David Roe, Christelle Vincent'
@app.route("/EllipticCurves/Fq")
def ECFq_redirect():
4: 5
},
7: {
1: 343,
2: 343,
3: 7
},
}
maxgen = {1: 500, 2: 211, 3: 25}
if p < 10:
return maxspec[p][g]
else:
return maxgen[g]
logger = make_logger("abvarfq")
#########################
# Label manipulation
#########################
def validate_label(label):
parts = label.split(".")
if len(parts) != 3:
raise ValueError(
"it must be of the form g.q.iso, with g a dimension and q a prime power"
)
g, q, iso = parts
try:
g = int(g)
# -*- coding: utf-8 -*-
from lmfdb import db
from lmfdb.logger import make_logger
from lmfdb.number_fields.web_number_field import nf_display_knowl, field_pretty
from lmfdb.elliptic_curves.web_ec import split_lmfdb_label
from lmfdb.nfutils.psort import primes_iter, ideal_from_label, ideal_label
from lmfdb.utils import web_latex, names_and_urls, prop_int_pretty
from lmfdb.lfunctions.LfunctionDatabase import (
get_lfunction_by_url, get_instances_by_Lhash_and_trace_hash)
from flask import url_for
from sage.all import QQ, PolynomialRing, NumberField
logger = make_logger("bmf")
# Labels of BMFs which have no elliptic curve but are not twists of
# base change. Those which have no curve but are twists of base
# change are detectable automatically in the code below, but these are
# not. Up to Galois conjugacy and quadratic twist there are only four
# of these known; each is associated to the Jacobian of a genus 2
# curve over the base field; these curves were found by Ciaran
# Schembri. At some point we will want to list these abelian surfaces
# as friends when there is no curve.
# TO (after adding 31 more for 2.0.43.1): make this list into a table,
# OR add a column to the bmf_forms table to indicate whether or not a
# curve exists (which could be because we have not foud one, but is
# normally because there really is not curve).
bmfs_with_no_curve = [
'2.0.4.1-34225.7-b', '2.0.4.1-34225.7-a', '2.0.4.1-34225.3-b',
'2.0.4.1-34225.3-a', '2.0.3.1-67081.3-a', '2.0.3.1-67081.3-b',
# -*- coding: utf-8 -*-
from lmfdb.app import app
from lmfdb.logger import make_logger
from flask import Blueprint
from lmfdb.api2.searchers import register_search_function
higher_genus_w_automorphisms_page = Blueprint("higher_genus_w_automorphisms",
__name__, template_folder='templates',
static_folder="static")
logger = make_logger(higher_genus_w_automorphisms_page)
@higher_genus_w_automorphisms_page.context_processor
def body_class():
return {'body_class': 'higher_genus_w_automorphisms'}
import main
assert main # silence pyflakes
app.register_blueprint(higher_genus_w_automorphisms_page, url_prefix="/HigherGenus/C/Aut")
register_search_function(
"group_actions_higher_genus_curves",
"Group actions on higher genus curves",
"Search over group actions on higher genus curves",
auto_search = 'hgcwa_passports'
)
# / modular_forms/__init__.py import flask from lmfdb.logger import make_logger from lmfdb.app import app MF_TOP = "Modular Forms" MF = "mf" mf = flask.Blueprint(MF, __name__, template_folder="views/templates", static_folder="views/static") mf_logger = make_logger(mf) import maass_forms assert maass_forms import views assert views app.register_blueprint(mf, url_prefix="/ModularForm/") app.register_blueprint(mf, url_prefix="/AutomorphicForm/") app.register_blueprint(maass_forms.maassf, url_prefix="/ModularForm/Maass") app.register_blueprint(maass_forms.maass_waveforms.mwf, url_prefix="/ModularForm/GL2/Q/Maass") app.register_blueprint(maass_forms.picard.mwfp, url_prefix="/ModularForm/GL2/C/Maass")
