List Decoding of Insertions and Deletions

TL;DR

This paper develops bounds and algorithms for list decoding of insertions and deletions in sequences, enabling efficient decoding beyond traditional limits, with specific focus on Levenshtein metric and VT codes.

Contribution

It introduces a Johnson-like upper bound for list decoding in the Levenshtein metric and provides an efficient decoder for small numbers of insertions/deletions.

Findings

Polynomial-time list decoding beyond half the Levenshtein distance is feasible.

The maximum list size can grow exponentially with deletions for VT codes.

An efficient decoder for two insertions/deletions with VT codes is presented.

Abstract

List decoding of insertions and deletions in the Levenshtein metric is considered. The Levenshtein distance between two sequences is the minimum number of insertions and deletions needed to turn one of the sequences into the other. In this paper, a Johnson-like upper bound on the maximum list size when list decoding in the Levenshtein metric is derived. This bound depends only on the length and minimum Levenshtein distance of the code, the length of the received word, and the alphabet size. It shows that polynomial-time list decoding beyond half the Levenshtein distance is possible for many parameters. Further, we also prove a lower bound on list decoding of deletions with with the well-known binary Varshamov-Tenengolts (VT) codes which shows that the maximum list size grows exponentially with the number of deletions. Finally, an efficient list decoding algorithm for two insertions/deletions with VT codes is given. This decoder can be modified to a polynomial-time list decoder of any constant number of insertions/deletions.

Equations

$$\tau \triangleq ϵ+\delta <\frac{d}{2}.$$

$$\ell\triangleq\max_{\textup{{r}}\in\mathbb{F}_{q}^{N}}\big{\{}\big{|}\mathcal{C}\cap\mathcal{B}^{(\tau)}_{\mathsf{L}}(\textup{{r}})\big{|}\big{\}}.$$

$$\mathcal{VT}_{a}(n)\triangleq\Big{\{}\textup{{c}}=(c_{1},\ldots,c_{n})\,:\,\sum_{i=1}^{n}i\cdot c_{i}\equiv a\leavevmode\nobreak\ \bmod(n+1)\Big{\}}.$$

$$\eta \triangleq \frac{q}{q+1}(n+N).$$

$$\tau <\eta -\sqrt{\eta (\eta -d)}\triangleq {\tau }_{\mathsf{L}}(q),$$

$$\ell$$

$$=\frac{d(n+N)}{\frac{q+1}{q}{\tau }^2-(2\tau -d)(n+N)}.$$

$$\mathcal{L}\triangleq \mathcal{C}\cap {\mathcal{B}}_{\mathsf{L}}^{(\tau )}(\text{r})=\{{\text{c}}_1,{\text{c}}_2,\dots ,{\text{c}}_{\ell }\}\subseteq \mathcal{C}\subseteq {\mathbb{F}}_q^n,$$

$${\mathcal{D}}^{(i)}\subseteq [1,n]\text{ and }{\mathcal{E}}^{(i)}\subseteq [1,N].$$

$$d_{\mathsf{L}}(\text{r},{\text{c}}_i)=|{\mathcal{D}}^{(i)}|+|{\mathcal{E}}^{(i)}|={\delta }_i+{ϵ}_i\le \tau ,\forall i\in [1,\ell ].$$

$$d_{\mathsf{L}}({\text{c}}_{i_1},{\text{c}}_{i_2})=|{\mathcal{F}}^{(i_1,i_2)}|+|{\mathcal{F}}^{(i_2,i_1)}|\ge d,\forall i_1,i_2\in [1,\ell ],i_1\ne i_2.$$

$$\sum\limits_{a\in\mathbb{F}_{q}}\Big{(}\sum\limits_{j\in[1,n]}x_{a,j}+\sum\limits_{j\in[1,N]}y_{a,j}\Big{)}\leq\ell\tau.$$

$$\sum _{j\in [1,n]}{x}_{\otimes ,j}+\sum _{j\in [1,N]}{y}_{\otimes ,j}\ge \ell (N+n-\tau ).$$

$$\{j\in {\mathcal{E}}^{(i_1)}\cap {\mathcal{E}}^{(i_2)}\text{ and for the deleted values }{a}_{i_1}\ne a_{i_2}\}=\varnothing ,$$

$$\lambda \triangleq \sum _{i_1\in [1,\ell ]}\sum _{\begin{array}{c}{i}_2\in [1,\ell ]\\ i_2\ne i_1\end{array}}|{\mathcal{D}}^{(i_1)}\cup {\mathcal{D}}^{(i_2)}\setminus \{k:k\in {\mathcal{D}}^{(i_1)}\cap {\mathcal{D}}^{(i_2)}\wedge a_{i_1}=a_{i_2}\}|$$

$$+|({\mathcal{E}}^{(i_1)}\cup {\mathcal{E}}^{(i_2)})\setminus ({\mathcal{E}}^{(i_1)}\cap {\mathcal{E}}^{(i_2)})|$$

$$\ge \sum _{i_1\in [1,\ell ]}\sum _{\begin{array}{c}{i}_2\in [1,\ell ]\\ i_2\ne i_1\end{array}}|{\mathcal{F}}^{(i_1,i_2)}|+|{\mathcal{F}}^{(i_2,i_1)}|\ge \ell (\ell -1)d.$$

