The Asymptotic Complexity of Coded-BKW with Sieving Using Increasing Reduction Factors

TL;DR

This paper analyzes the asymptotic complexity of an improved coded-BKW algorithm with sieving for solving the LWE problem, achieving a slight complexity reduction through variable reduction factors.

Contribution

It introduces a novel approach of using different reduction factors at each step of the sieving process in coded-BKW, leading to improved asymptotic complexity results.

Findings

Asymptotic complexity improved to 2^{0.8917n} in the Regev setting

Method achieves similar improvements under quantum computing assumptions

Provides a detailed analysis of reduction factors in coded-BKW with sieving

Abstract

The Learning with Errors problem (LWE) is one of the main candidates for post-quantum cryptography. At Asiacrypt 2017, coded-BKW with sieving, an algorithm combining the Blum-Kalai-Wasserman algorithm (BKW) with lattice sieving techniques, was proposed. In this paper, we improve that algorithm by using different reduction factors in different steps of the sieving part of the algorithm. In the Regev setting, where $q = n^2$ and $\sigma = n^{1.5}/(\sqrt{2\pi}\log_2^2 n)$, the asymptotic complexity is $2^{0.8917n}$, improving the previously best complexity of $2^{{0.8927n}}$. When a quantum computer is assumed or the number of samples is limited, we get a similar level of improvement.

Tables

Table 1. TABLE I: The asymptotic complexity exponent for the different versions of BKW in the Regev setting.

	Classical	Quantum
	Setting	Setting
Exponential samples
Polynomial samples

Equations

$$z_i=⟨{\mathbf{a}}_{\mathbf{i}},\mathbf{s}⟩+e_i,$$

$${\mathbf{a}}_{1,2}=[\underset{b\text{ symbols}}{\underbrace{\begin{array}{cccc}0& 0& \cdots & 0\end{array}}}\begin{array}{ccccc}& \ast & \ast & \cdots & \ast \end{array}].$$

$$\begin{array}[]{ccl}z_{1}&=&\left\langle[\mathbf{c}_{0}+\hat{\mathbf{e}}_{1},\mathbf{a}_{1}],\textbf{ s}\right\rangle+{e_{1}}\\ z_{2}&=&\left\langle[\mathbf{c}_{0}+\hat{\mathbf{e}}_{2},\mathbf{a}_{2}],\textbf{ s}\right\rangle+{e_{2}},\end{array}$$

$$z_1-z_2=⟨[{\hat{\mathbf{e}}}_1-{\hat{\mathbf{e}}}_2,{\mathbf{a}}_1-{\mathbf{a}}_2],\text{ s}⟩+e_1-e_2.$$

$${\gamma }_i={\gamma }_s+\frac{{\gamma }_f-{\gamma }_s}{t_2-1}(i-1).$$

$$\underset{\alpha ,\gamma }{\mathrm{minimize}}$$

$$\displaystyle\frac{1}{\lambda(\gamma)}\left(1-\frac{c_{s}}{\alpha\log_{2}\gamma+c_{s}}\cdot\exp(I(\alpha,\gamma))\right)\Bigg{)}^{-1}$$

$$0\le \alpha \le 2(c_q-c_s)+1,$$

$$0<\gamma \le \sqrt{2}.$$

$$I(\alpha ,\gamma )={\int }_0^{\alpha }\frac{{\log }_2\gamma -\lambda (\gamma )}{t{\log }_2\gamma +c_s}dt.$$

$$\underset{\alpha ,{\gamma }_s,{\gamma }_f}{\mathrm{minimize}}$$

$$\displaystyle\int_{0}^{\alpha}\frac{c_{s}}{\left(t\cdot\ell(t)+c_{s}\right)^{2}}\cdot\exp(I(t;\alpha,\gamma_{s},\gamma_{f}))dt\bigg{)}^{-1}$$

$$0\le \alpha \le 2(c_q-c_s)+1,$$

$$0<{\gamma }_s<{\gamma }_f\le \sqrt{2}.$$

$$I(t;\alpha ,{\gamma }_s,{\gamma }_f)={\int }_0^t\frac{{\log }_2\gamma (s)-\lambda (\gamma (s))}{s\cdot \ell (s)+c_s}ds,$$

$$\gamma (s)$$

$$\ell (s)$$

$$0<{\gamma }_1<{\gamma }_2<\dots <{\gamma }_{t_2}\le \sqrt{2}.$$

$$b=\frac{cn}{c_q\log n}.$$

