Chapter 15

Factoring and Discrete

Logarithms in Subexponential
Time

This is a chapter from version 2.0 of the book “Mathematics of Public Key Cryptography”
by Steven Galbraith, available from http://www.math.auckland.ac.nz/˜sgal018/crypto-
book/crypto-book.html The copyright for this chapter is held by Steven Galbraith.
This book was published by Cambridge University Press in early 2012. This is the
extended and corrected version. Some of the Theorem/Lemma/Exercise numbers may be
different in the published version.
Please send an email to [email protected] if you find any mistakes.

One of the most powerful tools in mathematics is linear algebra, and much of mathe-
matics is devoted to solving problems by reducing them to it. It is therefore natural to try
to solve the integer factorisation and discrete logarithm problems (DLP) in this way. This
chapter briefly describes a class of algorithms that exploit a notion called “smoothness”,
to reduce factoring or DLP to linear algebra. We present such algorithms for integer
factorisation, the DLP in the multiplicative group of a finite field, and the DLP in the
divisor class group of a curve.
It is beyond the scope of this book to give all the details of these algorithms. In-
stead, the aim is to sketch the basic ideas. We mainly present algorithms with nice
theoretical properties (though often still requiring heuristic assumptions) rather than the
algorithms with the best practical performance. We refer to Crandall and Pomerance
[162], Shoup [556] and Joux [317] for further reading.
The chapter is arranged as follows. First we present results on smooth integers, and
then sketch Dixon’s random squares factoring algorithm. Section 15.2.3 then summarises
the important features of all algorithms of this type. We then briefly describe a number
of algorithms for the discrete logarithm problem in various groups.

15.1 Smooth Integers

Recall from Definition 12.3.1 that an integer is B-smooth if all its prime divisors are at
most B. We briefly recall some results on smooth integers; see Granville [267] for a survey
of this subject and for further references.

323
324 CHAPTER 15. SUBEXPONENTIAL ALGORITHMS

Definition 15.1.1. Let X, Y ∈ N be such that 2 ≤ Y < X. Define

Ψ(X, Y ) = #{n ∈ N : 1 ≤ n ≤ X, n is Y -smooth}.

It is important for this chapter to have good bounds on Ψ(X, Y ). Let u = log(X)/ log(Y )
(as usual log denotes the natural logarithm), so that u > 1, Y = X 1/u and X = Y u .
There is a function ρ : R>0 → R>0 called the Dickman-de Bruijn function (for the
exact definition of this function see Section 1.4.5 of [162]) such that, for fixed u > 1,
Ψ(X, X 1/u ) ∼ Xρ(u), where f (X) ∼ g(X) means limX→∞ f (X)/g(X) = 1. A crude es-
timate for ρ(u), as u → ∞ is ρ(u) ≈ 1/uu . For further details and references see Section
1.4.5 of [162].
The following result of Canfield, Erdös and Pomerance [117] is the main tool in this
subject. This is a consequence of Theorem 3.1 (and the corollary on page 15) of [117].

Theorem 15.1.2. Let N ∈ N. Let ǫ, u ∈ R be such that ǫ > 0 and 3 ≤ u ≤ (1 −

ǫ) log(N )/ log(log(N )). Then there is a constant cǫ (that does not depend on u) such that

Ψ(N, N 1/u ) = N exp(−u(log(u) + log(log(u)) − 1 + (log(log(u)) − 1)/ log(u) + E(N, u)))

(15.1)
where |E(N, u)| ≤ cǫ (log(log(u))/ log(u))2 .

Corollary 15.1.3. Let the notation be as in Theorem 15.1.2. Then Ψ(N, N 1/u ) =
N u−u+o(u) = N u−u(1+o(1)) uniformly as u → ∞ and u ≤ (1 − ǫ) log(N )/ log(log(N ))
(and hence also N → ∞).

Exercise 15.1.4. Prove Corollary 15.1.3.

[Hint: Show that the expression inside the exp in equation (15.1) is of the form −u log(u)+
o(u) log(u).]

We will use the following notation throughout the book.

Definition 15.1.5. Let 0 ≤ a ≤ 1 and c ∈ R>0 . The subexponential function for the
parameters a and c is

LN (a, c) = exp(c log(N )a log(log(N ))1−a ).

Note that taking a = 0 gives LN (0, c) = log(N )c (polynomial) while taking a = 1 gives
LN (1, c) = N c (exponential). Hence LN (a, c) interpolates exponential and polynomial
growth. A complexity O(LN (a, c)) with 0 < a < 1 is called subexponential.

Lemma 15.1.6. Let 0 < a < 1 and 0 < c.

1. LN (a, c)m = LN (a, mc) for m ∈ R>0 .

2. Let 0 < a1 , a2 < 1 and 0 < c1 , c2 . Then, where the term o(1) is as N → ∞,

 LN (a1 , c1 + o(1)) if a1 > a2 ,
LN (a1 , c1 ) · LN (a2 , c2 ) = LN (a1 , c1 + c2 ) if a1 = a2 ,

LN (a2 , c2 + o(1)) if a2 > a1 .

3.

 O(LN (a1 , c1 )) if a1 > a2 ,
LN (a1 , c1 ) + LN (a2 , c2 ) = O(LN (a1 , max{c1 , c2 } + o(1))) if a1 = a2 ,

O(LN (a2 , c2 )) if a2 > a1 .
15.2. FACTORING USING RANDOM SQUARES 325

4. Let 0 < b < 1 and 0 < d. If M = LN (a, c) then LM (b, d) = LN (ab, dcb a1−b + o(1))
as N → ∞.
5. log(N )m = O(LN (a, c)) for any m ∈ N.
6. LN (a, c) log(N )m = O(LN (a, c + o(1))) as N → ∞ for any m ∈ N. Hence, one can
always replace Õ(LN (a, c)) by O(LN (a, c + o(1))).
7. log(N )m ≤ LN (a, o(1)) as N → ∞ for any m ∈ N.
8. If F (N ) = O(LN (a, c)) then F (N ) = LN (a, c + o(1)) as N → ∞.
√
9. LN (1/2, c) = N c log(log(N ))/ log(N ) .
Exercise 15.1.7. Prove Lemma 15.1.6.
Corollary 15.1.8. Let c > 0. As N → ∞, the probability that a randomly chosen integer
1 ≤ x ≤ N is LN (1/2, c)-smooth is LN (1/2, −1/(2c) + o(1)).
Exercise 15.1.9. Prove Corollary 15.1.8 (using Corollary 15.1.3).
Exercise 15.1.10. Let 0 < b < a < 1. Let 1 ≤ x ≤ LN (a, c) be a randomly chosen
integer. Show that the probability that x is LN (b, d)-smooth is LN (a−b, −c(a−b)/d+o(1))
as N → ∞.

15.2 Factoring using Random Squares

The goal of this section is to present a simple version of Dixon’s random squares factoring
algorithm. This algorithm is easy to describe and analyse, and already displays many of
the important features of the algorithms in this chapter. Note that the algorithm is not
used in practice. We give a complexity analysis and sketch how subexponential running
times naturally arise. Further details about this algorithm can be found in Section 16.3
of Shoup [556] and Section 19.5 of von zur Gathen and Gerhard [238].
Let N ∈ N be an integer to be factored. We assume in this section that N is odd,
composite and not a perfect power. As in Chapter 12 we focus on splitting N into a
product of two smaller numbers (neither of which is necessarily prime). The key idea is
that if one can find congruent squares
x2 ≡ y 2 (mod N )
such that x 6≡ ±y (mod N ) then one can split N by computing gcd(x − y, N ).
Exercise 15.2.1. Let N be an odd composite integer and m be the number of distinct
primes dividing N . Show that the equation x2 ≡ 1 (mod N ) has 2m solutions modulo N .
A general way to find congruent squares is the following.1 Select a factor base
B = {p1 , . . . , ps } consisting of the primes ≤ B for some B ∈ N. Choose uniformly at
random an integer 1 ≤ x < N , compute a = x2 (mod N ) reduced to the range 1 ≤ a < N
and try to factor a as a product in B (e.g., using trial division).2 If a is B-smooth then
this succeeds, in which case we have a relation
s
Y
x2 ≡ pei i (mod N ). (15.2)
i=1
1 This idea goes back to Kraitchik in the 1920s; see [489] for some history. √
2 To
√
obtain non-trivial relations one should restrict to integers in the range N < x < N − N . But
it turns out to be simpler to analyse the algorithm for the case
√ 1 ≤ x < N . Note that the probability
that a randomly chosen integer 1 ≤ x < N satisfies 1 ≤ x < N is negligible.
326 CHAPTER 15. SUBEXPONENTIAL ALGORITHMS

The values x for which a relation is found are stored as x1 , x2 , . . . , xt . The corresponding
exponent vectors ej = (ej,1 , . . . , ej,s ) for 1 ≤ j ≤ t are also stored. When enough relations
have been found we can use linear algebra modulo 2 to obtain congruent squares. More
precisely, compute λj ∈ {0, 1} such that not all λj = 0 and
t
X
λj ej ≡ (0, 0, . . . , 0) (mod 2).
j=1

Equivalently, this is an integer linear combination

t
X
λj ej = (2f1 , . . . , 2fs ) (15.3)
j=1

with not all the fi equal to zero. Let

t
Y s
Y
λ
X≡ xj j (mod N ) , Y ≡ pfi i (mod N ). (15.4)
j=1 i=1

One then has X 2 ≡ Y 2 (mod N ) and one can hope to split N by computing gcd(X −Y, N )
(note that this gcd could be 1 or N , in which case the algorithm has failed). We present
the above method as Algorithm 22.

Algorithm 22 Random squares factoring algorithm

Input: N ∈ N
Output: Factor of N
1: Select a suitable B ∈ N and construct the factor base B = {p1 , . . . , ps } consisting of
all primes ≤ B
2: repeat
3: Choose an integer 1 ≤ x < N uniformly at random and compute a = x2 (mod N )
reduced to the range 1 ≤ a < N
4: Try to factor a as a product in B (e.g., using trial division)
5: if a is B-smooth then
6: store the value x and the exponent row vector e = (e1 , . . . , es ) as in equa-
tion (15.2) in a matrix
7: end if
8: until there are s + 1 rows in the matrix
9: Perform linear algebra over F2 to find a non-trivial linear dependence among the
vectors ej modulo 2
10: Define X and Y as in equation (15.4)
11: return gcd(X − Y, N )

We emphasise that the random squares algorithm has two distinct stages. The first
stage is to generate enough relations. The second stage is to perform linear algebra.
The first stage can easily be distributed or parallelised, while the second stage is hard to
parallelise.
Example 15.2.2. Let N = 19 · 29 = 551 and let B = {2, 3, 5}. One finds the following
congruences (in general 4 relations would be required, but we are lucky in this case)
342 ≡ 2 · 33 (mod N )
522 ≡ 22 · 53 (mod N )
552 ≡ 2 · 33 · 5 (mod N ).
15.2. FACTORING USING RANDOM SQUARES 327

These relations are stored as the matrix

 
1 3 0
 2 0 3 .
1 3 1
The sum of the three rows is the vector
(4, 6, 4) .
Let
X = 264 ≡ 34 · 52 · 55 (mod 551) and Y = 496 ≡ 22 · 33 · 52 (mod 551).
It follows that
X 2 ≡ Y 2 (mod N )
and gcd(X − Y, N ) = 29 splits N .
Exercise 15.2.3. Factor N = 3869 using the above method and factor base {2, 3, 5, 7}.

15.2.1 Complexity of the Random Squares Algorithm