$$\lambda=\sum\limits_{a\in\mathbb{F}_{q}\cup\otimes}\Big{(}\sum\limits_{k\in[1,n]}x_{a,k}(\ell-x_{a,k})+\sum\limits_{j\in[1,N]}y_{a,j}(\ell-y_{a,j})\Big{)}.$$

$$\lambda=\ell^{2}(n+N)-\sum\limits_{a\in\mathbb{F}_{q}\cup\otimes}\Bigg{(}\sum\limits_{k\in[1,n]}x_{a,k}^{2}+\sum\limits_{j\in[1,N]}y_{a,j}^{2}\Bigg{)}.$$

$$\ell^{2}(n+N)-\ell(\ell-1)d\geq\!\!\sum\limits_{a\in\mathbb{F}_{q}\cup\otimes}\Bigg{(}\sum\limits_{k\in[1,n]}x_{a,k}^{2}+\sum\limits_{j\in[1,N]}y_{a,j}^{2}\Bigg{)}.$$

$$x_{\otimes,k}^{2}=\Big{(}\ell-\sum_{a\in\mathbb{F}_{q}}x_{a,k}\Big{)}^{2}\quad\text{and}\quad y_{\otimes,j}^{2}=\Big{(}\ell-\sum_{a\in\mathbb{F}_{q}}y_{a,j}\Big{)}^{2}.$$

$${\ell }^2(n+N)-\ell (\ell -1)d$$

$$\ge \sum _{a\in {\mathbb{F}}_q}\left(\sum _{k\in [1,n]}{x}_{a,k}^2+\sum _{j\in [1,N]}{y}_{a,j}^2\right)+\sum _{k\in [1,n]}{x}_{\otimes ,k}^2+\sum _{j\in [1,N]}{y}_{\otimes ,j}^2$$

$$\displaystyle=\!\ell^{2}(n\!+\!N)+\!\!\!\!\sum\limits_{k\in[1,n]}\!\!\Bigg{(}\!\sum_{a\in\mathbb{F}_{q}}x_{a,k}^{2}\!-2\ell\sum_{a\in\mathbb{F}_{q}}\!x_{a,k}\!+\!\Big{(}\!\sum_{a\in\mathbb{F}_{q}}x_{a,k}\Big{)}^{\!2}\!\Bigg{)}$$

$$\displaystyle\hskip 12.91663pt+\sum\limits_{j\in[1,N]}\Bigg{(}\sum_{a\in\mathbb{F}_{q}}y_{a,j}^{2}-2\ell\sum_{a\in\mathbb{F}_{q}}y_{a,j}+\Big{(}\sum_{a\in\mathbb{F}_{q}}y_{a,j}\Big{)}^{2}\Bigg{)}.$$

$$\sum_{a\in\mathbb{F}_{q}}x_{a,k}^{2}\geq\frac{1}{q}\cdot\Big{(}\sum_{a\in\mathbb{F}_{q}}x_{a,k}\Big{)}^{2}.$$

$$X_k\triangleq \sum _{a\in {\mathbb{F}}_q}{x}_{a,k},\text{and}{Y}_j\triangleq \sum _{a\in {\mathbb{F}}_q}{y}_{a,j}.$$

$$\ell$$

$$\le \sum _{k\in [1,n]}\left(2\ell X_k-\frac{q+1}{q}{X}_k^2\right)+\sum _{j\in [1,N]}\left(2\ell Y_j-\frac{q+1}{q}{Y}_j^2\right).$$

$$f(z)=2\ell z-\frac{q+1}{q}{z}^2.$$

$$\sum _{k\in [1,n]}{X}_k+\sum _{j\in [1,N]}{Y}_j\le \ell \tau .$$

$$\sum _{k\in [1,n]}f(X_k)+\sum _{j\in [1,N]}f(Y_j)$$

$$X_k=Y_j=\frac{\ell \tau }{n+N},\forall i\in [1,n],k\in [1,N].$$

$$\ell (\ell -1)d\le 2{\ell }^2\tau -\frac{q+1}{q}\frac{{\ell }^2{\tau }^2}{n+N}.$$

Full text

I Introduction

Lately, codes for correcting insertions and deletions attract a lot of attention due to their possible application to correcting errors in DNA storage and DNA sequencing, cf. [8]. Furthermore, insertions and deletions can be seen as synchronization errors in communication systems since the information about the position is lost when receiving a certain symbol.

The algebraic concepts by Varshamov, Tenengolts, and Levenshtein for correcting insertions and deletions go back to the 1960s. Varshamov and Tenengolts designed a class of codes, nowadays called VT codes, which was originally designed to correct asymmetric errors on the Z-channel [24, 25]. Levenshtein proved that these codes can also be used to correct a single insertion or deletion [26]. Further, he constructed a class of codes that can correct two adjacent insertions or deletions [13], and designed $q$-ary single insertion-/deletion-correcting codes [24]. Brakensiek, Guruswami and Zbarsky recently presented multiple insertion-/deletion-correcting codes in [2] with low redundancy. The papers [3, 21, 22] deal with bursts of insertions/deletions. Special types of insertions include duplications [12] and sticky insertions [17]. Asymptotic bounds on the size of insertion-/deletion-correcting codes were derived by Levenshtein [26] and non-asymptotic bounds were recently presented by Kulkarni and Kiyavash [11].

