Resultants, Resolvents and the Computation of Galois Groups

Alexander D. Healy
[email protected]

Abstract

We will develop the machinery of resultants and resolvent polynomials with the ultimate goal of
understanding the so-called “resolvent method” for computing Galois groups over Q. Along the way,
we will encounter tangential applications of these tools, such as the determination of the minimal
polynomial of, say, the sum of two algebraic numbers using resultants. In this way, this paper can serve
at once as an exposition on computing Galois groups of rational polynomials and as an introduction
to some techniques of computation in number fields.

1 Preliminaries

The following notational conventions will be used throughout the remaining sections. Given a polynomial
A(X) = an xn + · · · + a1 x + a0 , `(A) denotes the leading coefficient, an , of A, and cont(A), the content
of A, is equal to gcd(an , an−1 , . . . , a0 ). We will assume a familiarity with basic mathematical/numerical
algorithms such as the Euclidean algorithm (for computing the gcd of two elements of a Euclidean domain)
and Newton’s method (for approximating the real and complex roots of polynomials over R). Such topics,
as well as the majority of the material in the following sections, are covered in either [Coh93], [Knu73]
or [Knu81].

2 Resultants

Definition 2.1. Let R be an integral domain. Given two polynomials A(X), B(X) ∈ R[X] with roots
α1 , . . . , αm and β1 , . . . , βn respectively (in some extension of the field of fractions of R), the resultant
R(A, B) of A and B is defined to be
Y
R(A, B) = `(A)n `(B)m (αi − βj )
i,j

which is equivalent to both

R(A, B) = `(A)n B(α1 ) · · · B(αm )
and
R(A, B) = (−1)nm `(B)m A(β1 ) · · · A(βn )

The resultant has several properties which make it useful and easy to compute. For instance, R(A, B) ∈ R,
which is a corollary to the following proposition:

1
Proposition 2.2. Let A(X) = am X m + · · · + a0 and B(X) = bn X n + · · · + b0 , and let
 
am · · · · · · a0 0 ··· 0
 0 am · · · · · · a0 . . . 0 
 

 .. . . .. 

. . . . . . . .
 . . . . . . .
 
 0 · · · 0 am · · · · · · a0 
S=  
 b n · · · · · · b 0 0 · · · 0 

 0 bn · · · · · · b0 . . . 0 
 
 .. . . .
 
.. .. .. ..
 . . . . . . .. 
0 ··· 0 b n · · · · · · b0
be Sylvester’s matrix. Then R(A, B) = det(S).

Proof. We follow [Coh93] and use Vandermonde determinants to show this proposition. Recall the fol-
lowing Vandermonde determinant identity:
 k−1
· · · xk−1

x 
 1 k 
 .. .. ..  =
Y
 . . .  (xi − xj )

 x0 · · · xk 0  i<j
1
Let  m+n−1
βnm+n−1 α1m+n−1 m+n−1

β1 ··· ··· αm
β m+n−2 · · · βnm+n−2 α1m+n−2 ··· m+n−2 
αm
 1
V =

.. .. .. .. 
 . ··· . . ··· . 
β10 ··· βn0 α10 ··· 0
αm
where we take the αi , βi to be (distinct) formal variables defined by A(αi ) = 0, B(βi ) = 0, and note that
Y Y Y
det(V ) = (βi − βj ) (αi − αj ) (βi − αj )
1≤i<j≤n 1≤i<j≤m 1≤i≤n
1≤j≤m

by the Vandermonde identity. Now consider

 n−1
βnn−1 A(βn )

β1 A(β1 ) ··· 0 ··· 0
 .. .. .. .. 
 0 .
 ··· . . ··· . 
βn0 A(βn )

 β1 A(β1 ) ··· 0 ··· 0 
SV =  m−1 m−1


 0 ··· 0 α1 B(α1 ) · · · αm B(αm ) 
 .. .. .. .. 
 . ··· . . ··· . 
0 ··· 0 α10 B(α1 ) ··· 0
αm B(αm )
Naturally, det(SV ) is equal to the product of the determinants of the upper-left block and the lower-right
block. Each of these blocks is a Vandermonde matrix where the columns have been scaled by A(βi ) or
B(αi ), so by applying the Vandermonde identity to each block, we have
Y Y
det(SV ) = A(β1 ) · · · A(βn )B(α1 ) · · · B(αm ) (βi − βj ) (αi − αj )
1≤i<j≤n 1≤i<j≤m
Y Y Y
= anm B(α1 ) · · · B(αm ) (βi − βj ) (αi − αj ) (βi − αj )
1≤i<j≤n 1≤i<j≤m 1≤i≤n
1≤j≤m

= anm B(α1 ) · · · B(αm ) det(V )

2
Recall that αi and βi are distinct formal variables so det(V ) 6= 0. Hence, det(S) = anm B(α1 ) · · · B(αm ),
and when we replace the formal variables αi and βi , with the actual roots of A and B, we get det(S) =
R(A, B).

This gives us a method for computing resultants explicitly as the determinant of Sylvester’s matrix.
When R = Z, another approach to computing the resultant of A(X) and B(X) would be Q to find the
n m
roots of both polynomials in C to high precision, and then explicitly calculate `(A) `(B) i,j (αi − βj ),
rounding the result to the nearest integer. This is quite costly however, and is hopeless when R is a more
complicated ring, for example when R = Q[Y ].
The following algorithm (from [Coh93]) allows us to compute the resultant R(A, B) very efficiently, while
only performing computations in R[X]:

Algorithm 2.3 (Sub-Resultant).

SUB-RESULTANT(A, B)
IF A = 0 or B = 0 THEN RETURN 0;
IF deg(A) < deg(B) THEN
swap(A, B);
s = (−1)deg(A)·deg(B) ;
END IF
a = cont(A);
b = cont(B);
A = A/a;
B = B/b;
t = adeg(B) · bdeg(A) ;
g = 1;
h = 1;
δ = deg(A) − deg(B);
WHILE deg(B) > 0 DO
R = `(B)δ+1 A (mod B); \\ i.e. R is such that `(B)δ+1 A = BQ + R
A = B;
B = R/(g · hδ );
g = `(A);
h = h1−δ · g δ ;
δ = deg(A) − deg(B);
s = (−1)deg(A)·deg(B) · s;
END WHILE
RETURN(s · t · h1−deg(A) · B deg(A) );
END SUB-RESULTANT