There are a number of issues to deal with when analysing this algorithm. The main
problem is to decide how many primes to include in the factor base. The prime number
theorem implies that s = #B ≈ B/ log(B). If we make B larger then the chances of
finding a B-smooth number increase, but on the other hand, we need more relations and
the linear algebra takes longer. We will determine an optimal value for B later. First we
must write down an estimate for the running time of the algorithm, as a function of s.
Already this leads to various issues:
• What is the probability that a random value x2 (mod N ) factors over the factor
base B?
• How many relations do we require until we can be sure there is a non-trivial vector
e?
• What are the chances that computing gcd(X − Y, N ) splits N ?
We deal with the latter two points first. It is immediate that s+1 relations are sufficient
for line 9 of Algorithm 22 to succeed. The question is whether 1 < gcd(X − Y, N ) < N
for the corresponding integers X and Y . There are several ways the algorithm can fail to
split N . For example, it is possible that a relation in equation (15.2) is such that all ei
Q ei /2
√ x ≡ ± i√pi
are even and (mod N ). One way that such relations could arise is from
1 ≤√ x < N or N −√ N < x < N ; this situation occurs with negligible √ probability.
If N < x < N − N and a = Y 2 is a square in N then 1 ≤ Y < N and so
x 6≡ ±Y (mod N ) and the relation is useful. The following result shows that all these
(and other) bad cases occur with probability at most 1/2.
1
Lemma 15.2.4. The probability to split N using X and Y is at least 2.
Proof: Let X and Y be the integers computed in line 10 of Algorithm 22. We treat Y
as fixed, and consider the probability distribution for X. By Exercise 15.2.1, the number
of solutions Z to Z 2 ≡ Y 2 (mod N ) is 2m where m ≥ 2 is the number of distinct primes
dividing N . The two solutions Z = ±Y are useless but the other 2m − 2 solutions will all
split N .
Since the values for x are chosen uniformly at random it follows that X is a randomly
chosen solution to the equation X 2 ≡ Y 2 (mod N ). It follows that the probability to split
N is (2m − 2)/2m ≥ 1/2. 
328 CHAPTER 15. SUBEXPONENTIAL ALGORITHMS

Exercise 15.2.5. Show that if one takes s + l relations where l ≥ 2 then the probability
of splitting N is at least 1 − 1/2l .

We now consider the probability of smoothness. We first assume the probability that
x2 (mod N ) is smooth is the same as the probability that a random integer modulo N is
smooth.3

Lemma 15.2.6. Let the notation be as above. Let TB be the expected number of trials
until a randomly chosen integer modulo N is B-smooth. Assuming that squares modulo N
are as likely to be smooth as random integers of the same size, Algorithm 22 has expected
running time at most
c1 #B 2 TB M (log(N )) + c2 (#B)3
bit operations for some constants c1 , c2 (where M (n) is the cost of multiplying two n-bit
integers).

Proof: Suppose we compute the factorisation of x2 (mod N ) over B by trial division.

