In this repository we store raw data for the collection [Dirichlet_char_modl] in the database [mod_l_eigenvalues] for the LMFDB.

Notation:

• ℓ is a prime
• GF(ℓ) is the finite field of size ℓ
• Conway(ℓ,d) is the Conway polynomial of degree d in GF(ℓ)[T]
• F is the model GF(ℓ)[T] / Conway(ℓ,d) of the finite field of size ℓ^d, and t is the image of T in F
• m is a positive integer
• We decompose m as m' × ℓ^v, where m' is prime to ℓ
• We consider a (not necessarily primitive) character X: (Z/mZ)* -> F*
• Zℓ is the ring of ℓ-adic integers
• Teich: (Z/ℓZ)* -> Zℓ* is the Teichmüller lift, so that Teich(x) is the unique (ℓ-1)^th root of 1 that is congruent to x mod ℓ
• C is the field of the complex numbers
• mu(n) is the group of n-th roots of 1 in C
• e(x) is exp(2 Pi I x).

The label of the character X is of the form ℓ-m.i, where ℓ and m are defined above, and i is an index in (Z/mZ)* which we now define.

By CRT, X factors uniquely as X' × Y, where X': (Z/m'Z)* -> GF(ℓ^d)* and Y: (Z/ℓ^v Z)* -> F*. The m'-part of i will come from X', and the ℓ-part of i will come from Y.

• Embed F* into mu(ℓ^d-1) by sending t to e(1/(ℓ^d-1)). This allows us to view X' as a character from (Z/m'Z)* to C*. This character has a Conrey index i' in (Z/m'Z)*.

• Since F* has no ℓ-torsion, the conductor of Y is either 1 or ℓ. Either way, Y factors as a character (Z/ℓZ)* -> F*, which must assume values in GF(ℓ)*. Let Conway(ℓ,1)=T-g where g in GF(ℓ)* is a generator of GF(ℓ)*. Identify canonically (Z/ℓZ)* = GF(ℓ)*, and let h = Y(g), and element of (Z/ℓZ)*. Let j be the image of Teich(h) in (Z/ℓ^v Z)*.

The index i is defined by CRT as the unique element of (Z/mZ)* that is i' mod m' and j mod ℓ^v.

Keep the same notations. Embedding F* into mu(ℓ^d-1) allows us to lift X into a character (Z/mZ)* -> C*.

If the label of X is ℓ-m.i, then the index of the lift is m.i.

In particular, lifting characters is injective.

Let now X: (Z/mZ)* -> C* be a complex-valued character. Let N be the multiplicative order of X, so that X assumes values in mu(N), and write N = N' × L where L is a power of ℓ. This corresponds to the decomposition X = X' × Y, where X' assumes values in mu(N') and Y assumes values in mu(L).

Since F* has no ℓ-power torsion, if we want to reduce X to a F*-valued character we must drop Y altogether. We now focus on reducing X'.

Let d be the multiplicative order of (ℓ mod N'); this is the smallest value such that F* contains a primitive N'-th root of 1, namely z := t^((ℓ^d-1)/N'). We reduce X' by sending e(1/N') to z.

Let m.c be the Conrey label of the character X: (Z/mZ)* -> C* and let ℓ-m.i the label of the corresponding reduction. Then i = (j,k) is an element of (Z/mZ)* = (Z/m')* × (Z/ℓ)* and we have c = (j, k'): reduction is not injective, ignoring the ℓ-part there is a canonical way of lifting.

In this repository we store raw data for the collection [Dirichlet_gp_modl] in the database [mod_l_eigenvalues] for the LMFDB.

In this repository we store raw data for the collection [finite_fields] in the database [mod_l_eigenvalues] for the LMFDB.

This collection contains the following data: each entry represents a finite field in the follwoing format:

• characteristic: (int) characteristic of the finite field
• degree: (int) degree of the finite field
• polynomial: (list of ints) coefficient of the minimal polynomial of a generator of the field
• conway: (Boolean) 1 True, 0 False (at the moment all fields in the database are given by Conway polynomials)

A requirement for the choice of the representation of the finite field is compatibility between roots of unity and field extensions. The database includes the Sage library ConwayPolynomials.

Here is one entry in the database:

{u'polynomial': [2, 1, 1, 0, 1, 4, 3, 4, 2, 2, 0, 2, 3, 4, 4, 0, 4, 4, 0, 3, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 1], 
u'characteristic': 5, 
u'_id': ObjectId('58d00706ffe979233bcc472a'), 
u'degree': 30, 
u'conway': 1}