Most of the steps of this algorithm are very straightforward computationally, except perhaps the line
that reads “R = `(B)δ+1 A (mod B);”. The assignment in this line is accomplished by using a variant of
Euclidean division of polynomials known as “pseudo-division”, which is very fast in part because all the
intermediate computations remain in R[X]. The details of this calculation are discussed in [Knu81].
Next we will prepare to prove the correctness of the sub-resultant algorithm. Let Ai be the value of the
variable A at the beginning of the i-th iteration of the WHILE loop (i = 0, 1, 2, . . .), and let gi , hi , δi , si
be the values of g, h, δ, s respectively at the beginning of the i-th iteration of the WHILE loop. For

3
notational convenience, set `i = `(Ai ) and di = deg(Ai ). Following [Coh93], we will prove the validity of
Algorithm 2.3 by proving an inductive relationship between R(Ak , Ak+1 ) and R(Ak+1 , Ak+2 ). Applying
this relationship r + 1 times, where r is the index of the final iteration, we will see that the quantity that
1−d dr+1
is returned, namely sr+1 · t · hr+1r+1 · Ar+2 , is exactly equal to R(A, B).

Proof of correctness of Algorithm 2.3. Clearly, if either A0 = 0 or A1 = 0, then R(A0 , A1 ) = 0. All the
other lines in the algorithm that precede the WHILE loop serve to ensure that deg(A0 ) ≥ deg(A1 ), to
guarantee that A0 and A1 are primitive, i.e. their content is a unit, and to initialize g0 = h0 = 1, δ0 =
d0 −d1 . From the definition of the resultant, it is clear that R(aA0 , bA1 ) = ad1 bd0 R(A0 , A1 ) = tR(A0 , A1 ),
1−d dr+1
so we may assume that A0 and A1 are primitive and simply show that R(A0 , A1 ) = sr+1 · hr+1r+1 · Ar+2 .
By the definition of the resultant,
dk+1
Y
R(Ak , Ak+1 ) = (−1) dk dk+1
· `dk+1
k
· Ak (βi )
i=0

