Sure. I'm essentially following the same technique used in Seng-Kiat Chua
and San Ling's article "On the Rational Cuspidal Subgroup and the Rational
Torsion Points of J_0(pq)", and my thesis (arXiv:0707.0437).
Let L be the space of functions on the upper half plane generated
(multiplicatively) by eta function $\eta_d$ as d runs through divisor of
N. Then we can give an explicit isomorphism between (L \tensor \QQ) and
(C \tensor \QQ), where C is the group of divisors supported on the cusps
(call this isomorphism \Lambda). Furthermore, Ligozat has a proposition
on precisely when an element in L is a function on $X_0(N)$ (Proposition
2.2.3 in my thesis). Using this proposition, and the isomorphism Lambda, one
can generate the lattice of all principle divisors in C, and quotiening
out degree zero divisors by these principle divisors gives the cuspidal
subgroup.
I'm enclosing the code that does this in this email, although
as it is written is really hackish. The example is
sage: load "cuspidal_subgroup.py"
sage: CS=CuspidalGroup(15)
sage: CS.PrincipleDivisor
Free module of degree 4 and rank 3 over Integer Ring
Echelon basis matrix:
[ 1 3 1 -5]
[ 0 4 0 -4]
[ 0 0 2 -2]
I don't know how to quotient two lattices in sage (I'm afraid it might
not be implemented yet), but looking at the principledivisor, you can
see the cuspidal subgroup is Z/2 \times Z/4.
Soroosh
On Fri, Jul 13, 2007 at 10:31:21PM +0100, John Cremona wrote:
>
> And to me please!!
>
>
> On 7/13/07, William Stein <[EMAIL PROTECTED]> wrote:
> >
> > On 7/13/07, William Stein <[EMAIL PROTECTED]> wrote:
> > > > I was writing a function to calculate the structure of cuspidal
subgroup of
> > > > J_0(N) without using modular symbols. I came across the following
puzzling
> >
> > How are you doing that? I didn't know there was an algorithm to compute
> > the structure of J_0(N)(Qbar)_tor without using modular
symbols. Interesting.
> > Could you explain it to me?
> >
> > William
> >
> > >
> >
>
>
> --
> John Cremona
>
>
def degree_zero_divisor(rank,den=1):
amb=FreeModule(ZZ,rank)
B=amb.basis()
gens=[]
for i in range(rank):
gens.append((B[0]-B[i])*den)
return amb.submodule(gens)
def binary_to_prod(n,facs):
prod=1
for p in facs:
prod=prod*(p**(1-n%2))
n=n.div(2)
return prod
class CuspidalGroup():
def __init__(self, N):
"""
INPUT:
N -- Level for the cuspidal group. Currently only defined for
N square free.
This group is denoted stored as two lattice: degree zero cusps,
and principle cusps.
"""
if not N.is_squarefree():
raise TypeError, "N (=%s) should be square free."%N
self.__level=N
self.__facs=N.factor()
self.__den=prod([p[0]**2-1 for p in self.__facs])
rank=(2**len(self.__facs))
self.__rank=rank
self.__divisor_lattice=degree_zero_divisor(rank)
ambZ=self.__divisor_lattice.ambient_module()
ambQ=self.__divisor_lattice.ambient_vector_space()
"""
The divisor lattice is generated by P_{\prod pi_i^{a_i}}.
Such elements are denoted by \sum 2^i a_i. So B[0]=P_1.
"""
LambdaZ=self._generate_lambda()
LambdaQ=LambdaZ*(24/self.__den)
self.Cond1=phi_inverse(LambdaQ)
self.Cond4=degree_zero_divisor(rank)
self.Cond5=phi_inverse
(self._generate_cond5()*LambdaZ*(12/self.__den))
Lat0=self.Cond1.intersection(self.Cond4).intersection(self.Cond5)
self.PrincipleDivisor=Lat0
def _generate_lambda(self):
"""
Generates the lambda matrix, which maps cusps to eta functions.
"""
rank=self.__rank
Lambda=Matrix(QQ,rank)
facs=[-p[0] for p in self.__facs]
for i in range(rank):
for j in range(rank):
Lambda[i,j]=binary_to_prod(ZZ(i)._xor(ZZ(j)),facs)
return Lambda
def _generate_cond5(self):
l=len(self.__facs)
M=Matrix(QQ,l,self.__rank)
for j in range(l):
divpoint=2**j
for i in range(2**(l-1)):
x=2*divpoint*ZZ(i).div(divpoint)+divpoint+ZZ(i).mod(divpoint)
M[j,x]=1
return M
"""
This should go somewhere reasonable, but for now, let's just have it
as a random function.
"""
def row_inverse(phi):
"""
Input:
phi: \ZZ^n \rightarrow \QQ, given as an n-dimensional rational
vector.
Output:
phi^{-1}(\ZZ).
This function has no error checking in it yet.
Also, this algorithm is prone to coefficient explosion. I will worry
about
that later. I think we can do everything modulo denomanitor. That would
solve the coefficient explosion.
"""
den=phi.denominator()
phiZ=(den*phi).change_ring(ZZ)
rank=phi.degree()
M=Matrix(ZZ,rank)
g=[den]
p=[]
q=[]
for i in range(rank):
(a,b,c)=XGCD(g[i],phiZ[i])
g.append(a)
p.append(b)
q.append(c)
M[i,i]=g[i].div(g[i+1])
K=phiZ[i].div(g[i+1])
for j in range(i-1,-1,-1):
M[i,j]=-K*q[j]
K=(K*p[j])%den
return M.row_space()
def phi_inverse(phi):
v=phi.rows()[0]
M=row_inverse(v)
for v in phi.rows():
M=M.intersection(row_inverse(v))
return M
--~--~---------~--~----~------------~-------~--~----~
To post to this group, send email to sage-devel@googlegroups.com
To unsubscribe from this group, send email to [EMAIL PROTECTED]
For more options, visit this group at http://groups.google.com/group/sage-devel
URLs: http://sage.scipy.org/sage/ and http://modular.math.washington.edu/sage/
-~----------~----~----~----~------~----~------~--~---
