Finding shortest lattice vectors faster using quantum search

By applying a quantum search algorithm to various heuristic and provable sieve algorithms from the literature, we obtain improved asymptotic quantum results for solving the shortest vector problem on lattices. With quantum computers we can provably find a shortest vector in time \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$2^{1.799n + o(n)}$$\end{document}21.799n+o(n), improving upon the classical time complexities of \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$2^{2.465n + o(n)}$$\end{document}22.465n+o(n) of Pujol and Stehlé and the \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$2^{2n + o(n)}$$\end{document}22n+o(n) of Micciancio and Voulgaris, while heuristically we expect to find a shortest vector in time \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$2^{0.268n + o(n)}$$\end{document}20.268n+o(n), improving upon the classical time complexity of \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$2^{0.298n + o(n)}$$\end{document}20.298n+o(n) of Laarhoven and De Weger. These quantum complexities will be an important guide for the selection of parameters for post-quantum cryptosystems based on the hardness of the shortest vector problem.


Introduction
Large-scale quantum computers will redefine the landscape of computationally secure cryptography, including breaking public-key cryptography based on integer factorization or the discrete logarithm problem [75] or the principle ideal problem in real quadratic number fields [37], providing sub-exponential attacks for some systems based on elliptic curve isogenies [23], speeding up exhaustive searching [15,35], counting [18] and (with appropriate assumptions about the computing architecture) finding collisions and claws [4,17,19], among many other quantum algorithmic speed-ups [22,61,76].
Currently, a small set of systems [12] are being studied intensely as possible systems to replace those broken by large-scale quantum computers. These systems can be implemented with conventional technologies and to date seem resistant to substantial quantum attacks. It is critical that these systems receive intense scrutiny for possible quantum or classical attacks. This will boost confidence in the resistance of these systems to (quantum) attacks, and allow us to fine-tune secure choices of parameters in practical implementations of these systems.
One such set of systems bases its security on the computational hardness of certain lattice problems. Since the late 1990s, there has been a lot of research into the area of lattice-based cryptography, resulting in encryption schemes [39,60,68], digital signature schemes [26,33,56] and even fully homomorphic encryption schemes [16,32]. Each of the lattice problems that underpin the security of these systems can be reduced to the shortest vector problem [77]. Conversely, the decisional variant of the shortest vector problem can be reduced to the average case of such lattice problems. For a more detailed summary on the security of lattice-based cryptography, see [49,77].
In this paper, we closely study the best-known algorithms for solving the shortest vector problem, and how quantum algorithms may speed up these algorithms. By challenging and improving the best asymptotic complexities of these algorithms, we increase the confidence in the security of lattice-based schemes. Understanding these algorithms is critical when selecting key-sizes and other security parameters. Any non-trivial algorithmic advance has the potential to compromise the security of a deployed cryptosystem, for example in [13] an improvement in the index calculus method for finding discrete logarithms led to the break of a Diffie-Hellman system that had been deployed in software and was in the process of being implemented in hardware.

Lattices
Lattices are discrete subgroups of R n . Given a set of n linearly independent vectors B = {b 1 , . . . , b n } in R n , we define the lattice generated by these vectors as L = n i=1 λ i b i : λ i ∈ Z . We call the set B a basis of the lattice L . This basis is not unique; applying a unimodular matrix transformation to the vectors of B leads to a new basis B of the same lattice L .
In lattices, we generally work with the Euclidean or 2 -norm, which we will denote by · . For bases B, we write B = max i b i . We refer to a vector s ∈ L \ {0} such that s ≤ v for any v ∈ L \ {0} as a shortest (non-zero) vector of the lattice. Its length is denoted by λ 1 (L ). Given a basis B, we write P(B) = n i=1 λ i b i : 0 ≤ λ i < 1 for the fundamental domain of B.
One of the most important hard problems in the theory of lattices is the shortest vector problem (SVP). Given a basis of a lattice, the shortest vector problem consists of finding a shortest non-zero vector in this lattice. In many applications, finding a reasonably short vector instead of a shortest vector is also sufficient. The approximate shortest vector problem with approximation factor δ (SVP δ ) asks to find a non-zero lattice vector v ∈ L with length bounded from above by v ≤ δ · λ 1 (L ).
Finding short vectors in a lattice has been studied for many reasons, including the construction of elliptic curve cryptosystems [7,28,29], the breaking of knapsack cryptosystems [25,51,57,66] and low-exponent RSA [24,78], and proving hardness results in Diffie-Hellman-type schemes [14]. For appropriately chosen lattices, the shortest vector problem appears to be hard, and may form the basis of new public-key cryptosystems.

Finding short vectors
The approximate shortest vector problem is integral in the cryptanalysis of lattice-based cryptography [30]. For small values of δ, this problem is known to be NP-hard [2,44], while for certain exponentially large δ polynomial time algorithms are known to exist that solve this problem, such as the celebrated LLL algorithm of Lenstra et al. [52,57]. Other algorithms trade extra running time for a better δ, such as LLL with deep insertions [73] and the BKZ algorithm of Schnorr and Euchner [73].
The current state-of-the-art for classically finding short vectors is BKZ 2.0 [21,72], which is essentially the original BKZ algorithm with the improved SVP subroutine of Gama et al. [31]. Implementations of this algorithm, due to Chen and Nguyen [21] and Aono and Naganuma [8], currently dominate the SVP and lattice challenge hall of fame [53,71] together with a yet undocumented modification of the random sampling reduction (RSR) algorithm of Schnorr [74], due to Kashiwabara et al. [71].
In 2003, Ludwig [55] used quantum algorithms to speed up the original RSR algorithm. By replacing a random sampling from a big list by a quantum search, Ludwig achieves a quantum algorithm that is asymptotically faster than its classical counterpart. Ludwig also details the effect that this faster quantum algorithm would have had on the practical security of the lattice-based encryption scheme NTRU [39], had there been a quantum computer in 2005.