Rk+1 (βi )
where βi are the roots of Ak+1 . Since `δk+1
k +1
Ak = Qk+1 · Ak+1 + Rk+1 , Ak (βi ) = δ +1
k
, so this is equal
`k+1
to
dk+1 dk+1
Y Rk+1 (βi ) dk −dk+1 (δk +1)
Y
(−1) dk dk+1
· `dk+1
k
· = (−1) dk dk+1
· `k+1 · Rk+1 (βi )
i=0 `δk+1
k +1
i=0

d −dk+1 (δk +1) 1

= (−1)dk dk+1 · `k+1
k
· dk+2
R(Ak+1 , gk hδkk Ak+2 )
`k+1
Rk+1
since δ = Ak+2 . Again, from the definition of the resultant, it is easy to see that R(A, cB) =
gk hkk
cdeg(A) R(A, B), so the above is equal to
 dk+1
d −dk+1 (δk +1)−dk+2
(−1)dk dk+1 · `k+1
k
· gk hδkk R(Ak+1 , Ak+2 )

1−δ δ
For i > 0 we have `i = gi and hi = hi−1 i−1 · gi i−1 , allowing us to write this as
 dk+1
d −dk+1 (δk +1)−dk+2
R(Ak , Ak+1 ) = (−1)dk dk+1 · gk+1
k
· gk hδkk · R(Ak+1 , Ak+2 )
dk d δ dk+1
dk dk+1
gk+1 gk k+1 hkk
= (−1) · δ d d d
R(Ak+1 , Ak+2 )
k k+1 k+1 k+2
gk+1 gk+1 gk+1
d δ dk+1
gk k+1 hkk
= (−1)dk dk+1 δ (d −1) dk+2
R(Ak+1 , Ak+2 )
k k+1
gk+1 gk+1
dk+1 δk dk+1
gk hk
= (−1)dk dk+1  dk+1 −1 R(Ak+1 , Ak+2 )
hk+1 dk+2
1−δk gk+1
hk
d
gk k+1 hdkk −1
= (−1)dk dk+1 d d −1
R(Ak+1 , Ak+2 )
k+2 k+1
gk+1 hk+1

4
Recall that r is the index of the final iteration of the algorithm, so by applying the above relationship
between R(Ak , Ak+1 ) and R(Ak+1 , Ak+2 ) a total of r + 1 times, we have

Pr+1
di di+1 g0d1 hd00 −1 1−d d
R(A0 , A1 ) = (−1) i=0
dr+2 dr+1 −1
R(Ar+1 , Ar+2 ) = sr+1 hr+1r+1 Ar+2
r+1

gr+1 hr+1

r+1 d
since g0 = h0 = 1 and Ar+2 is a constant (so dr+2 = 0 and R(Ar+1 , Ar+2 ) = Ar+2 ). Hence, Algorithm
2.3 returns the correct value of R(A0 , A1 ) when A0 and A1 are primitive. We noted earlier that this is
sufficient to prove the correctness of the algorithm when A0 and A1 are not necessarily primitive, and so
the proof is complete.

Another remarkable fact about this algorithm, is that despite the numerous divisions in the line that
reads “B = R/(g · hδ );”, all constants remain in the ring R and all polynomials remain in R[X], (see
[Knu81]). Finally, it is interesting to note that by simply changing the line of Algorithm 2.3 that reads

RETURN(s · t · h1−deg(A) · B deg(A) );

to
RETURN(gcd(a, b)A/ cont(A));
we obtain an efficient algorithm for computing the greatest common divisor of two polynomials in R[X].
In fact, this is the algorithm which is studied in [Knu81], and the algorithm which is recommended for
computing the greatest common divisor of polynomials in [Coh93].

Applications of Resultants

Algorithm 2.3 is particularly powerful because it gives us an efficient way to implicitly manipulate the
roots of polynomials, while only performing computations in the ring R[X]. For instance, if we let
α, β be two algebraic numbers with minimal polynomials f (X), g(X) respectively, then the quantity
RY (f (X − Y ), g(Y )), (i.e. the resultant with respect to the variable Y , taking R = Q[X]), is equal to:

`(g)deg(f ) f (X − β1 )f (X − β2 ) · · · f (X − βn )

