The first version of this package was released in V2.15 (December 2008). It has been developed further in each subsequent release, and is still under development. We encourage users to send feedback regarding the package, and desirable features or improvements.
The package contains implementations of two separate algorithms. The primary focus is on parallel weight 2. Higher weight spaces (including non-parallel weight) are also handled; however some features are only available for weight 2, and the main routines are better optimized in weight 2. All levels Γ0(N) are allowed; some spaces with nontrivial character are also handled.
The main purposes of the current functionality are to efficiently compute Hecke operators on these spaces, to decompose spaces into newforms, and to efficiently obtain large numbers of eigenvalues for newforms (at least those having small degree). Some additional features such as Atkin-Lehner operators are also included.
Hilbert modular forms are a generalization of classical modular forms where the modular group is replaced by a subgroup of GL2(ZF) where ZF is the ring of integers in a totally real number field. This section gives a brief and partly informal introduction to Hilbert modular forms. The sections about the algorithms also introduce quaternionic modular forms and the Jacquet-Langlands theory in order to use the package!
The books by Freitag [Fre90] and Garrett [Gar90] are good references for standard material on Hilbert modular forms.
Let F be a totally real field of degree n over Q, with ring of integers ZF. Let v1, ..., vn be the embeddings of F into R. For x∈F, we write xi as a shorthand for vi(x). Each embedding vi induces an embedding vi:(Mat)2(F) -> (Mat)2(R). Extending our shorthand to matrices, for γ∈(Mat)2(F) we write γ for vi(γ). Let
GL2^ + (F) = { γ∈GL2(F) : (det) γi > 0 for all i }.
The group GL2^ + (F) acts on the cartesian product Hn by the rule
γ(τ, ..., τn)=(γτ1, ..., γτn)
where as usual GL2^ + (R) acts on H by linear fractional transformations.
Let γ= pmatrix( a & b
c & d ) ∈GL2(R) and τ∈H. We define
j(γ, τ) = cτ + d∈C.
For a weight k=(k1, ..., kn) ∈(Z>0)n, we define a right weight-k action of GL2^ + (F) on the space of complex-valued functions on Hn by
(f(|k) γ)(τ)=f(γτ)∏i=1n ((det)γ)ki/2j(γ, τi) - ki
for f : Hn to C and γ ∈GL2^ + (F). The center F x of GL2^ + (F) acts trivially on such f. Therefore, the weight-k action descends to an action of PGL2^ + (F)=GL2^ + (F)/F x .
Now let N be a (nonzero) ideal of ZF. Define
Γ0(N)= { pmatrix( a & b
c & d ) ∈GL2^ + (ZF) : c∈N }.
A Hilbert modular cusp form of weight-k and level Γ0(N) is an analytic function f:Hnto C such that f(|k)γ=f for all γ∈Γ0(N) and such that f vanishes at the cusps of Γ0(N).
When F has narrow class number 1, it is possible to define double coset operators in the same way as for classical modular forms; among these are Hecke operators, Atkin-Lehner operators and degeneracy maps. More precisely, the definitions work for primes in the trivial ideal class. In the general case, the adelic definition of Hilbert modular forms is more convenient for the purpose of defining operators, among other considerations. We refer to the book by Freitag [Fre90].
Two separate algorithms are implemented for computing the Hecke action on cuspidal spaces of Hilbert modular forms. Both rely on the Jacquet-Langlands correspondence, which states that the Hecke action on a space of Hilbert cusp forms is the same as the Hecke action on a space of automorphic forms on some order in a suitable quaternion algebra. See [Hid06] for definitions of quaternionic automorphic forms and the correspondence.
Let F be a totally real field of degree n over Q. Algorithm I uses a definite quaternion algebra over F (ramified at all n infinite places). Algorithm II uses the Shimura curve associated to a quaternion algebra ramified at exactly n - 1 infinite places. By default, the algorithm (and the quaternion order to be used) are selected automatically, but can also be specified by the user. The essential requirement is that the quaternion order can be ramified only at primes p for which the space is p-new. The required conditions are stated fully in the descriptions of the commands HilbertCuspForms and NewSubspace. It is worth noting that a different algorithm and order may be selected for a newspace than for the space containing it. In fact, there is more freedom for a new space; in particular, over Q neither algorithm can compute full spaces, but can compute new subspaces for nonsquare levels.
Algorithm II is implemented only for parallel weight 2 (weight [2, 2, ..., 2]). In the current implementation, Algorithm I is more optimized than Algorithm II, and therefore should be preferred in most cases. For spaces over odd degree fields with level not divisible by any small primes, Algorithm II may be preferable.
An exposition of both algorithms is given in [DV12], in addition to the references mentioned in the following two sections.
This algorithm, described in [Dem07] and [DD08], is an efficient formulation of the Brandt module approach to computing modular forms.
A key advantage of this algorithm is that the most expensive steps come in the precomputation phase (computations depending only on the quaternion algebra). This means that for a given number field, forms of many different levels and weights can be computed based on the same precomputation.
This algorithm, described in [GV11], is based on computing the homology of a Shimura curve (and therefore is closer to the usual modular symbols algorithm over Q than Algorithm I). Voight's algorithm ([Voi09]) for the fundamental domain of the action of the Fuchsian group on the upper half plane is applied. The algorithm simultaneously determines a fundamental domain and generators and relations for the fundamental group. From this a description of the homology is obtained, in such a way that the Hecke action on it can then be explicitly calculated.
The Magma category for spaces of Hilbert modular forms is ModFrmHil, while elements in these spaces have type ModFrmHilElt.
To see some information printed during computation about what the program is doing, use SetVerbose("ModFrmHil",n), where n is 0 (silent, by default), 1 (prints concise information), 2 or 3 (which may display bulky data).