Finding shortest vectors
Although it is commonly sufficient to find a short vector (rather than a shortest vector), the BKZ algorithm and its variants all require a low-dimensional exact SVP solver as a subroutine. In theory, any of the known methods for finding a shortest vector could be used. We briefly discuss the three main classes of algorithms for finding shortest vectors below.
Enumeration The classical method for finding shortest vectors is enumeration, dating back to work by Pohst [64], Kannan [43] and Fincke and Pohst [27] in the first half of the 1980s. In order to find a shortest vector, one enumerates all lattice vectors inside a giant ball around the origin. If the input basis is only LLL-reduced, enumeration runs in 2 O(n 2 ) time, where n is the lattice dimension. The algorithm by Kannan uses a stronger preprocessing of the input basis, and runs in 2 O(n log n) time. Both approaches use only polynomial space in n.
Sieving In 2001, Ajtai et al. [3] introduced a technique called sieving, leading to the first probabilistic algorithm to solve SVP in time 2 O(n) . Several different sieving methods exist, but they all rely on somehow saturating the space of short lattice vectors, by storing all these vectors in a long list. This list will inevitably be exponential in the dimension n, but it can be shown that these algorithms also run in single exponential time, rather than superexponential (as is the case for enumeration). Recent work has also shown that the time and space complexities of sieving improve when working with ideal lattices [40,70], leading to the current highest record in the ideal lattice challenge hall of fame [63].
Computing the Voronoi cell In 2010, Micciancio and Voulgaris presented a deterministic algorithm for solving SVP based on constructing the Voronoi cell of the lattice [58]. In time 2 2n+o(n) , this algorithm is able to construct an exact 2 n+o(n) -space description of the Voronoi cell of the lattice, which can then be used to solve both SVP and CVP. The overall time complexity of 2 2n+o(n) was until late 2014 the best known complexity for solving SVP in high dimensions. 1 Discrete Gaussian sampling Very recently, an even newer technique was introduced by Aggarwal et al. [1], making extensive use of discrete Gaussians on lattices. By initially sampling 2 n+o(n) lattice vectors from a very wide discrete Gaussian distribution (with a large standard deviation), and then iteratively combining and averaging samples to generate samples from a more narrow discrete Gaussian distribution on the lattice, the standard deviation can be reduced until the point where a set of many samples of the resulting distribution is likely to contain a shortest non-zero vector of the lattice. This algorithm runs in provable 2 n+o(n) time and space.
Practice While sieving, the Voronoi cell algorithm, and the discrete Gaussian sampling algorithm have all surpassed enumeration in terms of classical asymptotic time complexities, in practice enumeration still dominates the field. The version of enumeration that is currently used in practice is due to Schnorr and Euchner [73] with improvements by Gama et al. [31]. It does not incorporate the stronger version of preprocessing of Kannan [43] and hence has an asymptotic time complexity of 2 O(n 2 ) . However, due to the larger hidden constants in the exponents and the exponential space complexity of the other algorithms, enumeration is actually faster than other methods for most practical values of n. That said, these other methods are still relatively new and unexplored, so a further study of these other methods may tip the balance.

Quantum search
In this paper we will study how quantum algorithms can be used to speed up the SVP algorithms outlined above. More precisely, we will consider the impact of using Grover's quantum search algorithm [35], which considers the following problem.
Given a list L of length N and a function f : L → {0, 1}, such that the number of elements e ∈ L with f (e) = 1 is small. Construct an algorithm "Search" that, given L and f as input, returns an e ∈ L with f (e) = 1, or determines that (with high probability) no such e exists. We assume for simplicity that f can be evaluated in unit time.
Classical algorithm With classical computers, the natural way to find such an element is to go through the whole list, until one of these elements is found. This takes on average O(N ) time. This is also optimal up to a constant factor; no classical algorithm can find such an element in less than Ω(N ) time.
Quantum algorithm Using Grover's quantum search algorithm [15,18,35], we can find such an element in time O( √ N ). This is optimal up to a constant factor, as any quantum algorithm needs at least Ω( √ N ) evaluations of f [10]. Throughout the paper, we will write x ← Search{e ∈ L : f (e) = 1} to highlight subroutines that perform a search in some long list L, looking for an element e ∈ L satisfying f (e) = 1. This assignment returns true if an element e ∈ L with f (e) = 1 is found (and assigns such an element to x), and returns false if no such e exists. This allows us to give one description for both the classical and quantum versions of each algorithm, as the only difference between the two versions is which version of the subroutine is used.

RAM model
For both the classical and the quantum versions of these search algorithms, we assume a RAM model of computation where the jth entry of the list L can be looked up in constant time (or polylogarithmic time). In the case that L is a virtual list where the jth element can be computed in time polynomial in the length of j (thus polylogarithmic in the length of the list L), then look-up time is not an issue. When L is indeed an unstructured list of values, for classical computation, the assumption of a RAM-like model has usually been valid in practice. However, there are fundamental reasons for questioning it [11], and there are practical computing architectures where the assumption does not apply. In the case of quantum computation, a practical RAM-like quantum memory (e.g. [34]) looks particularly challenging, especially for first generation quantum computers. Some authors have studied the limitations of quantum algorithms in this context [11,36,41].
Some algorithms (e.g. [4]) must store a large database of information in regular quantum memory (that is, memory capable of storing quantum superpositions of states). In contrast, quantum searching an actual list of N (classical) strings requires the N values to be stored in quantumly addressable classical memory (e.g. as Kuperberg discusses in [45,46]) and O(log N ) regular qubits. Quantumly addressable classical memory in principle could be much easier to realize in practice than regular qubits. Furthermore, quantum searching for a value x ∈ {0, 1} n satisfying f (x) = 1 for a function f : {0, 1} n → {0, 1} which can be implemented by a circuit on O(n) qubits only requires O(n) regular qubits, and there is no actual list to be stored in memory. In this paper, the quantum search algorithms used require the lists of size N to be stored in quantumly addressable classical memory and use O(log N ) regular qubits and O( √ N ) queries into the list of numbers. In this work, we consider (conventional) classical RAM memories for the classical algorithms, and RAM-like quantumly addressable classical memories for the quantum search algorithms. This is both a first step for future studies in assessing the impact of more practical quantum architectures, and also represents a more conservative approach in determining parameter choices for lattice-based cryptography that should be resistant against the potential power of quantum algorithmic attacks. Future work may also find ways to take advantage of advanced quantum search techniques, such as those surveyed in [69].

