In this chapter we develop a theory for computing with Dirichlet characters, which are extremely important to computations with modular forms for (at least) two reasons:
To compute the Eisenstein subspace of , we write down Eisenstein series attached to pairs of Dirichlet characters (the space will be defined in Chapter Eisenstein Series and Bernoulli Numbers).
To compute , we instead compute a decomposition
and then compute each factor (see Section Dirichlet Character Decomposition). Here the sum is over all Dirichlet characters of modulus .
Dirichlet characters appear frequently in many other areas of number theory. For example, by the Kronecker-Weber theorem, Dirichlet characters correspond to the -dimensional representations of .
After defining Dirichlet characters in Section The Definition, in Section Representing Dirichlet Characters we describe a good way to represent Dirichlet characters using a computer. Section Evaluation of Dirichlet Characters is about how to evaluate Dirichlet characters and leads naturally to a discussion of the baby-step giant-step algorithm for solving the discrete log problem and methods for efficiently computing the Kronecker symbol. In Section Conductors of Dirichlet Characters we explain how to factor Dirichlet characters into their prime power constituents and apply this to the computations of conductors. We describe how to carry out a number of standard operations with Dirichlet characters in Section Restriction, Extension, and Galois Orbits and discuss alternative ways to represent them in Section Alternative Representations of Characters. Finally, in Section Dirichlet Characters in Sage we give a very short tutorial about how to compute with Dirichlet characters using Sage.
Fix an integral domain and a root of unity in .
A Dirichlet character of modulus over is a map such that there is a homomorphism for which
We denote the group of such Dirichlet characters by . Note that elements of are in bijection with homomorphisms .
A familiar Dirichlet character is the Legendre symbol , with an odd prime, that appears in quadratic reciprocity theory. It is a Dirichlet character of modulus that takes the value on integers that are congruent to a nonzero square modulo , the value on integers that are congruent to a nonzero nonsquare modulo , and on integers divisible by .
The groups and are isomorphic.
We prove the more general fact that for any finite abelian group , we have that . To deduce this latter isomorphism, first reduce to the case when is cyclic by writing as a product of cyclic groups. The cyclic case follows because if is cyclic of order , then contains an root of unity, so is also cyclic of order . Any two cyclic groups of the same order are isomorphic, so and are isomorphic.
We have , with equality if and only if the order of our choice of is a multiple of the exponent of the group .
This is because .
Fix a positive integer . To find the set of “canonical” generators for the group , write where are the prime divisors of . By Exercise 4.2, each factor is a cyclic group , except if and , in which case is a product of the cyclic subgroup of order with the cyclic subgroup . In all cases we have
For such that , choose the generator of to be the element of that is smallest and generates. Finally, use the Chinese Remainder Theorem (see [Coh93, Section 1.3.3]) to lift each to an element in , also denoted , that is modulo each for .
Given a prime power with odd, this algorithm computes the minimal generator of .
See Exercise 4.3 for a proof that this algorithm is correct.
A minimal generator for is . We have and
so is not a generator for . (We see this just from .) However is a generator since
In this example we compute minimal generators for , , and :
In Sage, the command Integers(N) creates .
sage: R = Integers(49) sage: R Ring of integers modulo 49
The unit_gens command computes the minimal generators for , as defined above.
sage: R.unit_gens()  sage: Integers(25).unit_gens()  sage: Integers(100).unit_gens() [51, 77] sage: Integers(200).unit_gens() [151, 101, 177] sage: Integers(2005).unit_gens() [402, 1206] sage: Integers(200000000).unit_gens() [174218751, 51562501, 187109377]
Fix an element of finite multiplicative order in a ring , and let denote the group of Dirichlet characters of modulus over , with image in . In most of this chapter, we specify an element by giving the list
of images of the generators of . (Note that if is even, the number of elements of the list (1) does depend on whether or not —there are two factors corresponding to if , but only one if .) This representation completely determines and is convenient for arithmetic operations. It is analogous to representing a linear transformation by a matrix.
In any actual implementation (e.g., the one in Sage), it is better to represent the by recording an integer such that , where is a fixed root of unity. Then (1) is internally represented as an element of , where is the multiplicative order of . When the representation of (1) is needed for an algorithm, it can be quickly computed on the fly using a table of the powers of . See Section Alternative Representations of Characters for further discussion about ways to represent characters.
The group has elements , so it is cyclic of order . In contrast, the group has only the two elements and and order .
The command : DirichletGroup(N) with no second argument creates the group of Dirichlet characters with values in the cyclotomic field , where is the exponent of the group . Every element in takes values in , so .
sage: list(DirichletGroup(5)) [, [zeta4], [-1], [-zeta4]] sage: list(DirichletGroup(5, QQ)) [, [-1]]
This section is about how to compute , where is a Dirichlet character and is an integer. We begin with an example.
If , then , and , as we saw in Example 4.6. The exponent of is , since that is the least common multiple of the exponents of and . The orders of , , and are , , and . Let be a primitive root of unity in . Then the following are generators for :
and is an example element of order . To evaluate , we write in terms of , , and . First, reducing modulo , we see that . Next reducing modulo and trying powers of , we find that . Thus
We next illustrate the above computation of in Sage. First we make the group and list its generators.
sage: G = DirichletGroup(200) sage: G Group of Dirichlet characters of modulus 200 over Cyclotomic Field of order 20 and degree 8 sage: G.exponent() 20 sage: G.gens() ([-1, 1, 1], [1, -1, 1], [1, 1, zeta20])
We construct .
sage: K = G.base_ring() sage: zeta = K.0 sage: eps = G([1,-1,zeta^5]) sage: eps [1, -1, zeta20^5]
Finally, we evaluate at .
sage: eps(3) zeta20^5 sage: -zeta^15 zeta20^5
Example 4.9 illustrates that if is represented using a list as described above, evaluation of is inefficient without extra information; it requires solving the discrete log problem in .
For a general character , is calculation of at least as hard as finding discrete logarithms? Quadratic characters are easier—see Algorithm 4.23.
Given a Dirichlet character of modulus , represented by a list , and an integer , this algorithm computes .
Exercise 4.4 gives an isomorphism of groups
so one sees by induction that step (2) is “about as difficult” as finding a discrete log in . There is an algorithm called “baby-step giant-step”, which solves the discrete log problem in in time , where is the largest prime factor of (note that the discrete log problem in reduces to a series of discrete log problems in each prime-order cyclic factor). This is unfortunately still exponential in the number of digits of ; it also uses memory. We now describe this algorithm without any specific optimizations.
Given a prime , a generator of , and an element , this algorithm finds an such that . (Note that this algorithm works in any cyclic group, not just .)
[Make Lists] Let be the ceiling of , and construct two lists
[Find Match] Sort the two lists and find a match . Then .
We prove that there will always be a match. Since we know that for some with and any such can be written in the form for , we will find such a match.
Algorithm 4.12 uses nothing special about , so it works in a generic group. It is a theorem that there is no faster algorithm to find discrete logs in a “generic group” (see [Sho97, Nec94]). There are much better subexponential algorithms for solving the discrete log problem in , which use the special structure of this group. They use the number field sieve (see, e.g., [Gor93]), which is also the best-known algorithm for factoring integers. This class of algorithms has been very well studied by cryptographers; though sub-exponential, solving discrete log problems when is large is still extremely difficult. For a more in-depth survey see [Gor04]. For computing Dirichlet characters in our context, is not too large, so Algorithm 4.12 works well.
For many applications of Dirichlet characters to computing modular forms, is fairly small, e.g., , and we evaluate on a huge number of random elements, inside inner loops of algorithms. Thus for such purposes it will often be better to make a table of all values of , so that evaluation of is extremely fast. The following algorithm computes a table of all values of , and it does not require computing any discrete logs since we are computing all values.
Given a Dirichlet character represented by the list of values of on the minimal generators of , this algorithm creates a list of all the values of .
[Initialize] For each minimal generator , set . Let , and set . Create a list of values, all initially set equal to . When this algorithm terminates, the list will have the property that
Notice that we index starting at .
[Add Value to Table] Set .
[Finished?] If each is one less than the order of , output and terminate.
[Increment] Set , , and . If , set , and then set , , and . If , do what you just did with but with all subscripts replaced by . Etc. (Imagine a car odometer.) Go to step (2).
The following algorithm for computing the order of reduces the problem to computing the orders of powers of in .
This algorithm computes the order of a Dirichlet character .
Computing the order of is potentially difficult. Simultaneously using a different representation of Dirichlet characters avoids having to compute the order of elements of (see Section Alternative Representations of Characters).
The next algorithm factors as a product of “local” characters, one for each prime divisor of . It is useful for other algorithms, e.g., for explicit computations with trace formulas (see [Hij74]). This factorization is easy to compute because of how we represent .
Given a Dirichlet character , with , this algorithm finds Dirichlet characters modulo , such that for all , we have . If , the steps are as follows:
Let be the minimal generators of , so is given by a list
For , let be the element of defined by the singleton list .
Let be the element of defined by the list of length . Output the and terminate.
The factorization of Algorithm 4.16 is unique since each is determined by the image of the canonical map in , which sends to the element of that is and for .
If , then and .
The conductor of a Dirichlet character is the smallest positive divisor such that there is a character for which for all with . A Dirichlet character is primitive if its modulus equals its conductor. The character associated to with modulus equal to the conductor of is called the primitive character associated to .
We will be interested in conductors later, when computing new subspaces of spaces of modular forms with character. Also certain formulas for special values of functions are only valid for primitive characters.
This algorithm computes the conductor of a Dirichlet character .
Let be the local factors of , as in step (1)). We first show that the product of the conductors of the is the conductor of . Since factors through , the product of the factors through , so the conductor of divides . Conversely, if for some , then we could factor as a product of local (prime power) characters differently, which contradicts that this factorization is unique.
It remains to prove that if is a nontrivial character of modulus , where is a prime, and if is the order of , then the conductor of is , except possibly if . Since the order and conductor of and of the associated primitive character are the same, we may assume is primitive, i.e., that is the conductor of ; note that , since is nontrivial.
First suppose is odd. Then the abelian group splits as a direct sum , where is the -power torsion subgroup of . Also has order , where , which is coprime to , is the order of the image of in and is the order of the image in . If , then the order of is coprime to , so is in , which means that , so , as required. If , then must have order divisible by , so has characteristic not equal to . The conductor of does not change if we adjoin roots of unity to , so in light of Lemma 4.2 we may assume that . It follows that for each , the -power subgroup of is the -torsion subgroup of . Thus , since is by assumption the smallest such group that contains the projection of . This proves the formula of step ((3). We leave the argument when as an exercise (see Exercise 4.5).
If , then as in Example 4.17, is the product of and . Because , the conductor of is . The order of is (since is a root of unity), so the conductor of is . Thus the conductor of is .
In this section all characters have values in .
Frequently quadratic characters are described in terms of the Kronecker symbol , which we define for any integer and positive integer as follows. First, if is an odd prime, then for any integer ,
If , then
More generally, if with the prime, then
One can also extend to , but we will not need this. The extension is to set and , for , and to extend multiplicatively (in the denominator). Note that the map is not a Dirichlet character (see Exercise 4.1).
Let be the product of the primes such that is odd. If is odd, let ; otherwise, let .
is a Dirichlet character of modulus . The function
is a Dirichlet character of modulus .
When restricted to , each map , for prime, is a homomorphism, so a product of homomorphisms. The second statement follows from the definition and the fact that is a square modulo an odd prime if and only if .
This section is about going between representing quadratic characters as row matrices and via Kronecker symbols. This is valuable because the algorithms in [Coh93, Section 1.1.4] for computing Kronecker symbols run in time quadratic in the number of digits of the input. They do not require computing discrete logarithms; instead, they use, e.g., that , when is an odd prime.
Given , this algorithm computes a representation of the Kronecker symbol as a Dirichlet character.
We compute the Dirichlet character associated to . Using Sage, we compute the , for , where the are as in Example 4.9:
sage: kronecker(151,200) 1 sage: kronecker(101,200) -1 sage: kronecker(177,200) 1
Thus the corresponding character is defined by .
We compute the character associated to . We have , and minimal generators are
We have , , and . We find and . The corresponding character is .
Using the following algorithm, we can go in the other direction, i.e., write any quadratic Dirichlet character as a Kronecker symbol.
Given of order with modulus , this algorithm writes as a Kronecker symbol.
Since is the conductor of a quadratic Dirichlet character, it is a square-free product of odd primes times either or , so the group does not inject into for any proper divisor of (see this by reducing to the prime power case). Since is odd and square-free, the character has conductor . For each odd prime , by step (3) of Algorithm 4.19 the factor at of both and is a quadratic character with modulus . By Exercise 4.2 and Lemma 4.2 the group is cyclic, so it has a unique element of order , so the factors of and at are equal.
The quadratic characters with conductor a power of are , , and . The character is and the character is .
Consider with modulus . It has conductor , and , so for all with , we have .
The following two algorithms restrict and extend characters to a compatible modulus. Using them, it is easy to define multiplication of two characters and , as long as and are subrings of a common ring. To carry out the multiplication, extend both characters to a common base ring, and then extend them to characters modulo and multiply.
Given a Dirichlet character and a divisor of that is a multiple of the conductor of , this algorithm finds a characters , such that , for all with .
The only part that is not clear is that in step (3) there is an such that . If we write , with and divisible by all primes that divide , then since . By the Chinese Remainder Theorem, there is an such that and . Then and , which completes the proof.
Given a Dirichlet character and a multiple of , this algorithm finds a character , such that , for all with .
Let be the prime subfield of , and assume that , where is a separable closure of . If and , let ; this defines an action of on . Our next algorithm computes the orbits for the action of on . This algorithm can provide huge savings for modular forms computations because the spaces and are canonically isomorphic if and are conjugate.
Given a Dirichlet character , this algorithm computes the orbit of under the action of , where is the prime subfield of , so or .
[Order of ] Let be the order of the chosen root .
[Nontrivial Automorphisms] If , let
If , compute the multiplicative order of , and let
[Compute Orbit] Compute and output the set of unique elements for each (there could be repeats, so we output unique elements only).
We prove that the nontrivial automorphisms of in characteristic are as in step (2). It is well known that every automorphism in characteristic on is of the form , for some . The images of under such automorphisms are
Suppose is minimal such that . Then the orbit of is . Also , where is the multiplicative order of , so is the multiplicative order of modulo , which completes the proof.
The Galois orbits of characters in are as follows:
The conductors of the characters in orbit are , in orbit they are , in orbit they are , in they are , in the conductor is , and in the conductor is . (You should verify this.)
Sage computes Galois orbits as follows:
sage: G = DirichletGroup(20) sage: G.galois_orbits() [ [[1, 1]], [[1, zeta4], [1, -zeta4]], [[1, -1]], [[-1, 1]], [[-1, zeta4], [-1, -zeta4]], [[-1, -1]] ]
Let be a positive integer and an integral domain, with fixed root of unity of order , and let . As in the rest of this chapter, write , and let be the corresponding cyclic factors of . In this section we discuss other ways to represent elements . Each representation has advantages and disadvantages, and no single representation is best. It is easy to convert between them, and some algorithms are much easier using one representation than when using another. In this section we present two other representations, each having advantages and disadvantages. There is no reason to restrict to only one representation; for example, Sage internally uses both.
We could represent by giving a list , where each and . Then arithmetic in is arithmetic in , which is very efficient. A drawback to this approach (in practice) is that it is easy to accidently consider sequences that do not actually correspond to elements of . Also the choice of is less clear, which can cause confusion. Finally, the orders of the local factors is more opaque, e.g., compare with . Overall this representation is not too bad and is more like representing a linear transformation by a matrix. It has the advantage over the representation discussed earlier in this chapter that arithmetic in is very efficient and does not require any operations in the ring .
Another way to represent would be to give a list of integers, but this time with , where is the order of . Then
which is already pretty complicated. With this representation we set up an identification
and arithmetic is efficient. This approach is seductive because every sequence of integers determines a character, and the sizes of the integers in the sequence nicely indicate the local orders of the character. However, giving analogues of many of the algorithms discussed in this chapter that operate on characters represented this way is tricky. For example, the representation depends very much on the order of , so it is difficult to correctly compute natural maps , for rings.
To create a Dirichlet character in Sage, first create the group of Dirichlet characters then construct elements of that group. First we make :
sage: G = DirichletGroup(11, QQ); G Group of Dirichlet characters of modulus 11 over Rational Field
A Dirichlet character prints as a matrix that gives the values of the character on canonical generators of (as discussed below).
sage: list(G) [, [-1]] sage: eps = G.0 # 0th generator for Dirichlet group sage: eps [-1]
The character takes the value on the unit generator.
sage: G.unit_gens()  sage: eps(2) -1 sage: eps(3) 1
It is on any integer not coprime to :
sage: [eps(11*n) for n in range(10)] [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
We can also create groups of Dirichlet characters taking values in other rings or fields. For example, we create the cyclotomic field .
sage: R = CyclotomicField(4) sage: CyclotomicField(4) Cyclotomic Field of order 4 and degree 2
Then we define .
sage: G = DirichletGroup(15, R) sage: G Group of Dirichlet characters of modulus 15 over Cyclotomic Field of order 4 and degree 2
Next we list each of its elements.
sage: list(G) [[1, 1], [-1, 1], [1, zeta4], [-1, zeta4], [1, -1], [-1, -1], [1, -zeta4], [-1, -zeta4]]
Now we evaluate the second generator of on various integers:
sage: e = G.1 sage: e(4) -1 sage: e(-1) -1 sage: e(5) 0
Finally we list all the values of .
sage: [e(n) for n in range(15)] [0, 1, zeta4, 0, -1, 0, 0, zeta4, -zeta4, 0, 0, 1, 0, -zeta4, -1]
We can also compute with groups of Dirichlet characters with values in a finite field.
sage: G = DirichletGroup(15, GF(5)); G Group of Dirichlet characters of modulus 15 over Finite Field of size 5
We list all the elements of , again represented by lists that give the images of each unit generator, as an element of .
sage: list(G) [[1, 1], [4, 1], [1, 2], [4, 2], [1, 4], [4, 4], [1, 3], [4, 3]]
We evaluate the second generator of on several integers.
sage: e = G.1 sage: e(-1) 4 sage: e(2) 2 sage: e(5) 0 sage: print [e(n) for n in range(15)] [0, 1, 2, 0, 4, 0, 0, 2, 3, 0, 0, 1, 0, 3, 4]
Let be the map given by
Prove that is not a Dirichlet character of any modulus .
This exercise is about the structure of the units of .
Prove that Algorithm 4.4 works, i.e., that if and for all , then is a generator of .
Let be an odd prime and an integer, and prove that
Use the first part to show that solving the discrete log problem in is “not much harder” than solving the discrete log problem in .
Suppose is a nontrivial Dirichlet character of modulus of order over the complex numbers . Prove that the conductor of is