This paper investigates list decoding of insertions and deletions. A list decoder returns the list of all codewords in radius at most $\tau$ around a given received word. The idea of list decoding was introduced by Elias [4] and Wozencraft [29]. In this paper, we investigate list decoding in the Levenshtein metric. The Levenshtein distance between two words is the minimum number of insertions and deletions needed to turn one of the words into the other. A $(\tau,\ell)_{\mathsf{L}}$-list decoder is therefore a decoder which returns all codewords of a given code in Levenshtein distance at most $\tau$ around any given received word. The size of this list is at most $\ell$.

A fundamental question when considering list decoding in a certain metric is whether the complexity of a list decoding algorithm is “feasible”. This leads to investigating the possibility of polynomial-time (w.r.t. the code-length) list decoding. The list size $\ell$ gives a lower bound on the complexity of such a decoder, since writing down the whole list of codewords is part of any list decoding algorithm. On the one hand, a lower bound on the maximum list size that grows exponentially in the length of the code rules out the possibility of polynomial-time list decoding. This is the case for example for certain families of rank-metric codes, cf. [27, 18]. On the other hand, a polynomial upper bound shows that polynomial-time list decoding is possible (but explicit algorithms still have to be found). In the Hamming metric, the Johnson upper bound [9, 10, 1, 7] shows for any code of length $n$ and minimum Hamming distance $D$ that the size of the decoding list is polynomial in $n$ when $\tau$ is less than the so-called Johnson radius $n-\sqrt{n(n-D)}$.

In this paper, we investigate list decoding of insertions and deletions in the Levenshtein metric. First, we derive a Johnson-like upper bound on the list size. Second, a lower bound on list decoding VT codes and a list decoding algorithm of a constant number of insertions/deletions with VT codes are given.

To our knowledge, this is the first paper which considers list decoding of insertions/deletions in the Levenshtein metric. The recent work by Mazooji [16, 15] considers unique decoding beyond half the minimum Levenshtein distance, but this is a different setting since such a decoder always fails when the list size is larger than one. The paper [6] by Guruswami and Wang shows that there exists a binary code of length $n$ which can list-decode $n\left(\frac{1}{2}-\epsilon\right)$ deletions, where $0<\epsilon<\frac{1}{2}$. However, they consider deletions only, and their code rate is very small, in the order of $\epsilon^{3}$. In this region, our upper bound shows that from a combinatorial point of view, polynomial-time list decoding is actually possible up to a larger radius. Another similar-looking problem is the sequence reconstruction problem of insertions or deletions, see [14, 20, 5], where the maximum intersection of two insertion/deletion balls of radius $\tau$ around any two words is calculated. The problem in this paper can on the contrary be seen as calculating the maximum number of codewords in a ball around any word.

The rest of this paper is organized as follows. Section II provides notations and definitions, and defines VT codes. In Section III, we derive the main result, i.e., the Johnson-like upper bound on the maximum list size and also give an alphabet-free version of this bound. This bound is then illustrated and discussed in Section IV and simplified for the cases of deletions only and insertions only. Section V provides the lower bound on list decoding deletions only with VT codes and finally, in Section VI we give a list decoder for two insertions/deletions with VT codes and explain how it can be extended to any constant number of insertions/deletions.

II Preliminaries

II-A Notations and Definitions

Let $\mathbb{F}_{q}$ be a finite field of order $q$, where $q$ is a power of a prime, and let $\mathbb{F}_{q}^{n}$ denote the set of all vectors (sequences) of length $n$ over $\mathbb{F}_{q}$. A subsequence of a vector $\textup{{x}}=(x_{1},x_{2},\dots,x_{n})$ is formed by taking a subset of the symbols of x and aligning them without changing their order. Hence, for $N<n$, any vector $\textup{{y}}=(x_{i_{1}},x_{i_{2}},\dots,x_{i_{N}})$ is a subsequence of x if $1\leq i_{1}<i_{2}<\dots<i_{N}\leq n$, and in this case we say that $n-N$ deletions occurred in the sequence x and y is the result.

Vice versa, $N-n$ insertions occurred in the sequence x if $N>n$ and x is a subsequence of $\textup{{y}}=(y_{1},y_{2},\dots,y_{N})$. Here, y is called a supersequence of x.

The Levenshtein distance $d_{\mathsf{L}}(\textup{{a}},\textup{{b}})$ between two words a and b (not necessarily of the same length) is the minimum number of insertions and deletions which is needed to transform a into b. In this sense, an additive error of Hamming weight one (also called substitution error) consists of one insertion and one deletion at the same position. Therefore, if the Hamming distance between a and b is $d_{\mathsf{H}}(\textup{{a}},\textup{{b}})=D$, then $d_{\mathsf{L}}(\textup{{a}},\textup{{b}})\leq 2D$. Also notice that for two vectors a of length $n$ and b of length $N$, $d_{\mathsf{L}}(\textup{{a}},\textup{{b}})$ can become larger than $n$ and at most $n+N$.