Contributions
In this paper, we show that quantum algorithms can significantly speed up various sieving algorithms from the literature. The constants in the time exponents generally decrease by approximately 25 %, leading to an improvement in both the best provable (exact and approximate) and the best heuristic asymptotic results for solving the shortest vector problem: -Provably, we can find a shortest vector in any lattice in time 2 1.799n+o(n) .
(Without quantum search, the best provable algorithm (see footnote 1) runs in time 2 2.000n+o(n) .) -Heuristically, we can find a shortest vector in any lattice in time 2 0.286n+o(n) . (Without quantum search, the best heuristic algorithm runs in time 2 0.337n+o(n) .) -Provably, we can solve SVP δ in any lattice in time 2 0.603n+o δ (n) . 2 (Without quantum search, the best provable algorithm runs in time 2 0.804n+o δ (n) .) Table 1 contains an overview of classical and quantum complexities of various SVP algorithms, and summarizes the results in this paper. While the Voronoi cell algorithm [58] is asymptotically the best algorithm in the provable classical setting (see footnote 1), we show that with quantum search, both the AKS-Birthday algorithm described by Hanrot et al. [38] and the ListSieve-Birthday algorithm of Pujol and Stehlé [65] surpass the 2 2n+o(n) time complexity of the Voronoi cell algorithm. While the main focus in this paper is on sieving algorithms, we also briefly consider applying quantum search to other methods, and argue why applying the same techniques does not easily lead to significant speed-ups for those algorithms.
After the initial submission of our paper, it was shown that the provable time complexity of solving SVP can be further improved to 2 n+o(n) using a new method based on discrete Gaussian sampling [1]. Since the provable time complexity of sieving (using quantum search) is asymptotically higher than 2 n+o(n) , this means that sieving on a quantum computer is no longer the best provable algorithm (asymptotically) for solving SVP exactly. In Sect. 9.3 we therefore also discuss the impact that quantum search may have on the discrete Gaussian sampling method.
The heuristic improvements obtained with quantum search are also shown in Fig. 1. This figure also shows the tunable trade-offs that may be obtained with various classical and quantum sieving algorithms (rather than just the single entries given in Table 1). As can be seen in the figure, we only obtain a useful trade-off between the quantum time and space complexities for the HashSieve and SphereSieve algorithms; for other algorithms the trade-offs are not really trade-offs, as both the time and the space complexity increase by changing the parameters.

Outline
The outline of this paper is as follows, and can also be found in Table 1. In Sect. 2 we first consider the current best provable sieving algorithm for solving the shortest vector problem, the ListSieve-Birthday algorithm of Pujol and Stehlé [65]. This is the birthday paradox variant of the ListSieve algorithm of Micciancio and Voulgaris [59] (which is briefly described in Sect. 8.2), and we get the best provable quantum time complexity by applying quantum search to this algorithm. In Sects. 3 and 4 we then consider two of the most important heuristic sieving algorithms to date, the NV-Sieve algorithm of Nguyen and Vidick [62] and the GaussSieve algorithm of Micciancio and Voulgaris [59]. In Sect. 5 we then show how we obtain the best heuristic quantum time complexity, by applying quantum search to the very recent HashSieve algorithm of Laarhoven [47], which in turn builds upon the NV-Sieve and the GaussSieve. Finally, in Sect. 8 we discuss quantum speed-ups for various other sieving algorithms, and in Sect. 9 we discuss why quantum search does not seem to lead to big asymptotic improvements in the time complexity of the Voronoi cell algorithm and enumeration algorithms. 2 Here o δ (n) corresponds to a function f (δ, n) satisfying lim δ→∞ lim n→∞ 1 n f (δ, n) → 0.  Except for the italicized algorithms, these are all results based on sieving. The top rows describe provable algorithms for SVP, the middle rows describe heuristic algorithms for SVP, and the bottom rows describe provable algorithms for solving SVP δ , and their asymptotic complexities as δ, n → ∞ Entries in bold indicate the best known asymptotic time complexities to date

The provable ListSieve-Birthday algorithm of Pujol and Stehlé
Using the birthday paradox [57], Pujol and Stehlé [65] showed Algorithm 1. Here γ = 1 − 1 n , B n (0, ξμ) denotes the ball centered at 0 of radius ξμ, and the various other parameters will be discussed below.

Description of the algorithm
The algorithm can roughly be divided in three stages, as follows.
First, the algorithm generates a long list L of lattice vectors with norms between Rμ and B . This 'dummy' list is used for technical reasons to make the proof strategy work. The number of samples used for generating this list is taken as a random variable, which again is done to make certain proof techniques work. Note that besides the actual lattice vectors v, to generate this list we also consider slightly perturbed vectors v which are not in the lattice, but are at most ξμ away from v. This is yet again a technical modification purely aimed at making the proofs work, as experiments show that without such perturbed vectors, these algorithms also work fine.
After generating L, we generate a fresh list of short lattice vectors S. The procedure for generating these vectors is similar to that of generating T , with two exceptions: (i) now all sampled lattice vectors are added to S (regardless of their norms), and (ii) the vectors are reduced with the dummy list L rather than with vectors in S. The latter guarantees that the vectors in S are all independent and identically distributed.
Finally, when S has been generated, we hope that it contains two distinct lattice vectors s 1 , s 2 that are at most μ ≈ λ 1 (L ) apart. So we search S × S for a pair (s 1 , s 2 ) of close, distinct lattice vectors, and return their difference.

Algorithm 1
The ListSieve-Birthday algorithm 1: Sample a random number N 1 ∈ [0, N 1 ] 2: Initialize an empty list L 3: for i ← 1 to N 1 do 4: Sample a random perturbation vector e ← B n (0, ξμ) 5: Compute the translated vector v ← e mod P(B) 6: Reduce v with w 8: Subtract the perturbation vector e: v ← v − e 9: if v ≥ Rμ then 10: Add the lattice vector v to the list L 11: Initialize an empty list S 12: for i ← 1 to N 2 do 13: Sample a random perturbation vector e ← B n (0, ξμ) 14: Compute the translated vector v ← e mod P(B) 15: Reduce v with w 17: Subtract the perturbation vector e: v ← v − e 18: Add the lattice vector v to the list S 19:

Classical complexities
With a classical search applied to the subroutines in Lines 6, 15, and 19, Pujol and Stehlé analyzed that the costs of the algorithm are: The constants c b , c t , c g , N 1 and N 2 above are defined as In [65] this led to the following result on the time and space complexities.

Lemma 1 [65]
Let ξ > 1 2 and R > 2ξ , and suppose μ > λ 1 (L ). Then with probability at least 1 16 , the ListSieve-Birthday algorithm returns a lattice vector s ∈ L \ {0} with s < μ, in time at most 2 c time n+o(n) and space at most 2 c space n+o(n) , where c time and c space are given by By balancing ξ and R optimally, Pujol and Stehlé obtained the following result.
Corollary 1 [65] Letting ξ ≈ 0.9476 and R ≈ 3.0169, we obtain Thus, using polynomially many queries to the ListSieve-Birthday algorithm with these parameters, we can find a shortest vector in a lattice with probability exponentially close to 1 using time at most 2 2.465n+o(n) and space at most 2 1.233n+o(n) .