This requires O(#BM (log(N ))) bit operations for each value of x. We need (#B + 1)
relations to have a soluble linear algebra problem. As said above, the expected number
of trials of x to get a B-smooth value of x2 (mod N ) is TB . Hence the cost of finding the
relations is O((#B + 1)TB (#B)M (log(N ))), which gives the first term.
The linear algebra problem can be solved using Gaussian elimination (we are ignoring
that the matrix is sparse) over F2 , which takes O((#B)3 ) bit operations. This gives the
second term. 
It remains to choose B as a function of N to minimise the running time. By the dis-
cussion in Section 15.1, it is natural to approximate TB by uu where u = log(N )/ log(B).
We now explain how subexponential functions naturally arise in such algorithms. Since
increasing B makes the linear algebra slower, but makes relations more likely (i.e., lowers
TB ), a natural approach to selecting B is to try to equate both terms of the running time
in Lemma 15.2.6. This leads to uu = #B. Putting u = log(N )/ log(B), #B = B/ log(B),
taking logs, and ignoring log(log(B)) terms, gives

log(N ) log(log(N ))/ log(B) ≈ log(B).

This implies log(B)2 ≈ log(N ) log(log(N )) and so B ≈ LN (1/2, 1). The overall complex-
ity for this choice of B would be LN (1/2, 3 + o(1)) bit operations.
A more careful argument is to set B = LN (1/2, c) and use Corollary 15.1.3. It fol-
lows that TB = LN (1/2, 1/(2c) + o(1)) as N → ∞. Putting this into the equation of
Lemma 15.2.6 gives complexity LN (1/2, 2c + 1/(2c) + o(1)) + LN (1/2, 3c) bit operations.
The function x + 1/x is minimised at x = 1, hence we should take c = 1/2.

Theorem 15.2.7. Let the notation be as above. Under the same assumptions as Lemma 15.2.6
then Algorithm 22 has complexity

LN (1/2, 2 + o(1))

bit operations as N → ∞.
3 Section 16.3 of Shoup [556] gives a modification of the random squares algorithm for which one can

avoid this assumption. The trick is to note that at least one of the cosets of (Z/N Z)∗ /((Z/N Z)∗ )2 has
at least as great a proportion of smooth numbers as random integers up to N (Shoup credits Rackoff
for this trick). The idea is to work in one of these cosets by choosing at random some 1 < δ < N and
considering relations coming from smooth values of δx2 (mod N ).
15.2. FACTORING USING RANDOM SQUARES 329

Proof: Put B = LN (1/2, 1/2) into Lemma 15.2.6. 

We remark that, unlike the Pollard rho or Pollard p − 1 methods, this factoring
algorithm has essentially no dependence on the factors of N . In other words, its running
time is essentially the same for all integers of a given size. This makes it particularly
suitable for factoring N = pq where p and q are primes of the same size.

15.2.2 The Quadratic Sieve

To improve the result of the previous section it is necessary to reduce the cost of the
linear algebra and to reduce the cost of decomposing smooth elements as products of
primes. We sketch the quadratic sieve algorithm of Pomerance. We do not have space
to present all the details of this algorithm (interested readers should see Section 6.1 of
[162] or Section 16.4.2 of [556]).
A crucial idea, which seems to have first appeared in the work of Schroeppel4 , is
sieving. The point is to consider a range of values of x and simultaneously determine
the decompositions of x2 (mod N ) over the factor base. It is possible to do this so that
the cost of each individual decomposition is only O(log(B)) bit operations.
Another crucial observation is that the relation matrix is sparse, in other words, rows
of the matrix have rather few non-zero entries. In such a case, the cost of linear algebra can
be reduced from O((#B)3 ) bit operations to O((#B)2+o(1) ) bit operations (as #B → ∞).
The best methods are due to Lanczos or Wiedemann; see Section 6.1.3 of Crandall and
Pomerance [162] or Section 3.4 of Joux √ [317] for references and discussion.
A further√trick is to choose x = ⌊ N ⌋ + i where i = 0, 1, −1, 2, −2, . . . . The √ idea is
that if x = N + ǫ then either x2 − N or N − x2 is a positive integer of size 2 N |ǫ|.
Since these integers are much smaller than N they have a much better chance of being
smooth than the integers x2 (mod N ) in the random squares algorithm. To allow for the
case of ǫ <Q0 we need to add −1 to our factor base andQ use the fact that a factorisation
s s
N − x2 = i=1 pei i corresponds to a relation x2 ≡ (−1) i=1 ei
√ pi (mod N ).
Since we are now only considering values x of the form N + ǫ where |ǫ| is small it is
necessary to assume the probability that x2 − N or N − x2 (as appropriate) is B-smooth
is that same as the probability that a randomly chosen integer of that size is B-smooth.
This is a rather strong assumption (though it is supported by numerical evidence) and so
the running time estimates of the quadratic sieve are only heuristic.
The heuristic complexity of the quadratic sieve is determined in Exercise 15.2.8. Note
that, since we will need to test LN (1/2, 1 + o(1)) values (here o(1) is as N → ∞) for
smoothness, we have |ǫ|√ = LN (1/2, 1 + o(1)). It follows that the integers being tested for
smoothness have size N LN (1/2, 1 + o(1)) = N 1/2+o(1) .
Exercise
√ 15.2.8. ⋆ Let TB be the expected number of trials until an integer of size
2 N LN (1/2, 1) is B-smooth. Show that the running time of the quadratic sieve is at
most
c1 #BTB log(B)M (log(N )) + c2 #B 2+o(1)
bit operations for some constants c1 , c2 as N → ∞.
Let B = LN (1/2, 1/2). Show that the natural heuristic assumption (based on Corol-
lary 15.1.8) is that TB = LN (1/2, 1/2 + o(1)). Hence, show that the heuristic complexity
of the quadratic sieve is LN (1/2, 1 + o(1)) bit operations as N → ∞.
√
Example 15.2.9. Let N = 2041 so that ⌊ N ⌋ = 45.
Let B = {−1, 2, 3, 5}. Taking x = 43, 44, 45, 46 one finds the following factorisations
of x2 − N :
4 See [371, 489] for some remarks on the history of integer factoring algorithms.
330 CHAPTER 15. SUBEXPONENTIAL ALGORITHMS

x x2 (mod N ) e
43 −26 · 3 (1, 6, 1, 0 )
44 Not 5-smooth
45 −24 ( 1, 4, 0, 0 )
46 3 · 52 ( 0, 0, 1, 2 )

Taking e = e1 + e2 + e3 = (2, 10, 2, 2) gives all coefficients even. Putting everything

together, we set X = 43 · 45 · 46 ≡ 1247 (mod N ) and Y = −1 · 25 · 3 · 5 ≡ 1561 (mod N ).
One can check that X 2 ≡ Y 2 (mod N ) and that gcd(X − Y, N ) = 157.
√
Exercise 15.2.10. Show that in the quadratic sieve one can also use values x = ⌊ kN ⌋+i
where k ∈ N is very small and i = 0, 1, −1, 2, −2, . . . .
Exercise 15.2.11. Show that using sieving and fast linear algebra, but not restricting to
values ±x2 (mod√N ) of size N 1/2+o(1) gives an algorithm with heuristic expected running
time of LN (1/2, 2 + o(1)) bit operations as N → ∞.
Exercise 15.2.12. A subexponential algorithm is asymptotically much faster than a
Õ(N 1/4 ) algorithm. Verify that if N = 21024 then N 1/4 = 2256 while LN (1/2, 2) ≈ 2197
and LN (1/2, 1) ≈ 298.5 .
The best proven asymptotic complexity for factoring integers N is LN (1/2, 1 + o(1))
bit operations. This result is due to Pomerance and Lenstra [381].

15.2.3 Summary
We briefly highlight the key ideas in the algorithms of this section. The crucial concept
of smooth elements of the group (Z/N Z)∗ arises from considering an integer modulo N
as an element of Z. The three essential properties of smooth numbers that were used in
the algorithm are:
1. One can efficiently decompose an element of the group as a product of smooth
elements, or determine that the element is not smooth.
2. The probability that a random element is smooth is sufficiently high.
3. There is a way to apply linear algebra to the relations obtained from smooth ele-
ments to solve the computational problem.
We will see analogues of these properties in the algorithms below.
There are other general techniques that can be applied in most algorithms of this
type. For example, the linear algebra problems are usually sparse and so the matrices
and algorithms should be customised for this. Another general concept is “large prime
variation” which, in a nutshell, is to also store “nearly smooth” relations (i.e., elements
that are the product of a smooth element with one or two prime elements that are not
too large) and perform some elimination of these “large primes” before doing the main
linear algebra stage (this is similar to, but more efficient than, taking a larger factor base).
Finally we remark that the first stage of these algorithms (i.e., collecting relations) can
always be distributed or parallelised.

15.3 Elliptic Curve Method Revisited

We assume throughout this section that N ∈ N is an integer to be factored and that N
is odd, composite, and not a perfect power. We denote by p the smallest prime factor of
N.
15.3. ELLIPTIC CURVE METHOD REVISITED 331

The elliptic curve method (ECM) works well in practice but, as with the Pollard
p − 1 method, its complexity depends on the size of the smallest prime dividing N .
It is not a polynomial-time algorithm because, for any constant c > 0 and over all N
and p | N , a randomly chosen elliptic curve over Fp is not likely to have O(log(N )c )-
smooth order. As we have seen, the theorem of Canfield, Erdös and Pomerance [117] says
it is more reasonable to hope that integers have a subexponential probability of being
subexponentially smooth. Hence, one might hope that the elliptic curve method has
subexponential complexity. Indeed, Lenstra [377] makes the following conjecture (which
is essentially that the Canfield-Erdös-Pomerance result holds in small intervals).
Conjecture 15.3.1. (Lenstra [377], page 670) √ The probability
√ that an integer, cho-
sen uniformly at random in the range (X − X, X + X), is LX (1/2, c)-smooth is
LX (1/2, −1/(2c) + o(1)) as X tends to infinity.5
One can phrase Conjecture 15.3.1 as saying that, if√ps is the probability that
√ a random
integer between 1 and X is Y -smooth, then Ψ(X + 2 X, Y ) − Ψ(X, Y ) ≈ 2 Xps . More
generally, one would like to know that, for sufficiently large6 X, Y and Z,

Ψ(X + Z, Y ) − Ψ(X, Y ) ∼ ZΨ(X, Y )/X (15.5)

or, in other words, that integers in a short interval at X are about as likely to be Y -smooth
as integers in a large interval at X.
We now briefly summarise some results in this area; see Granville [267] for details and
references. Harman (improved by Lenstra, Pila and Pomerance [380]) showed, for any
fixed β > 1/2 and X ≥ Y ≥ exp(log(X)2/3+o(1) ), where the o(1) is as X → ∞, that

Ψ(X + X β , Y ) − Ψ(X, Y ) > 0.

Obtaining√ results for the required value β = 1/2 seems to be hard and the experts refer
to the “ X barrier” for smooth integers in short intervals. It is known that this barrier
can be broken most of the time: Hildebrand and Tenenbaum showed that, for any ǫ > 0,
equation (15.5) holds when X ≥ Y ≥ exp(log(X)5/6+ǫ ) and Y exp(log(X)1/6 ) ≤ Z ≤ X
for all but at most M/ exp(log(M )1/6−ǫ ) integers 1 ≤ X ≤ M . As a special case, this
√ √
result shows that, for almost all primes p, the interval [p− p, p+ p] contains a Y -smooth
integer where Y = exp(log(X)5/6+ǫ ) (i.e., subexponential smoothness).
Using Conjecture 15.3.1 one obtains the following complexity for the elliptic curve
method (we stress that the complexity is in terms of the smallest prime factor p of N ,
rather than N itself).
Theorem 15.3.2. (Conjecture 2.10 of [377]) Assume √ Conjecture 15.3.1. One can find
the smallest factor p of an integer N in Lp (1/2, 2 + o(1))M (log(N )) bit operations as
p → ∞.
√
Proof: Guess the size of p and choose B = Lp (1/2, 1/ 2) (since the size of p is not known
one actually runs the algorithm repeatedly for slowly increasing values
√ of B). Then each
run of Algorithm 12 requires O(B log(B)M (log(N ))) = Lp (1/2, 1/ 2 + o(1))M √(log(N ))
bit operations. By Conjecture 15.3.1 one needs to repeat the process Lp (1/2, 1/ 2+ o(1))
times. The result follows. 
5 Lenstra
√ √ √ √
considers the sub-interval (X − X, X + X) of the Hasse interval [X +1−2 X, X +1+2 X]
because the distribution of isomorphism classes of randomly chosen elliptic curves is relatively close to
uniform when restricted to those whose group order lies in this sub-interval. In contrast, elliptic curves
whose group orders are near the edge of the Hasse interval arise with lower probability.
6 The notation ∼ means taking a limit as X → ∞, so it is necessary that Y and Z grow in a controlled

way as X does.
332 CHAPTER 15. SUBEXPONENTIAL ALGORITHMS
√
Exercise√ 15.3.3. Let N = pq where p is prime and p < N < 2p. Show that
Lp (1/2, 2 + o(1)) = LN (1/2, 1 + o(1)). Hence, in the worst case, the complexity of
ECM is the same as the complexity of the quadratic sieve.

For further details on the elliptic curve method we refer to Section 7.4 of [162]. We
remark that Lenstra, Pila and Pomerance [380] have considered a variant of the elliptic
curve method using divisor class groups of hyperelliptic curves of genus 2. The Hasse-Weil
interval for such curves contains an interval of the form (X, X + X 3/4 ) and Theorem 1.3
of [380] proves that such intervals contain LX (2/3, c1 )-smooth integers (for some constant
c1 ) with probability 1/LX (1/3, 1). It follows that there is a rigorous factoring algorithm
with complexity Lp (2/3, c) bit operations for some constant c2 . This algorithm is not
used in practice, as the elliptic curve method works fine already.

Exercise 15.3.4. Suppose a sequence of values 1 < x < N are chosen uniformly at
random. Show that one can find such a value that is LN (2/3, c)-smooth, together with
its factorisation, in expected LN (1/3, c′ + o(1)) bit operations for some constant c′ .

Remark 15.3.5. It is tempting to conjecture that the Hasse interval contains a polynomially-
smooth integer (indeed, this has been done by Maurer and Wolf [407]; see equation (21.9)).
This is not relevant for the elliptic curve factoring method, since such integers would
be very rare. Suppose the probability that an integer of size X is Y -smooth is ex-
actly 1/uu , where u = log(X)/ log(Y ) (by Theorem 15.1.2, this √ is reasonable
√ as long as
Y 1−ǫ ≥ log(X)). It is natural to suppose
√ that the interval [X − 2 X, X + 2 X] is likely
to contain a Y -smooth integer if 4 X > uu . Let Y = log(X)c . Taking logs of both sides
of the inequality gives the condition

1 log(X)
log(4) + 2 log(X) > (log(log(X)) − log(c log(log(X)))).
c log(log(X))

It is therefore natural to conclude that when c ≥ 2 there is a good chance that the Hasse
interval of an elliptic curve over Fp contains a log(p)c -smooth integer. Proving such a
claim seems to be far beyond the reach of current techniques.

15.4 The Number Field Sieve

The most important integer factorisation algorithm for large integers is the number field
sieve (NFS). A special case of this method was invented by Pollard.7 The algorithm
requires algebraic number theory and a complete discussion of it is beyond the scope of
this book. Instead, we just sketch some of the basic ideas. For full details we refer to
Lenstra and Lenstra [372], Section 6.2 of Crandall and Pomerance [162], Section 10.5 of
Cohen [136] or Stevenhagen [584].
As we have seen from the quadratic sieve, reducing the size of the values being tested
for smoothness yields a better algorithm. Indeed, in the quadratic sieve the numbers were
reduced from size O(N ) to O(N 1/2+o(1) ) and,
√ as shown by Exercise 15.2.11, this trick alone
lowers the complexity from O(LN (1/2, 2 + o(1))) to O(LN (1/2, 1 + o(1))). To break
the “O(LN (1/2, c)) barrier” one must make the numbers being tested for smoothness
dramatically smaller. A key observation is that if the numbers are of size O(LN (2/3, c′ ))
then they are O(LN (1/3, c′′ )) smooth, for some constants c′ and c′′ , with probability
approximately 1/uu = 1/LN (1/3, c′ /(3c′′ ) + o(1)). Hence, one can expect an algorithm
7 The goal of Pollard’s method was to factor integers of the form n3 + k where k is small. The the

algorithm in the case of numbers of a special form is known as the special number field sieve.
15.4. THE NUMBER FIELD SIEVE 333

with running time O(LN (1/3, c+o(1))) bit operations, for some constant c, by considering
smaller values for smoothness.
It seems to be impossible to directly choose values x such that x2 (mod N ) is of size
LN (2/3, c + o(1)) for some constant c. Hence, the number field sieve relies on two factor
bases B1 and B2 . Using smooth elements over B1 (respectively, B2 ) and linear algebra one
finds an integer square u2 and an algebraic integer square v 2 . The construction allows us
to associate an integer w modulo N to v such that u2 ≡ w2 (mod N ) and hence one can
try to split N .
We briefly outline the ideas behind the algorithm. First, choose a monic irreducible
polynomial P (x) ∈ Z[x] of degree d (where d grows like ⌊(3 log(N )/ log(log(N )))1/3 ⌋)
with a root m = ⌊N 1/d ⌋ modulo N (i.e., P (m) ≡ 0 (mod N )). Factor base B1 is primes
up to B = LN (1/3, c) and factor base B2 is small prime ideals in the ring Z[θ] in the
number field K = Q(θ) = Q[x]/(P (x)) (i.e., θ is a generic root of P (x)). The algorithm
exploits, in the final step, the ring homomorphism φ : Z[x]/(P (x)) → Z/N Z given by
φ(θ) = m (mod N ). Suppose the ideal (a − bθ) is a product of prime ideals in B2 (one
factors the ideal (a − bθ) by factoring its norm in Z), say
r
Y
(a − bθ) = ℘ei i .
i=1

Suppose also that a − bm is a smooth integer in B1 , say

s
Y f
a − bm = pj j .
j=1

If these equations hold then we call (a − bθ) and a − bm smooth and store a, b and the
sequences of ei and fj . We do not call this a “relation” as there is no direct relationship
between the prime ideals ℘i and the primes pj . Indeed, the ℘j are typically non-principal
ideals and do not necessarily contain an element of small norm. Hence, the two products
are modelled as being “independent”.
It is important to estimate the probability that both the ideal (a − bθ) and the integer
a−bm are smooth. One shows that taking integers |a|, |b| ≤ LN (1/3, c′ +o(1)) for a suitable
constant c′ gives (a − bθ) of norm LN (2/3, c′′ + o(1)) and a − bm of size LN (2/3, c′′′ + o(1))
for certain constants c′′ and c′′′ . To obtain a fast algorithm one uses sieving to determine
within a range of values for a and b the pairs (a, b) such that both a − bm and (a − bθ)
factor over the appropriate factor base.
Performing linear algebra on both sides gives a set S of pairs (a, b) such that (ignoring
issues with units and non-principal ideals)
Y
(a − bm) = u2
(a,b)∈S
Y
(a − bθ) = v 2
(a,b)∈S

for some u ∈ Z and v ∈ Z[θ]. Finally we can “link” the two factor bases: Applying the
ring homomorphism φ : Z[θ] → Z gives u2 ≡ φ(v)2 (mod N ) and hence we have a chance
to split N . A non-trivial task is computing the actual numbers u and φ(v) modulo N so
that one can compute gcd(u − φ(v), N ).
Since one is only considering integers a − bm in a certain range (and ideals in a certain
range) for smoothness one relies on heuristic assumptions about the smoothness prob-
ability. The conjectural complexity of the number field sieve is O(LN (1/3, c + o(1)))
334 CHAPTER 15. SUBEXPONENTIAL ALGORITHMS

bit operations as N → ∞ where c = (64/9)1/3 ≈ 1.923. Note, comparing with Exer-

cise 15.2.12, that if N ≈ 21024 then LN (1/3, 1.923) ≈ 287 .

15.5 Index Calculus in Finite Fields

We now explain how similar ideas to the above have been used to find subexponential
algorithms for the discrete logarithm problem in finite fields. The original idea is due
to Kraitchik [354]. While all subexponential algorithms for the DLP share certain basic
concepts, the specific details vary quite widely (in particular, precisely what “linear alge-
bra” is required). We present in this section an algorithm that is very convenient when
working in subgroups of prime order r in F∗q as it relies only on linear algebra over the
field Fr .
Let g ∈ F∗q have prime order r and let h ∈ hgi. The starting point is the observation
that if one can find integers 0 < Z1 , Z2 < r such that

g Z1 hZ2 = 1 (15.6)

in F∗q then logg (h) = −Z1 Z2−1 (mod r). The idea will be to find such a relation using
a factor base and linear algebra. Such algorithms go under the general name of index
calculus algorithms; the reason for this is that index is another word for discrete loga-
rithm, and the construction of a solution to equation (15.6) is done by calculations using
indices.

15.5.1 Rigorous Subexponential Discrete Logarithms Modulo p

We now sketch a subexponential algorithm for the discrete logarithm problem in F∗p . It
is closely related to the random squares algorithm of Section 15.2. Let g ∈ F∗p have order
r (we will assume r is prime, but the general case is not significantly different) and let
h ∈ F∗p be such that h ∈ hgi. We will also assume, for simplicity, that r2 ∤ (p − 1) (we
show in Exercise 15.5.8 that this condition can be avoided).
The natural idea is to choose the factor base B to be the primes in Z up to B. We let
s = #B. One can take random powers g z (mod p) and try to factor over B. One issue
is that the values g z only lie in a subgroup of F∗p and so a strong smoothness heuristic
would be required. To get a rigorous algorithm (under the assumption that r2 ∤ (p − 1))
write G′ for the subgroup of F∗p of order (p − 1)/r, choose a random δ ∈ G′ at each
iteration and try to factor g z δ (mod p); this is now a uniformly distributed element of F∗p
and so Corollary 15.1.8 can be applied. We remark that the primes pi themselves do not
necessarily lie in the subgroup hgi.
Exercise 15.5.1. Let r | (p − 1) be a prime such that r2 ∤ (p − 1). Let g ∈ F∗p have
order dividing r and denote by G′ ⊆ F∗p the subgroup of order (p − 1)/r. Show that
hgi ∩ G′ = {1}.
Exercise 15.5.2. Give two ways to sample randomly from G′ . When would each be
used?
[Hint: see Section 11.4.]
The algorithm proceeds by choosing random values 1 ≤ z < r and random δ ∈ G′ and
testing g z δ (mod p) for smoothness. The i-th relation is
s
Y e
g z i δi ≡ pj i,j (mod p). (15.7)
j=1
15.5. INDEX CALCULUS IN FINITE FIELDS 335

The values zi are stored in a vector and the values ei = (ei,1 , . . . , ei,s ) are stored as a row
in a matrix. We need s relations of this form. We also need at least one relation involving
h (alternatively, we could have used a power of h in every relation in equation (15.7))
so try random values zs+1 and δs+1 ∈ G′ until g zs+1 hδs+1 (mod p) is B-smooth. One
performs linear algebra modulo r to find integers 0 ≤ λ1 , . . . , λs+1 < r such that
s+1
X
λi ei = (rf1 , . . . , rfs ) ≡ (0, . . . , 0) (mod r)
i=1

where f1 , . . . , fs ∈ Z≥0 . In matrix notation, writing A = (ei,j ), this is (λ1 , . . . , λs+1 )A ≡

(0, . . . , 0) (mod r). In other words, the linear algebra problem is finding a non-trivial
Ps+1
element in the kernel of the matrix A modulo r. Let Z1 = i=1 λi zi (mod r) and
Z2 = λs+1 . Then
! !r
Y Y f
λ
g Z1 hZ2 δi i ≡ pi i (mod p). (15.8)
i i
Z1 Z2
Since g h ∈ hgi and the other terms are all in G′ it follows from Exercise 15.5.1
Q that
g Z1 hZ2 ≡ 1 (mod r) as required. We stress that it is not necessary to compute i δiλi or
the right hand side of equation (15.8).
The algorithm succeeds as long as λs+1 6≡ 0 (mod r) (and if λs+1 = 0 then there is
a linear dependence from the earlier relations, which can be removed by deleting one or
more rows of the relation matrix).

Exercise 15.5.3. Show that if one replaces equation (15.7) by g z1,i hz2,i δi for random
z1,i , z2,i and δi then one obtains an algorithm that succeeds with probability 1 − 1/r.

Example 15.5.4. Let p = 223. Then g = 15 has prime order r = 37. Suppose h = 68
is the instance of the DLP we want to solve. Let B = {2, 3, 5, 7}. Choose the element
g1 = 184 of order (p − 1)/r = 6. One can check that we have the following relations.

z i Factorization of g z g1i (mod p)

1 1 22 · 3 · 7
33 0 23 · 7
8 1 32 · 5
7 0 23 · 3 · 5

One also finds the relation hg 7 g12 = 23 · 32 .

We represent the relations as the vector and matrix
   
1 2 1 0 1
 33   3 0 0 1 
   
z=  8  ,
  0 2 1
 0 .

 7   3 1 1 0 
7 3 2 0 0

Now perform linear algebra modulo 37. One finds the non-trivial kernel vector v =
(1, 36, 20, 17, 8). Computing Z1 = v · z = 7 (mod 37) and Z2 = 8 we find g Z1 hZ2 ≡
1 (mod 223) and so the solution is −Z1 Z2−1 ≡ 13 (mod 37).

Exercise 15.5.5. Write the above algorithm in pseudocode (using trial division to de-
termine the smooth relations).
336 CHAPTER 15. SUBEXPONENTIAL ALGORITHMS

Exercise 15.5.6. Let the notation be as above. Let TB be the expected number of trials
of random integers modulo p until one is B-smooth. Show that the expected running
time of this algorithm (using naive trial division for the relations and using the Lanczos
or Wiedemann methods for the linear algebra) is

O((#B)2 TB M (log(p)) + (#B)2+o(1) M (log(r)))

bit operations as p → ∞

Exercise 15.5.7. Show that taking B = Lp (1/2, 1/2) is the optimal value to minimise
the complexity of the above algorithm, giving a complexity of O(Lp (1/2, 2 + o(1))) bit
operations for the discrete logarithm problem in F∗p as p → ∞. (Note that, unlike many
of the results in this chapter, this result does not rely on any heuristics.)

We remark that, in practice, rather than computing a full exponentiation g z one might
use a pseudorandom walk as done in Pollard rho. For further implementation tricks see
Sections 5.1 to 5.5 of Odlyzko [469].
If g does not have prime order (e.g., suppose g is a generator of F∗p and has order p − 1)
then there are several options: One can apply Pohlig-Hellman and reduce to subgroups
of prime order and apply index calculus in each subgroup (or at least the ones of large
order). Alternatively, one can apply the algorithm as above and perform the linear algebra
modulo the order of g. There will usually be difficulties with non-invertible elements in
the linear algebra, and there are several solutions, such as computing the Hermite normal
form of the relation matrix or using the Chinese remainder theorem, we refer to Section
5.5.2 of Cohen [136] and Section 15.2.1 of Joux [317] for details.

Exercise 15.5.8. Give an algorithm similar to the above that works when r2 | (p − 1).

Exercise 15.5.9. This exercise is about solving many different discrete logarithm in-
stances hi = g ai (mod p), for 1 ≤ i ≤ n, to the same base g. Once sufficiently many
relations are found, determine the cost of solving each individual instance of the DLP.
Hence show that one can solve any constant number of instances of the DLP to a given
base g ∈ F∗p in O(Lp (1/2, 2 + o(1))) bit operations as p → ∞.

15.5.2 Heuristic Algorithms for Discrete Logarithms Modulo p

To get a faster algorithm it is necessary to improve the time to find smooth relations.
It is natural to seek methods to sieve rather than factoring each value by trial division,
but it is not known how to do this for relations of the form in equation (15.7). It would
also be natural to find an analogue to Pomerance’s method of considering residues of size
about the square-root of random; Exercise 15.5.10 gives an approach to this, but it does
not lower the complexity.

Exercise 15.5.10. (Blake, Fuji-Hara, Mullin and Vanstone [61]) Once one has computed
w = g z δ (mod p) one can apply the Euclidean algorithm to find integers w1 , w2 such that
√
w1 w ≡ w2 (mod p) and w1 , w2 ≈ p. Since w1 and w2 are smaller one would hope
that they are much more likely to both be smooth (however, note that both must be
smooth). We now make the heuristic assumption that the probability each wi is B-
√
smooth is independent and the same as the probability that any integer of size p is
B-smooth. Show that the heuristic running time of the algorithm has uu replaced by
(u/2)u (where u = log(p)/ log(B)) and so the asymptotic running time remains the same.
15.5. INDEX CALCULUS IN FINITE FIELDS 337

Coppersmith, Odlyzko and Schroeppel [145] proposed an algorithm for the DLP in F∗p
√
that uses sieving. Their idea is to let H = ⌈ p⌉ and define the factor base to be
B = {q : q prime, q < Lp (1/2, 1/2)} ∪ {H + c : 1 ≤ c ≤ Lp (1/2, 1/2 + ǫ)}.
Since H 2 (mod p) is of size ≈ p1/2 it follows that if (H + c1 ), (H + c2 ) ∈ B then (H +
c1 )(H +c2 ) (mod p) is of size p1/2+o(1) . One can therefore generate relations in B. Further,
it is shown in Section 4 of [145] how to sieve over the choices for c1 and c2 . A heuristic
analysis of the algorithm gives complexity Lp (1/2, 1 + o(1)) bit operations.
The number field sieve (NFS) is an algorithm for the DLP in F∗p with heuristic
complexity O(Lp (1/3, c + o(1))) bit operations. It is closely related to the number field
sieve for factoring and requires algebraic number theory. As with the factoring algorithm,
there are two factor bases. Introducing the DLP instance requires an extra algorithm (we
will see an example of this in Section 15.5.4). We do not have space to give the details
and instead refer to Schirokauer, Weber and Denny [519] or Schirokauer [515, 517] for
details.

15.5.3 Discrete Logarithms in Small Characteristic

We now consider the discrete logarithm problem in F∗q where q = pn , p is relatively small
(the case of most interest is p = 2) and n is large. We represent such a field with a
polynomial basis as Fp [x]/(F (x)) for some irreducible polynomial F (x) of degree n. The
natural notion of smoothness of an element g(x) ∈ Fp [x]/(F (x)) is that it is a product of
polynomials of small degree. Since factoring polynomials over finite fields is polynomial-
time we expect to more easily get good algorithms in this case. The first work on this
topic was due to Hellman and Reyneri but we follow Odlyzko’s large paper [469]. First
we quote some results on smooth polynomials.
Definition 15.5.11. Let p be prime and n, b ∈ N. Let I(n) be the number of monic
irreducible polynomials in Fp [x] of degree n. A polynomial g(x) ∈ Fp [x] is called b-
smooth if all its irreducible factors have degree ≤ b. Let N (n, b) be the number of
b-smooth polynomials of degree exactly equal to n. Let p(n, b) be the probability that a
uniformly chosen polynomial of degree at most n is b-smooth.
Theorem 15.5.12. Let p be prime and n, b ∈ N.
P
1. I(n) = n1 d|n µ(d)pn/d = n1 pn + O(pn/2 /n) where µ(d) is the Möbius function.8
2. If n1/100 ≤ b ≤ n99/100 then N (n, b) = pn (b/n)(1+o(1))n/b as n tends to infinity.
3. If n1/100 ≤ b ≤ n99/100 then p(n, b) is at least u−u(1+o(1)) where u = n/b and n
tends to infinity.
4. If n1/100 ≤ b ≤ n99/100 then the expected number of trials before a randomly chosen
element of Fp [x] of degree n is b-smooth is uu(1+o(1)) as u → ∞.
Proof: Statement 1 follows from an elementary counting argument (see, for example,
Theorem 3.25 of Lidl and Niederreiter [388]).
Statement 2 in the case p = 2 is Corollary A.2 of Odlyzko [469]. The general result
was proved by Soundararajan (see Theorems 2.1 and 2.2 of Lovorn Bender and Pomer-
ance [397]). Also see Section 9.15 of [388].
Statement 3 follows immediately from statement 2 and the fact there are pn monic
polynomials of degree at most n (when considering smoothness it is sufficient to study
monic polynomials). Statement 4 follows immediately from statement 3. 
8 This is the “prime number theorem for polynomials”, I(n) ≈ pn / logp (pn ).
338 CHAPTER 15. SUBEXPONENTIAL ALGORITHMS

The algorithm then follows exactly the ideas of the previous section. Suppose g has
prime order r | (pn − 1) and h ∈ hgi. The factor base is

B = {P (x) ∈ Fp [x] : P (x) is monic, irreducible and deg(P (x)) ≤ b}

for some integer b to be determined later. Note that #B = I(1) + I(2) + · · · + I(b) ≈
pb+1 /(b(p − 1)) (see Exercise 15.5.14). We compute random powers of g multiplied by a
suitable δ ∈ G′ (where, if r2 ∤ (pn − 1), G′ ⊆ F∗pn is the subgroup of order (pn − 1)/r;
when r2 | (pn − 1) then use the method of Exercise 15.5.8), reduce to polynomials in
Fp [x] of degree at most n, and try to factor them into products of polynomials from B.
By Exercise 2.12.11 the cost of factoring the b-smooth part of a polynomial of degree n
is O(bn log(n) log(p)M (log(p))) = O(log(pn )3 ) bit operations (in any case, polynomial-
time). As previously, we are generating polynomials of degree n uniformly at random
and so, by Theorem 15.5.12, the expected number of trials to get a relation is uu(1+o(1))
where u = n/b as u → ∞. We need Q to obtain #B relations in general. Then we obtain
a single relation of the form hg a δ = P ∈B P eP , perform linear algebra, and hence solve
the DLP.
Exercise 15.5.13. Write the above algorithm in pseudocode.
Pb
Exercise 15.5.14. Show that i=1 I(b) ≤ 1b pb (1 + 2/(p − 1)) + O(bpb/2 ). Show that a
very rough approximation is pb+1 /(b(p − 1)).
Exercise 15.5.15. Let the notation be as above. Show that the complexity of this
algorithm is at most

c1 #Buu(1+o(1)) log(q)3 + c2 (#B)2+o(1) M (log(r))

bit operations (for some constants c1 and c2 ) as n → ∞ in q = pn .

For the complexity analysis it is natural to arrange that #B ≈ Lpn (1/2, c) for a
suitable constant c. Recall that #B ≈ pb /b. To have pb /b = Lpn (1/2, c) then, taking logs,
p
b log(p) − log(b) = c n log(p)(log(n) + log(log(p))).
p
It follows that b ≈ c n log(n)/ log(p).
Exercise 15.5.16. Show that one can compute discrete logarithms in F∗pn in expected
√
O(Lpn (1/2, 2 + o(1))) bit operations for fixed p and as n → ∞. (Note that this result
does not rely on any heuristic assumptions.)
Exercise 15.5.17. Adapt the trick of exercise 15.5.10 to this algorithm. Explain that
the complexity of the algorithm remains the same, but is now heuristic.
√
Lovorn Bender and Pomerance [397] give rigorous complexity Lpn (1/2, 2 + o(1)) bit
operations as pn → ∞ and p ≤ no(n) (i.e., p is not fixed).

15.5.4 Coppersmith’s Algorithm for the DLP in F∗2n

This algorithm (inspired by the “systematic equations” of Blake, Fuji-Hara, Mullin and
Vanstone [61]) was the first algorithm in computational number theory to have heuristic
subexponential complexity of the form Lq (1/3, c + o(1)).
The method uses a polynomial basis for F2n of the form F2 [x]/(F (x)) for F (x) =
xn + F1 (x) where F1 (x) has very small degree. For example, F2127 = F2 [x]/(x127 + x + 1).
15.5. INDEX CALCULUS IN FINITE FIELDS 339

The “systematic equations” of Blake et al are relations among elements of the factor
base that come almost for free. For example, in F2127 , if A(x) ∈ F2 [x] is an irreducible
polynomial in the factor base then A(x)128 = A(x128 ) ≡ A(x2 + x) (mod F (x)) and
A(x2 + x) is either irreducible or is a product P (x)P (x + 1) of irreducible polynomials of
the same degree (Exercise 15.5.18). Hence, for many polynomials A(x) in the factor base
one gets a non-trivial relation.

Exercise 15.5.18. Let A(x) ∈ F2 [x] be an irreducible polynomial. Show that A(x2 + x)
is either irreducible or a product of two polynomials of the same degree.

Coppersmith [140] extended the idea as follows: Let b ∈ N be such that b = cn1/3 log(n)2/3
2/3
for a suitable
p constant c (later we take c = (2/(3 log(2))) √ ), let√ k ∈ N be such that
1
2 ≈ n/b ≈ c (n/ log(n)) , and let l = ⌈n/2 ⌉ ≈ nb ≈ cn2/3 log(n)1/3 . Let
k √ 1/3 k

B = {A(x) ∈ F2 [x] : deg(A(x)) ≤ b, A(x) irreducible}. Note that #B ≈ 2b /b by Ex-

ercise 15.5.14. Suppose A(x), B(x) ∈ F2 [x] are such that deg(A(x)) = dA ≈ b and
deg(B(x)) = dB ≈ b and define C(x) = A(x)xl + B(x). In practice one restricts to pairs
(A(x), B(x)) such that gcd(A(x), B(x)) = 1. The crucial observation is that
k k k k k k k
C(x)2 = A(x2 ) · (x2 )l + B(x2 ) ≡ A(x2 )x2 l−n
F1 (x) + B(x2 ) (mod F (x)). (15.9)

Write D(x) for the right hand side of equation (15.9). We have deg(C(x)) ≤ max{dA +
l, dB } ≈ l ≈ n2/3 log(n)1/3 and deg(D(x)) ≤ max{2k dA + (2k l − n) + deg(F1 (x)), 2k dB } ≈
2k b ≈ n2/3 log(n)1/3 .

Example 15.5.19. (Thomé [608]) Let n = 607 and F1 (x) = x9 + x7 + x6 + x3 + x + 1.

Let b = 23, dA = 21, dB = 28, 2k = 4, l = 152. The degrees of C(x) and D(x) are 173
and 112 respectively.

We have two polynomials C(x), D(x) of degree ≈ n2/3 that we wish to be b-smooth
where b ≈ n1/3 log(n)2/3 . We will sketch the complexity later under the heuristic as-
sumption that, from the point of view of smoothness, these polynomials are independent.
We will also assume that the resulting relations are essentially random (and so with
high probability there is a non-trivial linear dependence once #B + 1 relations have been
collected).
Having generated enough relations among elements of the factor base, it is necessary
to find some relations involving the elements g and h of the DLP instance. This is not
trivial. All DLP algorithms having complexity Lq (1/3, c + o(1)) feature a process called
special q-descent
Q that achieves this. The first step is to express g (respectively, h) as a
product i Gi (x) of polynomials of degree at most b1 = n2/3 log(n)1/3 ; this can be done
by multiplying g (resp. h) by random combinations of elements of B and factoring (one
can also apply the Blake et al trick as in Exercise 15.5.10). We now have a list of around
2n1/3 < n polynomials Gi (x) of degree ≈ n2/3 that need to be “smoothed” further.
Section VII of [140] gives a method to do this: essentially one performs the same sieving
as earlier except that A(x) and B(x) are chosen so that Gi (x) | C(x) = A(x)xl + B(x)
(not necessarily with the same value of l or the same degrees for A(x) and B(x)). Defining
k
D(x) = C(x)2 (mod F (x)) (not necessarily the same value of k as before) one hopes that
C(x)/G(x) and D(x) are b-smooth. After sufficiently many trials one has a relation that
expresses Gi (x) in terms of elements of B. Repeating for the polynomially many values
Gi (x) one eventually has the values g and h expressed in terms of elements of B. One can
then do linear algebra modulo the order of g to find integers Z1 , Z2 such that g Z1 hZ2 = 1
and the DLP is solved.
340 CHAPTER 15. SUBEXPONENTIAL ALGORITHMS

Example 15.5.20. We give an example of Coppersmith’s method for F215 = F2 [x]/(F (x))
where F (x) = x15 + x + 1. We consider the subgroup of F∗215 of order r = 151 (note that
(215 − 1)/r = 7 · 31 = 217). Let g = x11 + x7 + x5 + x2 + 1 and h = x14 + x11 + x10 + x9 + 1
be the DLP instance.
First note that n1/3 ≈ 2.5 and n2/3 ≈ 6.1. We choose b = 3 and so B = {x, x + 1, x2 +
x + 1, x3 + x + 1, x3 + x2 + 1}. We hope to be testing polynomials of degree around 6 to
8 for smoothness.
First, we find some “systematic equations”. We obviously have the relation x15 = x+1.
We also have (x + 1)16 = x2 + x + 1 and (x3 + x + 1)16 = (x3 + xp + 1)(x3 +√x2 + 1).
k
Now, we do Coppersmith’s method. We must choose 2 ≈ n/b = 5 ≈ 2.2 so
take 2k = 2. Let l = ⌈n/2k ⌉ = 8, choose A(x) and B(x) of degree at most 2, set
C(x) = A(x)x8 + B(x) and D(x) = C(x)2 (mod F (x)), and test C(x) and D(x) for
smoothness over B. We find the following pairs (A(x), B(x)) such that both C(x) and
D(x) factor over B.

A(x) B(x) C(x) D(x)

1 1 (x + 1)8 x2 + x + 1
1 x x(x + 1)(x3 + x + 1)(x3 + x2 + 1) x
1 x2 x2 (x + 1)2 (x2 + x + 1)2 x(x3 + x + 1)

The first relation in the table is a restatement of (x + 1)16 = x2 + x + 1. All together,

we have the relation matrix
 
15 −1 0 0 0
 0 16 −1 0 0 
 
 0 0 0 15 −1 
 . (15.10)
 1 2 0 2 2 
3 4 4 −1 0

To solve the DLP one can now try to express g and h over the factor base. One has

g 22 = x(x + 1)(x2 + x + 1)2 (x3 + x2 + 1).

For h we find
hg 30 = x6 (x + 1)4 G(x)
where G(x) = x4 +x+1 is a “large prime”. To “smooth” G(x) we choose A(x) = 1, B(x) =
A(x)x8 (mod G(x)) = x2 + 1, C(x) = A(x)x8 + B(x) and D(x) = C(x)2 (mod F (x)).
One finds C(x) = G(x)2 and D(x) = (x + 1)(x3 + x2 + 1). In other words, G(x)4 =
(x + 1)(x3 + x2 + 1).
There are now two ways to proceed. Following the algorithm description above we add
to the matrix the two rows (1, 1, 2, 0, 1) and 4(6, 4, 0, 0, 0)+(0, 1, 0, 0, 0, 1) = (24, 17, 0, 0, 1)
corresponding to g 22 and h4 g 120 . Finding a non-trivial kernel vector modulo 151, such as
(1, 114, 0, 132, 113, 133, 56) gives the relation

1 = (g 22 )133 (h4 g 120 )56 = g 133 h73

from which we deduce h = g 23 .

An alternative approach to the linear algebra is to diagonalise the system in equa-
tion (15.10) using linear algebra over Z (or at least modulo 215 − 1) to get x + 1 =
x15 , x2 + x + 1 = x240 , x3 + x + 1 = x1023 and x3 + x2 + 1 = x15345 . One then gets

g 22 = x(x + 1)(x2 + x + 1)2 (x3 + x2 + 1) = x1+15+2·240+15345 = x15841

15.5. INDEX CALCULUS IN FINITE FIELDS 341

and so
−1
(mod (215 −1))
g = x15841·22 = x26040 = (x217 )120 .
Similarly, G(x)4 = (x+ 1)(x3 + x2 + 1) = x15+15345 = x15360 and so G(x) = x3840 . Finally,

h = g −30 x6 (x + 1)4 G(x) = x−30·26040+6+4·15+3840 = x9114 = (x217 )42

−1
and so h = g 42·120 (mod 151)
= g 23 .

Conjecture 15.5.21. Coppersmith’s algorithm solves the DLP in F∗q where q = 2n in

Lq (1/3, (32/9)1/3 + o(1)) bit operations as n → ∞.

Note that, to compare with Exercise 15.2.12, if q = 21024 then Lq (1/3, (32/9)1/3) ≈
67
2 .
This conjecture would hold if the probability that the polynomials C(x) and D(x) are
smooth was the same as for independently random polynomials of the same degree. p We
now give a justification for √ the constant. Let b = cn1/3 log(n)2/3 . Note that 2k ≈ n/b ≈
√
(n/ log(n))1/3 / c and l ≈ nb. We need around 2b /b relations, and note that log(2b /b) ≈
b log(2) = c log(2)n1/3 log(n)2/3 . We have deg(C(x)) ≈ dA + l and deg(D(x)) ≈ k
p 2 dA .
u
The number of trials until C(x) is b-smooth is u where u = (dA + l)/b ≈ h/b ≈ n/b =
√1 (n/ log(n))1/3 . Hence, log(uu ) = u log(u) ≈ √ 1
n1/3 log(n)2/3 . Similarly, the number
c 3 c p
of trials until D(x) is b-smooth is approximately uu where u = (2k dA )/b ≈ 2k ≈ n/b
and the same argument applies. Since both events must occur the expected number of
2
trials to get a relation is exp( 3√ c
(n log(n)2 )1/3 ). Hence, total expected time to generate
enough relations is  
2 1/3 2/3
exp (c log(2) + 3√ c
)n log(n) .

This is optimised when c3/2 log(2) = 2/3, which leads to the stated complexity for the
first stage of the algorithm. (In practice one chooses c so that there are enough smooth
pairs (C(x), D(x)) to generate the required number of relations.) The linear algebra is
O((2b /b)2+o(1) M (log(r))) bit operations, which is the same complexity, and the final stage
of solving the DLP has lower complexity (it is roughly the same as the cost of finding
polynomially many smooth relations, rather than finding 2b /b of them). For more details
about the complexity of Coppersmith’s method we refer to Section 2.4 of Thomé [608].
Since one can detect smoothness of polynomials in polynomial-time it is not necessary,
from a complexity theory point of view, to sieve. However, in practice sieving can be
worthwhile and a method to do this was given by Gordon and McCurley [263].
Coppersmith’s idea is a special case of a more general approach to index calculus
algorithms known as the function field sieve. Note that Coppersmith’s algorithm only
has one factor base, whereas the function field sieve works using two factor bases.

15.5.5 The Joux-Lercier Algorithm

The function field sieve of Adleman is a general algorithm for discrete logarithms in Fpn
where p is relatively small compared with n. Joux and Lercier gave a much simpler and
better algorithm. We will sketch this algorithm, but refer to Joux and Lercier [318] and
Section 15.2 of [317] for full details. We also refer to [517] for a survey of the function
field sieve. √
Let p be prime and n ∈ N. Let d = ⌈ n⌉. Suppose one has monic polynomials
F1 (t), F2 (t) ∈ Fp [t] such that deg(F1 (t)) = deg(F2 (t)) = d and F2 (F1 (t)) − t has an irre-
ducible factor F (t) of degree n. We represent Fpn with the polynomial basis Fp [t]/(F (t)).
342 CHAPTER 15. SUBEXPONENTIAL ALGORITHMS

Given a prime p and an integer n one can find such polynomials F1 (t) and F2 (t) in very
little time (e.g., by choosing polynomials of the right degree uniformly at random and
testing the condition using polynomial factorisation).

Exercise 15.5.22. Let n = 15. Find polynomials F1 (t), F2 (t) ∈ F2 [t] of degree 4 such
that F2 (F1 (t)) − t has an irreducible factor of degree 15.

Now consider the polynomial ring A = Fp [x, y] and two ring homomorphisms ψ1 :
A → A1 = Fp [x] by ψ1 (y) = F1 (x) and ψ2 : A → A2 = Fp [y] by ψ2 (x) = F2 (y). Define
φ1 : A1 → Fpn by φ1 (x) = t (mod F (t)) and φ2 : A2 → Fpn by φ2 (y) = F1 (t) (mod F (t)).

Exercise 15.5.23. Let the notation be as above and G(x, y) ∈ Fp [x, y]. Show that
φ1 (ψ1 (G(x, y))) = φ2 (ψ2 (G(x, y))) in Fpn .

Let B1 ⊆ A1 = Fp [x] and B2 ⊆ Fp [y] be the sets of linear polynomials. The idea
of the algorithm is simply to consider polynomials in Fp [x, y] of the form G(x, y) =
Q
xy + ax + by + c. If ψ1 (G(x, y)) = (x + b)F1 (x) + (ax + c) factors over B1 as d+1
i=1 (x − ui )
Qd+1
and if ψ2 (G(x, y)) = (y + a)F2 (y) + (by + c) factors over B2 as j=1 (y − vj ) then we have
a relation. The point is that such a relation corresponds to

d+1
Y d+1
Y
(t − ui ) = (F1 (t) − vj )
i=1 j=1

in Fpn .
One also needs to introduce the DLP instance by using a special q-descent: given
an irreducible polynomial q(x) one constructs polynomials a(x), b(x) such that q(x) |
(a(x)F1 (x) + b(x)) and one hopes that (a(x)F1 (x) + b(x))/q(x) has small factors and that
a(F2 (y))y + b(F2 (y)) has small factors, and hence iterate the process. When enough rela-
tions are collected (including at least one “systematic equation” to remove the parasitic
solution explained on page 442 of Joux/indexAJoux, A. [317]) one can perform linear al-
gebra to solve the DLP. The heuristic complexity of this algorithm is shown in [318] and
Section 15.2.1.2 of [317] to be between Lpn (1/3, 31/3 +o(1)) and Lpn (1/3, (32/9)1/3 +o(1))
for p ≤ Lpn (1/3, (4/9)1/3 + o(1)).

15.5.6 Number Field Sieve for the DLP

Concepts from the number field sieve for factoring have been applied in the setting of
the DLP. Again, one uses two factor bases, corresponding to ideals in the ring of integers
of some number field (one of the number fields may be Q). As with Coppersmith’s
method, once sufficiently many relations have been found among elements of the factor
bases, special q-descent is needed to solve a general instance of the DLP. We refer to
Schirokauer [517] for details of the NFS algorithm for the DLP, and also for the heuristic
arguments that one can solve the DLP in F∗p in Lp (1/3, (64/9)1/3 + o(1)) bit operations.
When p has a special form (e.g., p = 2n ±1) then the special number field sieve (SNFS)
can be used to solve the DLP in (heuristic) Lp (1/3, (32/9)1/3 + o(1)) bit operations, see
[518].
We should also mention the special function field sieve (SFFS) for solving the
DLP in F∗pn , which has heuristic complexity Lpn (1/3, (32/9)1/3 + o(1)) bit operations as
√
pn → ∞ as long as p ≤ no( n) , see Schirokauer [516, 517].
15.6. DISCRETE LOGARITHMS ON HYPERELLIPTIC CURVES 343

15.5.7 Discrete Logarithms for all Finite Fields

We have sketched algorithms for the DLP in F∗p when p is large or F∗pn when p is relatively
small. We have not considered cases F∗q where q = pn with p large and n > 1. The basic
concepts can be extended to cover all cases, but ensuring that subexponential complexity
is achieved for all combinations of p and n is non-trivial. Adleman and Demarrais [2]
were the first to give a heuristic subexponential algorithm for all finite fields. They
split the problem space into p > n and p ≤ n; in the latter case they have complexity
Lq (1/2, 3 + o(1)) bit operations as q → ∞ and in the former case heuristic complexity
Lq (1/2, c + o(1)) for a non-explicit constant c.
Heuristic algorithms with complexity Lq (1/3, c + o(1)) for all finite fields are given by
Joux and Lercier [318] and Joux, Lercier, Smart and Vercauteren [319].

15.6 Discrete Logarithms on Hyperelliptic Curves

Some index calculus algorithms for the discrete logarithm problem in finite fields generalise
naturally to solving the DLP in the divisor class group of a curve. Indeed, some of these
algorithms also apply to the ideal class group of a number field, but we do not explore that
situation in this book. An excellent survey of discrete logarithm algorithms for divisor
class groups is Chapter VII of [65].
We consider hyperelliptic curves C : y 2 + H(x)y = F (x) over Fq of genus g, so
deg(H(x)) ≤ g + 1 and deg(F (x)) ≤ 2g + 2. Recall that elements of the divisor class
group have a Mumford representation (u(x), y − v(x)) (for curves with a split model there
is also an integer 0 ≤ n ≤ g − deg(u(x)) to take into account the behaviour at infinity).
Let D1 and D2 be reduced divisors representing divisor classes of order r (where r is a
prime such that r2 ∤ #Pic0Fq (C)). The goal is to compute a ∈ Z/rZ such that D2 ≡ [a]D1 .
Recall from Exercise 10.3.12 that a reduced divisor with Mumford representation
(u(x), v(x)) is said to be a prime divisor if the polynomial u(x) is irreducible over Fq .
The degree of the effective affine divisor is deg(u(x)). Any effective affine divisor D can
be written as a sum of prime effective affine divisors by factoring the u(x) polynomial of
its Mumford representation. Hence, it is natural to define D to be b-smooth if it is a sum
of prime effective divisors of degree at most b. This suggests selecting the factor base B
to consist of all prime effective affine divisors of degree at most b for some smoothness
bound 1 ≤ b ≤ g.
We assume that B generates the group Pic0Fq (C); this is immediate when the group
has prime order and B contains a non-trivial element. Voloch [624] has proved that degree
1 primes generate Pic0Fq (C) whenever q > (8g(C) − 2)2 , where g(C) is the genus of C.
One can obtain an algorithm for the DLP of a familiar form, by generating reduced
divisors and testing whether they are smooth. One issue is that our smoothness results for
polynomials apply when polynomials are sampled uniformly from the set of all polynomials
of degree n in Fq [x], whereas we now need to apply the results to the set of polynomials
u(x) ∈ Fq [x] of degree g that arise in Mumford’s representation. This issue is handled
using Theorem 15.6.1.
There are two rather different ways to generate reduced divisors, both of which are
useful for the algorithm.

1. One can take random group elements of the form [n]D1 or [n1 ]D1 + [n2 ]D2 and
compute the Mumford representation of the corresponding reduced effective affine
divisor. This is the same approach as used in Section 15.5.1 and, in the context of
ideal/divisor class groups, is sometimes called the Hafner-McCurley algorithm.
344 CHAPTER 15. SUBEXPONENTIAL ALGORITHMS

If the divisor is B-smooth then we obtain a relation between elements of B and D1

and D2 .
2. One can consider the effective affine divisor of the function a(x) + yb(x) for random
polynomials a(x), b(x). This idea is due to Adleman, DeMarrais and Huang [4].
Since a principal divisor is equivalent to zero in the ideal class group, if the divisor
is B-smooth then we get a relation in B.

To introduce the instance of the DLP into the system it is necessary to have some relations
involving D1 and D2 . This can either be done using the first method, or by choosing
a(x) and b(x) so that points in the support of either D1 or D2 lie in the support of
div(a(x)+yb(x)) (we have seen this kind of idea already, e.g., in Coppersmith’s algorithm).
It is convenient to add to B all points at infinity and all points P ∈ C(Fq ) such
that P = ι(P ) (equivalently all Fq -rational prime divisors with this property). Since the
latter divisors all have order 2 one automatically obtains relations that can be used to
eliminate them during the linear algebra stage of the algorithm. Hence, we say that a
reduced divisor D = div(u(x), y − v(x)) in Mumford representation is b-smooth if u(x)
is b-smooth after any factors corresponding to points of order 2 have been removed.
Let C be a hyperelliptic curve over Fq of genus g and 1 ≤ b < g. Prime effective
affine divisors on C of degree b correspond to irreducible polynomials u(x) of degree
b (and for roughly half of all such polynomials u(x) there are two solutions v(x) to
v(x)2 + v(x)H(x) − F (x) ≡ 0 (mod u(x))). Hence, it is natural to expect that there
Pb
are approximately q b /b such divisors. It follows that #B should be around i=1 q i /i ≈
1 b
b p (1 + 2/(p − 1)) by the same argument as Exercise 15.5.14.
For the analysis, one needs to estimate the probability that a randomly chosen reduced
divisor is smooth.

Theorem 15.6.1. (Theorem 6 of Enge and Stein [198]) Let C be a hyperelliptic curve of
genus g over Fq . Let c > 1 and let b = ⌈logq (Lqg (1/2, c))⌉. Then the number of b-smooth
reduced divisors of degree g is at least

qg
Lqg (1/2, 1/(2c) + o(1))

for fixed q and g → ∞.

Note that the smoothness bound in the above result is the ceiling of a real number.
Hence one cannot deduce subexponential running time unless the genus is sufficiently
large compared with the field size.

15.6.1 Index Calculus on Hyperelliptic Curves

Suppose that r | N = #Pic0Fq (C) and r2 ∤ N . Suppose D1 , D2 are two divisor classes
on C over Fq of order r represented by reduced divisors D1 and D2 . The algorithm
of Section 15.5.1 immediately applies to solve the DLP: choose the factor base as above;
generate random reduced divisors by computing [n1 ]D1 + [n2 ]D2 + δ (where δ is uniformly
chosen9 from the subgroup G′ ⊆ Pic0Fq (C) of order N/r); store the resulting smooth
relations; perform linear algebra modulo r to find integers a, b such that [a]D1 + [b]D2 ≡ 0
(extra care is needed when there are two points at infinity to be sure the relation is
correct).
9 We assume that generators for this group are known so that it is easy to sample uniformly from this

group.
15.6. DISCRETE LOGARITHMS ON HYPERELLIPTIC CURVES 345

Exercise√15.6.2. Show that the expected running time of this algorithm is (rigorously!)
Lqg (1/2, 2 + o(1)) bit operations as g → ∞.

We refer to Section VII.5 of [65] for practical details of the algorithm. Note that the
performance can be improved using the sieving method of Flassenberg and Paulus [206].

15.6.2 The Algorithm of Adleman, De Marrais and Huang

This algorithm, from [4], uses the same factor base as the method of the previous section.
The main difference is to generate relations by decomposing principal divisors A(x) +
yB(x). An advantage of this approach is that group operations are not required.
By Exercise 10.1.26 it is easy to compute vP (A(x) + yB(x)) by computing the norm
A(x)2 − H(x)A(x)B(x) − F (x)B(x)2 and factoring it as a polynomial. If deg(A(x)) =
dA < g and deg(B(x)) = dB < g then the norm has degree at most max{2dA , (g + 1) +
dA + dB , 2g + 2 + 2dB }, which is much larger in general than the degree g polynomial in
a reduced Mumford representation, but still O(g) in practice.
We need to make the heuristic assumption that the probability the norm is b-smooth is
the same as the probability that a random polynomial of the same degree is b-smooth. We
therefore assume the expected number of trials to get an Lqg (1/2, c)-smooth polynomial
is Lqg (1/2, 1/(2c) + o(1)) as g tends to infinity.
We also need some relations involving D1 and D2 . Adleman et al do this by first
decomposing D1 and D2 as a sum of prime divisors. Then they “smooth” each prime
divisor div(u(x), y − v(x)) by choosing polynomials B(x), W (x) ∈ Fq [x], setting A′ (x) =
B(x)(v(x) + H(x)) (mod u(x)) and then A(x) = A′ (x) + u(x)W (x). One computes
N (x) = (A(x)2 − H(x)A(x)B(x) − F (x)B(x)2 ). By construction, u(x) | N (x) and one
continues randomly choosing A and W until N (x)/u(x) is b-smooth.
The details of the algorithm are then the same as the algorithm in Section 15.5.1: one
uses linear algebra modulo r to get a relation [a]D1 + [b]D2 ≡ 0 (again, care is needed
when there are two points at infinity). We leave the details as an exercise.

Exercise 15.6.3. Write pseudocode for the Adleman, DeMarrais, Huang algorithm.

The heuristic complexity of the algorithm is of the same form as the earlier algorithm
(the cost of smoothing the divisors D1 and D2 is heuristically the same as finding less √
than
2g relations so is negligible. One obtains heuristic asymptotic complexity of Lqg (1/2, 2+
o(1)) bit operations as g tends to infinity. This is much better than the complexity claimed
in [4] since that paper also gives an algorithm to compute the group structure (and so
the linear algebra requires computing the Hermite normal form).
These ideas will be used again in Section 15.9.1.

15.6.3 Gaudry’s Algorithm

Gaudry [242] considered the algorithm of Section 15.6.1 for fixed genus, rather than
asympotically as g → ∞. In particular he chose the smoothness bound b = 1 (so the
factor base B only consists of degree one prime divisors, i.e., points). Good surveys of
Gaudry’s algorithm are given in Chapter VII of [65] and Section 21.2 of [16].

Exercise 15.6.4. Let C be a hyperelliptic curve of genus g over a finite field Fq . Show
that the number of prime divisors on C of degree 1 is #C(Fq ) = q(1 + o(1)) for fixed g
as q → ∞. Hence, show that the probability that a randomly chosen reduced divisor is
1
1-smooth is g! (1 + o(1)) as q → ∞.
346 CHAPTER 15. SUBEXPONENTIAL ALGORITHMS

Exercise 15.6.5. Following Exercise 15.6.4, it is natural to conjecture that one needs to
choose O(g!q(1 + o(1))) divisors (again, this is for fixed g as q → ∞, in which case it is
more common to write it as O(q(1 + o(1)))) to find enough relations to have a non-trivial
linear dependence in B. Under this assumption, show that the heuristic expected running
time of Gaudry’s algorithm is at most

c1 g 2 g!q(1 + o(1))M (log(q)) + c2 g 3 q 2 M (log(q))) = O(q 2 M (log(q))(1 + o(1))) (15.11)

bit operations (for some constants c1 and c2 ) for fixed g as q → ∞.

The first term in equation (15.11) is the running time for relation generation. If g is
fixed then asymptotically this is dominated by the second term, which is the running time
for the linear algebra stage. If g is fixed, then the running time is Õ(q 2 ) bit operations.
Hence Gaudry’s algorithm is asymptotically faster than Pollard’s rho method for hyper-
elliptic curves of a fixed genus g ≥ 5. However, the hidden constant in the expression
Õ(q 2 ) depends very badly on g. In practice, Gaudry’s method seems to be superior to
rho for small g (e.g., g = 5, 6, 7).
Harley and Thériault (see [607]) suggested reducing the factor base size in Gaudry’s
algorithm in order to balance the running times of the relation generation and linear alge-
bra stages. Thériault [607] also proposed a “large prime” variant of Gaudry’s algorithm.
Gaudry, Thériault, Thomé and Diem [250] proposed a “double large prime” variant of
Gaudry’s algorithm that is based on the double large prime strategy that was successful
in accelerating integer factorization algorithms. The factor base B is now chosen to be a
subset of the degree one divisors and degree one divisors that are not in B are called large
primes. A divisor is defined to be smooth if it can be written as a sum of prime divisors
and at most two large primes. Relations are collected as before, and then combined to
eliminate the large primes (we refer to Section 21.3 of [16] for further discussion of large
primes and graph methods for eliminating them). It is shown in [250] that, for fixed g,
2
the expected running time of the algorithm is Õ(q 2− g ) bit operations. This is faster than
Pollard rho for g ≥ 3 when q is sufficiently large. Gaudry’s approach was generalised to
all curves of fixed genus by Diem [176].

15.7 Weil Descent

As we have seen, there are subexponential algorithms for the DLP in the divisor class
group of a hyperelliptic curve of high genus. A natural approach to solve the DLP on
elliptic curves is therefore to transform the problem into a DLP on a high genus curve.
However, the naive way to do this embeds a small problem into a big one, and does not
help to solve the DLP. Frey [212] proposed10 to use Weil restriction of scalars to transform
the DLP on an elliptic curve E(Fqn ) for n > 1 to the DLP on a curve of genus g ≥ n over
Fq . Frey called this idea Weil descent.
Geometrically the principle is to identify the Weil restriction of an open affine subset
of E(Fqn ) (see Section 5.7) with an open affine subset of an Abelian variety A over Fq of
dimension n. One can then try to find a curve C on A, so that there is a map from the
Jacobian of C to A. Following Gaudry, Hess and Smart [246] it is more convenient to
express the situation in terms of function fields and divisor class groups. We only sketch
10 The standard reference is a lecture given by Frey at the ECC 1998 conference. His talk was mostly

about a different (constructive) application of Weil restriction of scalars. However, he did mention the
possibility of using this idea for an attack. Galbraith and Smart developed the details further in [229]
and many works followed.
15.8. ELLIPTIC CURVES OVER EXTENSION FIELDS 347

the details since an excellent survey is provided by Hess in Chapter VIII of [65] and many
important details are explained by Diem in [172].
Let E be an elliptic curve over K = Fqn and let k = Fq . The function field of E is
K(E). The idea (called in this setting a covering attack) is to find a curve C over K
such that K(C) is a finite extension of K(E) (so that there is a map C → E of finite
degree) and such that there is an automorphism σ of degree n on K(C) extending the
q-power Frobenius so that the fixed field of K(C) under hσi is k(C 0 ) for some curve C 0 .
The composition of the conorm map from E(K) to Pic0C (K) and the norm map from
Pic0C (K) to Pic0C 0 (k) transfers the DLP from E(K) to Pic0C 0 (k). Hence, as long as the
composition of these maps is not trivial, then one has reduced the DLP from E(K) to
the divisor class group of a curve C 0 over k. One can then solve the DLP using an index
calculus algorithm, which is feasible if the genus of C 0 is not too large.
A variant of the Weil descent concept that avoids function fields and divisor class
groups is to perform index calculus directly on Abelian varieties. This variant is the
subject of the following section.

15.8 Discrete Logarithms on Elliptic Curves over Ex-

tension Fields
We now discuss some related algorithms, which can be applied to elliptic curves over
extension fields. We start by recalling Semaev’s idea of summation polynomials.

15.8.1 Semaev’s Summation Polynomials

Suppose that E is an elliptic curve defined over a prime field Fp , and that elements of Fp
are represented as integers in the interval [0, p − 1]. Semaev [539] considered a factor base

B = {(x, y) ∈ E(Fp ) : 0 ≤ x ≤ p1/n }

for some fixed integer n ≥ 2. Note that #B ≈ p1/n .

Semaev hoped to perform an index calculus algorithm similar to the one in Sec-
tion 15.5.1. For random points R = [a]P + [b]Q the task is to write R as a sum of points
in B. To accomplish this, Semaev introduced the notion of a summation polynomial.
Definition 15.8.1. Let E : y 2 = x3 + a4 x + a6 be an elliptic curve defined over Fq ,
where the characteristic of Fq is neither 2 nor 3 (this condition can be avoided). The
summation polynomials Summn ∈ Fq [x1 , x2 , . . . , xn ] for n ≥ 2 are defined as follows:
• Summ2 (x1 , x2 ) = x1 − x2 .
• Summ3 (x1 , x2 , x3 ) = (x1 − x2 )2 x23 − 2((x1 + x2 )(x1 x2 + a4 ) + 2a6 )x3 + ((x1 x2 −
a4 )2 − 4a6 (x1 + x2 )).
• Summn (x1 , x2 , . . . , xn ) = Rx (Summn−1 (x1 , . . . , xn−2 , x), Summ3 (xn−1 , xn , x)) for
n ≥ 4 where Rx (F, G) is the resultant of the polynomials F and G with respect to
the variable x.
For many more details see Section 3 of [177]. The following result is from [539].
Theorem 15.8.2. Summation polynomials have the following properties:
n n
• (x1 , . . . , xn ) ∈ Fq is a root of Summn if and only if there exists (y1 , . . . , yn ) ∈ Fq
Pn
such that Pi = (xi , yi ) ∈ E(Fq ) and i=1 Pi = ∞.
348 CHAPTER 15. SUBEXPONENTIAL ALGORITHMS

• Summn is symmetric.
• The degree of Summn in xi is 2n−2 .
Exercise 15.8.3. Prove Theorem 15.8.2.
One way to decompose R = (xR , yR ) in B is to find solutions (x1 , . . . , xn ) ∈ Zn to

Summn+1 (x1 , x2 , . . . , xn , xR ) ≡ 0 (mod p), such that 0 ≤ xi ≤ p1/n . (15.12)

If such a solution exists and can be found then one finds the corresponding y-coordinates
±yi . Suppose that each yi ∈ Fp . Then each Pi = (xi , yi ) is in B and by Theorem 15.8.2
there exist si ∈ {−1, 1} such that s1 P1 + · · · + sn Pn = R. The sign bits si can be found
by exhaustive search, thereby yielding a relation. Since #{P1 + P2 + · · · + Pn : Pi ∈ B} ≈
(p1/n )n /n! = p/n! the expected number of points R that have to be selected before a
relation is obtained is about n!.
Unfortunately, no efficient algorithm is known for solving the polynomial equation (15.12)
even for n = 5 (in which case the equation has degree 16 in each of its 5 variables). Cop-
persmith’s method (see Section 19.2) seems not to be useful for this task.
In reference to the remarks of Section 15.2.3 we see that all requirements for an index
calculus algorithm are met, except that it is not efficient to decompose a smooth element
over the factor base.

15.8.2 Gaudry’s Variant of Semaev’s Method

Gaudry [245] realised that it might be possible to take roots of summation polynomials
if one was working with elliptic curves over extension fields. Gaudry’s algorithm may
be viewed as doing Weil descent without divisor class groups. Indeed, the paper [245]
presents a general approach to index calculus on Abelian varieties and so the results apply
in greater generality than just Weil descent of elliptic curves.
Suppose that E is an elliptic curve defined over a finite field Fqn with n > 1.
Gaudry [245] defines a factor base

B = {(x, y) ∈ E(Fqn ) : x ∈ Fq }

so that #B ≈ q. Gaudry considers this as the set of Fq -rational points on the algebraic
set F formed by intersecting the Weil restriction of scalars of E with respect to Fqn /Fq
by n − 1 hyperplanes V (xi ) for 2 ≤ i ≤ n, where x = x1 θ1 + · · · + xn θn (with θ1 = 1) as
in Lemma 5.7.1. If the algebraic set F is irreducible then it is a 1-dimensional variety F .
In the relation generation stage, one attempts to decompose a randomly selected point
R ∈ E(Fqn ) as a sum of points in B. Gaudry observed that this can be accomplished by
finding solutions

(x1 , x2 , . . . , xn ) ∈ Fnq such that Summn+1 (x1 , x2 , . . . , xn , xR ) = 0. (15.13)

Note that Summn+1 (x1 , . . . , xn , xR ) ∈ Fqn [x1 , . . . , xn ] since E is defined over Fqn and
xR ∈ Fqn . The conditions xj ∈ Fq in equation (15.13) can be expressed algebraically as
follows. Select a basis {θ1 , . . . , θn } for Fqn over Fq and write
n
X
Summn+1 (x1 , . . . , xn , xR ) = Gi (x1 , . . . , xn )θi (15.14)
i=1

where Gi (x1 , . . . , xn ) ∈ Fq [x1 , . . . , xn ]. Note that the degree of Gi in xj is at most 2n−1 .

The polynomials Gi of equation (15.14) define an algebraic set in X ⊆ An and we are
15.8. ELLIPTIC CURVES OVER EXTENSION FIELDS 349

interested in the points in X(Fq ) (if there are any). Since Fq is finite there are only finitely
many Fq -rational solutions (x1 , . . . , xn ) to the system.
Gaudry assumes that X is generically a zero-dimensional algebraic set (Gaudry justi-
fies this assumption by noting that if F is a variety then the variety F n is n-dimensional,
and so the map from F n to the Weil restriction of E, given by adding together n points
in F , is a morphism between varieties of the same dimension, and so generically has
finite degree). The Fq -rational solutions can therefore be found by finding a Gröbner
basis for the ideal generated by the Gi and then taking roots in Fq of a sequence of uni-
variate polynomials each of which has degree at most 2n(n−1) . This is predicted to take
O(2cn(n−1) M (log(q))) bit operations for some constant c. Alternatively one could add
some field equations xqj − xj to the ideal, to ensure it is zero-dimensional, but this could
have an adverse effect on the complexity. Gaudry makes a further heuristic assumption,
namely that the smoothness probability behaves as expected when using the large prime
variant.
The size of the set {P1 + P2 + · · · + Pn : Pi ∈ B} is approximately q n /n! and so the
expected number of points R that have to be selected before a relation is obtained is about
n!. One needs approximately #B ≈ q relations to be able to find a non-trivial element in
the kernel of the relation matrix and hence integers a and b such that [a]D1 + [b]D2 ≡ 0.
It follows that the heuristic expected running time of Gaudry’s algorithm is

Õ(2cn(n−1) n!qM (log(q)) + q 2+o(1) ) (15.15)

bit operations as q → ∞. This is exponential in terms of n and log(q). However, for fixed
n, the running time can be expressed as Õ(q 2 ) bit operations.
Gaudry’s focus was on n fixed and relatively small. For any fixed n ≥ 5, Gaudry’s
heuristic algorithm for solving the ECDLP over Fqn is asymptotically faster than Pollard’s
rho method. The double large prime variant (mentioned in Section 15.6.3) can also be
2
used in this setting. The complexity therefore becomes (heuristic) Õ(q 2− n ) bit operations.
Hence Gaudry’s algorithm is asymptotically faster than Pollard rho even for n = 3 and
n = 4, namely Õ(q 4/3 ) rather than Õ(q 3/2 ) for n = 3 and Õ(q 3/2 ) rather than Õ(q 2 ) for
n = 4.

15.8.3 Diem’s Algorithm for the ECDLP

Gaudry’s focus was on the DLP in E(Fqn ) when n is fixed. This yields an exponential-
time algorithm. Diem [173, 177] considered the case where n is allowed to grow, and
obtained a subexponential-time algorithm. p
The crux of Diem’s method is remarkably simple: he assumes n ≈ log(q) and obtains
an algorithm for the DLP in E(Fqn ) with complexity O(q c ) for some constant c (note that
2
even some exponential-time computations in n are polynomial in q as en ≈ q). Now, q c =
n 3/2 c n 2/3
exp(c log(q)) and log(q ) = n log(q) ≈ log(q) so q ≈ exp(c log(q ) ) < Lqn (2/3, c).
Diem’s algorithm is very similar to Gaudry’s. In Gaudry’s algorithm, the factor base
consists of points whose x-coordinates lie in Fq . Diem defines a function ϕ = α ◦ x,
where α is an automorphism over Fqn of P1 that satisfies a certain condition, and defines
the factor base to be B = {P ∈ E(Fqn ) : ϕ(P ) ∈ P1 (Fq )}. The process of generating
relations proceeds in the standard way. Some important contributions of [177] are to
prove that the algebraic set defined by the summation polynomials has a good chance of
having dimension zero, and that when this is the case the points can be found by taking
2
resultants of multihomogeneous polynomials in time polynomial in en log(q) (which is
exponential in n but polynomial in q).
350 CHAPTER 15. SUBEXPONENTIAL ALGORITHMS

The main result of [177] is the following. We stress that this result does not rely on
any heuristics.

Theorem 15.8.4. (Diem) Let a, b ∈ R be such that 0 < a < b. There is an algorithm
such that, if q is a prime power and n ∈ N is such that
p p
a log(q) ≤ n ≤ b log(q)

and E is any elliptic curve over Fqn , then the algorithm solves the DLP in E(Fqn ) in an
n 2/3
expected eO(log(q ) ) bit operations.

15.9 Further Results

To end the chapter we briefly mention some methods for non-hyperelliptic curves. It
is beyond the scope of the book to present these algorithms in detail. We then briefly
summarise the argument that there is no subexponential algorithm for the DLP on elliptic
curves in general.

15.9.1 Diem’s Algorithm for Plane Curves of Low Degree

Diem [175] used the Adleman-DeMarrais-Huang idea of generating relations using prin-
cipal divisors a(x) − yb(x) for the DLP on plane curves F (x, y) = 0 of low degree (the
degree of such a curve is the total degree of F (x, y) as a polynomial). Such curves are
essentially the opposite case to hyperelliptic curves (which have rather high degree in x
relative to their genus). The trick is simply to note that if F (x, y) has relatively low de-
gree compared to its genus then so does b(x)d F (x, a(x)) and so the divisor of the function
a(x) − yb(x) has relatively low weight. The main result is an algorithm with heuristic
complexity Õ(q 2−2/(d−2) ) bit operations for a curve of degree d over Fq .
In the case of non-singular plane quartics (genus 3 curves C over Fq ) Diem takes the
factor base to be a large set of points B ⊆ C(Fq ). He generates relations by choosing two
distinct points P1 , P2 ∈ B and intersecting the line y = bx + c between them with the
curve C. There are two other points of intersection, corresponding to the roots of the
quadratic polynomial F (x, bx + c)/((x − xP1 )(x − xP2 )) and so with probability roughly
1/2 we expect to get a relation in the divisor class group among points in C(Fq ). Diem
shows that the algorithm has complexity Õ(q) bit operations.
Due to lack of space, and since our focus in this book is hyperelliptic curves (though, it
is important to note that Smith [573] has given a reduction of the DLP from hyperelliptic
curves of genus 3 to plane quartics) we do not present any further details. Interested
readers should see [175, 178].

15.9.2 The Algorithm of Enge-Gaudry-Thomé and Diem

The algorithms for the DLP in the divisor class√group of a hyperelliptic curve in Sec-
tions 15.6.1 and 15.6.2 had complexity Lqg (1/2, 2 + o(1)) bit operations as q → ∞. A
natural problem is to find algorithms with complexity Lqg (1/3, c + o(1)), and this is still
open in general. However, an algorithm is known for curves of the form y n + F (x, y) = 0
where degy (F (x, y)) ≤ n − 1 and degx (F (x, y)) = d for n ≈ g 1/3 and d ≈ g 2/3 . We
do not have space to give the details, so simply quote the results and refer to Enge and
Gaudry [196], Enge, Gaudry and Thomé [197] and Diem [174]. An algorithm to compute
the group structure of Pic0C (Fq ) is given with heuristic complexity of Lqg (1/3, c + o(1))
15.9. FURTHER RESULTS 351

bit operations for some constant c. For the discrete logarithm problem the algorithm has
heuristic complexity Lqg (1/3, c′ + o(1)) bit operations where c′ is a constant.
Unlike the LN (1/3, c + o(1)) algorithms for factoring or DLP in finite fields, the al-
gorithm does not use two different factor bases. Instead, the algorithm is basically the
same idea as Sections 15.6.2 and 15.9.1 with a complexity analysis tailored for curves of
a certain form.

15.9.3 Index Calculus for General Elliptic Curves

In this section we briefly discuss why there does not seem to be a subexponential algorithm
for the DLP on general elliptic curves.
An approach to an index calculus algorithm for elliptic curves was already discussed by
Miller [428] in the paper that first proposed elliptic curves for cryptography. In particular
he considered “lifting” an elliptic curve E over Fp to an elliptic curve E e over Q (i.e., so
that reducing the coefficients of E e modulo p yields E). The factor base B was defined to
e
be the points of small height (see Section VIII.6 of [564] for details of heights) in E(Q).
The theory of descent (see Chapter VIII of Silverman [564]) essentially gives an algorithm
to decompose a point as a sum of points of small height (when this is possible). The idea
would therefore be to take random points [a]P + [b]Q ∈ E(Fp ), lift them to E(Q) e and
then decompose them over the factor base. There are several obstructions to this method.
e
First, lifting a random point from E(Fp ) to E(Q) seems to be hard in general. Indeed,
Miller argued (see also [566]) that there are very few points of small height in E(Q)e and
so (since we are considering random points [a]P + [b]Q from the exponentially large set
e
E(Fp )) it would be necessary to lift to exponentially large points in E(Q). Second, the
lifting itself seems to be a non-trivial computational task (essentially, solving a non-linear
Diophantine equation over Z).
Silverman proposed the Xedni calculus attack11 , which was designed to solve the lift-
ing problem. This algorithm was analysed in [322], where it is shown that the probability
of finding useful relations is too low.
By now, many people have tried and failed to discover an index calculus algorithm for
the DLP on general elliptic curves. However, this does not prove that no such algorithm
exists, or that a different paradigm could not lead to faster attacks on the elliptic curve
DLP.

11 “Xedni” is “Index” spelled backwards.