which has roots αi + βj where αi are the roots of f and βj are the roots of g. In particular, α + β is
a root of h(X) = RY (f (X − Y ), g(Y )), so if h(X) is irreducible, it is the minimal polynomial of α + β.
On the other hand, if h(X) is not irreducible, then one of its irreducible factors must be the minimal
polynomial of α + β, so we can factor h(X) as h1 (X) · · · hk (X) and evaluate each of hi (X) at a high-
precision numerical approximation of α + β to find the factor that has α + β as a root. (For this example,
we will assume that we have a procedure for factoring polynomials over Z[X], as this topic is far beyond
the scope of this paper. The subject of modern polynomial factoring methods is treated in [Coh93].)
√ √ √ √
For example, α = 2 + 3 and β = 5 + 6 are roots of f (X) = X 4 − 10X 2 + 1 and g(X) =
X 4 − 22X 2
√ +√ 1, respectively.
√ √ A priori, however, it is not apparent what the minimal polynomial of
α + β = 2 + 3 + 5 + 6 is. Nonetheless, we can compute the resultant h(X) = RY (f (X − Y ), g(Y ))
using, for instance, the GP/PARI command polresultant (see [BBB+ 00]):

?polresultant((X - Y)^4 - 10*(X - Y)^2 + 1, Y^4 - 22*Y^2 + 1, Y)

5
which returns

h(X) = X 16 − 128X 14 + 5712X 12 − 117248X 10 + 1169248X 8

−5289984X 6 + 8195328X 4 − 1990656X 2 + 20736
X 8 − 64X 6 + 96X 5 + 808X 4 − 1152X 3 − 2304X 2 + 1152X + 144


=
X 8 − 64X 6 − 96X 5 + 808X 4 + 1152X 3 − 2304X 2 − 1152X + 144

= h1 (X) · h2 (X)

Now we need to determine which of h1 (X) and h2 (X) actually has α + β as a root. α + β ≈ 7.83182209,
and h1 (7.83182209) = 4, 568, 619.29 . . ., whereas h2 (7.83182209) = −0.000689531 . . ., so the minimal
polynomial of α + β is

h2 (X) = X 8 − 64X 6 − 96X 5 + 808X 4 + 1152X 3 − 2304X 2 − 1152X + 144

Similarly, RY (f (X + Y ), g(Y )), RY (f (X/Y ), g(Y )), RY (f (XY ), g(Y )) will give polynomials with roots
α + β, αβ and α/β, respectively.
Another application of the sub-resultant algorithm is the Tschirnhausen transformation, which will play
an important role in section 4 when we examine the computation of Galois groups. The purpose of this
transformation is to take a monic irreducible polynomial P (X) ∈ Z[X] of degree n and return another
monic irreducible polynomial Q(X) of degree n with the same splitting field, and hence the same Galois
group. The algorithm is as follows:

Algorithm 2.4 (Random Tschirnhausen Transformation).

TSCHIRNHAUSEN(P (X))
Q = X 2;
WHILE gcd(Q, Q0 ) ∈/ Z DO
Choose A ∈ Z[X] randomly, with deg(A) = n − 1
(e.g. choose n coefficients at random from {−100, −99, . . . , 99, 100})
Q = RY (P (X), X − A(Y ));
END WHILE
RETURN Q
END TSCHIRNHAUSEN

In the following sections we will employ this transformation when the “resolvent” we are considering has
integer roots all of which have multiplicity greater than one. In this case, we hope that by applying a
Tschirnhausen transformation to the input polynomial we will obtain a new resolvent with either a simple
integer root or no integer roots at all. While we do not prove that the transformation will achieve this
in a reasonable amount of time (or that the transformation itself is an efficient computation), it is very
effective and runs very rapidly in practice. We will, nonetheless, prove the correctness of the algorithm.

Proof of correctness. Clearly, when the algorithm terminates, it returns a square-free polynomial Q(X) =
RY (P (X), X − A(Y )) for some A(X) ∈ Z[X]. By the definition of the resultant, Q(X) = (X −
A(α1 )) · · · (X − A(αn )), so the splitting field of Q(X), Spl(Q) = Q(A(α1 ), . . . , A(αn )), is contained
in the splitting field of P (X), Spl(P ) = Q(α1 , . . . , αn ). Every σ ∈ Gal(P ) acts by permuting the αi ,
and hence by permuting the A(αi ). Now we consider the action of Gal(P ) on the roots of Q(X). In
particular, every automorphism of Spl(P ) restricts to an automorphism of the splitting field of Spl(Q).