By $\mathcal{B}^{(\tau)}_{\mathsf{L}}(\textup{{r}})$ we denote the set of all vectors in Levenshtein distance at most $\tau$ around a given word r; by $\mathcal{B}^{(\delta)}_{\mathsf{D}}(\textup{{r}})$ the set of all vectors which can be obtained from r by at most $\delta$ deletions; and by $\mathcal{B}^{(\epsilon)}_{\mathsf{I}}(\textup{{r}})$ the set of words which can be obtained from r by at most $\epsilon$ insertions. The size of $\mathcal{B}^{(\tau)}_{\mathsf{L}}(\textup{{r}})$ and $\mathcal{B}^{(\delta)}_{\mathsf{D}}(\textup{{r}})$ depends on its center, whereas the size of $\mathcal{B}^{(\epsilon)}_{\mathsf{I}}(\textup{{r}})$ only depends on the radius $\epsilon$ and the length $N$ of $\mathbf{r}$ and therefore, by slight abuse of notation, we also write $|\mathcal{B}^{(\epsilon)}_{\mathsf{I}}(N)|$.

By the triple $(n,M,d)^{\mathsf{L}}_{q}$ we denote a code of Levenshtein distance $d$, of length $n$, and cardinality $M$. An $(n,M,d)^{\mathsf{L}}_{q}$ code can always decode uniquely if the number of insertions $\epsilon$ and the number of deletions $\delta$ satisfy

[TABLE]

In this paper, we analyze the capability of $(n,M,d)^{\mathsf{L}}_{q}$ codes to perform polynomial-time list decoding beyond $d/2$. Given a received word $\textup{{r}}\in\mathbb{F}_{q}^{N}$, a $(\tau,\ell)_{\mathsf{L}}$-list decoder for an $(n,M,d)^{\mathsf{L}}_{q}$ code returns the set of all codewords in Levenshtein distance at most $\tau$ from r and the size of this list is at most $\ell$.

Throughout this paper, the maximum list size is denoted by

[TABLE]

Finally, for any positive integers $a,b$, we denote by $[a,b]$ the set of integers $\{i:a\leq i\leq b,i\in\mathbb{Z}\}$.

II-B Varshamov–Tenengolts Codes

The binary Varshamov–Tenengolts (VT) codes [25] are single-deletion correcting codes (cf. Sloane’s survey in [23]), defined as follows.

Definition 1** **(VT Codes)

For $a\in[0,n]$, the binary Varshamov–Tenengolts (VT) code $\mathcal{VT}_{a}(n)$ is the following set of binary vectors:

[TABLE]

Levenshtein proved in [26] that VT codes can correct either a single deletion or a single insertion. The largest VT codes are obtained for $a=0$, and these codes are conjectured to be optimal in the sense that they have the largest cardinality among all single-deletion correcting codes [23]. The cardinality of the $\mathcal{VT}_{0}(n)$ code is at least $\frac{2^{n}}{n+1}$; for the exact cardinality of the $\mathcal{VT}_{0}(n)$ code, see [23, Eq. (10)].

For all $n$, the union of all VT codes forms a partition of the space $\mathbb{F}_{2}^{n}$, that is $\bigcup_{a=0}^{n}\mathcal{VT}_{a}(n)=\mathbb{F}_{2}^{n}$.

III Johnson-like Upper Bound

In this section, we derive a Johnson-like upper bound on the list size which holds for any $q$-ary code, minimum Levenshtein distance $d$, and any received word of length $N\geq 0$. Thus, from a combinatorial point of view, polynomial-time list decoding is possible at least up to the derived radius.

The proof follows similar ideas as the proof of Bassalygo [1] and Roth [19, Prop. 4.11] for the Johnson bound in Hamming metric, but the adaptations to the Levenshtein metric are non-trivial since we have to deal with sequences of different lengths and spheres in the Levenshtein metric behave completely different than spheres in the Hamming metric. E.g., the size of a deletion sphere depends on its center, not only its radius.

Theorem 1** **(Main Theorem: Johnson-like Upper Bound)

Let $q\geq 2$ and let an integer $\tau<d\leq n+N$ be given. Let $\textup{{r}}\in\mathbb{F}_{q}^{N}$ be a given word of length $N$, where $N\in[n-\tau,n+\tau]$. Denote

[TABLE]

Then, for any $(n,M,d)^{\mathsf{L}}_{q}$ code $\mathcal{C}$ and for any integer $\tau$ such that

[TABLE]

the maximum list size \ell=\max_{\textup{{r}}\in\mathbb{F}_{q}^{N}}\big{\{}\big{|}\mathcal{C}\cap\mathcal{B}^{(\tau)}_{\mathsf{L}}(\textup{{r}})\big{|}\big{\}} is bounded by

[TABLE]

Proof:

We denote the list of codewords as follows:

[TABLE]

with $|\mathcal{L}|=\ell$. Therefore, for each $i=1,\dots,\ell$, the number of insertions $\epsilon_{i}$ and the number of deletions $\delta_{i}$ of elements of $\textup{{c}}_{i}$ to obtain r (where $\delta_{i}+\epsilon_{i}$ is minimized), satisfies $\epsilon_{i}+\delta_{i}=d_{\mathsf{L}}(\textup{{r}},\textup{{c}}_{i})\leq\tau$. Equivalently, $d_{\mathsf{L}}(\textup{{r}},\textup{{c}}_{i})$ is obtained by $\delta_{i}$ deletions of elements of $\textup{{c}}_{i}$ and $\epsilon_{i}$ deletions of elements of r such that both result in the same vector and $\delta_{i}+\epsilon_{i}$ is minimized.