$$B_1=\frac{B}{{\Pi }_{i=1}^{t_2}{\gamma }_i}.$$

$$\left(\log ({\Pi }_{i=1}^{t_2}{\gamma }_i)+c_s\log (n)\right)\cdot n_1=cn-{\lambda }_1\cdot n_1.$$

$$\begin{array}{rl}{n}_1& =\frac{cn}{c_s\log n+\log ({\Pi }_{i=1}^{t_2}{\gamma }_i)+{\lambda }_1}\\ & =\frac{cn}{c_s\log n+\log ({\Pi }_{i=1}^{t_2}{\gamma }_i)}\cdot (1+\Theta ({\log }^{-1}n)).\end{array}$$

$$\left(\log ({\Pi }_{j=i}^{t_2}{\gamma }_j)+c_s\log (n)\right)\cdot n_i=cn-{\lambda }_i\sum _{j=1}^i{n}_j.$$

$${\lambda }_{i-1}{\star }_i{n}_i-{\lambda }_i{\star }_{i-1}{n}_{i-1}=cn({\lambda }_{i-1}-{\lambda }_i)-{\lambda }_{i-1}{\lambda }_i{n}_i.$$

$$n_i=\frac{{\lambda }_i{\star }_{i-1}{n}_{i-1}+cn({\lambda }_{i-1}-{\lambda }_i)}{{\lambda }_{i-1}{\star }_i+{\lambda }_{i-1}{\lambda }_i}.$$

$$n_{t_2}=n_1\prod _{i=2}^{t_2}\frac{{\lambda }_i{\star }_{i-1}}{{\lambda }_{i-1}({\star }_i+{\lambda }_i)}$$

$$+$$

$$\begin{array}{rl}\prod _{j=i+1}^{t_2}& \left(\frac{{\lambda }_j{\star }_{j-1}}{{\lambda }_{j-1}({\star }_j+{\lambda }_j)}\right)=\prod _{j=i+1}^{t_2}\frac{{\lambda }_j}{{\lambda }_{j-1}}\left(\frac{{\star }_{j-1}}{{\star }_j+{\lambda }_j}\right)\\ & =\frac{{\lambda }_{t_2}}{{\lambda }_i}\prod _{j=i+1}^{t_2}\left(\frac{{\star }_j+\log ({\gamma }_{j-1})+{\lambda }_j-{\lambda }_j}{{\star }_j+{\lambda }_j}\right)\\ & =\frac{{\lambda }_{t_2}}{{\lambda }_i}\prod _{j=i+1}^{t_2}\left(1+\frac{\log ({\gamma }_{j-1})-{\lambda }_j}{{\star }_j+{\lambda }_j}\right).\end{array}$$

$$\begin{array}{rl}cn& \sum _{i=2}^{t_2}\frac{{\lambda }_{i-1}-{\lambda }_i}{{\lambda }_{i-1}{a}_i}\frac{{\lambda }_{t_2}}{{\lambda }_i}{\Pi }_i\\ & =cn\sum _{i=2}^{t_2}\frac{1}{a_i}\frac{{\lambda }_{t_2}}{{\lambda }_i}{\Pi }_i-cn\sum _{i=2}^{t_2}\frac{1}{a_i}\frac{{\lambda }_{t_2}}{{\lambda }_{i-1}}{\Pi }_i\\ & =cn\left(\frac{1}{a_{t_2}}-\frac{1}{a_2}\frac{{\lambda }_{t_2}}{{\lambda }_1}{\Pi }_2+\sum _{i=2}^{t_2-1}\frac{{\lambda }_{t_2}}{{\lambda }_i}\left(\frac{{\Pi }_i}{a_i}-\frac{{\Pi }_{i+1}}{a_{i+1}}\right)\right).\end{array}$$

$$\begin{array}{rl}& \frac{{\Pi }_i{a}_{i+1}-{\Pi }_{i+1}{a}_i}{a_i{a}_{i+1}}\\ & =\frac{{\Pi }_{i+1}\left(\left(1+\frac{\log ({\gamma }_i)-{\lambda }_{i+1}}{\log ({\Pi }_{j=i+1}^{t_2}{\gamma }_j)+c_s\log (n)+{\lambda }_{i+1}}\right)a_{i+1}-a_i\right)}{a_i{a}_{i+1}}\\ & =\frac{{\Pi }_{i+1}\left(a_{i+1}+\log ({\gamma }_i)-{\lambda }_{i+1}-a_i\right)}{a_i{a}_{i+1}}\\ & =\frac{{\Pi }_{i+1}\left({\lambda }_{i+1}+\log ({\gamma }_i)-{\lambda }_{i+1}-(\log ({\gamma }_i)+{\lambda }_i)\right)}{a_i{a}_{i+1}}\\ & =-\frac{{\lambda }_i}{a_i{a}_{i+1}}{\Pi }_{i+1}.\end{array}$$