Quantum complexities
Applying a quantum search subroutine to Lines 6, 15, and 19, we get the following costs for the quantum algorithm based on ListSieve-Birthday: This leads to the following general lemma about the overall quantum time and space complexities.

Lemma 2
Let ξ > 1 2 and R > 2ξ , and suppose μ > λ 1 (L ). Then with probability at least 1 16 , the ListSieve-Birthday algorithm returns a lattice vector s ∈ L \ {0} with s < μ on a quantum computer in time at most 2 q time n+o(n) and space at most 2 q space n+o(n) , where q time and q space are given by Re-optimizing the parameters ξ and R subject to the given constraints, to minimize the overall time complexity, we obtain the following result.
Theorem 1 Letting ξ ≈ 0.9086 and R ≈ 3.1376, we obtain Thus, using polynomially many queries to the ListSieve-Birthday algorithm, we can find a shortest non-zero vector in a lattice on a quantum computer with probability exponentially close to 1, in time at most 2 1.799n+o(n) and space at most 2 1.286n+o(n) .
So the constant in the exponent of the time complexity decreases by about 27 % when using quantum search.
Remark If we generate S in parallel, we can potentially achieve a time complexity of 2 1.470n+o(n) , by setting ξ ≈ 1.0610 and R ≈ 4.5166. However, it would require exponentially many parallel quantum computers of size O(n) to achieve a substantial theoretical speed-up over the 2 1.799n+o(n) of Theorem 1.

The heuristic NV-Sieve algorithm of Nguyen and Vidick
In 2008, Nguyen and Vidick [62] considered a heuristic, practical variant of the original AKS-Sieve algorithm of Ajtai et al. [3], which 'provably' returns a shortest vector under a certain natural, heuristic assumption. A slightly modified but essentially equivalent description of this algorithm is given in Algorithm 2.

Algorithm 2
The NV-Sieve algorithm 1: Sample a list L 0 of exponentially many random lattice vectors, and set m = 0 2: repeat 3: Compute the maximum norm R m = max v∈L m v 4: Initialize an empty list L m+1 and an empty list of centers C m+1 5: for each v ∈ L m do 6: if v ≤ γ R m then 7: Add v to the list L m+1 8: Continue the loop 9: while w ← Search{w ∈ C m+1 : v ± w ≤ w } do 10: Reduce v with w 11: Add v to the list L m+1 12: Continue the outermost loop 13: Add v to the centers C m+1 14: Increment m by 1 15: until L m is empty 16: Search for a shortest vector in L m−1

Description of the algorithm
The algorithm starts by generating a big list L 0 of random lattice vectors with length at most n B . Then, by repeatedly applying a sieve to this list, shorter lists of shorter vectors are obtained, until the list is completely depleted. In that case, we go back one step and search for the shortest vector in the last non-empty list.
The sieving step consists of splitting the previous list L m in a set of 'centers' C m+1 and a new list of vectors L m+1 that will be used for the next round. For each vector v ∈ L m , the algorithm first checks if a vector w ∈ C m exists that is close to ±v. If this is the case, then we add the vector v ± w to L m+1 . Otherwise v is added to C m+1 . Since the set C m+1 consists of vectors with a bounded norm and any two vectors in this list have a specified minimum pairwise distance, one can bound the size of C m+1 from above using a result of Kabatiansky and Levenshtein [42] regarding sphere packings. In other words, C m+1 will be sufficiently small, so that sufficiently many vectors are left for inclusion in the list L m+1 . After applying the sieve, we discard all vectors in C m+1 and apply the sieve again to the vectors in L m+1 .

Classical complexities
In Line 9 Algorithm 2, we have highlighted an application of a search subroutine that could be replaced by a quantum search. Using a standard classical search algorithm for this subroutine, under a certain heuristic assumption Nguyen and Vidick give the following estimate for the time and space complexity of their algorithm. Note that these estimates are based on the observation that the sizes of S and C are bounded from above by 2 c h n+o(n) , so that the total space complexity is at most O(|S|+|C|) = 2 c h n+o(n) and the total time complexity is at mostÕ(|S|· |C|) = 2 2c h n+o(n) , assuming the sieve needs to be performed a polynomial number of times.
To obtain a minimum time complexity, γ should be chosen as close to 1 as possible. Letting γ → 1 Nguyen and Vidick thus obtain the following estimates for the complexity of their heuristic algorithm.

Quantum complexities
If we use a quantum search subroutine in Line 9, the complexity of this subroutine decreases fromÕ(|C|) toÕ( √ |C|). Since this search is part of the bottleneck for the time complexity, applying a quantum search here will decrease the overall running time as well. Since replacing the classical search by a quantum search does not change the internal behavior of the algorithm, the estimates and heuristics are as valid as they were in the classical setting.
Lemma 4 Let 2 3 < γ < 1. Then the quantum version of the NV-Sieve algorithm heuristically returns a shortest non-zero lattice vector in time at most 2 q time n+o(n) and space at most 2 q space n+o(n) , where q time and q space are given by Again, minimizing the asymptotic quantum time complexity corresponds to taking γ as close to 1 as possible, which leads to the following result.
Thus, the quantum version of the NV-Sieve algorithm heuristically finds a shortest vector in time 2 0.312n+o(n) and space 2 0.208n+o(n) .
In other words, applying quantum search to Nguyen and Vidick's sieve algorithm leads to a 25 % decrease in the asymptotic exponent of the runtime.

The heuristic GaussSieve algorithm of Micciancio and Voulgaris
In 2010, Micciancio and Voulgaris [59] described a heuristic variant of their provable ListSieve algorithm, for which they could not give a (heuristic) bound on the time complexity, but which has a better heuristic bound on the space complexity, and has a better practical time complexity. The algorithm is described in Algorithm 3.

Description of the algorithm
The algorithm is similar to the ListSieve-Birthday algorithm described earlier, with the following main differences: (i) we do not explicitly generate two lists S, L to apply the Algorithm 3 The GaussSieve algorithm 1: Initialize an empty list L and an empty stack S 2: repeat 3: Get a vector v from the stack (or sample a new one) 4: while w ← Search{w ∈ L : v ± w ≤ v } do 5: Reduce v with w 6: while w ← Search{w ∈ L : w ± v ≤ w } do 7: Remove w from the list L 8: Reduce w with v 9: Add w to the stack S 10: if v has changed then 11: Add v to the stack S 12: else 13: Add v to the list L 14: until v is a shortest vector birthday paradox in the proof; (ii) we do not use a geometric factor γ < 1 but always reduce a vector if it can be reduced; (iii) we also reduce existing list vectors w ∈ L with newly sampled vectors, so that each two vectors in the list are pairwise Gauss-reduced; and (iv) instead of specifying the number of iterations in advance, we run the algorithm until we get so many collisions that we are convinced we have found a shortest vector in our list.

