def dimension_eis(self, k=2, eps=None, algorithm="CohenOesterle"):
r"""
Return the dimension of the space of Eisenstein series forms for self,
or the dimension of the subspace corresponding to the given character
if one is supplied.
INPUT:
- ``k`` - an integer (default: 2), the weight.
- ``eps`` - either None or a Dirichlet character modulo N, where N is
the level of this group. If this is None, then the dimension of the
whole space is returned; otherwise, the dimension of the subspace of
Eisenstein series of character eps.
- ``algorithm`` -- either "CohenOesterle" (the default) or "Quer". This
specifies the method to use in the case of nontrivial character:
either the Cohen--Oesterle formula as described in Stein's book, or
by Moebius inversion using the subgroups GammaH (a method due to
Jordi Quer).
AUTHORS:
- William Stein - Cohen--Oesterle algorithm
- Jordi Quer - algorithm based on GammaH subgroups
- David Loeffler (2009) - code refactoring
EXAMPLES:
The following two computations use different algorithms: ::
sage: [Gamma1(36).dimension_eis(1,eps) for eps in DirichletGroup(36)]
[0, 4, 3, 0, 0, 2, 6, 0, 0, 2, 3, 0]
sage: [Gamma1(36).dimension_eis(1,eps,algorithm="Quer") for eps in DirichletGroup(36)]
[0, 4, 3, 0, 0, 2, 6, 0, 0, 2, 3, 0]
So do these: ::
sage: [Gamma1(48).dimension_eis(3,eps) for eps in DirichletGroup(48)]
[0, 12, 0, 4, 0, 8, 0, 4, 12, 0, 4, 0, 8, 0, 4, 0]
sage: [Gamma1(48).dimension_eis(3,eps,algorithm="Quer") for eps in DirichletGroup(48)]
[0, 12, 0, 4, 0, 8, 0, 4, 12, 0, 4, 0, 8, 0, 4, 0]
"""
from all import Gamma0
# first deal with special cases
if eps is None:
return GammaH_class.dimension_eis(self, k)
N = self.level()
eps = DirichletGroup(N)(eps)
if eps.is_trivial():
return Gamma0(N).dimension_eis(k)
# Note case of k = 0 and trivial character already dealt with separately, so k <= 0 here is valid:
if (k <= 0) or ((k % 2) == 1 and eps.is_even()) or ((k%2) == 0 and eps.is_odd()):
return ZZ(0)
if algorithm == "Quer":
n = eps.order()
dim = ZZ(0)
for d in n.divisors():
G = GammaH_constructor(N,(eps**d).kernel())
dim = dim + moebius(d)*G.dimension_eis(k)
return dim//phi(n)
elif algorithm == "CohenOesterle":
from sage.modular.dims import CohenOesterle
K = eps.base_ring()
j = 2-k
# We use the Cohen-Oesterle formula in a subtle way to
# compute dim M_k(N,eps) (see Ch. 6 of William Stein's book on
# computing with modular forms).
alpha = -ZZ( K(Gamma0(N).index()*(j-1)/ZZ(12)) + CohenOesterle(eps,j) )
if k == 1:
return alpha
else:
return alpha - self.dimension_cusp_forms(k, eps)
else: #algorithm not in ["CohenOesterle", "Quer"]:
raise ValueError, "Unrecognised algorithm in dimension_eis"
def dimension_eis(self, k=2, eps=None, algorithm="CohenOesterle"):
r"""
Return the dimension of the space of Eisenstein series forms for self,
or the dimension of the subspace corresponding to the given character
if one is supplied.
INPUT:
- ``k`` - an integer (default: 2), the weight.
- ``eps`` - either None or a Dirichlet character modulo N, where N is
the level of this group. If this is None, then the dimension of the
whole space is returned; otherwise, the dimension of the subspace of
Eisenstein series of character eps.
- ``algorithm`` -- either "CohenOesterle" (the default) or "Quer". This
specifies the method to use in the case of nontrivial character:
either the Cohen--Oesterle formula as described in Stein's book, or
by Moebius inversion using the subgroups GammaH (a method due to
Jordi Quer).
AUTHORS:
- William Stein - Cohen--Oesterle algorithm
- Jordi Quer - algorithm based on GammaH subgroups
- David Loeffler (2009) - code refactoring
EXAMPLES:
The following two computations use different algorithms: ::
sage: [Gamma1(36).dimension_eis(1,eps) for eps in DirichletGroup(36)]
[0, 4, 3, 0, 0, 2, 6, 0, 0, 2, 3, 0]
sage: [Gamma1(36).dimension_eis(1,eps,algorithm="Quer") for eps in DirichletGroup(36)]
[0, 4, 3, 0, 0, 2, 6, 0, 0, 2, 3, 0]
So do these: ::
sage: [Gamma1(48).dimension_eis(3,eps) for eps in DirichletGroup(48)]
[0, 12, 0, 4, 0, 8, 0, 4, 12, 0, 4, 0, 8, 0, 4, 0]
sage: [Gamma1(48).dimension_eis(3,eps,algorithm="Quer") for eps in DirichletGroup(48)]
[0, 12, 0, 4, 0, 8, 0, 4, 12, 0, 4, 0, 8, 0, 4, 0]
"""
from all import Gamma0
# first deal with special cases
if eps is None:
return GammaH_class.dimension_eis(self, k)
N = self.level()
eps = DirichletGroup(N)(eps)
if eps.is_trivial():
return Gamma0(N).dimension_eis(k)
# Note case of k = 0 and trivial character already dealt with separately, so k <= 0 here is valid:
if (k <= 0) or ((k % 2) == 1 and eps.is_even()) or ((k % 2) == 0
and eps.is_odd()):
return ZZ(0)
if algorithm == "Quer":
n = eps.order()
dim = ZZ(0)
for d in n.divisors():
G = GammaH_constructor(N, (eps**d).kernel())
dim = dim + moebius(d) * G.dimension_eis(k)
return dim // phi(n)
elif algorithm == "CohenOesterle":
from sage.modular.dims import CohenOesterle
K = eps.base_ring()
j = 2 - k
# We use the Cohen-Oesterle formula in a subtle way to
# compute dim M_k(N,eps) (see Ch. 6 of William Stein's book on
# computing with modular forms).
alpha = -ZZ(
K(Gamma0(N).index() *
(j - 1) / ZZ(12)) + CohenOesterle(eps, j))
if k == 1:
return alpha
else:
return alpha - self.dimension_cusp_forms(k, eps)
else: #algorithm not in ["CohenOesterle", "Quer"]:
raise ValueError, "Unrecognised algorithm in dimension_eis"
def dimension_cusp_forms(self, k=2, eps=None, algorithm="CohenOesterle"):
r"""
Return the dimension of the space of cusp forms for self, or the
dimension of the subspace corresponding to the given character if one
is supplied.
INPUT:
- ``k`` - an integer (default: 2), the weight.
- ``eps`` - either None or a Dirichlet character modulo N, where N is
the level of this group. If this is None, then the dimension of the
whole space is returned; otherwise, the dimension of the subspace of
forms of character eps.
- ``algorithm`` -- either "CohenOesterle" (the default) or "Quer". This
specifies the method to use in the case of nontrivial character:
either the Cohen--Oesterle formula as described in Stein's book, or
by Moebius inversion using the subgroups GammaH (a method due to
Jordi Quer).
EXAMPLES:
We compute the same dimension in two different ways ::
sage: K = CyclotomicField(3)
sage: eps = DirichletGroup(7*43,K).0^2
sage: G = Gamma1(7*43)
Via Cohen--Oesterle: ::
sage: Gamma1(7*43).dimension_cusp_forms(2, eps)
28
Via Quer's method: ::
sage: Gamma1(7*43).dimension_cusp_forms(2, eps, algorithm="Quer")
28
Some more examples: ::
sage: G.<eps> = DirichletGroup(9)
sage: [Gamma1(9).dimension_cusp_forms(k, eps) for k in [1..10]]
[0, 0, 1, 0, 3, 0, 5, 0, 7, 0]
sage: [Gamma1(9).dimension_cusp_forms(k, eps^2) for k in [1..10]]
[0, 0, 0, 2, 0, 4, 0, 6, 0, 8]
"""
from all import Gamma0
# first deal with special cases
if eps is None:
return GammaH_class.dimension_cusp_forms(self, k)
N = self.level()
if eps.base_ring().characteristic() != 0:
raise ValueError
eps = DirichletGroup(N, eps.base_ring())(eps)
if eps.is_trivial():
return Gamma0(N).dimension_cusp_forms(k)
if (k <= 0) or ((k % 2) == 1 and eps.is_even()) or ((k%2) == 0 and eps.is_odd()):
return ZZ(0)
if k == 1:
try:
n = self.dimension_cusp_forms(1)
if n == 0:
return ZZ(0)
else: # never happens at present
raise NotImplementedError, "Computations of dimensions of spaces of weight 1 cusp forms not implemented at present"
except NotImplementedError:
raise
# now the main part
if algorithm == "Quer":
n = eps.order()
dim = ZZ(0)
for d in n.divisors():
G = GammaH_constructor(N,(eps**d).kernel())
dim = dim + moebius(d)*G.dimension_cusp_forms(k)
return dim//phi(n)
elif algorithm == "CohenOesterle":
K = eps.base_ring()
from sage.modular.dims import CohenOesterle
from all import Gamma0
return ZZ( K(Gamma0(N).index() * (k-1)/ZZ(12)) + CohenOesterle(eps,k) )
else: #algorithm not in ["CohenOesterle", "Quer"]:
raise ValueError, "Unrecognised algorithm in dimension_cusp_forms"
def dimension_cusp_forms(self, k=2, eps=None, algorithm="CohenOesterle"):
r"""
Return the dimension of the space of cusp forms for self, or the
dimension of the subspace corresponding to the given character if one
is supplied.
INPUT:
- ``k`` - an integer (default: 2), the weight.
- ``eps`` - either None or a Dirichlet character modulo N, where N is
the level of this group. If this is None, then the dimension of the
whole space is returned; otherwise, the dimension of the subspace of
forms of character eps.
- ``algorithm`` -- either "CohenOesterle" (the default) or "Quer". This
specifies the method to use in the case of nontrivial character:
either the Cohen--Oesterle formula as described in Stein's book, or
by Moebius inversion using the subgroups GammaH (a method due to
Jordi Quer).
EXAMPLES:
We compute the same dimension in two different ways ::
sage: K = CyclotomicField(3)
sage: eps = DirichletGroup(7*43,K).0^2
sage: G = Gamma1(7*43)
Via Cohen--Oesterle: ::
sage: Gamma1(7*43).dimension_cusp_forms(2, eps)
28
Via Quer's method: ::
sage: Gamma1(7*43).dimension_cusp_forms(2, eps, algorithm="Quer")
28
Some more examples: ::
sage: G.<eps> = DirichletGroup(9)
sage: [Gamma1(9).dimension_cusp_forms(k, eps) for k in [1..10]]
[0, 0, 1, 0, 3, 0, 5, 0, 7, 0]
sage: [Gamma1(9).dimension_cusp_forms(k, eps^2) for k in [1..10]]
[0, 0, 0, 2, 0, 4, 0, 6, 0, 8]
"""
from all import Gamma0
# first deal with special cases
if eps is None:
return GammaH_class.dimension_cusp_forms(self, k)
N = self.level()
if eps.base_ring().characteristic() != 0:
raise ValueError
eps = DirichletGroup(N, eps.base_ring())(eps)
if eps.is_trivial():
return Gamma0(N).dimension_cusp_forms(k)
if (k <= 0) or ((k % 2) == 1 and eps.is_even()) or ((k % 2) == 0
and eps.is_odd()):
return ZZ(0)
if k == 1:
try:
n = self.dimension_cusp_forms(1)
if n == 0:
return ZZ(0)
else: # never happens at present
raise NotImplementedError, "Computations of dimensions of spaces of weight 1 cusp forms not implemented at present"
except NotImplementedError:
raise
# now the main part
if algorithm == "Quer":
n = eps.order()
dim = ZZ(0)
for d in n.divisors():
G = GammaH_constructor(N, (eps**d).kernel())
dim = dim + moebius(d) * G.dimension_cusp_forms(k)
return dim // phi(n)
elif algorithm == "CohenOesterle":
K = eps.base_ring()
from sage.modular.dims import CohenOesterle
from all import Gamma0
return ZZ(
K(Gamma0(N).index() * (k - 1) / ZZ(12)) +
CohenOesterle(eps, k))
else: #algorithm not in ["CohenOesterle", "Quer"]:
raise ValueError, "Unrecognised algorithm in dimension_cusp_forms"