$$\frac{cn}{a_1}\frac{{\lambda }_{t_2}}{{\lambda }_1}{\Pi }_1.$$

$$cn\left(\frac{1}{a_{t_2}}-{\lambda }_{t_2}\sum _{i=1}^{t_2-1}\frac{{\Pi }_{i+1}}{a_i{a}_{i+1}}\right).$$

$$\begin{split}&\prod_{j=i+2}^{t_{2}}1+\frac{\log(\gamma_{j-1})-\lambda_{j}}{\log(\Pi_{k=j}^{t_{2}}\gamma_{k})+c_{s}\log(n)+\lambda_{j}}\\ &=\exp\left(\ln\left(\prod_{j=i+2}^{t_{2}}1+\frac{\log(\gamma_{j-1})-\lambda_{j}}{\log(\Pi_{k=j}^{t_{2}}\gamma_{k})+c_{s}\log(n)+\lambda_{j}}\right)\right)\\ &=\leavevmode\resizebox{436.8687pt}{}{$\exp\left(\sum_{j=i+2}^{t_{2}}\frac{\log(\gamma_{j-1})-\lambda_{j}}{\log(\Pi_{k=j}^{t_{2}}\gamma_{k})+c_{s}\log(n)+\lambda_{j}}+\Theta\left(\log^{-2}n\right)\right).$}\end{split}$$

$${\gamma }_i={\gamma }_s+d(i-1)={\gamma }_s+\frac{{\gamma }_f-{\gamma }_s}{t_2-1}(i-1).$$

Full text

I Introduction

Given access to large-scale quantum computers, Shor’s algorithm solves both the integer factoring problem and the discrete logarithm problem in polynomial time. To remedy this, National Institute of Standards and Technology (NIST) has an ongoing competition to develop post-quantum cryptosystems [1]. One of the main underlying mathematical problems in the competition is the Learning with Errors problem (LWE).

The LWE problem was introduced by Regev in [2]. It has some really nice features, such as a reduction from average-case LWE instances to worst-case instances of hard lattice problems. An application of LWE is Fully Homomorphic Encryption (FHE) [3]. An important special case of LWE is the Learning Parity with Noise problem (LPN), essentially a binary version of LWE with Bernoulli distributed noise.

There are mainly three types of algorithms for solving the LWE problem. For surveys on the concrete and asymptotic complexity of these algorithms see [4] and [5] respectively.

The first type is the Arora-Ge algorithm, which was introduced in [6], and then improved in [7]. This type of algorithm is mostly applicable when the noise is too small for Regev’s reduction proof to apply [2].

The second type of approach is lattice-based algorithms, where LWE is transformed into a lattice problem and then solved by methods like lattice-reduction, lattice sieving and enumeration. Lattice-based algorithms are currently the fastest algorithms in practice, and have the advantage of not needing an exponential amount of samples. For more details see [4] and the references therein.

The third type of approach is the Blum-Kalai-Wasserman (BKW) set of algorithms. These will be the focus of this paper.

The BKW algorithm was introduced in [8] as the first sub-exponential algorithm for solving the LPN problem. It was first used to solve the LWE problem in [9]. This was improved in [10] using Lazy Modulus Switching (LMS). Further improvements were made in [11, 12] by using a varying step size and a varying degree of reduction. In [13] coded-BKW with sieving was introduced, where lattice sieving techniques were used to improve the BKW algorithm. The full version in [14] improved the coded-BKW with sieving algorithm by finding the optimal reduction factor used for lattice sieving.

In this paper we further improve upon the coded-BKW with sieving algorithm by increasing the reduction factor for each step of the algorithm. We achieve a record low time complexity of $2^{0.8917n}$ in the Regev setting; that is, when $q=n^{2}$ and $\sigma=n^{1.5}/(\sqrt{2\pi}\log_{2}^{2}n)$. The previous best result was $2^{0.8927n}$ from [14]. Also if a quantum computer is assumed or the number of samples is limited we get a similar level of improvement.