Classical complexities
Micciancio and Voulgaris state that the algorithm above has an experimental time complexity of about 2 0.52n and a space complexity which is most likely bounded by 2 0.208n due to the kissing constant [59,Sect. 5]. In practice this algorithm even seems to outperform the NV-Sieve algorithm of Nguyen and Vidick [62]. It is therefore sometimes conjectured that this algorithm also has a time complexity of the order 2 0.415n+o(n) , and the apparent extra factor 2 0.1n in the experimental time complexity may come from non-negligible polynomial factors in low dimensions. Thus one might conjecture the following.
Note that this algorithm is again (conjectured to be) quadratic in the space complexity, since each pair of list vectors needs to be compared and potentially reduced at least once (and at most a polynomial number of times) to make sure that the final list is Gauss-reduced.

Quantum complexities
To this heuristic algorithm, we can again apply the quantum speed-up using quantum search. If the number of times a vector is compared with L to look for reductions is polynomial in n, this then leads to the following result.

Conjecture 2
The quantum version of the GaussSieve algorithm heuristically returns a shortest non-zero lattice vector in time at most 2 q time n+o(n) and space at most 2 q space n+o(n) , where q time and q space are given by q time ≈ 0.312, q space ≈ 0.208.
Algorithm 4 The HashSieve algorithm 1: Initialize an empty list L and an empty stack S 2: Initialize t empty hash tables 3: Sample k · t random hash vectors 4: repeat 5: Get a vector v from the stack (or sample a new one) 6: Let the set of candidates C be those vectors that collide with v in one of the hash tables 7: Reduce v with w 9: while w ← Search{w ∈ C : w ± v ≤ w } do 10: Remove w from the list L 11: Remove w from the t hash tables 12: Reduce w with v 13: Add w to the stack S 14: if v has changed then 15: Add v to the stack S 16: else 17: Add v to the list L 18: Add v to the t hash tables 19: until v is a shortest vector This means that the exponent in the time complexity is again conjectured to be reduced by about 25 % using quantum search, and the exponents are the same as for the NV-Sieve algorithm. Since the GaussSieve seems to outperform the NV-Sieve in practice, applying quantum search to the GaussSieve will probably lead to better practical time complexities.

Description of the algorithm
Recently, a modification of the GaussSieve and NV-Sieve algorithms was proposed in [47], improving the time complexity by using angular locality-sensitive hashing [20]. By storing low-dimensional sketches of the list vectors w ∈ L in these algorithms, it is possible to significantly reduce the number of list vectors w that need to be compared to a target vector v at the cost of increasing the space complexity. Using an exponential number of hash tables, where each list vector is assigned to one of the hash buckets in each hash table, and where vectors in the same bucket are more likely to be "close" in the Euclidean sense than vectors which are not in the same bin, we obtain the set of candidate close(st) vectors by computing which bucket this vector would have landed in, and taking all vectors from those bins as candidates.

Classical complexities
With a proper balancing of the parameters, it can be guaranteed (heuristically) that the number of candidate vectors for each comparison is of the order 2 0.1290n . This roughly corresponds to having O(1) colliding vectors in each hash table, as the number of hash tables is also of the order t = 2 0.1290n , and this choice is optimal in the sense that this leads to a minimal time complexity of 2 0.3366n ; the space complexity is also 2 0.3366n , and thus using even more hash tables increases the space complexity beyond the time complexity, thus also increasing the time complexity further. The exact choice of parameters is given below.
In other words, using t ≈ 2 0.129n hash tables and a hash length of k ≈ 0.221n, the time and space complexities of the HashSieve algorithm are balanced at 2 0.337n+o(n) .

Quantum complexities
With a quantum search on the set of candidates in Lines 7 and 9, we can further reduce the time complexity. The optimization changes in the sense that the time to search the list of candidates with quantum search is potentially reduced from 2 (2−α)c n n+o(n) to 2 ( 3 2 − 1 2 α)c n n+o(n) , where c n = log 2 N ≈ 0.2075 is the expected log-length of the list L and α is defined in [47]. The numerical optimization of the parameters can be performed again, and leads to the following result.

Theorem 3
Let log 2 (t) ≈ 0.078. Then the quantum HashSieve algorithm heuristically returns a shortest non-zero lattice vector in time at most 2 q time n+o(n) and space at most 2 q space n+o(n) , where q time and q space are given by In other words, using t ≈ 2 0.078n hash tables and a hash length of k ≈ 0.134n, the quantum time and space complexities of the algorithm are balanced at 2 0.286n+o(n) .
It is possible to obtain a continuous trade-off between the quantum time and space complexities, by choosing log 2 (t) ∈ [0, 0.07843] differently. Similar to Fig. 1 of [47], Fig. 1 shows the resulting trade-off, and a comparison with previous classical heuristic time complexities.

Description of the algorithm
Even more recently, another LSH-based modification of the NV-Sieve algorithm was proposed in [48], improving upon the time complexity of the HashSieve using spherical locality-sensitive hashing. This particular hash method, introduced by Andoni et al. [5,6], works very well for data sets that (approximately) lie on the surface of a hypersphere, which is the case for the iterative sieving steps of the NV-Sieve. By dividing up the sphere into 2 Θ( √ n) regions in a way similar as in the 2-Level-Sieve of Wang et al. [79], it can be guaranteed that vectors have a significantly lower probability of ending up in the same region if their angle is large. Again using exponentially many hash tables, where each list vector is assigned to one of the hash buckets in each hash table, we obtain a set of candidate close(st) vectors by computing which bucket this vector would have landed in, and taking all vectors from those bins as candidates. The algorithm itself is a merge of the introduction of hash tables, as in the HashSieve, and the NV-Sieve of Nguyen and Vidick, with the important observation is that the hash functions used are different than in the HashSieve.

Classical complexities
With a proper balancing of the parameters, it can be guaranteed (heuristically) that the number of candidate vectors for each comparison is of the order 2 0.0896n , which is again similar to the number of hash tables, which is of the order t = 2 0.0896n . This choice is optimal in that this leads to a minimal time complexity of 2 0.2972n ; the space complexity is also 2 0.2972n , and thus using even more hash tables increases the space complexity beyond the time complexity. The exact choice of parameters is given below. In other words, using t ≈ 2 0.0896n hash tables and a hash length of k = Θ( √ n), the time and space complexities of the SphereSieve algorithm are balanced at 2 0.298n+o(n) .