We therefore denote sets of positions of deletions from $\textup{{c}}_{i}$ and r, respectively, of smallest size to obtain the same vector by $\mathcal{D}^{(i)}$ and $\mathcal{E}^{(i)}$, where $|\mathcal{D}^{(i)}|=\delta_{i}$ and $|\mathcal{E}^{(i)}|=\epsilon_{i}$. Note that these sets do not have to be unique, but the choice is fixed for the remainder of the proof. We associate each $\textup{{c}}_{i}$ with the two corresponding sets $\mathcal{D}^{(i)}$ and $\mathcal{E}^{(i)}$. For these sets, the following holds:

[TABLE]

The Levenshtein distance is therefore:

[TABLE]

Further, we denote by $\mathcal{F}^{(i_{1},i_{2})}\subseteq[1,n]$ and $\mathcal{F}^{(i_{2},i_{1})}\subseteq[1,n]$ the sets of positions which have to be deleted to obtain the same vector from $\textup{{c}}_{i_{1}}$ and from $\textup{{c}}_{i_{2}}$ such that the sum of their cardinalities $|\mathcal{F}^{(i_{1},i_{2})}|+|\mathcal{F}^{(i_{2},i_{1})}|$ is minimal. Therefore,

[TABLE]

Let $x_{a,j}$ denote the number of times in all $\ell$ codewords in $\mathcal{L}$ that a fixed position $j\in[1,n]$ is contained in $\mathcal{D}^{(i)}$ and the deleted value equals $a\in\mathbb{F}_{q}$. Similarly, let $y_{a,j}$ denote the number of times in all $\ell$ codewords in $\mathcal{L}$ that $j\in[1,N]$ is contained in $\mathcal{E}^{(i)}$ and the deleted value equals $a\in\mathbb{F}_{q}$.

Thus,

[TABLE]

Denote by $x_{\otimes,j}$ and $y_{\otimes,j}$ the number of times that a fixed position $j\notin\mathcal{D}^{(i)}$, respectively $j\notin\mathcal{E}^{(i)}$, $\forall i\in[1,\ell]$. Hence,

[TABLE]

In the following, consider all $\ell(\ell-1)$ tuples of two distinct codewords in $\mathcal{L}$, i.e., all tuples $(\textup{{c}}_{i_{1}},\textup{{c}}_{i_{2}})$ where $i_{1}\neq i_{2}$, and their associated sets $\mathcal{D}^{(i_{1})},\mathcal{E}^{(i_{1})},\mathcal{D}^{(i_{2})},\mathcal{E}^{(i_{2})}$.

We count the overall number of the following events $\forall i_{1},i_{2}\in[1,\ell]$, $i_{1}\neq i_{2}$, $\forall k\in[1,n]$ and $\forall j\in[1,N]$:

• •

$k\in\mathcal{D}^{(i_{1})}\cap\mathcal{D}^{(i_{2})}$ and for the deleted values $a_{i_{1}}\neq a_{i_{2}}$

• •

or $k\notin\mathcal{D}^{(i_{1})}$ and $k\in\mathcal{D}^{(i_{2})}$

• •

or $k\in\mathcal{D}^{(i_{1})}$ and $k\notin\mathcal{D}^{(i_{2})}$

• •

or $j\notin\mathcal{E}^{(i_{1})}$ and $j\in\mathcal{E}^{(i_{2})}$

• •

or $j\in\mathcal{E}^{(i_{1})}$ and $j\notin\mathcal{E}^{(i_{2})}$.

Notice that

[TABLE]

since deleting the symbol at the same position of r always has the same value, otherwise this case would have to be considered as well.

The total number $\lambda$ of the previously mentioned five events can be bounded from below as follows:

[TABLE]

On the other hand, we can explicitly count the five events as follows: given a position $k\in[1,n]$ and a fixed element $a\in\mathbb{F}_{q}$, the list size equals $\ell=x_{a,k}+\hat{x}_{a,k}+x_{\otimes,k}$ where $\hat{x}_{a,k}$ denotes the number of values $i$, $i\in[1,\ell]$, for which $k\in\mathcal{D}^{(i)}$ but where the deleted $k$-th symbol of $\textup{{c}}^{(i)}$ does not equal $a$. Then, the number of values $i_{1}$ and $i_{2}$, $i_{1},i_{2}\in[1,\ell]$ and $i_{1}\neq i_{2}$, for which the first event holds (for a fixed $k$) is $\sum_{a\in\mathbb{F}_{q}}x_{a,k}\cdot\hat{x}_{a,k}$. Similarly, the number of pairs $(i_{1},i_{2})$ for which the second or third event holds are $\sum_{a\in\mathbb{F}_{q}}x_{a,k}\cdot{x}_{\otimes,k}+x_{\otimes,k}(\ell-x_{\otimes,k})$. Thus, summing over the number of pairs $(i_{1},i_{2})$ for which one of the first three events occur for a fixed $k$, gives $\sum_{a\in\mathbb{F}_{q}\cup\otimes}x_{a,k}(\ell-x_{a,k})$.

A similar argument shows that the total number of pairs $(i_{1},i_{2})$ of the last two events for a fixed $j$ equals $\sum_{a\in\mathbb{F}_{q}\cup\otimes}y_{a,j}(\ell-y_{a,j})$. It therefore follows from summing over all $j$ and $k$ that (pay attention that the $\otimes$ is included in the summation):

[TABLE]

Since $\sum_{a\in\mathbb{F}_{q}\cup\otimes}x_{a,k}=\ell$ for all $k\in[1,n]$ and $\sum_{a\in\mathbb{F}_{q}\cup\otimes}y_{a,j}=\ell$ for all $j\in[1,N]$, we can simplify (6) as follows:

[TABLE]

Combining (5) and (7) yields:

[TABLE]

Further, $x_{\otimes,k}=\ell-\sum_{a\in\mathbb{F}_{q}}x_{a,k}$ and similarly, $y_{\otimes,j}=\ell-\sum_{a\in\mathbb{F}_{q}}y_{a,j}$, and therefore,

[TABLE]

Hence,

[TABLE]

The Cauchy–Schwarz inequality states that

[TABLE]

Further, for ease of notation, we denote:

[TABLE]

Plugging this into (8) gives:

[TABLE]

We will now bound the RHS of (9) from above. For that purpose, denote the following function $f(z)$ (over the reals):

[TABLE]

This function $f(z)$ is monotonically increasing for $z\leq\frac{q}{q+1}\ell$, achieves its global maximum for $z_{max}\triangleq z=\frac{q}{q+1}\ell$ where $f(z_{max})=\ell^{2}\frac{q}{q+1}$. For bounding (9), we have to take into account the restriction from (4), i.e.,

[TABLE]

Since $f(X_{k})$ and $f(Y_{j})$ are monotonically increasing, also the following sum (which is equal to the RHS of (9))

[TABLE]

is monotonically increasing and has its maximum value when $X_{k}=Y_{j}=\frac{q}{q+1}\ell$ which is $\frac{q}{q+1}\ell^{2}(n+N)$. Since $\ell\tau\leq\frac{q}{q+1}\ell^{2}(n+N)$, the RHS of (9) is maximized under the restriction of (10) for

[TABLE]

Therefore, we can bound (9) from above as follows:

[TABLE]

Solving (11) for $\ell$ leads to the statement of Theorem 1. The restriction on $\tau$ holds since the denominator of (3) has to be positive. ∎

The following corollary shows an alphabet-free Johnson-like upper bound which holds since the bound from (3) can be bounded from above by (13).

Corollary 1** **(Alphabet-free Johnson-like Bound)

For any $(n,M,d)^{\mathsf{L}}_{q}$ code $\mathcal{C}$, any received word of length $N$, and any integer $\tau$ such that

[TABLE]

the list size $\ell$ is bounded from above by

[TABLE]

We have therefore derived an upper bound on the list size, depending on the length of the code $n$, the minimum Levenshtein distance of the code $d$, and the length of the received word $N$. This bound holds for any number of insertions $\epsilon$ and number of deletions $\delta$ where $\epsilon+\delta\leq\tau$, when $\tau$ satisfies (2), respectively (12). Thus, polynomial-time list decoding is feasible up to this radius.

Corollary 1 is an alphabet-free version of the Johnson-like bound from Theorem 1 which is clearly weaker. Similar to the Johnson bound in Hamming metric, taking into account the field size $q$ makes the largest difference for the smallest field size $q$, i.e., for $q=2$.

IV Discussion of the Johnson-like Bound

IV-A Illustration

In this section, we plot our Johnson-like bounds in order to illustrate the gain in the decoding radius compared to unique decoding.

First, we illustrate the alphabet-free Johnson-like upper bound (Corollary 1). Since $\Delta\triangleq N-n$ depends on $\tau$, we normalize the radius by $2n$ (and not by $n+N$) and illustrate $\frac{\tau_{\mathsf{L}}}{2n}$ of (12) as a function of $\frac{d}{2n}$ for different values of $\Delta$ in Fig. 1. This normalization of (12) gives:

[TABLE]

Fig. 1 illustrates (14) for different values of $\Delta$.

Notice that since $N\in[n-\tau,n+\tau]$, we know that $\Delta\in[-\tau,\tau]$. Thus, for e.g., $\Delta=-\frac{n}{2}$, we have $\frac{\tau}{2n}\geq\frac{1}{4}$. On the other hand, the argument in the square root is only defined for $\frac{\tau}{2n}\leq\frac{3}{4}$ and therefore the curve is only plotted for this region.

In general, the plot shows a notable improvement compared to the unique decoding radius (1) (green dash-dotted line).

Interestingly, for $\Delta=0$, the result equals the alphabet-free Hamming-metric Johnson radius $n-\sqrt{n(n-d)}$ when normalized by $n$.

Second, we take the field size into account which gives a further improvement, especially for small $q$. The alphabet-dependent bound from (2) when normalized by $2n$ gives:

[TABLE]

For $q=2$, this gives:

[TABLE]

In Fig. 1, the last black dash-dotted curve illustrates $\frac{\tau_{\mathsf{L}}(q)}{2n}$ for $\Delta=0$. Compared to the second curve, we notice that taking the field size into account demonstrates a further improvement.

IV-B VT Codes

The following example shows that polynomial-time list decoding of two insertions/deletions is possible with VT codes.

Example 1** **(Johnson-like Bound for VT Codes)

First note that VT codes have Levenshtein distance $d=4$ since all codewords have equal length $n$ (thus $d$ has to be even) and since it is proven that they can correct any single deletion or insertion (and therefore $d\geq 3$).

For fixed $d$, the larger $n+N$ gets, the smaller the RHS of (2) and (12) get. Thus, for fixed $n$ and $d$ and $N\in[n-\tau,n+\tau]$, the minimum of the RHS is achieved for $N=n+\tau$. Thus, if we prove that $\tau$ insertions can be corrected, any combination of $\tau$ insertions and deletions can be corrected as well.