The remaining parts of the paper are organized the following way. We start off in Section II by introducing the LWE problem. In Section III we go over the previous versions of the BKW algorithm, when used for solving the LWE problem. In Section IV we introduce the new algorithm and in Section V we cover the asymptotic complexity of it and other algorithms for solving LWE. We show our results in Section VI and conclude the paper in Section VII.

II Preliminaries

Let us define the LWE problem.

Definition 1** (LWE)**

Let $n$ be a positive integer, $q$ a prime. Let $\bf s$ be a uniformly random secret vector in $\mathbb{Z}_{q}^{n}$. Assume access to $m$ noisy scalar products between $\bf s$ and known vectors $\bf a_{i}$, i.e.

[TABLE]

for $i=1,\ldots,m$. The small error terms ${e_{i}}$ are discrete Gaussian distributed with mean 0 and standard deviation $\sigma$. The (search) LWE problem is to find the secret vector $\bf s$.

In other words, when solving LWE you have access to a large set of pairs $(\mathbf{a_{i}},z_{i})$ and want to find the corresponding secret vector $\mathbf{s}$. In some versions there are restrictions on the number of samples you have access to.

III BKW

BKW was introduced as the first sub-exponential algorithm for solving LPN (essentially LWE with $q=2$) in [8]. It was first used for solving LWE in [9].

III-A Plain BKW

The BKW algorithm consists of two steps, dimension reduction and guessing.

III-A1 Reduction

Map all the samples into categories, such that the first $b$ positions get canceled when adding/subtracting a pair of $\mathbf{a}$ vectors within the same category.

Given two samples $([\pm\mathbf{a_{0}},\mathbf{a_{1}}],z_{1})$ and $([\pm\mathbf{a_{0}},\mathbf{a_{2}}],z_{2})$ within the same category. By adding/subtracting the $\mathbf{a}$ vectors we get

[TABLE]

By also calculating the corresponding $z$ value we get $z_{1,2}=z_{1}\pm z_{2}$. Now we have a new sample $(\mathbf{a_{1,2}},z_{1,2})$. The corresponding noise variable is $e_{1,2}=e_{1}\pm e_{2}$. Thus the variance of the new noise is $2\sigma^{2}$, where $\sigma^{2}$ is the variance of the originial noise. By going through all categories and calculating a suitable amount of new samples we have reduced the dimensionality of the problem by $b$, at the cost of increasing the noise. If we repeat the reduction process $t_{0}$ times we end up with a dimensionality of $n-t_{0}b$, and a noise variance of $2^{t_{0}}\cdot\sigma^{2}$.

III-A2 Guessing

The final positions of the secret vector $\mathbf{s}$ can be guessed and then each guess can be tested using a distinguisher. The guessing procedure does not affect the asymptotics, but is important for concrete complexity. The guessing procedure was improved in [15] using the Fast Fourier Transform (FFT).

III-B Lazy Modulus Switching

The basic BKW algorithm was improved in [10] by Albrecht et al. The main idea there was to map samples that, almost but not completely, canceled each other, into the same category. This technique is called Lazy Modulus Switching (LMS).

By doing this an extra error term gets added in each step. The variance of this noise also doubles in each new reduction step. However, LMS allows us to use a larger step size, allowing us to solve larger LWE problems.

One problem with this version of the algorithm is that the extra added noise of the earlier steps grows in size much more than the noise of the later steps, leading to an uneven noise distribution among the positions of the final samples used for the guessing procedure.

III-C Coded-BKW

The problem with the uneven noise distribution was adressed independently in [11, 12]. The idea was to use a small step size and almost reduce the positions in the $\mathbf{a}$ vectors to 0 in the first step, and then gradually increase the step size $n_{i}$ and use less strict reduction for each step.

In [11] different $q$-ary linear codes $\mathcal{C}_{i}$ with parameters $[n_{i},b]$ were used, to vary the strictness of reduction. That version of BKW is called coded-BKW. For simplicity, consider the first reduction step. Pick two samples, such that the first $n_{1}$ positions of the $\mathbf{a}$ vectors map to the same codeword $\mathbf{c_{0}}$ in $\mathcal{C}_{1}$. In other words, we can write

[TABLE]

where $\hat{\mathbf{e}}_{1}$ and $\hat{\mathbf{e}}_{2}$ have small Euclidean norms. We can get a new sample by calculating

[TABLE]