Quantum complexities
With a quantum search on the set of candidates, we can again potentially reduce the time complexity. Again, the time to search the list of candidates with quantum search is reduced from 2 (2−α)c n n+o(n) to 2 3 2 − 1 2 α c n n+o(n) , where c n = log 2 N ≈ 0.2075 is the expected loglength of the list L and bounds on α are defined in [48]. The numerical optimization of the parameters can be performed again, and leads to the following result.
In other words, using t ≈ 2 0.0413n hash tables and a hash length of k = Θ( √ n), the quantum time and space complexities of the algorithm are balanced at 2 0.268n+o(n) .
Again, one may obtain a trade-off between the quantum time and space complexities, by choosing log 2 (t) ∈ [0, 0.0413]. This trade-off is shown in Fig. 1.   7 The approximate ListSieve-Birthday analysis of Liu et al.

Description of the algorithm
While most sieving algorithms are concerned with finding exact solutions to the shortest vector problem (i.e., finding a lattice vector whose norm is the minimum over all non-zero lattice vectors), in many cryptographic applications, finding a short (rather than shortest) vector in the lattice also suffices. Understanding the costs of finding approximations to shortest vectors (i.e., solving SVP δ with δ > 1) may therefore be as important the costs of exact SVP.
In 2011, Liu et al. [54] analyzed the impact of this relaxation of SVP on lattice sieving algorithms. In particular, they analyzed the ListSieve-Birthday algorithm of Sect. 2, taking into account the fact that an approximate solution is sufficient. The algorithm, described in [54,Algorithm 1], is effectively identical to the original ListSieve-Birthday algorithm of Pujol and Stehlé [65].

Classical complexities
Intuitively, the effect of large δ can be understood as that the impact of the use of perturbed lattice vectors (rather than actual lattice vectors) becomes less and less. In the limit of large δ, the impact of perturbations disappears (although it still guarantees correctness of the algorithm), and we get the same upper bound on the list size of 2 0.401n as obtained for the perturbation-free heuristic version of the ListSieve, the GaussSieve [59]. Since the runtime of the sieve remains quadratic in the list size, this leads to a time complexity of 2 0.802n .

Quantum complexities
As expected, using quantum search in the ListSieve-Birthday algorithm leads to a gain in the exponent of 25 %; a single search can be done in timeÕ( √ N ), leading to a total time complexity ofÕ(N 3/2 ) rather thanÕ(N 2 ).

Theorem 5
The quantum ListSieve-Birthday algorithm heuristically returns a δapproximation to the shortest non-zero lattice vector in time at most 2 q time n+o(n) and space at most 2 q space n+o(n) , where q time and q space are given by 8 Other sieve algorithms

The provable AKS-Sieve of Ajtai et al.
Ajtai et al. [3] did not provide an analysis with concrete constants in the exponent in their original paper of the AKS-Sieve. We expect that it is possible to speed up this version of the algorithm using quantum search as well, but instead we consider several subsequent variants that are easier to analyse. The first of these was by Regev [67], who simplified the presentation and gave concrete constants for the running time and space complexity. His variant is quadratic in the list size, which is bounded by 2 8n+o(n) , leading to a worst-case time complexity of 2 16n+o(n) . Using quantum search, the exponent in the runtime decreases by 25 %, which results in a run-time complexity of 2 12n+o(n) .
Nguyen and Vidick [62] improved this analysis by carefully choosing the parameters of the algorithm, which resulted in a space complexity of 2 2.95n+o(n) . The running time of 2 5.9n+o(n) is again quadratic in the list size, and can be improved using quantum search by 25 % to 2 4.425n .
Micciancio and Voulgaris improve the constant as follows. Say that the initial list contains 2 c 0 n+o(n) vectors, the probability that a point is not a collision at the end is p = 2 −c u n+o(n) and the maximum number of points used as centers is 2 c s n+o(n) . Each step of sieving costs 2 (c 0 +c s )n+o(n) time. Now, after k sieving steps of the algorithm the number of points will be |P k | =Õ(2 c 0 n − k2 c s n ), which results in |V k | =Õ((2 c 0 n − k2 c s n )/2 c u n ) ≈ 2 c R n+o(n) distinct non-perturbed lattice points. This set P k is then searched for a pair of lattice vectors such that the difference is a non-zero shortest vector, which classically costs |V k | · |P k | = 2 (2c R +c u )n+o(n) .
Classical complexities In the above description, we have the following correspondence: where ξ ∈ [0.5, 1 2 √ 2) and γ < 1. The space complexity is 2 c 0 n+o(n) and the time complexity Optimizing ξ and γ to minimize the classical time complexity leads to ξ ≈ 0.676 and γ ≈ 0.496 which gives space 2 1.985n+o(n) and time 2 3.398n+o(n) .
Quantum complexities Quantum searching in the sieving step speeds up this part of the algorithm to 2 c 0 + 1 2 c s n+o(n) . In the final step quantum search can be used to speed up the Thus, the exponents of the quantum time and space become Optimizing gives ξ → 1 2 √ 2 and γ = 0.438, which results in a space complexity of 2 1.876n+o(n) and running time of 2 2.672n+o(n) .

The provable ListSieve of Micciancio and Voulgaris
The provable ListSieve algorithm of Micciancio and Voulgaris [59] was introduced as a provable variant of their heuristic GaussSieve algorithm, achieving a better time complexity than with the optimized analysis of the AKS-Sieve. Instead of starting with a big list and repeatedly applying a sieve to reduce the length of the list (and the norms of the vectors in the list), the ListSieve builds a longer and longer list of vectors, where each new vector to be added to the list is first reduced with all other vectors in the list. (But unlike the GaussSieve, vectors already in the list are never modified.) Complete details of the algorithm and its analysis can be found in [59].
Classical complexities First, for ξ ∈ (0.5, 0.7) we write Then the ListSieve algorithm has a provable complexity of at most 2 (2c 1 +c 2 )n+o(n) (time) and 2 c 1 n+o(n) (space) for any ξ in this interval. Minimizing the time complexity leads to ξ ≈ 0.685, with a time complexity of 2 3.199n+o(n) and a space complexity of 2 1.325n+o(n) .
Quantum complexities Using quantum search, it can be seen that the inner search of the list of length N = 2 c 1 n+o(n) can now be performed in time 2 1 2 c 1 n+o(n) . Thus the total time complexity becomes 2 3 2 c 1 +c 2 n+o(n) now. Optimizing for ξ shows that the optimum is at the boundary of ξ → 0.7.
Looking a bit more closely at Micciancio and Voulgaris' analysis, we see that the condition ξ < 0.7 comes from the condition that ξ × μ ≤ 1 2 λ 2 1 . Taking μ < 1.01λ 1 then approximately leads to the given bound for ξ , and since in the classical case the optimum does not lie at the boundary anyway, this was sufficient for Micciancio and Voulgaris. However, now that the optimum is at the boundary, we can see that we can slightly push the boundary further and slightly relax the condition ξ < 0.7. For any constant ε > 0 we can also let μ < (1 + )λ 1 without losing any performance of the algorithm, and for small ε this roughly translates to the bound ξ < 1 2 √ 2 ≈ 0.707. With this adjustment in their analysis, the optimum is at the boundary of ξ → 1 2 √ 2, in which case we get a quantum time complexity of 2 2.527n+o(n) and a space complexity of 2 1.351n+o(n) .