6
Since the A(αi ) are distinct by assumption, the restriction of each σ ∈ Gal(P ) to Spl(Q), is in fact
a distinct automorphism. In particular, |Aut(Spl(Q))| = [Spl(P ) : Q] ≥ [Spl(Q) : Q]. Since it is
true in general that |Aut(Spl(Q))| ≤ [Spl(Q) : Q], we have that |Aut(Spl(Q))| = [Spl(Q) : Q]. Be-
cause |Aut(Spl(Q))| = [Spl(P ) : Q] = [Spl(Q) : Q] and Spl(Q) ⊆ Spl(P ), we can conclude that
Spl(Q) = Spl(P ).

Finally, we will show how the sub-resultant algorithm can be used to efficiently compute the discriminant
of a polynomial A(X) ∈ R[X]. Recall that the discriminant of a polynomial A(X) of degree n with roots
α1 , . . . , αn , is defined as (assuming charR = 0)
Y
disc(P ) = `(A)2n−2 (αi − αj )2
1≤i<j≤n
   
n
= (−1)( ) `(A)n−2 `(A)
Y Y
2 (α1 − αi ) · · · `(A) (αn − αi )
i6=1 i6=n
n
= (−1)( ) `(A)n−2 A0 (α1 ) · · · A0 (αn )
2

n
= (−1)( 2 ) R(A, A0 )/`(A)

giving us an efficient way to compute the discriminant using the sub-resultant algorithm. Note that every
entry in the first column of Sylvester’s matrix (where B = A0 ) is divisible by `(A) (since the only entries
in the first column are zero and `(A) = `(A0 )), so R(A, A0 ) = det(S) is in fact divisible by `(A), which
proves that disc(A) ∈ R.

3 Resolvents

Definition 3.1. Given a polynomial F (X1 , . . . , Xn ) ∈ Z[X1 , . . . , Xn ], a subgroup G ⊆ Sn , and a polyno-

mial P (X) ∈ Z[X] with roots α1 , . . . , αn , let

H = StabG (F ) = {σ ∈ G|F (Xσ(1) , . . . , Xσ(n) ) = F (X1 , . . . , Xn )}

be the stabilizer of F in G. Then the resolvent ResG (F, P ) is defined by

Y

ResG (F, P )(X) = X − F (ασ(1) , . . . , ασ(n) )
σ∈G/H

where σ ranges over a set of |G/H|coset representatives of G/H.

The following result will play an important role in the determination of Galois groups.

Proposition 3.2. If Gal(P ) is conjugate (in G) to a subgroup of H = StabG (F ), then ResG (F, P ) has
a root in Z. Furthermore, if ResG (F, P ) has a simple root in Z then Gal(P ) is conjugate to a subgroup
of H = StabG (F ).

Proof. First, suppose Gal(P ) is conjugate to subgroup N ≤ H, i.e. Gal(P ) = σ −1 N σ for a fixed σ ∈ G.
Pick an arbitrary τ ∈ Gal(P ). τ = σ −1 νσ for some ν ∈ N . Let η ∈ H be such that σ −1 η ∈ G/H is the

7
representative of the coset σ −1 H. Then one of the roots of ResG (F, P ) is F (ασ−1 η(1) , . . . , ασ−1 η(n) ), by
definition. If we apply τ to this root, we have

τ F (ασ−1 η(1) , . . . , ασ−1 η(n) ) = σ −1 νσF (ασ−1 η(1) , . . . , ασ−1 η(n) )

= σ −1 νF (αη(1) , . . . , αη(n) )
= σ −1 F (ανη(1) , . . . , ανη(n) )
= σ −1 F (α1 , . . . , αn )

since both ν and η are in H = StabG (F ). Hence,

τ F (ασ−1 η(1) , . . . , ασ−1 η(n) ) = F (ασ−1 (1) , . . . , ασ−1 (n) )

which is exactly F (ασ−1 η(1) , . . . , ασ−1 η(n) ), since they only differ by η ∈ Stab(F ). In particular, the root
F (ασ−1 η(1) , . . . , ασ−1 η(n) ), is fixed by Gal(P ), so it must be in Q, and hence in Z since the αi are integral,
and thus so is F (ασ−1 η(1) , . . . , ασ−1 η(n) ).
On the other hand, if F (ασ−1 η(1) , . . . , ασ−1 η(n) ) ∈ Z is a simple root, it must be fixed by Gal(P ). Therefore,
we have that for any τ ∈ Gal(P ),