We want to understand if list decoding of VT codes for $\tau=2$ is possible for any $N\in[n-2,n+2]$ and therefore check (12) for $d=4$ and $N=n+2$. From (12), we therefore need that:

[TABLE]

which is true for any $n>0$.

Thus, list decoding of two insertions/deletions is feasible in polynomial time. This potentially doubles the error-correcting capability of VT codes (at the cost of having a list of codewords). In Section VI, a simple list decoding algorithm for this case is shown and also how to generalize it to any constant number of insertions/deletions.

IV-C Only Deletions or Only Insertions

The bound from Theorem 1 simplifies to the following corollary when only deletions occur.

Corollary 2** **(Johnson-like Upper Bound for Deletions)

Let $q\geq 2$ and let $\textup{{r}}\in\mathbb{F}_{q}^{N}$ be a given word of length $N=n-\delta\geq 0$. Then, for any $(n,M,d)^{\mathsf{L}}_{q}$ code $\mathcal{C}$ and for any integer $\delta$ such that

[TABLE]

the list size $\ell$ is bounded from above by

[TABLE]

where $\mathcal{B}^{(\delta)}_{\mathsf{D}}(\textup{{r}})$ denotes a deletion ball around r of deletion radius $\delta$, i.e., the number of deletions $\delta$ between all words in the ball and r is at most $\delta$.

Similarly, we obtain the following Johnson-like upper bound for list decoding only insertions.

Corollary 3** **(Johnson-like Upper Bound for Insertions)

Let $q\geq 2$ and let $\textup{{r}}\in\mathbb{F}_{q}^{N}$ be a given word of length $N=n+\epsilon\geq n$. Then, for any $(n,M,d)^{\mathsf{L}}_{q}$ code $\mathcal{C}$ and for any integer $\epsilon$ such that

[TABLE]

the list size $\ell$ is bounded from above by

[TABLE]

where $\mathcal{B}^{(\epsilon)}_{\mathsf{I}}(\textup{{r}})$ denotes a ball around r of insertion radius $\epsilon$, i.e., the number of insertions $\epsilon$ between all words in the ball and r is at most $\epsilon$.

Interestingly, the Johnson-like bound for deletions is larger than the one for insertions; i.e., it seems that more deletions can be list decoded than insertions.

V A Lower Bound for Deletion-List-Decoding of VT Codes

In this section, we derive a lower bound on the maximum list size when list decoding deletions only with VT codes. In general, a lower bound on the maximum list size will give a minimum complexity estimate of any list decoder since stating the list of codewords is a necessary task of any list decoder.

Theorem 2** **(Lower Bound of VT Codes for Deletions)

For the binary $\mathcal{VT}_{0}(n)$ code of cardinality $|\mathcal{VT}_{0}(n)|\geq\frac{2^{n}}{n+1}$, the maximum list size of list decoding up to $\delta$ deletions is bounded from below as follows:

[TABLE]

Proof:

The length of the received word r is $N=n-\delta$. Due to the pigeonhole principle, there is a received word r of length $N$ such that the number of codewords of length $n$ around r in insertion radius at most $\delta$ is at least the average number of codewords in an insertion ball of radius $\delta$ (whose size does not depend on r, but on $N$):

[TABLE]

It is known that for a binary vector of length $N$, the number of supersequences of length $N+s$ is exactly $\sum_{i=0}^{s}\binom{N+s}{i}$. Thus, the number of supersequences of a vector of length $N$ of length at most $N+\delta$ is $|\mathcal{B}^{(\delta)}_{\mathsf{I}}(N)|=\sum_{s=0}^{\delta}\sum_{i=0}^{s}\binom{N+s}{i}$ and with the size of the VT code, we obtain:

[TABLE]

and the statement follows. ∎

The maximum list size therefore grows exponentially with the number of deletions and at least polynomially with a degree-$\delta$-function in the length $n$ of the VT code. Notice that this result does not contradict in any sense Example 1 or Algorithm 2, since this shows in general a lower bound on list decoding $\delta$ deletions, while Example 1 and Algorithm 2 show that list decoding of a constant number deletions with VT codes always results in a polynomial-sized list of codewords.

Deriving a similar lower bound for list decoding of insertions does not work in this way since the actual size as well as lower bounds on the size of the deletion ball $|\mathcal{B}^{(\delta)}_{\mathsf{D}}(\textup{{r}})|$ depend on the received word rather than only its length (or actually, the number of runs of the received word), see [26, Equation (1)] and therefore the pigeonhole argument of the proof of Theorem 2 does not work. The same problem occurs when deriving a lower bound for insertions and deletions. Additionally, we are not aware of an expression or an explicit lower bound for $|\mathcal{B}^{(\tau)}_{\mathsf{L}}(\textup{{r}})|$.

VI List Decoding Algorithm for VT Codes

As shown in Example 1, polynomial-time list decoding of VT codes for $\tau=2$ is possible. In this section, we present a simple $(2,n)_{\mathsf{L}}$-list decoder for VT codes. We restrict ourselves to $a=0$, but this principle works for any other VT code as well. Usually, the list size will be much smaller than $n$. Despite its simple concept, this decoder is the first explicit polynomial-time list decoding algorithm in the Levenshtein metric. It is also shown how to generalize the algorithm to any constant number of insertions/deletions.