The provable AKS-Sieve-Birthday algorithm of Hanrot et al.
Hanrot, Pujol and Stehlé [38] described a speed-up for the AKS-Sieve using the birthday paradox [57], similar to the speed-up that Pujol and Stehlé describe for Listsieve. Recall that the AKS-Sieve consists of an initial sieving step that generates a list of reasonably small vectors, followed by a pairwise comparison of the remaining vectors because the difference of at least one pair is expected to be a shortest non-zero vector. If this list of reasonably small vectors are independent and identically distributed, the number of vectors required is reduced to the square root of the original amount by the birthday paradox. They describe how this can be done for the AKS-Sieve, which requires fixing what vectors are used as centers for every iteration. This means that when a perturbed vector does not lie close to any of the fixed centers in the generation of the list of small vectors, it is discarded.
Classical complexities For ξ > 1 2 and γ < 1 we write The AKS-Sieve-Birthday algorithm now has a time complexity of 2 c time n+o(n) and a space complexity of 2 c space n+o(n) , where Working out the details, the classically optimized constants are ξ → 1 and γ ≈ 0.609 leading to a time complexity of 2 2.64791n+o(n) and a space complexity of 2 1.32396n+o(n) .
Quantum complexities Replacing various steps with quantum search gives the same space exponent q space = c space as in the classical case, and leads to the following time exponent: Optimizing the parameters to obtain the lowest quantum time complexity, we get the same constants ξ → 1 and γ ≈ 0.609 leading to a time complexity of 2 1.98548n+o(n) (which is exactly a 25 % gain in the exponent) and a space complexity of 2 1.32366n+o(n) .

The heuristic 2-Level-Sieve of Wang et al.
To improve upon the time complexity of the algorithm of Nguyen and Vidick, Wang et al. [79] introduced a further trade-off between the time complexity and the space complexity. Their algorithm uses two lists of centers C 1 and C 2 and two geometric factors γ 1 and γ 2 , instead of the single list C and single geometric factor γ in the algorithm of Nguyen and Vidick. For details, see [79].
Quantum complexities By using the quantum search algorithm for searching the lists C 1 and C 2 , the time complexity is reduced toÕ(|C 1 | · |C 2 | · √ |C 1 | + |C 2 |), while the space complexity remains O(|C 1 |·|C 2 |). Re-optimizing the constants for a minimum quantum time complexity leads to (γ 1 , γ 2 ) ≈ ( √ 2, 1), leading to the same time and space complexities as the quantum-version of the algorithm of Nguyen and Vidick. Due to the simpler algorithm and smaller constants, a quantum version of the algorithm of Nguyen and Vidick will most likely be more efficient than a quantum version of the algorithm of Wang et al.

The heuristic 3-Level-Sieve of Zhang et al.
To further improve upon the time complexity of the 1-Level-Sieve (NV-Sieve) of Nguyen and Vidick and the 2-Level-Sieve of Wang et al. [79], Zhang et al. [80] introduced the 3-Level-Sieve, with a further trade-off between the time complexity and the space complexity. Their algorithm generalizes the 2-Level-Sieve with two lists of centers (with different radii) to three lists of centers. For the complete details of this algorithm, see [80].

The heuristic Overlattice-Sieve of Becker et al.
The Overlattice-Sieve works by decomposing the lattice into a sequence of overlattices such that the lattice at the bottom corresponds to the challenge lattice, whereas the lattice at the top corresponds to a lattice where enumerating short vectors is easy due to orthogonality. The algorithm begins by enumerating many short vectors in the top lattice and then iteratively moves down through the sequence of lattices by combining short vectors in the overlattice to form vectors in the lattice directly below it in the sequence. It keeps only the short non-zero vectors that are formed in this manner and uses them for the next iteration. In the last iteration, it generates short vectors in the challenge lattice, and these give a solution to the shortest vector problem. Since the algorithm actually works on cosets of the lattice, it is more naturally seen as an algorithm for the closest vector problem, which it solves as well. The algorithm relies on the assumption that the Gaussian Heuristic holds in all the lattices in the sequence.
More specifically, at any one time the algorithm deals with β n vectors that are divided into α n buckets with on average β n /α n vectors per bucket. These buckets are divided into pairs such that any vector from a bucket and any vector from its paired bucket combine into a lattice vector in the sublattice. Therefore, exactly β 2n /α n combinations need to be made in each iteration.

Classical complexities
The above leads to a classical running time ofÕ(β 2n /α n ) and a space complexity ofÕ(β n ), under the constraints that where ε n is some function that decreases towards 0 as n grows. Optimizing α and β for the best time complexity gives α = 4 3 and β = 3 2 for a running time of 2 0.3774n+o(n) and a space complexity of 2 0.2925n+o(n) .
Quantum complexities By using the quantum search algorithm to search for suitable combinations for every vector, the running time can be reduced toÕ(β 3n/2 /α n/2 ). This is optimal for α → 1, β = 4 3 , which gives a quantum time complexity of 2 0.311n+o(n) and a space complexity of 2 0.2075n+o(n) . Interestingly, in the classical case there is a trade-off between α and β, which allows for a bigger α (reducing the running time) at the cost of increasing β (increasing the space complexity). In the quantum case, this trade-off is no longer possible: increasing α and β actually leads to a larger running time as well as a larger space complexity. Thus, the resulting quantum complexity is heuristically no better than the other sieving algorithms, but this algorithm solves CVP as well as SVP.