τ F (ασ−1 η(1) , . . . , ασ−1 η(n) ) = F (ασ−1 η(1) , . . . , ασ−1 η(n) )

and since η ∈ H = StabG (F ), this is equivalent to

τ F (ασ−1 (1) , . . . , ασ−1 (n) ) = F (ασ−1 (1) , . . . , ασ−1 (n) )

It is an easy exercise to verify that StabG (σ −1 F ) = σ −1 Stab(F )σ for any σ −1 ∈ G, and consequently that
ResG (σ −1 F, P ) = ResG (F, P ). Therefore, we can renumber the roots of P (X), by setting αi0 = ασ−1 (i) ,
to get
τ F (α10 , . . . , αn0 ) = F (α10 , . . . , αn0 )
where F (α10 , . . . , αn0 ) ∈ Z is a simple root of ResG (σ −1 F, P ) = ResG (F, P ). Therefore, τ ∈ StabG (σ −1 F ),
for if it were not then τ would belong to another coset of Stab(σ −1 F ), and hence τ F (α10 , . . . , αn0 ) would
be a different root (of ResG (σ −1 F, P ) = ResG (F, P )) from F (α10 , . . . , αn0 ). This cannot be the case since
we assumed that F (α10 , . . . , αn0 ) was a simple root. So τ ∈ StabG (σ −1 F ) = σ −1 StabG (F )σ = σ −1 Hσ.
Since the choice of τ was arbitrary, this suffices to show that Gal(P ) ⊆ σ −1 Hσ, i.e. Gal(P ) is a subgroup
of a conjugate of H.

To apply this result in practice, we compute numerical approximations to the roots of P (X) and then use
these to determine F (ασ(1) , . . . , ασ(n) ) numerically. Naturally, these approximations need to be accurate
enough to guarantee that we can correctly recognize when ResG (F, P ) has an integer root and recognize
that this root is in fact simple. In practice this is not usually very problematic (at least for small
degree polynomials with small coefficients). So from this point onward we will suppress the details of
the numerical approximations and assume that all numerical computations are carried out to sufficient
accuracy to ensure that no roundoff-related difficulties occur.
The following result is not difficult to prove directly, but in preparation for the next section, and to
demonstrate the applicability of Proposition 3.2, we will use resolvent polynomials.
Proposition 3.3. Given an irreducible polynomial p P (X) ∈ Z[X] of degree n, Gal(P ) is a subgroup of
An ⊆ Sn if and only if disc(P ) is a square, i.e. disc(P ) ∈ Z.