Just like when using LMS, using this version of BKW adds an extra noise term, but allows us to use larger step sizes.

III-D Coded-BKW with Sieving

In [13] an idea for combining BKW with lattice sieving techniques was introduced. Just like in [11, 12] in step $i$, samples were mapped into categories based on the current $n_{i}$ positions. Let $N_{i}=\sum_{j=1}^{i}n_{j}$. The new idea was to only add/subtract samples within a category such that also the previous $N_{i-1}$ positions of the resulting $\mathbf{a}$ vector were equally small. This could have been done by looking at all possible pairs and picking only the ones with the smallest values in these positions. However, a more efficient way of doing this was to use lattice sieving techniques to find close pairs of vectors within a category faster.

A micro picture of coded-BKW with sieving can be found in Figure 1. After step $i$, the average magnitude of the first $N_{i}$ positions in the $\mathbf{a}$ vector is less than a constant $B$.

III-D1 Using Different Reduction Factors

In [14] the idea of finding an optimal reduction factor was introduced. Instead of making sure the $N_{i}$ positions currently considered are as small as the $N_{i-1}$ positions in the previous step, they are made to be $\gamma$ times as large. Depending on the parameter setting the optimal strategy is either to use $\gamma<1$ or $\gamma>1$, or in other words to gradually decrease or increase the values in the $\mathbf{a}$ vector. The final average magnitude is still less than the same constant $B$.

The original coded-BKW with sieving algorithm from [13] is the special case where $\gamma=1$ and coded-BKW is the special case where $\gamma=\sqrt{2}$.

For an illustration of how the different BKW algorithms reduce the $\mathbf{a}$ vector, see Figure 2.

IV Coded-BKW with Sieving with Increasing Reduction Factors

The new idea in this paper is to use different reduction factors $\gamma_{i}$ in different steps $i$. The idea is that in the earlier steps the sieving is cheap, and we can therefore use small values of $\gamma_{i}$. Gradually the sieving procedure gets more and more expensive, forcing us to increase the value of $\gamma_{i}$.

Assume that we take $t_{2}$ steps of coded-BKW with sieving in total and let $\gamma_{1}=\gamma_{s}$ and$\gamma_{t_{2}}=\gamma_{f}$. We ended up choosing an arithmetic progression, that is we let

[TABLE]

We also tried a geometric and logarithmic progression of the $\gamma_{i}$ values, both leading to a slightly worse complexity. A power progression lead to an expression that had to be estimated numerically and resulted in almost exactly the same results as the arithmetic progression.

V Asymptotic Complexity

Asymptotically we let $q=n^{c_{q}}$ and $\sigma=n^{c_{s}}$, where $c_{q}$ and $c_{s}$ are constants. For most algorithms and settings the asymptotic complexity of solving LWE is $2^{cn+o(n)}$, where the exponent $c$ depends on $c_{q}$ and $c_{s}$. We leave settings such as a binary secret or a superpolynomial $q$ for future research.

We will now quickly cover the asymptotic complexities of the Arora-Ge algorithm, lattice-based algorithms and all the previous versions of BKW, as a function of $c_{q}$ and $c_{s}$. Initially, the assumed setting is one with a classical computer and an exponential amount of samples. Other settings will be discussed later.

V-1 Complexity Exponent for Lattice Sieving

The value $\lambda(\gamma)$ for lattice sieving using a reduction factor $\gamma$ is the best available complexity exponent for doing lattice sieving. It is (currently) calculated by doing the optimization from the section about the total cost of sieving in [16], replacing the angle $\pi/3$ by $\theta=2\arcsin(\gamma/2)$ and replacing $N=(4/3)^{n/2}$ by $(1/\sin(\theta))^{n}$. For $\gamma=1$ we get $\lambda\approx 0.292$.

V-2 Quantum Setting

If having access to a quantum computer, Grover’s algorithm can be used to speed up the lattice sieving, see [17], resulting in slightly improved complexity exponents. For $\gamma=1$ we get $\lambda\approx 0.265$.

V-A Arora-Ge and Lattice-based Methods

The Arora-Ge algorithm is polynomial when $c_{s}<0.5$ and superexponential when $c_{s}>0.5$, making it viable if and only if $c_{s}$ is too small for Regev’s reduction proof to apply [2]. Lattice-based algorithms can solve LWE with a time complexity exponent of $2\lambda c_{q}/(c_{q}-c_{s}+1/2)^{2}$, using an exponential amount of memory [5].

V-B Plain and Coded BKW