Enumeration algorithms
In enumeration, all lattice vectors are considered inside a giant ball around the origin that is known to contain at least one lattice vector. Let L be a lattice with basis {b 1 , . . . , b n }. Consider each lattice vector u ∈ L as a linear combination of the basis vectors, i.e., u = i u i b i . Now, we can represent each lattice vector by its coefficient vector (u 1 , . . . , u n ). We would like to have all combinations of values for (u 1 , . . . , u n ) such that the corresponding vector u lies inside the ball. We could try any combination and see if it lies within the ball by computing the norm of the corresponding vector, but there is a smarter way that ensures we only consider vectors that lie within the ball and none that lie outside.
To this end, enumeration algorithms search from right to left, by identifying all values for u n such that there might exist u 1 , . . . , u n−1 such that the vector corresponding to (u 1 , . . . , u n−1 , u n ) lies in the ball. To identify these values u 1 , . . . , u n−1 , enumeration algorithms use the Gram-Schmidt orthogonalization of the lattice basis as well as the projection of lattice vectors. Then, for each of these possible values for u n , the enumeration algorithm considers all possible values for u n−1 and repeats the process until it reaches possible values for u 1 . This leads to a search which is serial in nature, as each value of u n will lead to different possible values for u n−1 and so forth. Unfortunately, we can only really apply the quantum search algorithm to problems where the list of objects to be searched is known in advance.
One might suggest to forego the smart way to find short vectors and just search all combinations of (u 1 , . . . , u n ) with appropriate upper and lower bounds on the different u i 's. Then it becomes possible to apply quantum search, since we now have a predetermined list of vectors and just need to compute the norm of each vector. However, it is doubtful that this will result in a faster algorithm, because the recent heuristic changes by Gama et al. [31] have reduced the running time of enumeration dramatically (roughly by a factor 2 n/2 ) and these changes only complicate the search area further by changing the ball to an ellipsoid. There seems to be no simple way to apply quantum search to the enumeration algorithms that are currently used in practice, but perhaps the algorithms can be modified in some way.

The Voronoi cell algorithm
Consider a set of points in the Euclidean space. For any given point in this set, its Voronoi cell is defined as the region that contains all vectors that lie closer to this point than to any of the other points in the set. Now, given a Voronoi cell, we define a relevant vector to be any vector in the set whose removal from the set will change this particular Voronoi cell. If we pick our lattice as the set and we consider the Voronoi cell around the zero vector, then any shortest vector is also a relevant vector. Furthermore, given the relevant vectors of the Voronoi cell we can solve the closest vector problem in 2 2n+o(n) time.
So how can we compute the relevant vectors of the Voronoi cell of a lattice L ? Micciancio and Voulgaris [58] show that this can be done by solving 2 n − 1 instances of CVP in the lattice 2L . However, in order to solve CVP we would need the relevant vectors which means we are back to our original problem. Micciancio and Voulgaris show that these instances of CVP can also be solved by solving several related CVP instances in a lattice of lower rank. They give a basic and an optimized version of the algorithm. The basic version only uses LLL as preprocessing and solves all these related CVP instances in the lower rank lattice separately. As a consequence, the basic algorithm runs in time 2 3.5n+o(n) and in space 2 n+o(n) . The optimized algorithm uses a stronger preprocessing for the lattice basis, which takes exponential time. But since the most expensive part is the computation of the Voronoi relevant vectors, this extra preprocessing time does not increase the asymptotic running time as it is executed only once. In fact, having the reduced basis decreases the asymptotic running time toÕ (2 3n ). Furthermore, the optimized algorithm employs a trick that allows it to reduce 2 k CVP instances in a lattice of rank k to a single instance of an enumeration problem related to the same lattice. The optimized algorithm solves CVP in timeÕ(2 2n ) usingÕ(2 n ) space. Now, in the basic algorithm, it would be possible to speed up the routine that solves CVP given the Voronoi relevant vectors using a quantum computer. It would also be possible to speed up the routine that removes non-relevant vectors from the list of relevant vectors using a quantum computer. Combining these two changes gives a quantum algorithm with an asymptotic running timeÕ(2 2.5n ), which is still slower than the optimized classical algorithm. It is not possible to apply these same speedups to the optimized algorithm due to the aforementioned trick with the enumeration problem. The algorithm to solve this enumeration problem makes use of a priority queue, which means the search is not trivially parallellized. Once again, there does not seem to be a simple way to apply quantum search to this special enumeration algorithm. However, it may be possible that the algorithm can be modified in such a way that quantum search can be applied.

Discrete Gaussian sampling
A very recent method for finding shortest vectors in lattices is based on sampling and combining lattice vectors sampled from a discrete Gaussian on the lattice. Given a lattice, a discrete Gaussian distribution on the lattice is what you might expect it to be; the probability of sampling a non-lattice vector is 0, and the probability of sampling a lattice vector x is proportional to exp −O( x 2 ), comparable to a regular multivariate Gaussian distribution. These discrete Gaussians are commonly used in lattice-based cryptographic primitives, such as lattice-based signatures [26,56], and it is folklore that sampling from a discrete Gaussian distribution with a very large standard deviation is easy, while sampling from a distribution with a small standard deviation (often sampling short vectors) is hard.
The idea of Aggarwal et al. [1] to solve SVP with discrete Gaussian sampling is as follows. First, many vectors are sampled from a discrete Gaussian with large standard deviation. Then, to find shorter and shorter lattice vectors, list vectors are combined and averaged to obtain samples from a Gaussian with a smaller standard deviation. More precisely, two samples from a discrete Gaussian with width σ can be combined and averaged to obtain a sample from a discrete Gaussian with width σ/ √ 2. To be able to combine and average list vectors, they need to be in the same coset of 2L , which means that 2 n buckets are stored, and within each bucket (coset) vectors are combined to obtain new, shorter samples. Overall, this leads to a time complexity of 2 n+o(n) for SVP, also using space 2 n+o(n) .
The ideas of this algorithm are actually quite similar to the Overlattice-Sieve of Becker et al. [9] which we discussed in Sect. 8.6. Vectors are already stored in buckets, and so searching for vectors in the same coset is not costly at all. In this algorithm, the number of vectors in each bucket is even sub-exponential in n, so a quantum search speed-up does not seem to bring down the asymptotic time or space complexities at all. Due to the number of cosets of 2L (2 n ), this algorithm seems (classically and quantumly) bound by a time and space complexity of 2 n+o(n) , which it already achieves.
Open Access This article is distributed under the terms of the Creative Commons Attribution 4.0 International License (http://creativecommons.org/licenses/by/4.0/), which permits unrestricted use, distribution, and reproduction in any medium, provided you give appropriate credit to the original author(s) and the source, provide a link to the Creative Commons license, and indicate if changes were made.