CoCalc Public Fileswww / tables / magma_src / ModFrm / modular_symbols.mOpen with one click!
Author: William A. Stein
1
freeze;
2
3
/****-*-magma-* EXPORT DATE: 2004-03-08 ************************************
4
5
MODFORM: Modular Forms in MAGMA
6
7
William A. Stein
8
9
FILE: modular_symbols.m
10
11
$Header: /home/was/magma/packages/ModFrm/code/RCS/modular_symbols.m,v 1.9 2002/10/26 22:49:01 was Exp $
12
13
$Log: modular_symbols.m,v $
14
Revision 1.9 2002/10/26 22:49:01 was
15
.
16
17
Revision 1.8 2002/05/06 05:31:21 was
18
Added correct call to SpaceTypeParam.
19
20
Revision 1.7 2002/04/13 05:24:31 was
21
*** empty log message ***
22
23
Revision 1.6 2002/01/18 06:44:45 was
24
minor typo in ModularSymbols(modfrmelt)
25
26
Revision 1.5 2002/01/18 06:40:50 was
27
Added ModularSymbols for modular forms.
28
29
Revision 1.4 2001/07/08 18:40:23 was
30
Fixed a verbose print line in ModularSymbols.
31
32
Revision 1.3 2001/05/30 18:55:57 was
33
Created.
34
35
Revision 1.2 2001/05/16 04:07:21 was
36
*** empty log message ***
37
38
Revision 1.1 2001/05/16 03:51:59 was
39
Initial revision
40
41
42
***************************************************************************/
43
44
import "predicates.m": SpaceTypeParam;
45
46
forward MinimalCharacterModularSymbols,
47
MF_ModularSymbols,
48
MF_NewformModularSymbols;
49
50
function MinimalCharacterModularSymbols(eps, k, sign)
51
assert Type(eps) eq GrpDrchElt;
52
assert Type(k) eq RngIntElt;
53
assert Type(sign) eq RngIntElt;
54
assert sign in {-1, 0, 1};
55
assert k ge 2;
56
assert Type(BaseRing(eps)) in {FldRat, FldCyc};
57
58
e := MinimalBaseRingCharacter(eps);
59
return ModularSymbols(e,k,sign);
60
end function;
61
62
63
function MF_ModularSymbols(M, sign)
64
// The sequence of characteristic 0 spaces of modular symbols
65
// with given sign associated to M, when this makes sense.
66
assert Type(M) eq ModFrm;
67
assert Type(sign) eq RngIntElt;
68
if not (Weight(M) ge 2 and Weight(M) in Integers()) then
69
error "Argument 1 must have integer weight at least 2.";
70
end if;
71
if not (sign in {-1,0,1}) then
72
error "Argument 2 must be in {-1,0,1}.";
73
end if;
74
vprint ModularForms,2 : "Computing modular symbols space.";
75
76
if not assigned M`mf_modular_symbols then
77
M`mf_modular_symbols := [* false,false,false *];
78
end if;
79
if Type(M`mf_modular_symbols[sign+2]) eq BoolElt then
80
if not IsAmbientSpace(M) and
81
(assigned M`dimension and M`dimension eq 0) then
82
return [ZeroSubspace(m) : m in MF_ModularSymbols(AmbientSpace(M),sign)];
83
end if;
84
param := SpaceTypeParam(M);
85
case M`type:
86
when "full":
87
eps := DirichletCharacters(M);
88
M`mf_modular_symbols[sign+2] :=
89
[MinimalCharacterModularSymbols(e, Weight(M), sign) : e in eps];
90
when "cusp":
91
M`mf_modular_symbols[sign+2] :=
92
[CuspidalSubspace(m) : m in MF_ModularSymbols(AmbientSpace(M),sign)];
93
when "eis":
94
M`mf_modular_symbols[sign+2] :=
95
[EisensteinSubspace(m) : m in MF_ModularSymbols(AmbientSpace(M),sign)];
96
when "new":
97
// require false :
98
// "If argument 1 is new we require that it also be be cuspidal.";
99
M`mf_modular_symbols[sign+2] :=
100
[param eq 0 select NewSubspace(m) else NewSubspace(m,param) :
101
m in MF_ModularSymbols(AmbientSpace(M),sign)];
102
when "cusp_new":
103
M`mf_modular_symbols[sign+2] :=
104
[param eq 0 select NewSubspace(m) else NewSubspace(m,param) :
105
m in MF_ModularSymbols(CuspidalSubspace(AmbientSpace(M)),sign)];
106
when "eis_new":
107
// require false :
108
// "If argument 1 is new we require that it also be be cuspidal.";
109
M`mf_modular_symbols[sign+2] :=
110
[param eq 0 select NewSubspace(m) else NewSubspace(m,param) :
111
m in MF_ModularSymbols(EisensteinSubspace(AmbientSpace(M)),sign)];
112
when "cusp_newform":
113
modsym := ChangeSign(MF_NewformModularSymbols(M`made_from_newform),sign);
114
All := MF_ModularSymbols(AmbientSpace(M),sign);
115
M`mf_modular_symbols[sign+2] := [DirichletCharacter(A) eq DirichletCharacter(modsym)
116
select modsym else ZeroSubspace(A) : A in All];
117
when "eis_newform":
118
error "Modular symbols of eisenstein newform parents is not yet supported.";
119
120
else:
121
assert false;
122
end case;
123
124
end if;
125
return M`mf_modular_symbols[sign+2];
126
end function;
127
128
function MF_NewformModularSymbols(f)
129
// The space of modular symbols attached to a newform f, if there is one.
130
assert Type(f) eq ModFrmElt;
131
if not assigned f`mf_modular_symbols then
132
error "I don't know how to compute the associated space of modular symbols (yet).";
133
end if;
134
return f`mf_modular_symbols;
135
end function;
136
137
138
139
140
intrinsic ModularSymbols(M::ModFrm, sign::RngIntElt) -> ModSym
141
{The space of modular symbols over Q with given sign corresponding to the space M of modular forms.}
142
if not (Weight(M) ge 2 and Weight(M) in Integers()) then
143
error "Argument 1 must have integer weight at least 2.";
144
end if;
145
if not (sign in {-1,0,1}) then
146
error "Argument 2 must be in {-1,0,1}.";
147
end if;
148
m := MF_ModularSymbols(M,sign);
149
return DirectSumRestrictionOfScalarsToQ(m);
150
end intrinsic;
151
152
intrinsic ModularSymbols(M::ModFrm) -> ModSym
153
{The space of modular symbols over Q corresponding to the space M of modular forms.}
154
return ModularSymbols(M,0);
155
end intrinsic;
156
157
intrinsic ModularSymbols(f::ModFrmElt, sign::RngIntElt) -> ModSym
158
{The space of modular symbols over Q with given sign corresponding to the newform f.}
159
require IsNewform(f) : "Argument 1 must be newform.";
160
require sign in {-1,0,1} : "Argument 2 must be either -1, 0, or 1.";
161
require Characteristic(BaseRing(Parent(f))) eq 0 : "Argument 1 must be in characteristic 0.";
162
163
return DirectSumRestrictionOfScalarsToQ(MF_ModularSymbols(Parent(f),sign));
164
end intrinsic;
165
166
167
intrinsic ModularSymbols(f::ModFrmElt) -> ModSym
168
{The space of modular symbols over Q corresponding to the newform f.}
169
require IsNewform(f) : "Argument 1 must be newform.";
170
return ModularSymbols(f,0);
171
end intrinsic;
172