The time and space complexity for solving LWE using plain BKW is $c_{q}/(2(c_{q}-c_{s})+1)$ [9], and using Coded-BKW is $(1/c_{q}+2\ln(c_{q}/c_{s}))^{-1}$ [12].

V-C Coded-BKW with sieving

The time (and space) complexity of solving the LWE problem using coded-BKW with sieving gets calculated by solving increasingly difficult optimization problems. In both Theorem 1 and 2, the parameter $\alpha$ decides how large part of the samples should be pre-processed with plain BKW steps.

Theorem 1

The time and space complexity of coded-BKW with sieving and a constant value of the reduction factor $\gamma$, is $2^{cn+o(n)}$, where $c$ is the solution to the following optimization problem.

[TABLE]

Here, we have

[TABLE]

By setting $\gamma=1$ we get (a restatement of) the complexity of the original coded-BKW with sieving algorithm [13].

Proof:

The theorem is a slight restatement of Theorem 7 from [14], to make it more similar to Theorem 2 of this paper. Theorem 7 from [14] includes both the proof and the underlying heuristic assumptions the proof is based on. ∎

V-D Coded-BKW with Sieving with Increasing Reduction Factors

The complexity of the new algorithm is covered in the following theorem.

Theorem 2

The time and space complexity of coded-BKW with sieving and an arithmetic progression of the $\gamma_{i}$ values, is $2^{cn+o(n)}$, where $c$ is the solution to the following optimization problem.

[TABLE]

Here, we have

[TABLE]

and

[TABLE]

It should be mentioned that the objetive function of the optimization problem here would change slightly if another method for the progression of the $\gamma_{i}$ values was chosen.

Proof:

A proof of Theorem 2 can be found in the appendix.

∎

V-E Polynomial Number of Samples

With access to only a polynomial number of samples the complexity exponent of lattice-based algorithms changes to $2\lambda c_{q}/(c_{q}-c_{s})^{2}$ [5].

When using BKW with access to only a polynomial number of samples, amplification is used to increase the number of samples, at the cost of an increased noise. For plain and coded BKW the complexity exponents change to $c_{q}/(2(c_{q}-c_{s}))$ and $(1/c_{q}+2\ln(c_{q}/c_{s}))^{-1}$ [5].

In the optimization problems in Theorem 1 and 2 the upper limit of $\alpha$ changes to $2(c_{q}-c_{s})$. For each theorem the numerator in the first term of the objective function changes to $2(c_{q}-c_{s})-\alpha$.

VI Results

Let us use the Regev instances as a case study, in other words, let $c_{q}=2$ and $c_{s}=1.5$ [2]. Table I shows the complexity exponent for coded-BKW with sieving, with $\gamma=1$, an optimized constant $\gamma$ and an arithmetic progression of the $\gamma$ values, for four different scenarios. Either we use classical or quantum computers and either we have access to a polynomial or an exponential number of samples. Notice how using increasing reduction factors improves the complexity exponent in all the scenarios.

In all the scenarios in the Regev setting BKW algorithms beat lattice-based algorithms. For a picture comparing the asymptotic complexity of the different BKW versions with lattice-based algorithms in other settings, see Figure 5 and 7 in [14]. The new version constitutes an improvement compared to the constant $\gamma$ algorithm for all parameter pairs $(c_{q},c_{s})$, as can be seen in Figure 3.

The source code used for calculating all the complexity exponents in the different scenarios can be found on GitHub111https://github.com/ErikMaartensson/BKWIncreasingReductionFactors.

VII Conclusions

We have developed a new version of coded-BKW with sieving, achieving a further improved asymptotic complexity. We have also improved the complexity when having access to a quantum computer or only having access to a polynomial number of samples. All BKW algorithms solve a modified version of the 2-list problem, where we also have a modular reduction and have a limited number of total steps. Generalizing the optimization of the BKW algorithm from this perspective is an interesting new research idea. Another possible further research direction is looking at the complexity of different versions of BKW when only having access to a limited amount of memory, like was briefly started in [18]. Finally, it is interesting to investigate the concrete complexity of coded-BKW with sieving and implement it to see when BKW starts to beat lattice-type algorithms in practise.

Acknowledgment

The author would like to acknowledge Qian Guo, whose idea of using a reduction factor $\gamma\neq 1$ this paper generalizes. The author would also like to thank Thomas Johansson and Paul Stankovski Wagner for fruitful discussions during the writing of this paper.