We denote the following checksum $S(\textup{{r}})$ of the received word r (which is zero if $\textup{{r}}\in\mathcal{VT}_{0}(n)$ and $N=n$):

[TABLE]

Notice that the minus for the checksum is introduced such that (16) rather denotes the checksum deficiency as in [23].

The length of the received word $\textup{{r}}=(r_{1},r_{2},\dots,r_{N})$ is denoted by $N$ and provides information on how many insertions/deletions occurred. We thereby assume that the total number of insertions and deletions is at most $\tau=2$. Thus, for $N=n-2$, we will correct two deletions; for $N=n-1$ we correct a single deletion (with list size one); for $N=n$ we will correct one insertion and one deletion (if the received word is already a codeword, the list size will be one as explained later); for $N=n+1$, one insertion; and for $N=n+2$, two insertions.

For our list decoder, we make use of the well-known single insertion/deletion decoder for VT codes, cf. [23], which is summarized in Algorithm 1 for the case when $N=n-1$, i.e., a single deletion happened. Here, from a VT codeword $(c_{1},c_{2},\dots,c_{n})$ the symbol $c_{p}$ was deleted. Denote by $L_{0}$/$L_{1}$ the number of zeros/ones left of $c_{p}$ and by $R_{0}$/$R_{1}$ the number zeros/ones right of $c_{p}$. Note that $\operatorname{wt}_{\mathsf{H}}(\textup{{r}})=R_{1}+L_{1}$. Of course, the decoder knows neither $p$ nor $c_{p}$ nor $L_{0},L_{1},R_{0},R_{1}$.

[TABLE]

The complexity of Algorithm 1 is in $\mathcal{O}(n)$. Single insertion-correction works in a similar way and is denoted by VT-In-Dec in the following.

Our list decoding algorithm uses the VT single insertion/deletion decoder and is shown in Algorithm 2. If $N=n-1$ or $n+1$, we directly call a unique VT decoder since two insertions or deletions in a vector of length $n$ cannot result in a vector of length $n-1$ or $n+1$. In the other cases, we first generate all subsequences or supersequences of length $n-1$ or $n+1$, respectively, and call a VT decoder for each of these sequences.

[TABLE]

Clearly, this strategy provides all codewords around r in distance at most $\tau=2$. To understand the maximum list size, recall that for $N=n-2$, the number of supersequences of length $n-1$ is exactly $n$; for $N=n+2$, the number of subsequences of length $n+1$ is equal to the number of runs of r and therefore at most $n+2$. Further, there cannot be two codewords in the output list which result in the given received word by deleting the symbol at the same position (and one additional insertion or deletion at different positions) since otherwise these two words have Levenshtein distance only two. Thus, the list size for $N=n+2$ and also for $N=n$ is at most $n$.

The previously mentioned reasoning explains also why the list size will be one if r has length $N=n$ and is a codeword (i.e., $S(\textup{{r}})=0$).

The complexity of Algorithm 2 is in $\mathcal{O}(n^{2})$ since $\mathcal{O}(n)$ times a unique VT decoder is called.

This algorithm can be extended to any constant number of insertions and deletions $\tau$, by building simply all the corresponding sub- and supersequences. For example, when $N=n$, we know that the same number of insertions and deletions occurred; From r we then create

• •

all supersequences of length $n+1$ and use a single insertion decoder,

• •

all subsequences of length $n-1$ and use a single deletion decoder,

• •

all supersequences of length $n+2$, from each of these sequences all subsequences of length $n+1$ and then use a single insertion decoder,

• •

…

• •

all subsequences of length $n-\lfloor\tau/2\rfloor$, from each of these sequences all supersequences of length $n-\lfloor\tau/2\rfloor-1$, from each of these sequences all supersequences of length $n-\lfloor\tau/2\rfloor-2$ and so on until we have many sequences of length $n-1$ and use a single deletion decoder.

For analyzing the list size, let us look at the last step: here the number of subsequences of length $n-\lfloor\tau/2\rfloor$ is at most $n^{\lfloor\tau/2\rfloor}$, for each time when a new set of supersequences of these sequences is created, the number of investigated sequences is increased by a factor of $n$. Thus, a VT decoder has to be applied to at most $n^{\lfloor\tau/2\rfloor}\cdot n^{\lfloor\tau/2\rfloor-1}=n^{\tau-1}$ sequences. Since there are in total $\tau$ such steps, at most $\tau n^{\tau-1}$ sequences have to be investigated, i.e., for constant $\tau$, the list size is in $\mathcal{O}(n^{\tau-1})$. For $\tau=2$, we could previously show that the list size is at most $n$, and not $2n$, so it might be possible to prove that for the general case the list size is at most $n^{\tau-1}$ instead of $\tau n^{\tau-1}$, but this is not obvious.

In the case for a constant number $\delta$ of deletions only, for any received word of length $N=n-\delta$, we have to calculate all supersequences of length $n-1$ and apply a VT decoder. In this case, the list size is at most $n^{\delta-1}$.

Acknowledgment

The author would like to thank the reviewers whose very helpful comments helped to improve the paper significantly (and in particular to make the proof of the main result more understandable) and also the reviewers from ISIT 2017 (one of the reviewers made a comment which significantly simplified the list decoder of VT codes).

Further, the author wants to thank Andreas Lenz and Eitan Yaakobi for the helpful discussions.