def dimension_new_cusp_forms(X, k=2, p=0):
"""
Return the dimension of the new (or `p`-new) subspace of
cusp forms for the character or group `X`.
INPUT:
- ``X`` -- integer, congruence subgroup or Dirichlet
character
- ``k`` -- weight (integer)
- ``p`` -- 0 or a prime
EXAMPLES::
sage: from sage.modular.dims import dimension_new_cusp_forms
sage: dimension_new_cusp_forms(100,2)
1
sage: dimension_new_cusp_forms(Gamma0(100),2)
1
sage: dimension_new_cusp_forms(Gamma0(100),4)
5
sage: dimension_new_cusp_forms(Gamma1(100),2)
141
sage: dimension_new_cusp_forms(Gamma1(100),4)
463
sage: dimension_new_cusp_forms(DirichletGroup(100).1^2,2)
2
sage: dimension_new_cusp_forms(DirichletGroup(100).1^2,4)
8
sage: sum(dimension_new_cusp_forms(e,3) for e in DirichletGroup(30))
12
sage: dimension_new_cusp_forms(Gamma1(30),3)
12
Check that :trac:`12640` is fixed::
sage: dimension_new_cusp_forms(DirichletGroup(1)(1), 12)
1
sage: dimension_new_cusp_forms(DirichletGroup(2)(1), 24)
1
"""
if is_GammaH(X):
return X.dimension_new_cusp_forms(k, p=p)
elif isinstance(X, dirichlet.DirichletCharacter):
N = X.modulus()
if N <= 2:
return Gamma0(N).dimension_new_cusp_forms(k, p=p)
else:
# Gamma1(N) for N<=2 just returns Gamma0(N), which has no
# eps parameter. See trac #12640.
return Gamma1(N).dimension_new_cusp_forms(k, eps=X, p=p)
elif isinstance(X, (int, Integer)):
return Gamma0(X).dimension_new_cusp_forms(k, p=p)
raise TypeError(f"X (={X}) must be an integer, a Dirichlet character or a congruence subgroup of type Gamma0, Gamma1 or GammaH")
def __init__(self, index=20, index_max=50, odd_probability=0.5):
r"""
Create an arithmetic subgroup testing object.
INPUT:
- ``index`` - the index of random subgroup to test
- ``index_max`` - the maximum index for congruence subgroup to test
EXAMPLES::
sage: from sage.modular.arithgroup.tests import Test
sage: Test()
Arithmetic subgroup testing class
"""
self.congroups = []
i = 1
self.odd_probability = odd_probability
if index % 4:
self.odd_probability = 0
while Gamma(i).index() < index_max:
self.congroups.append(Gamma(i))
i += 1
i = 1
while Gamma0(i).index() < index_max:
self.congroups.append(Gamma0(i))
i += 1
i = 2
while Gamma1(i).index() < index_max:
self.congroups.append(Gamma1(i))
M = Zmod(i)
U = [x for x in M if x.is_unit()]
for j in range(1, len(U) - 1):
self.congroups.append(GammaH(i, prandom.sample(U, j)))
i += 1
self.index = index
def _p_stabilize_parent_space(self, p, new_base_ring):
r"""
Return the space of Pollack-Stevens modular symbols of level
`p N`, with changed base ring. This is used internally when
constructing the `p`-stabilization of a modular symbol.
INPUT:
- ``p`` -- prime number
- ``new_base_ring`` -- the base ring of the result
OUTPUT:
The space of modular symbols of level `p N`, where `N` is the level
of this space.
EXAMPLES::
sage: D = OverconvergentDistributions(2, 7)
sage: M = PollackStevensModularSymbols(Gamma(13), coefficients=D)
sage: M._p_stabilize_parent_space(7, M.base_ring())
Space of overconvergent modular symbols for Congruence Subgroup
Gamma(91) with sign 0 and values in Space of 7-adic distributions
with k=2 action and precision cap 20
sage: D = OverconvergentDistributions(4, 17)
sage: M = PollackStevensModularSymbols(Gamma1(3), coefficients=D)
sage: M._p_stabilize_parent_space(17, Qp(17))
Space of overconvergent modular symbols for Congruence
Subgroup Gamma1(51) with sign 0 and values in Space of
17-adic distributions with k=4 action and precision cap 20
"""
N = self.level()
if N % p == 0:
raise ValueError("the level is not prime to p")
from sage.modular.arithgroup.all import (Gamma, is_Gamma, Gamma0,
is_Gamma0, Gamma1, is_Gamma1)
G = self.group()
if is_Gamma0(G):
G = Gamma0(N * p)
elif is_Gamma1(G):
G = Gamma1(N * p)
elif is_Gamma(G):
G = Gamma(N * p)
else:
raise NotImplementedError
return PollackStevensModularSymbols(
G,
coefficients=self.coefficient_module().change_ring(new_base_ring),
sign=self.sign())
def dimension_modular_forms(X, k=2):
r"""
The dimension of the space of cusp forms for the given congruence
subgroup (either `\Gamma_0(N)`, `\Gamma_1(N)`, or
`\Gamma_H(N)`) or Dirichlet character.
INPUT:
- ``X`` - congruence subgroup or Dirichlet character
- ``k`` - weight (integer)
EXAMPLES::
sage: dimension_modular_forms(Gamma0(11),2)
2
sage: dimension_modular_forms(Gamma0(11),0)
1
sage: dimension_modular_forms(Gamma1(13),2)
13
sage: dimension_modular_forms(GammaH(11, [10]), 2)
10
sage: dimension_modular_forms(GammaH(11, [10]))
10
sage: dimension_modular_forms(GammaH(11, [10]), 4)
20
sage: e = DirichletGroup(20).1
sage: dimension_modular_forms(e,3)
9
sage: dimension_cusp_forms(e,3)
3
sage: dimension_eis(e,3)
6
sage: dimension_modular_forms(11,2)
2
"""
if isinstance(X, integer_types + (Integer, )):
return Gamma0(X).dimension_modular_forms(k)
elif is_ArithmeticSubgroup(X):
return X.dimension_modular_forms(k)
elif isinstance(X, dirichlet.DirichletCharacter):
return Gamma1(X.modulus()).dimension_modular_forms(k, eps=X)
else:
raise TypeError(
"Argument 1 must be an integer, a Dirichlet character or an arithmetic subgroup."
)
def J1(N):
"""
Return the Jacobian `J_1(N)` of the modular curve
`X_1(N)`.
EXAMPLES::
sage: J1(389)
Abelian variety J1(389) of dimension 6112
"""
key = 'J1(%s)' % N
try:
return _get(key)
except ValueError:
from sage.modular.arithgroup.all import Gamma1
return _saved(key, Gamma1(N).modular_abelian_variety())
def _raise(self, p, level, weight):
"""
Helper function for :meth:`raise_level` and :meth:`raise_weight`.
"""
from eigenform_collection import EigenformCollection
F = self.base_ring()
R = PolynomialRing(F, 't')
t = R.gen()
chi = self.character()
poly = t**2 - self.coefficient(p) * t + chi(p) * p**(self.weight() - 1)
roots = poly.roots(multiplicities=False)
apdict = copy(self._apdict)
C = EigenformCollection(Gamma1(level), weight, F, chi.extend(level))
for a in roots:
apdict[p] = a
yield C(apdict)
def dimension_eis(X, k=2):
"""
The dimension of the space of Eisenstein series for the given
congruence subgroup.
INPUT:
- ``X`` - congruence subgroup or Dirichlet character
or integer
- ``k`` - weight (integer)
EXAMPLES::
sage: dimension_eis(5,4)
2
::
sage: dimension_eis(Gamma0(11),2)
1
sage: dimension_eis(Gamma1(13),2)
11
sage: dimension_eis(Gamma1(2006),2)
3711
::
sage: e = DirichletGroup(13).0
sage: e.order()
12
sage: dimension_eis(e,2)
0
sage: dimension_eis(e^2,2)
2
::
sage: e = DirichletGroup(13).0
sage: e.order()
12
sage: dimension_eis(e,2)
0
sage: dimension_eis(e^2,2)
2
sage: dimension_eis(e,13)
2
::
sage: G = DirichletGroup(20)
sage: dimension_eis(G.0,3)
4
sage: dimension_eis(G.1,3)
6
sage: dimension_eis(G.1^2,2)
6
::
sage: G = DirichletGroup(200)
sage: e = prod(G.gens(), G(1))
sage: e.conductor()
200
sage: dimension_eis(e,2)
4
::
sage: dimension_modular_forms(Gamma1(4), 11)
6
"""
if is_ArithmeticSubgroup(X):
return X.dimension_eis(k)
elif isinstance(X, dirichlet.DirichletCharacter):
return Gamma1(X.modulus()).dimension_eis(k, X)
elif isinstance(X, (int, long, Integer)):
return Gamma0(X).dimension_eis(k)
else:
raise TypeError, "Argument in dimension_eis must be an integer, a Dirichlet character, or a finite index subgroup of SL2Z (got %s)" % X
def dimension_cusp_forms(X, k=2):
r"""
The dimension of the space of cusp forms for the given congruence
subgroup or Dirichlet character.
INPUT:
- ``X`` - congruence subgroup or Dirichlet character
or integer
- ``k`` - weight (integer)
EXAMPLES::
sage: dimension_cusp_forms(5,4)
1
::
sage: dimension_cusp_forms(Gamma0(11),2)
1
sage: dimension_cusp_forms(Gamma1(13),2)
2
::
sage: dimension_cusp_forms(DirichletGroup(13).0^2,2)
1
sage: dimension_cusp_forms(DirichletGroup(13).0,3)
1
::
sage: dimension_cusp_forms(Gamma0(11),2)
1
sage: dimension_cusp_forms(Gamma0(11),0)
0
sage: dimension_cusp_forms(Gamma0(1),12)
1
sage: dimension_cusp_forms(Gamma0(1),2)
0
sage: dimension_cusp_forms(Gamma0(1),4)
0
::
sage: dimension_cusp_forms(Gamma0(389),2)
32
sage: dimension_cusp_forms(Gamma0(389),4)
97
sage: dimension_cusp_forms(Gamma0(2005),2)
199
sage: dimension_cusp_forms(Gamma0(11),1)
0
::
sage: dimension_cusp_forms(Gamma1(11),2)
1
sage: dimension_cusp_forms(Gamma1(1),12)
1
sage: dimension_cusp_forms(Gamma1(1),2)
0
sage: dimension_cusp_forms(Gamma1(1),4)
0
::
sage: dimension_cusp_forms(Gamma1(389),2)
6112
sage: dimension_cusp_forms(Gamma1(389),4)
18721
sage: dimension_cusp_forms(Gamma1(2005),2)
159201
::
sage: dimension_cusp_forms(Gamma1(11),1)
0
::
sage: e = DirichletGroup(13).0
sage: e.order()
12
sage: dimension_cusp_forms(e,2)
0
sage: dimension_cusp_forms(e^2,2)
1
Check that Trac #12640 is fixed::
sage: dimension_cusp_forms(DirichletGroup(1)(1), 12)
1
sage: dimension_cusp_forms(DirichletGroup(2)(1), 24)
5
"""
if isinstance(X, dirichlet.DirichletCharacter):
N = X.modulus()
if N <= 2:
return Gamma0(N).dimension_cusp_forms(k)
else:
return Gamma1(N).dimension_cusp_forms(k, X)
elif is_ArithmeticSubgroup(X):
return X.dimension_cusp_forms(k)
elif isinstance(X, (Integer, int, long)):
return Gamma0(X).dimension_cusp_forms(k)
else:
raise TypeError, "Argument 1 must be a Dirichlet character, an integer or a finite index subgroup of SL2Z"