8
Proof. Let F (X1 , . . . , Xn ) = `(P )n−1 i6=j (Xi − Xj ) and let G = Sn . It is not hard to see H =
Q
StabG (F ) = An , and so
  
Y Y
ResG (F, P )(X) = X − `(P )n−1 (αi − αj ) X + `(P )n−1 (αi − αj ) = X 2 − disc(P )
i6=j i6=j

By assumption, P (X) is irreducible,

p and hence separable, so disc(P ) 6= 0. Therefore X 2 − disc(P ) has a
simple root in Z if and only if disc(P ) ∈
pZ, and in particular, by Proposition 3.2, Gal(P ) is a subgroup
of a conjugate of An ⊆ Sn if and only if disc(P ) ∈ Z. Since An is the only subgroup of index 2 in Sn ,
this proves the proposition.

4 Determining Gal(P )

In the previous section we had our first glance (Proposition 3.2) at how judiciously chosen resolvent
polynomials can be used to limit the possibilities for Gal(P ). In this section, we will consider some
more general algorithms that will determine Gal(P ) for irreducible monic polynomials P (X) ∈ Z[X] with
deg(P ) ≤ 5. Note that any irreducible polynomial in Z[X] can be transformed into a monic irreducible
polynomial with the same splitting field by computing
`(P )deg(P )−1 P (X/`(P )) = RY (P (Y ), X − `(P ))/`(P )
which is simply a Tschirnhausen transformation (so it has the same splitting field as P (X)) and it is
easy to check that its coefficients are in Z. Since there are only a finite number of possible Galois groups
Gal(P ), namely the transitive subgroups of Sdeg(P ) , we will actually give a separate algorithm for each
degree, which is tailored to distinguish between the possible Galois groups in each case. The subsequent
algorithms are adapted from those suggested in [Coh93].
For deg(P ) = 1 and deg(P ) = 2, there is only one transitive subgroup of Sn , namely S1 = C1 and S2 = C2
respectively. The first non-trivial case is when deg(P ) = 3.

deg(P) = 3

Since the only transitive subgroups of S3 are S3 and A3 , we only need Proposition 3.3 to determine
Gal(P ), i.e.
Algorithm 4.1 (Degree 3 Galois group).
3GALOIS(P)
p
IF disc(P ) ∈ Z THEN
RETURN A3
ELSE
RETURN S3
END 3GALOIS

deg(P) = 4

It is an exercise in group theory to show that the transitive subgroups of S4 are all isomorphic to either
C4 , V4 , D4 , A4 or S4 , and that any two isomorphic transitive subgroups are conjugate. Given this, we

9
can use the following inclusion lattice and Proposition 3.2 (together with Proposition 3.3) to determine
Gal(P ):

S4
A
A
A4 A
A A
A A
A D4 ={I, (12)(34), (13)(24), (14)(23), (1234), (1432), (24), (13)}
A A
A A
{I, (12)(34), (13)(24), (14)(23)} = V4 C4 ={I, (1234), (13)(24), (4321)}

The following algorithm determines the Galois group of a monic irreducible quartic polynomial P ∈ Z[X]:
Algorithm 4.2 (Degree 4 Galois group).
4GALOIS(P)
S4:
F1 (X1 , X2 , X3 , X4 ) = X1 X3 + X2 X4 ;
\\ Is Gal(P ) contained in a conjugate of D4 ? (Using S4 / StabS4 (F1 ) = {I, (12), (14)})
IF ResS4 (Fp 1 , P ) has no roots in Z THEN
IF disc(P ) ∈ Z THEN
RETURN A4 ;
ELSE
RETURN S4 ;
END IF
ELSE IF ResS4 (F1 , P ) has a simple root in Z THEN
GOTO D4;
ELSE
P = TSCHIRNHAUSEN(P );
GOTO S4;
END IF
D4:
\\ pNow ResS4 (F1 , P ) has a simple root in Z, so Gal(P ) is contained in a conjugate of D4 .
IF disc(P ) ∈ Z THEN RETURN V4 ;
σ = the element of {I, (12), (14)} corresponding to the simple root of ResSn (F1 , P );
\\ Renumber the roots of P so that α1 α3 + α2 α4 ∈ Z
Set αi = ασ(i) ;
F2 (X1 , X2 , X3 , X4 ) = X1 X22 + X2 X32 + X3 X42 + X4 X12 ;
\\ Is Gal(P ) contained in a conjugate of C4 ? (Using D4 / StabD4 (F2 ) = {I, (13)})
IF ResD4 (F2 , P ) has no root in Z THEN
RETURN D4 ;
ELSE IF ResD4 (F2 , P ) has a simple root in Z THEN
RETURN C4 ;
ELSE
P = TSCHIRNHAUSEN(P );
GOTO D4;
END IF
END 4GALOIS

10
At the point in the algorithm where we encounter the line that reads “Set αi = ασ(i) ;”, we know that
Gal(P ) is a subgroup of a conjugate of D4 . However, we need to ensure that we are working inside the
appropriate conjugate of D4 . That is, in order to apply Proposition 3.2 with G = D4 , we need the explicit
action of Gal(P ) on the roots of the resolvent. By reordering the roots, we ensure that we have the correct
conjugate of D4 for the choice of resolvent F2 and corresponding coset representatives. Bearing this in
mind, and noting that Stab(F1 ) = D4 and Stab(F2 ) = C4 , the correctness of this algorithm follows from
Proposition 3.2.

deg(P) = 5

Again, it is an exercise in group theory to show that the transitive subgroups of S5 are isomorphic
to S5 , A5 , M20 , D5 , C5 (where M20 is the “meta-cyclic” group h(12345), (2354)i, and that isomorphic
transitive groups are conjugate.

S5
A
A
A5 A
A A
A A
A M20 = h(12345), (2354)i
A
A
D5 = h(12345), (25)(34)i

C5 = h(12345)i

The following algorithm determines the Galois group of a monic irreducible quintic polynomial P ∈ Z[X]:

Algorithm 4.3 (Degree 5 Galois group).

5GALOIS(P)
S5:
;
F1 (X1 , X2 , X3 , X4 , X5 ) = X12 (X2 X5 + X3 X4 ) + X22 (X1 X3 + X4 X5 ) + X32 (X1 X5 + X2 X4 ) + X42 (X1 X2 + X3 X5 ) + X52 (X1 X4 + X2 X3 )

\\ Is Gal(P ) contained in a conjugate of M20 ? (Using S5 / StabS5 (F1 ) = {I, (12), (13), (14), (15), (25)})
IF ResS5 (Fp
1 , P ) has no roots in Z THEN
IF disc(P ) ∈ Z THEN
RETURN A5 ;
ELSE
RETURN S5 ;
END IF
ELSE IF ResS5 (F1 , P ) has a simple root in Z THEN
GOTO M20;
ELSE
P = TSCHIRNHAUSEN(P );
GOTO S5;
END IF
M20:
\\ p
Now ResS5 (F1 , P ) has a simple root in Z, so Gal(P ) is contained in a conjugate of M20 .
IF disc(P ) ∈
/ Z THEN RETURN M20 ;

11
 σ = the element of {I, (12), (13), (14), (15), (25)} corresponding to the simple root of ResS5 (F1 , P );
\\ Renumber the roots of P so that F1 (α1 , α2 , α3 , α4 , α5 ) ∈ Z
Set αi = ασ(i) ;
F2 (X1 , X2 , X3 , X4 , X5 ) = X1 X22 + X2 X32 + X3 X42 + X4 X52 + X5 X12 ;
\\ Is Gal(P ) contained in a conjugate of C5 ? (Using D5 / StabD5 (F2 ) = {I, (12)(35)})
IF ResD5 (F2 , P ) has no root in Z THEN
RETURN D5 ;
ELSE IF ResD5 (F2 , P ) has a simple root in Z THEN
RETURN C5 ;
ELSE
P = TSCHIRNHAUSEN(P );
GOTO M20;
END IF
END 5GALOIS

Just as with the algorithm for polynomials of degree 4, the correctness of this algorithm follows from
Proposition 3.2.
These algorithms demonstrate how we can use resolvent polynomials to navigate through the lattice
of possible Galois groups and ultimately determine Gal(P ). Unfortunately, the complexity of such an
algorithm grows with the complexity of the inclusion lattice of possible Galois groups. Algorithms for
degree 6 and degree 7 polynomials are given in [Coh93], and publicly available packages such a GP/PARI
([BBB+ 00]) are capable of determining Galois groups of irreducible polynomials up to degree 11.
In [SM85], the authors discuss a similar technique for determining Galois groups over Q using linear
resolvent polynomials. However, the “resolvent method” is by no means the only way to compute the
Galois groups of rational polynomials. Various techniques for computing Galois groups, including the
method presented here, are surveyed in [Hul].

5 Conclusion

We have seen how resolvent polynomials and resultant polynomials are not only theoretically useful
tools, but also how they lend themselves to efficient computation. This is fortunate since we can use
resultants to perform exact computations on (irrational) algebraic numbers, or to find discriminants.
Such computations proved essential in section 4 where we considered the problem of determining Gal(P )
algorithmically, and are basic to the study of computational algebraic number theory. As far as further
reading is concerned, [Coh93] builds upon the machinery developed here, and Knuth’s The Art of Com-
puter Programming(particularly volumes 1 and 2, [Knu73], [Knu81]) is an excellent reference for many of
the underlying algorithms which were not covered in detail here.

12
References

[BBB+ 00] C. Batut, K. Belabas, D. Benardi, H. Cohen, and M. Olivier. User’s Guide to PARI-
GP. by anonymous ftp from ftp://megrez.math.u-bordeaux.fr/pub/pari, 2000. see
http://pari.home.ml.org.

[Coh93] Henri Cohen. A Course in Computational Algebraic Number Theory. Springer, 1993.

[Hul] Alexander Hulpke. Techniques for the computation of galois groups. Available for download
at http://citeseer.nj.nec.com/465712.html.

[Knu73] D. E. Knuth. The Art of Computer Programming, Vol. 1: Fundamental Algorithms, Second
Edition. Addison-Wesley, 1973.

[Knu81] D. E. Knuth. The Art of Computer Programming, Vol. 2: Seminumerical Algorithms, Second
Edition. Addison-Wesley, 1981.

[SM85] L. Soicher and J. McKay. Computing galois groups over the rationals. J. Number Theory,
20:273–281, 1985.

13