def parse_label(s):
"""
Given a string s corresponding to a newform label, return the
corresponding group and index.
EXAMPLES::
sage: sage.modular.modform.constructor.parse_label('11a')
(Congruence Subgroup Gamma0(11), 0)
sage: sage.modular.modform.constructor.parse_label('11aG1')
(Congruence Subgroup Gamma1(11), 0)
sage: sage.modular.modform.constructor.parse_label('11wG1')
(Congruence Subgroup Gamma1(11), 22)
"""
m = re.match(r'(\d+)([a-z]+)((?:G.*)?)$', s)
if not m:
raise ValueError, "Invalid label: %s" % s
N, order, G = m.groups()
N = int(N)
index = 0
for c in reversed(order):
index = 26*index + ord(c)-ord('a')
if G == '' or G == 'G0':
G = arithgroup.Gamma0(N)
elif G == 'G1':
G = arithgroup.Gamma1(N)
elif G[:2] == 'GH':
if G[2] != '[' or G[-1] != ']':
raise ValueError, "Invalid congruence subgroup label: %s" % G
gens = [int(g.strip()) for g in G[3:-1].split(',')]
return arithgroup.GammaH(N, gens)
else:
raise ValueError, "Invalid congruence subgroup label: %s" % G
return G, index
def __init__(self, level, weight, sign, F):
"""
Initialize a space of boundary modular symbols for Gamma1(N).
INPUT:
- ``level`` - int, the level
- ``weight`` - int, the weight = 2
- ``sign`` - int, either -1, 0, or 1
- ``F`` - base ring
EXAMPLES::
sage: from sage.modular.modsym.boundary import BoundarySpace_wtk_g1
sage: B = BoundarySpace_wtk_g1(17, 2, 0, QQ) ; B
Boundary Modular Symbols space for Gamma_1(17) of weight 2 over Rational Field
sage: B == loads(dumps(B))
True
"""
level = int(level)
sign = int(sign)
if sign not in [-1, 0, 1]:
raise ArithmeticError("sign must be an int in [-1,0,1]")
if level <= 0:
raise ArithmeticError("level must be positive")
BoundarySpace.__init__(self,
weight=weight,
group=arithgroup.Gamma1(level),
sign=sign,
base_ring=F)
def __init__(self, character, weight=2, base_ring=None, eis_only=False):
"""
Create an ambient modular forms space with character.
.. note::
The base ring must be of characteristic 0. The ambient_R
Python module is used for computing in characteristic p,
which we view as the reduction of characteristic 0.
INPUT:
- ``weight`` - int
- ``character`` - dirichlet.DirichletCharacter
- ``base_ring`` - base field
EXAMPLES::
sage: m = ModularForms(DirichletGroup(11).0,3); m
Modular Forms space of dimension 3, character [zeta10] and weight 3 over Cyclotomic Field of order 10 and degree 4
sage: type(m)
<class 'sage.modular.modform.ambient_eps.ModularFormsAmbient_eps_with_category'>
"""
if not dirichlet.is_DirichletCharacter(character):
raise TypeError("character (=%s) must be a Dirichlet character"%character)
if base_ring is None: base_ring=character.base_ring()
if character.base_ring() != base_ring:
character = character.change_ring(base_ring)
if base_ring.characteristic() != 0:
raise ValueError("the base ring must have characteristic 0.")
group = arithgroup.Gamma1(character.modulus())
base_ring = character.base_ring()
ModularFormsAmbient.__init__(self, group, weight, base_ring, character, eis_only)
def __init__(self, level, weight):
r"""
Create a space of modular forms for `\Gamma_1(N)` of integral weight over the
rational numbers.
EXAMPLES::
sage: m = ModularForms(Gamma1(100),5); m
Modular Forms space of dimension 1270 for Congruence Subgroup Gamma1(100) of weight 5 over Rational Field
sage: type(m)
<class 'sage.modular.modform.ambient_g1.ModularFormsAmbient_g1_Q_with_category'>
"""
ambient.ModularFormsAmbient.__init__(self, arithgroup.Gamma1(level), weight, rings.QQ)
def _modular_symbols_space_gamma1(self):
"""
Return a space of modular symbols for Gamma1, with level a
random choice from self.levels, weight from self.weights, and
sign chosen randomly from [1, 0, -1].
EXAMPLES:
sage: sage.modular.modsym.tests.Test()._modular_symbols_space_gamma1() # random
level = 3, weight = 4, sign = 0
Modular Symbols space of dimension 2 for Gamma_1(3) of weight 4 with sign 0 and over Rational Field
"""
level, weight, sign = self._level_weight_sign()
M = modsym.ModularSymbols(arithgroup.Gamma1(level), weight, sign)
self.current_space = M
return M
def __init__(self, eps, weight, sign=0):
"""
Space of boundary modular symbols with given weight, character, and
sign.
INPUT:
- ``eps`` - dirichlet.DirichletCharacter, the
"Nebentypus" character.
- ``weight`` - int, the weight = 2
- ``sign`` - int, either -1, 0, or 1
EXAMPLES::
sage: B = ModularSymbols(DirichletGroup(6).0, 4).boundary_space() ; B
Boundary Modular Symbols space of level 6, weight 4, character [-1] and dimension 0 over Rational Field
sage: type(B)
<class 'sage.modular.modsym.boundary.BoundarySpace_wtk_eps_with_category'>
sage: B == loads(dumps(B))
True
"""
level = eps.modulus()
sign = int(sign)
self.__eps = eps
if not sign in [-1,0,1]:
raise ArithmeticError("sign must be an int in [-1,0,1]")
if level <= 0:
raise ArithmeticError("level must be positive")
BoundarySpace.__init__(self,
weight = weight,
group = arithgroup.Gamma1(level),
sign = sign,
base_ring = eps.base_ring(),
character = eps)
