def codeinit(self):
self.exnum = self.galorbnums[0]
self.exchi = ConreyCharacter(self.modulus, self.exnum)
values_gens = db.char_dir_values.lookup(
"{}.{}".format(self.modulus, self.exnum),
projection='values_gens'
)
vals = [int(v) for g, v in values_gens]
sage_zeta_order = self.exchi.sage_zeta_order(self.order)
self._genvalues_for_code = get_sage_genvalues(self.modulus,
self.order, vals, sage_zeta_order)
return {
'sage': [
'from sage.modular.dirichlet import DirichletCharacter',
'H = DirichletGroup({}, base_ring=CyclotomicField({}))'.format(
self.modulus, sage_zeta_order),
'M = H._module',
'chi = DirichletCharacter(H, M([{}]))'.format(
','.join(str(val) for val in self._genvalues_for_code)
),
'chi.galois_orbit()'
],
'pari': [
'[g,chi] = znchar(Mod(%i,%i))' % (self.exnum, self.modulus),
'order = charorder(g,chi)',
'[ charpow(g,chi, k % order) | k <-[1..order-1], gcd(k,order)==1 ]'
]
}
def __init__(self, **kwargs):
self.type = "Dirichlet"
self.isorbit = True
self.modulus = kwargs.get('modulus', None)
if self.modulus:
self.modulus = int(self.modulus)
self.modlabel = self.modulus
self.number = kwargs.get('number', None)
if self.number:
self.number = int(self.number)
self.numlabel = self.number
if self.modulus:
# Needed for Gauss sums, etc
self.H = PariConreyGroup(self.modulus)
if self.number:
self.chi = ConreyCharacter(self.modulus, self.number)
self.codelangs = ('pari', 'sage')
self.orbit_label = kwargs.get('orbit_label', None) # this is what the user inserted, so might be banana
self.label = "{}.{}".format(self.modulus, self.orbit_label)
self.orbit_data = self.get_orbit_data(self.orbit_label) # this is the meat
self.maxrows = 30
self.rowtruncate = False
self._set_galoisorbit(self.orbit_data)
self.maxcols = 10
self._contents = None
self._set_groupelts()
def get_dirchar(char_mod, char_num, char_order):
"""Helper method to compute Dirichlet Character on the fly"""
char_values_data = db.char_dir_values.lookup("{}.{}".format(
char_mod, char_num))
char_valuepairs = char_values_data['values_gens']
char_genvalues = [int(v) for g, v in char_valuepairs]
return ConreyCharacter(char_mod,
char_num).sage_character(char_order, char_genvalues)
def get_character_modulus(a, b, limit=7):
""" this function is also used by lfunctions/LfunctionPlot.py """
headers = list(range(1, limit))
headers.append("more")
entries = {}
rows = list(range(a, b + 1))
for row in rows:
if row != 1:
G = Integers(row).list_of_elements_of_multiplicative_group()
else:
G = [1]
for chi_n in G:
chi = ConreyCharacter(row, chi_n)
multorder = chi.multiplicative_order()
if multorder <= limit:
el = chi
col = multorder
entry = entries.get((row, col), [])
entry.append(el)
entries[(row, col)] = entry
entries2 = {}
out = lambda chi: (chi.number, chi.is_primitive(),
chi.multiplicative_order(), chi.is_even())
for k, v in entries.items():
l = []
v = sorted(v, key=lambda x: x.number)
while v:
e1 = v.pop(0)
e1_num = e1.number
inv_num = 1 if e1_num == 1 else e1_num.inverse_mod(e1.modulus)
inv = ConreyCharacter(e1.modulus, inv_num)
if e1_num == inv_num:
l.append((out(e1), ))
else:
l.append((out(e1), out(inv)))
v = [
x for x in v
if (x.modulus, x.number) != (inv.modulus, inv.number)
]
if k[1] == "more":
l = sorted(l, key=lambda e: e[0][2])
entries2[k] = l
cols = headers
return headers, entries2, rows, cols
def nextprimchar(m, n):
if m < 3:
return 3, 2
while 1:
n += 1
if n >= m:
m, n = m + 1, 2
if gcd(m, n) != 1:
continue
# we have a character, test if it is primitive
chi = ConreyCharacter(m,n)
if chi.is_primitive():
return m, n
def prevprimchar(m, n):
if m <= 3:
return 1, 1
while True:
n -= 1
if n <= 1: # (m,1) is never primitive for m>1
m, n = m - 1, m - 1
if m <= 2:
return 1, 1
if gcd(m, n) != 1:
continue
# we have a character, test if it is primitive
chi = ConreyCharacter(m,n)
if chi.is_primitive():
return m, n
def check_order_parity(self, rec, verbose=False):
"""
check order and parity by constructing a Conrey character in Sage (use the first index in galois_orbit)
"""
# TIME about 30000s for full table
char = ConreyCharacter(rec['modulus'], rec['galois_orbit'][0])
parity = 1 if char.is_even() else -1
success = (parity == rec['parity']
and char.conductor() == rec['conductor']
and char.multiplicative_order() == rec['order'])
if verbose and not success:
print("Order-parity failure", parity, rec['parity'],
char.conductor(), rec['conductor'],
char.multiplicative_order(), rec['order'])
return success
def check_ap2_slow(rec):
# Check a_{p^2} = a_p^2 - chi(p) for primes up to 31
ls = rec['lfunction_label'].split('.')
level, weight, chi = map(int, [ls[0], ls[1], ls[-2]])
char = ConreyCharacter(level, chi)
Z = rec['an_normalized[0:1000]']
for p in prime_range(31 + 1):
if level % p != 0:
# a_{p^2} = a_p^2 - chi(p)
charval = CC(2 * char.conreyangle(int(p)) * CC.pi() *
CC.gens()[0]).exp()
else:
charval = 0
if (CC(*Z[p**2 - 1]) - (CC(*Z[p - 1])**2 - charval)).abs() > 1e-11:
return False
return True
def __init__(self, **kwargs):
self.type = "Dirichlet"
self.modulus = kwargs.get('modulus', None)
if self.modulus:
self.modulus = int(self.modulus)
self.modlabel = self.modulus
self.number = kwargs.get('number', None)
if self.number:
self.number = int(self.number)
self.numlabel = self.number
if self.modulus:
# Needed for Gauss sums, etc
self.H = PariConreyGroup(self.modulus)
if self.number:
self.chi = ConreyCharacter(self.modulus, self.number)
self.maxcols = 30
self.codelangs = ('pari', 'sage')
self._compute()
def check_ap2_slow(self, rec, verbose=False):
"""
Check a_{p^2} = a_p^2 - chi(p) for primes up to 31
"""
ls = rec['label'].split('.')
level, weight, chi = map(int, [ls[0], ls[1], ls[-2]])
char = ConreyCharacter(level, chi)
Z = rec['an_normalized']
for p in prime_range(31+1):
if level % p != 0:
# a_{p^2} = a_p^2 - chi(p)
charval = CC(2*char.conreyangle(int(p)) * CC.pi()*CC.gens()[0]).exp()
else:
charval = 0
if (CC(*Z[p**2 - 1]) - (CC(*Z[p-1])**2 - charval)).abs() > 1e-13:
if verbose:
print("ap2 failure", p, CC(*Z[p**2 - 1]), CC(*Z[p-1])**2 - charval)
return False
return True
def jacobi_sum(self, val):
mod, num = self.modulus, self.number
try:
val = int(val)
except ValueError:
raise Warning ("n must be a positive integer coprime to the modulus {} and no greater than it".format(mod))
if gcd(mod, val) > 1:
raise Warning ("n must be coprime to the modulus : %s"%mod)
if val > mod:
raise Warning ("n must be less than the modulus : %s"%mod)
if val < 0:
raise Warning ("n must be positive")
chi_values_data = db.char_dir_values.lookup(
"{}.{}".format(mod, num)
)
chi_valuepairs = chi_values_data['values_gens']
chi_genvalues = [int(v) for g, v in chi_valuepairs]
chi = self.chi.sage_character(self.order, chi_genvalues)
psi = ConreyCharacter(self.modulus, val)
psi_values_data = db.char_dir_values.lookup(
"{}.{}".format(self.modulus, val)
)
psi_valuepairs = psi_values_data['values_gens']
psi_genvalues = [int(v) for g, v in psi_valuepairs]
psi = psi.sage_character(self.order, psi_genvalues)
jacobi_sum = chi.jacobi_sum(psi)
chitex = self.char2tex(mod, num, tag=False)
psitex = self.char2tex(mod, val, tag=False)
Gtex = r'\Z/%s\Z' % mod
chitexr = self.char2tex(mod, num, 'r', tag=False)
psitex1r = self.char2tex(mod, val, '1-r', tag=False)
deftex = r'\sum_{r\in %s} %s %s'%(Gtex,chitexr,psitex1r)
return r"\( \displaystyle J(%s,%s) = %s = %s \)" % (chitex, psitex, deftex, latex(jacobi_sum))
def charisprimitive(self,mod,num):
return ConreyCharacter(mod, num).is_primitive()
def _compute(self):
self.modulus = int(self.modlabel)
self.number = int(self.numlabel)
self.chi = ConreyCharacter(self.modulus, self.number)
self.codelangs = ('pari', 'sage')
def set_info_for_gamma1(level, weight, weight2=None):
dimension_table_name = WebModFormSpace._dimension_table_name
if weight != None and weight2 > weight:
w1 = weight
w2 = weight2
else:
w1 = weight
w2 = weight
table = {'galois_orbit': {}, 'galois_orbits_reps': {}, 'cells': {}}
table['weights'] = range(w1, w2 + 1)
emf_logger.debug("dimension table name={0}".format(dimension_table_name))
db_dim = getDBConnection()['modularforms2'][dimension_table_name]
s = {
'level': int(level),
'weight': {
"$lt": int(w2 + 1),
"$gt": int(w1 - 1)
},
'cchi': {
"$exists": True
}
}
q = db_dim.find(s).sort([('cchi', int(1)), ('weight', int(1))])
if q.count() == 0:
emf_logger.debug("No spaces in the database!")
flash(
'The database does not currently contain any spaces matching these parameters. Please try again!'
)
return None #'error':'The database does not currently contain any spaces matching these parameters!'}
else:
table['maxGalCount'] = 1
for r in q:
xi = r['cchi']
orbit = r['character_orbit']
k = r['weight']
## This is probably still quicker if it is in the database
parity = r.get('character_parity', 'n/a')
if parity == 'n/a':
chi = ConreyCharacter(level, xi)
if chi.is_odd():
parity = -1
elif chi.is_even():
parity = 1
else:
emf_logger.critical(
"Could not determine the parity of ConreyCharacter({0},{1})"
.format(xi, level))
trivial_trivially = ""
if parity != 'n/a':
if k % 2 == (1 +
parity) / 2: # is space empty because of parity?
trivial_trivially = "yes"
else:
trivial_trivially = ""
if parity == 1:
parity = 'even'
elif parity == -1:
parity = 'odd'
d = r.get('d_newf', "n/a")
indb = r.get('in_wdb', 0)
if d == 0:
indb = 1
if indb:
url = url_for('emf.render_elliptic_modular_forms',
level=level,
weight=k,
character=xi)
else:
url = ''
if not table['galois_orbits_reps'].has_key(xi):
table['galois_orbits_reps'][xi] = {
'head':
"\(\chi_{{{0}}}({1},\cdot) \)".format(
level, xi), # yes, {{{ is required
'chi':
"{0}".format(xi),
'url':
url_for('characters.render_Dirichletwebpage',
modulus=level,
number=xi),
'parity':
parity
}
table['galois_orbit'][xi] = [
{
#'head' : "\(\chi_{{{0}}}({1},\cdot) \)".format(level,xci), # yes, {{{ is required
## 'head' : "\(S_{{{0}}}({1},\chi({2}, \cdot) ) \)".format(weight,level,xci), # yes, {{{ is required
## 'head' : "\(S_{{{0}}}(\chi({1}, \cdot) ) \)".format(weight,xci), # yes, {{{ is required
'head':
r"\(S_{{{0}}}(\chi_{{{1}}}({2}, \cdot)) \)".format(
weight, level, xci), # yes, {{{ is required
# 'head' : "\({0}\)".format(xci),
'chi':
"{0}".format(xci),
# 'url': url_for('characters.render_Dirichletwebpage', modulus=level, number=xci)
'url':
url_for('emf.render_elliptic_modular_forms',
level=level,
weight=k,
character=xci) if indb else ''
} for xci in orbit
]
if len(orbit) > table['maxGalCount']:
table['maxGalCount'] = len(orbit)
table['cells'][xi] = {}
table['cells'][xi][k] = {
'N': level,
'k': k,
'chi': xi,
'url': url,
'dim': d,
'trivial_trivially': trivial_trivially,
}
table['galois_orbits_reps_numbers'] = table['galois_orbits_reps'].keys()
table['galois_orbits_reps_numbers'].sort()
#emf_logger.debug("Table:{0}".format(table))
return table