def __init__(self, modulus=1, number=1, update_from_db=True, compute=False):
r"""
Init self.
"""
emf_logger.critical("In WebChar {0}".format((modulus, number, update_from_db, compute)))
if not gcd(number, modulus) == 1:
raise ValueError, "Character number {0} of modulus {1} does not exist!".format(number, modulus)
if number > modulus:
number = number % modulus
self._properties = WebProperties(
WebInt("conductor"),
WebInt("modulus", value=modulus),
WebInt("number", value=number),
WebInt("modulus_euler_phi"),
WebInt("order"),
WebStr("latex_name"),
WebStr("label", value="{0}.{1}".format(modulus, number)),
WebNoStoreObject("sage_character", type(trivial_character(1))),
WebDict("_values_algebraic"),
WebDict("_values_float"),
WebDict("_embeddings"),
WebFloat("version", value=float(emf_version)),
)
emf_logger.debug("Set properties in WebChar!")
super(WebChar, self).__init__(update_from_db=update_from_db)
if self._has_updated_from_db is False:
self.init_dynamic_properties() # this was not done if we exited early
compute = True
if compute:
self.compute(save=True)
# emf_logger.debug('In WebChar, self.__dict__ = {0}'.format(self.__dict__))
emf_logger.debug("In WebChar, self.number = {0}".format(self.number))
def init_dynamic_properties(self, embeddings=False):
if self.number is not None:
emf_logger.debug('number: {0}'.format(self.number))
self.character = DirichletCharacter_conrey(
DirichletGroup_conrey(self.modulus), self.number)
if not self.number == 1:
self.sage_character = self.character.sage_character()
else:
self.sage_character = trivial_character(self.modulus)
self.name = "Character nr. {0} of modulus {1}".format(
self.number, self.modulus)
if embeddings:
from lmfdb.modular_forms.elliptic_modular_forms.backend.emf_utils import dirichlet_character_conrey_galois_orbit_embeddings
emb = dirichlet_character_conrey_galois_orbit_embeddings(
self.modulus, self.number)
self.set_embeddings(emb)
c = self.character
if self.conductor == 0:
self.conductor = c.conductor()
if self.order == 0:
self.order = c.multiplicative_order()
if self.modulus_euler_phi == 0:
self.modulus_euler_phi = euler_phi(self.modulus)
if self.latex_name == '':
self.latex_name = "\chi_{" + str(self.modulus) + "}(" + str(
self.number) + ", \cdot)"
def dict_to_ambient(modsym):
N,k,i = modsym['space']
eps = modsym['eps']
manin = modsym['manin']
basis = modsym['basis']
rels = modsym['rels']
mod2term = modsym['mod2term']
F = rels.base_ring()
if i == 0:
eps = trivial_character(N)
else:
eps = DirichletGroup(N, F)(eps)
from sage.modular.modsym.manin_symbols import ManinSymbolList, ManinSymbol
manin_symbol_list = ManinSymbolList(k, manin)
def custom_init(M):
# reinitialize the list of Manin symbols with ours, which may be
# ordered differently someday:
syms = M.manin_symbols()
ManinSymbolList.__init__(syms, k, manin_symbol_list)
M._manin_generators = [ManinSymbol(syms, x) for x in manin]
M._manin_basis = basis
M._manin_gens_to_basis = rels
M._mod2term = mod2term
return M
return ModularSymbols(eps, k, sign=1, custom_init=custom_init, use_cache=False)
def to_dirichlet_character(self, character):
if character['order'] == 1:
from sage.all import trivial_character
return trivial_character(character['modulus'])
from sage.all import DirichletGroup, CyclotomicField, QQ
from sage.modular.dirichlet import DirichletCharacter
zeta_order = character['zeta_order']
R = QQ if zeta_order == 2 else CyclotomicField(zeta_order)
G = DirichletGroup(character['modulus'], R, zeta_order=zeta_order)
v = G.an_element().element().parent()(character['element'])
return DirichletCharacter(G, v)
def to_dirichlet_character(self, character):
if character['order'] == 1:
from sage.all import trivial_character
return trivial_character(character['modulus'])
from sage.all import DirichletGroup, CyclotomicField, QQ
from sage.modular.dirichlet import DirichletCharacter
zeta_order = character['zeta_order']
R = QQ if zeta_order == 2 else CyclotomicField(zeta_order)
G = DirichletGroup(character['modulus'], R, zeta_order=zeta_order)
v = G.an_element().element().parent()(character['element'])
return DirichletCharacter(G, v)
def normalize(self, level, weight, character):
"""
Return normalized level, weight, character, and a MongoDB
document representing them. Normalized means the level and
weight are Python ints, and the character is a Sage Dirichlet
character (in particular, it is not None).
"""
from converter import to_db
level = to_db(level)
weight = to_db(weight)
if character is None:
from sage.all import trivial_character
character = trivial_character(level)
e = to_db(character)
return level, weight, character, {'level':level, 'weight':weight, 'character':e}
def __init__(self,
modulus=1,
number=1,
update_from_db=True,
compute_values=False,
init_dynamic_properties=True):
r"""
Init self.
"""
emf_logger.debug("In WebChar {0}".format(
(modulus, number, update_from_db, compute_values)))
if isinstance(modulus, basestring):
try:
m, n = modulus.split('.')
modulus = int(m)
number = int(n)
except:
raise ValueError, "{0} does not correspond to the label of a WebChar".format(
modulus)
if not gcd(number, modulus) == 1:
raise ValueError, "Character number {0} of modulus {1} does not exist!".format(
number, modulus)
if number > modulus:
number = number % modulus
self._properties = WebProperties(
WebInt('conductor'), WebInt('modulus', value=modulus),
WebInt('number', value=number), WebInt('modulus_euler_phi'),
WebInt('order'), WebStr('latex_name'),
WebStr('label', value="{0}.{1}".format(modulus, number)),
WebNoStoreObject('sage_character', type(trivial_character(1))),
WebDict('_values_algebraic'), WebDict('_values_float'),
WebDict('_embeddings'),
WebFloat('version', value=float(emf_version)))
emf_logger.debug('Set properties in WebChar!')
super(WebChar,
self).__init__(update_from_db=update_from_db,
init_dynamic_properties=init_dynamic_properties)
#if not self.has_updated_from_db():
# self.init_dynamic_properties() # this was not done if we exited early
# compute = True
if compute_values:
self.compute_values()
#emf_logger.debug('In WebChar, self.__dict__ = {0}'.format(self.__dict__))
emf_logger.debug('In WebChar, self.number = {0}'.format(self.number))
def normalize(self, level, weight, character):
"""
Return normalized level, weight, character, and a MongoDB
document representing them. Normalized means the level and
weight are Python ints, and the character is a Sage Dirichlet
character (in particular, it is not None).
"""
from converter import to_db
level = to_db(level)
weight = to_db(weight)
if character is None:
from sage.all import trivial_character
character = trivial_character(level)
e = to_db(character)
return level, weight, character, {
'level': level,
'weight': weight,
'character': e
}
def __init__(self, modulus=1, number=1, update_from_db=True, compute_values=False, init_dynamic_properties=True):
r"""
Init self.
"""
emf_logger.debug("In WebChar {0}".format((modulus,number,update_from_db,compute_values)))
if isinstance(modulus,basestring):
try:
m,n=modulus.split('.')
modulus = int(m); number=int(n)
except:
raise ValueError,"{0} does not correspond to the label of a WebChar".format(modulus)
if not gcd(number,modulus)==1:
raise ValueError,"Character number {0} of modulus {1} does not exist!".format(number,modulus)
if number > modulus:
number = number % modulus
self._properties = WebProperties(
WebInt('conductor'),
WebInt('modulus', value=modulus),
WebInt('number', value=number),
WebInt('modulus_euler_phi'),
WebInt('order'),
WebStr('latex_name'),
WebStr('label',value="{0}.{1}".format(modulus,number)),
WebNoStoreObject('sage_character', type(trivial_character(1))),
WebDict('_values_algebraic'),
WebDict('_values_float'),
WebDict('_embeddings'),
WebFloat('version', value=float(emf_version))
)
emf_logger.debug('Set properties in WebChar!')
super(WebChar, self).__init__(
update_from_db=update_from_db,
init_dynamic_properties=init_dynamic_properties
)
#if not self.has_updated_from_db():
# self.init_dynamic_properties() # this was not done if we exited early
# compute = True
if compute_values:
self.compute_values()
#emf_logger.debug('In WebChar, self.__dict__ = {0}'.format(self.__dict__))
emf_logger.debug('In WebChar, self.number = {0}'.format(self.number))
def dict_to_ambient_sage(modsym,convention='Conrey'):
r"""
Convert a dictionary to a Sage object of type ModularSymbols_ambient
INPUT:
- modsym -- dictionary
- convention -- String. 'Conrey' or 'Sage' depending on the numbering convention used for Dirichlet characters in the dict.
"""
N,k,i = modsym['space']
manin = modsym['manin']
basis = modsym['basis']
rels = modsym['rels']
mod2term = modsym['mod2term']
F = rels.base_ring()
if i == 0:
eps = trivial_character(N)
else:
if F<>QQ or convention=='Sage':
print "i=",i
eps = DirichletGroup(N, F)(i)
else:
eps = DirichletGroup_conrey(N)[i].sage_character()
from sage.modular.modsym.manin_symbols import ManinSymbolList, ManinSymbol
manin_symbol_list = ManinSymbolList(k, manin)
def custom_init(M):
# reinitialize the list of Manin symbols with ours, which may be
# ordered differently someday:
syms = M.manin_symbols()
ManinSymbolList.__init__(syms, k, manin_symbol_list)
M._manin_generators = [ManinSymbol(syms, x) for x in manin]
M._manin_basis = basis
M._manin_gens_to_basis = rels
M._mod2term = mod2term
return M
return ModularSymbols(eps, k, sign=1, custom_init=custom_init, use_cache=False)
def init_dynamic_properties(self, embeddings=False):
if self.number is not None:
emf_logger.debug('number: {0}'.format(self.number))
self.character = DirichletCharacter_conrey(DirichletGroup_conrey(self.modulus),self.number)
if not self.number == 1:
self.sage_character = self.character.sage_character()
else:
self.sage_character = trivial_character(self.modulus)
self.name = "Character nr. {0} of modulus {1}".format(self.number,self.modulus)
if embeddings:
from lmfdb.modular_forms.elliptic_modular_forms.backend.emf_utils import dirichlet_character_conrey_galois_orbit_embeddings
emb = dirichlet_character_conrey_galois_orbit_embeddings(self.modulus,self.number)
self.set_embeddings(emb)
c = self.character
if self.conductor == 0:
self.conductor = c.conductor()
if self.order == 0:
self.order = c.multiplicative_order()
if self.modulus_euler_phi == 0:
self.modulus_euler_phi = euler_phi(self.modulus)
if self.latex_name == '':
self.latex_name = "\chi_{" + str(self.modulus) + "}(" + str(self.number) + ", \cdot)"
def __init__(self,
modulus=1,
number=1,
update_from_db=True,
compute=False):
r"""
Init self.
"""
emf_logger.critical("In WebChar {0}".format(
(modulus, number, update_from_db, compute)))
if not gcd(number, modulus) == 1:
raise ValueError, "Character number {0} of modulus {1} does not exist!".format(
number, modulus)
if number > modulus:
number = number % modulus
self._properties = WebProperties(
WebInt('conductor'), WebInt('modulus', value=modulus),
WebInt('number', value=number), WebInt('modulus_euler_phi'),
WebInt('order'), WebStr('latex_name'),
WebStr('label', value="{0}.{1}".format(modulus, number)),
WebNoStoreObject('sage_character', type(trivial_character(1))),
WebDict('_values_algebraic'), WebDict('_values_float'),
WebDict('_embeddings'),
WebFloat('version', value=float(emf_version)))
emf_logger.debug('Set properties in WebChar!')
super(WebChar, self).__init__(update_from_db=update_from_db)
if self._has_updated_from_db is False:
self.init_dynamic_properties(
) # this was not done if we exited early
compute = True
if compute:
self.compute(save=True)
#emf_logger.debug('In WebChar, self.__dict__ = {0}'.format(self.__dict__))
emf_logger.debug('In WebChar, self.number = {0}'.format(self.number))
def __init__(self,group,dchar=(0,0),dual=False,is_trivial=False,dimension=1,**kwargs):
r"""
if dual is set to true we use the complex conjugate of the representation (we assume the representation is unitary)
The pair dchar = (conductor,char_nr) gives the character.
If char_nr = -1 = > kronecker_character
If char_nr = -2 = > kronecker_character_upside_down
"""
#print "kwargs0=",kwargs
self._group = group
self._dim = dimension
self._ambient_rank=kwargs.get('ambient_rank',None)
self._kwargs = kwargs
self._verbose = kwargs.get("verbose",0)
if self._verbose>0:
print "Init multiplier system!"
(conductor,char_nr)=dchar
self._conductor=conductor
self._char_nr=char_nr
self._character = None
self._level = group.generalised_level()
if kwargs.has_key('character'):
if str(type(kwargs['character'])).find('DirichletCharacter')>=0:
self._character = kwargs['character']
self._conductor=self._character.conductor()
self._char_nr=list((self._character).parent()).index(self._character)
elif group.is_congruence():
if conductor<=0:
self._conductor=group.level(); self._char_nr=0
if char_nr>=0:
self._char_nr=char_nr
if self._char_nr==0:
self._character = trivial_character(self._conductor)
elif self._char_nr==-1:
if self._conductor % 4 == 3:
self._character = kronecker_character(-self._conductor)
elif self._conductor % 4 == 1:
self._character = kronecker_character(self._conductor)
assert self._character.conductor()==self._conductor
elif self._char_nr<=-2:
self._character = kronecker_character_upside_down(self._conductor)
else:
D = list(DirichletGroup(self._conductor))
if self._char_nr <0 or self._char_nr>len(D):
self._char_nr=0
self._character = D[self._char_nr]
else:
self._conductor = 1
self._character = trivial_character(1)
#if not hasattr(self._character,'is_trivial'):
# if isinstance(self._character,(int,Integer)) and group.is_congruence():
# j = self._character
# self._character = DirichletGroup(group.level())[j]
## Extract the class name for the reduce algorithm
self._class_name=str(type(self))[1:-2].split(".")[-1]
if not isinstance(dimension,(int,Integer)):
raise ValueError,"Dimension must be integer!"
self._is_dual = dual
self._is_trivial=is_trivial and self._character.is_trivial()
if is_trivial and self._character.order()<=2:
self._is_real=True
else:
self._is_real=False
self._character_values = [] ## Store for easy access
def __init__(self,
group,
dchar=(1, 1),
dual=False,
is_trivial=False,
dimension=1,
**kwargs):
r"""
if dual is set to true we use the complex conjugate of the representation (we assume the representation is unitary)
The pair dchar = (conductor,number) gives the character in conrey numbering
If char_nr = -1 = > kronecker_character
If char_nr = -2 = > kronecker_character_upside_down
"""
self._group = group
if not hasattr(self, '_weight'):
self._weight = None
self._dim = dimension
self._ambient_rank = kwargs.get('ambient_rank', None)
self._kwargs = kwargs
self._verbose = kwargs.get("verbose", 0)
if self._verbose > 0:
print("Init multiplier system!")
(conductor, char_nr) = dchar
self._conductor = conductor
self._char_nr = char_nr
self._character = None
self._level = group.generalised_level()
if 'character' in kwargs:
if str(type(kwargs['character'])).find('Dirichlet') >= 0:
self._character = kwargs['character']
self._conductor = self._character.conductor()
try:
self._char_nr = self._character.number()
except:
for x in DirichletGroup_conrey(self._conductor):
if x.sage_character() == self._character:
self._char_nr = x.number()
elif group.is_congruence():
if conductor <= 0:
self._conductor = group.level()
self._char_nr = 1
if char_nr >= 0:
self._char_nr = char_nr
if self._char_nr == 0 or self._char_nr == 1:
self._character = trivial_character(self._conductor)
elif self._char_nr == -1:
if self._conductor % 4 == 3:
self._character = kronecker_character(-self._conductor)
elif self._conductor % 4 == 1:
self._character = kronecker_character(self._conductor)
assert self._character.conductor() == self._conductor
elif self._char_nr <= -2:
self._character = kronecker_character_upside_down(
self._conductor)
else:
self._character = DirichletCharacter_conrey(
DirichletGroup_conrey(self._conductor),
self._char_nr).sage_character()
else:
self._conductor = 1
self._character = trivial_character(1)
#if not hasattr(self._character,'is_trivial'):
# if isinstance(self._character,(int,Integer)) and group.is_congruence():
# j = self._character
# self._character = DirichletGroup(group.level())[j]
## Extract the class name for the reduce algorithm
self._class_name = str(type(self))[1:-2].split(".")[-1]
if not isinstance(dimension, (int, Integer)):
raise ValueError("Dimension must be integer!")
self._is_dual = dual
self._is_trivial = is_trivial and self._character.is_trivial()
if is_trivial and self._character.order() <= 2:
self._is_real = True
else:
self._is_real = False
self._character_values = [] ## Store for easy access
def character(N, i):
if i==0:
return trivial_character(N)
print "character(%s, %s)"%(N,i)
return characters(N)[i]