Polynomial time decodable codes for the binary deletion channel

TL;DR

This paper presents an explicit construction of codes that can be efficiently encoded and decoded to correct deletions in the binary deletion channel, achieving a rate proportional to the deletion probability, improving practical applicability.

Contribution

It introduces a polynomial-time decodable code construction for the binary deletion channel with a rate proportional to (1-p), advancing beyond existence proofs to explicit algorithms.

Findings

Codes with rate c₀(1-p) are explicitly constructed.

Encoding and decoding algorithms run in polynomial time.

The construction works for any deletion probability p < 1.

Abstract

In the random deletion channel, each bit is deleted independently with probability $p$. For the random deletion channel, the existence of codes of rate $(1-p)/9$, and thus bounded away from $0$ for any $p < 1$, has been known. We give an explicit construction with polynomial time encoding and deletion correction algorithms with rate $c_0 (1-p)$ for an absolute constant $c_0 > 0$.

Equations

$$\mathbf{Pr}\text{/}[A\le (1-\delta )\mathbb{E}\text{/}[A]]\le \exp \left(-{\delta }^2\mathbb{E}\text{/}[A]/2\right).$$

$$\mathbf{Pr}\text{/}[A\ge (1+\delta )\mathbb{E}\text{/}[A]]\le {\left(\frac{e^{\delta }}{(1+\delta {)}^{1+\delta }}\right)}^{\mathbb{E}\text{/}[A]}.$$

$$\mathbf{Pr}\text{/}\left[\sum _{i=1}^n{A}_i\ge n\gamma \right]\le \exp \left(-\frac{(\gamma -\alpha {)}^{2}n}{3\alpha \beta }\right).$$

$$\frac{2^{0.6942m}}{\delta m{\left(\genfrac{}{}{0ex}{}{m}{(1-\delta )m}\right)}^2}=2^{m(0.6942-2h(\delta )-O(\log (\delta m)/m))}.$$

$$\mathfrak{m}\stackrel{C_{out}}{\to }{c}^{(out)}\stackrel{C_{in},Buf}{\to }$$

$$\displaystyle\,\leavevmode\hbox to6.67pt{\vbox to6.67pt{\pgfpicture\makeatletter\hbox{\hskip 3.33301pt\lower-3.33301pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }{{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{0.0pt}{0.0pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hbox to0.0pt{}{}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}s\xrightarrow{DeBuf}\left\{s_{i}^{(dup)}\right\}_{i}\xrightarrow{DeDup}\left\{s_{i}^{(in)}\right\}_{i}\xrightarrow{\operatorname*{Dec}_{in}}s^{(out)}\xrightarrow{\operatorname*{Dec}_{out}}\mathfrak{m}\leavevmode\hbox to80.88pt{\vbox to80.88pt{\pgfpicture\makeatletter\hbox{\hskip 40.43831pt\lower-40.43831pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } { {}{}{}{}{}}{}{{}}{} { {}{}{}{}{}}{{}{}}{{}} {{{}}{{}}}{{}}{ {}{}{}{}{}}{{{}}{{}}}{ {}{}{}{}{}}{}{{}}{}{}{}{}{}{}{}{{}} {{{}{{}{}}{}}}{{ {}{}{}}}{{{{}}{{}}}}{{}}{{{ }}}\pgfsys@beginscope\pgfsys@invoke{ }\color[rgb]{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}\pgfsys@color@rgb@stroke{1}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{1}{0}{0}\pgfsys@invoke{ }\definecolor[named]{pgffillcolor}{rgb}{1,0,0}{}{{ {\pgfsys@beginscope\pgfsys@setlinewidth{0.32pt}\pgfsys@setdash{}{0.0pt}\pgfsys@roundcap\pgfsys@roundjoin{} {}{}{} {}{}{} \pgfsys@moveto{-1.19998pt}{1.59998pt}\pgfsys@curveto{-1.09998pt}{0.99998pt}{0.0pt}{0.09999pt}{0.29999pt}{0.0pt}\pgfsys@curveto{0.0pt}{-0.09999pt}{-1.09998pt}{-0.99998pt}{-1.19998pt}{-1.59998pt}\pgfsys@stroke\pgfsys@endscope}} }{}{}{{}}{}{}{{}}\pgfsys@moveto{2.12132pt}{-2.12132pt}\pgfsys@curveto{40.23831pt}{-40.23831pt}{-40.23831pt}{40.23831pt}{-2.44658pt}{2.44658pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{0.7071}{-0.7071}{0.7071}{0.7071}{-2.44658pt}{2.44658pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}}\hbox{\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{0.0pt}{0.0pt}\pgfsys@invoke{ }\hbox{{\definecolor[named]{.}{rgb}{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}\pgfsys@color@rgb@stroke{1}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{1}{0}{0}\pgfsys@invoke{ }\hbox{} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}}\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-10.97224pt}{7.06601pt}\pgfsys@invoke{ }\hbox{{\definecolor[named]{.}{rgb}{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}\pgfsys@color@rgb@stroke{1}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{1}{0}{0}\pgfsys@invoke{ }\hbox{{\definecolor[named]{.}{rgb}{1,0,0}\color[rgb]{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}BDC}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hbox to0.0pt{}{}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}$$

$${\mathbf{Pr}\text{/}}_{Z\sim \mathrm{Binomial}(\lceil B/(1-p)\rceil ,1-p)}[Z\ge B^{\ast }+1]\le {\mathbf{Pr}\text{/}}_Z[Z>(1+{\delta }^{\prime })\mathbb{E}\text{/}[Z]]\le {\left(e^{{\delta }^{\prime }}/(1+{\delta }^{\prime }{)}^{1+{\delta }^{\prime }}\right)}^B<\mathrm{0.00817.}$$

$${\mathbf{Pr}\text{/}}_{Z\sim \mathrm{Binomial}(2\lceil B/(1-p)\rceil ,1-p)}[Z\le B^{\ast }]<e^{-((1-\delta )/2{)}^{2}B}<\mathrm{0.0081.}$$

$$\mathbb{E}\text{/}[Y_j]=1\cdot \mathbf{Pr}\text{/}[\text{rj is type-2}]+6\cdot \mathbf{Pr}\text{/}[\text{rj is type-0}]<1\cdot 0.00817+6\cdot 10^{-9}<\mathrm{0.0082.}$$

$$\mathbb{E}\text{/}[Y_j]=1\cdot \mathbf{Pr}\text{/}[\text{rj is type-1}]+6\cdot \mathbf{Pr}\text{/}[\text{rj is type-0}]<1\cdot 0.0081+6\cdot 10^{-9}<\mathrm{0.0082.}$$

$$\displaystyle\mathop{\bf Pr\/}[\text{$s_{i}^{(in)}$ decoded incorrectly}]\$$

$$\le \mathbf{Pr}\text{/}[Y_1+Y_2+\cdots +Y_k\ge {\delta }_{in}k]$$

$$\le \exp \left(-\frac{({\delta }_{in}-0.0082{)}^{2}k}{3\cdot 6\cdot {\delta }_{in}}\right)$$

$$\le \exp \left(-\Omega (m)\right)$$

$$\mathbf{Pr}\text{/}[A\ge (1+\delta )\mathbb{E}\text{/}[A]]\le {\left(\frac{e^{\delta }}{(1+\delta {)}^{1+\delta }}\right)}^{\mathbb{E}\text{/}[A]}\le \exp \left(-{\delta }^2\mathbb{E}\text{/}[A]/3\right).$$

$$\frac{e^{\delta }}{(1+\delta {)}^{1+\delta }}\le \frac{e^{\delta }}{e^{(\delta -{\delta }^2/3)(1+\delta )}}=\exp \left({\delta }^2\cdot \frac{-2+\delta }{3}\right)\le \exp \left(-{\delta }^2/3\right).$$

$$\displaystyle\mathop{\bf Pr\/}\left[\sum_{i=1}^{n}A_{i}\geq n\gamma\right]\$$

$$\le \mathbf{Pr}\text{/}\left[\sum _{i=1}^n\frac{B_i}{\beta }\ge \left(1+\left(\frac{\gamma -\alpha }{\alpha }\right)\right)\frac{n\alpha }{\beta }\right]$$

$$\le \exp \left(-\frac{{\left(\frac{\gamma -\alpha }{\alpha }\right)}^2\cdot \frac{n\alpha }{\beta }}{3}\right)$$

$$=\exp \left(-\frac{(\gamma -\alpha {)}^{2}n}{3\alpha \beta }\right).\text{qed}$$

Full text

1 Introduction

We consider the problem of designing explicit and efficient error-correcting codes for reliable communication on the binary deletion channel. By explicit, we mean codes such that we can produce a description of its encoding and decoding functions in time polynomial in the blocklength of the code. By efficient, we mean codes that are encodable and decodable in time polynomial in the blocklength of the code. The binary deletion channel (BDC) deletes each transmitted bit independently with probability $p$, for some $p\in(0,1)$ which we call the deletion probability. Crucially, the location of the deleted bits are not known at the decoder, who receives a subsequence of the original transmitted sequence. The loss of synchronization in symbol locations makes the noise model of deletions challenging to cope with. As one indication of this, we still do not know the channel capacity of the binary deletion channel. This is in sharp contrast with the noise model of bit erasures, where each bit is independently replaced by a ’?’ with probability $p$ (the binary erasure channel (BEC)), or of bit errors, where each bit is flipped independently with probability $p$ (the binary symmetric channel (BSC)). The capacity of the BEC and BSC equal $1-p$ and $1-h(p)$ respectively, and we know codes of polynomial complexity with rate approaching the capacity in each case.

The capacity of the binary deletion channel is clearly at most $1-p$, the capacity of the simpler binary erasure channel. Diggavi and Grossglauser [6] establish that the capacity of the deletion channel for $p\leq\frac{1}{2}$ is at least $1-h(p)$. Kalai, Mitzenmacher, and Sudan [17] proved this lower bound is tight as $p\to 0$. Works by Kirsch and Drinea [20], and Mercier, Tarokh, and Labeau [22] provide improved, computed lower bounds for capacity, the first for $p\leq 0.35$, and the later for both small and large values of $p$. Kanoria and Montanari [18] determined a series expansion that can be used to determine the capacity for $p\to 0$. Turning to large $p$, Rahmati and Duman [25] prove that the capacity is at most $0.4143(1-p)$ for $p\geq 0.65$. Recently, Cheraghchi [4] gave the first nontrivial BDC capacity upper bound outside the limiting case $p\to 0$ without computer assistance. He proved that the capacity of the deletion channel is at most $(1-p)\log\varphi$ for $p\geq 1/2$, where $\varphi=\frac{1+\sqrt{5}}{2}$ is the golden ratio, and, under the conjecture that the capacity of the BDC is convex [5], at most $1-p\log(4/\varphi)$ for $p<1/2$. Drinea and Mitzenmacher [7, 8] proved that the capacity of the BDC is at least $(1-p)/9$, which is within a constant factor of the upper bound. In particular, the capacity is positive for every $p<1$, which is perhaps surprising. The asymptotic behavior of the capacity of the BDC at both extremes of $p\to 0$ and $p\to 1$ is thus known.

Recently, there has been good progress on codes for adversarial deletions, including explicit and efficiently decodable constructions. Here the model is that the channel can delete an arbitrary subset of $pn$ bits in the $n$-bit codeword, after seeing the entire codeword. We again think of $p\in(0,1)$ as fixed and $n\to\infty$. By standard concentration bounds, a code capable of correcting $pn$ worst-case deletions can also correct deletions caused by a BDC with deletion probability $(p-\varepsilon)$ with high probability, so one can infer results for the BDC from some results for worst-case deletions. For small $p$, Guruswami and Wang [13] constructed binary codes of rate $1-O(\sqrt{p})$ to efficiently correct a $p$ fraction worst-case deletions. Recent work on the document exchange problem [3, 14] provided an improved efficient construction, achieving rate $1-O(p\log^{2}(1/p))$. Hence, we have explicit codes of rate approaching $1$ for the BDC when $p\to 0$. For larger $p$, Kash et al. [19] proved that randomly chosen codes of small enough rate $R>0$ can correctly decode against $pn$ adversarial deletions when $p\leq 0.17$. Even non-explicitly, this remained the best achievability result in terms of correctable deletion fraction until the recent work of Bukh, Guruswami, and Håstad [2] who constructed codes of positive rate efficiently decodable against $pn$ adversarial deletions for any $p<\sqrt{2}-1$. For adversarial deletions, it is impossible to correct a deletion fraction of $1/2$, whereas the capacity of the BDC is positive for all $p<1$. So solving the problem for the much harder worst-case deletions is not a viable approach to construct positive rate codes for the BDC for $p>1/2$.

To the best of our knowledge, explicit efficiently decodable code constructions were not available for the binary deletion channel for arbitrary $p<1$. We present such a construction in this work. Our rate is worse than the $(1-p)/9$ achieved non-explicitly, but has asymptotically the same dependence on $p$ for $p\to 1$. We acknowledge that our code, while explicit and efficient, is not intended to be practical.

Theorem 1.1**.**

Let $p\in(0,1)$. There is an explicit family of binary codes that (1) has rate $(1-p)/120$, (2) is constructible in time $\operatorname*{poly}(N)$, (3) encodable in time $O(N)$, and (3) decodable with high probability on the binary deletion channel with deletion probability $p$ in time $O(N^{2})$. Here $N$ is the block length of the code.

1.1 Some other related work

One work that considers efficient recovery against random deletions is by Yazdi and Dolecek [28]. In their setting, two parties Alice and Bob are connected by a two-way communication channel. Alice has a string $X$, Bob has string $Y$ obtained by passing $X$ through a binary deletion channel with deletion probability $p\ll 1$, and Bob must recover $X$. They produce a polynomial-time synchronization scheme that transmits a total of $O(pn\log(1/p))$ bits and allows Bob to recover $X$ with probability exponentially approaching 1. A follow-up work [26] considers a similar model with larger alphabets, nonuniform distributions of alphabet symbols, and tolerating both insertions and deletions.

For other models of random synchronization errors, Kirsch and Drinea [20] prove information capacity lower bounds for channels with i.i.d deletions and duplications. Building on a previous work for the deletion channel [9], Fertonani et al. [10] prove capacity bounds for binary channels with i.i.d insertions, deletions, and substitutions. Haeupler and Mitzenmacher [15] show that the capacity of sending $k$ copies of a codeword through a BDC with deletion probability $p$ is $1-\alpha H(p^{k})-O(p^{k})$ for an explicit constant $\alpha$.

For deletion channels over non-binary alphabets, Rahmati and Duman [25] prove a capacity upper bound of $C_{2}(p)+(1-p)\log(|\Sigma|/2)$, where $C_{2}(p)$ denotes the capacity of the binary deletion channel with deletion probability $p$, when the alphabet size $|\Sigma|$ is even. In particular, using the best known bound for $C_{2}(p)$ of $C_{2}(p)\leq 0.4143(1-p)$, the upper bound is $(1-p)(\log|\Sigma|-0.5857)$.

In [12], the authors of this paper consider the model of oblivious deletions, which is in between the BDC and adversarial deletions in power. Here, the channel can delete any $pn$ bits of the codeword, but must do so without knowledge of the codeword. In this model, they prove the existence of codes of positive rate for correcting any fraction $p<1$ of oblivious deletions.

1.2 Our construction approach

Our construction concatenates a high rate outer code over a large alphabet that is efficiently decodable against a small fraction of adversarial insertions and deletions, with a good inner binary code. For the outer code, we can use the recent construction of [16]. To construct the inner code, we first choose a binary code correcting a small fraction of adversarial deletions. By concentration bounds, duplicating bits of a codeword in a disciplined manner is effective against the random deletion channel, so we, for some constant $B$, duplicate every bit of the binary code $B/(1-p)$ times. We further ensure our initial binary code has only runs of length 1 and 2 to maximize the effectiveness of duplication. We add small buffers of 0s between inner codewords to facilitate decoding.

One might wonder whether it would be possible to use Drinea and Mitzenmacher’s existential result [7, 8] of a $(1-p)/9$ capacity lower bound as a black box inner code to achieve a better rate together with efficient decodability. We discuss this approach in §3.2 and elaborate on what makes such a construction difficult to implement.

2 Preliminaries

General Notation. Throughout the paper, $\log x$ refers to the base-2 logarithm.

We use interval notation $[a,b]=\{a,a+1,\dots,b\}$ to denote intervals of integers, and we use $[a]=[1,a]=\{1,2,\dots,a\}$.

Let $\operatorname*{Binomial}(n,p)$ denote the Binomial distribution.

Words. A word is a sequence of symbols from some alphabet. We denote explicit words using angle brackets, like $\langle 01011\rangle$. We denote string concatenation of two words $w$ and $w^{\prime}$ with $ww^{\prime}$. We denote $w^{k}=ww\cdots w$ where there are $k$ concatenated copies of $w$.

A subsequence of a word $w$ is a word obtained by removing some (possibly none) of the symbols in $w$.

Let $\Delta_{i/d}(w_{1},w_{2})$ denote the insertion/deletion distance between $w_{1}$ and $w_{2}$, i.e. the minimum number of insertions and deletions needed to transform $w_{1}$ into $w_{2}$. By a lemma due to Levenshtein [21], this is equal to $|w_{1}|+|w_{2}|-2\operatorname*{LCS}(w_{1},w_{2})$, where $\operatorname*{LCS}$ denotes the length of the longest common subsequence.

Define a run of a word $w$ to be a maximal single-symbol subword. That is, a subword $w^{\prime}$ in $w$ consisting of a single symbol such that any longer subword containing $w^{\prime}$ has at least two different symbols. Note the runs of a word partition the word. For example, $110001$ has 3 runs: one run of 0s and two runs of 1s.

We say that $c\in\{0,1\}^{m}$ and $c^{\prime}\in\{0,1\}^{m}$ are confusable under $\delta m$ deletions if it is possible to apply $\delta m$ deletions to $c$ and $c^{\prime}$ and obtain the same result. If $\delta$ is understood, we simply say $c$ and $c^{\prime}$ are confusable.

Concentration Bounds. We use the following forms of Chernoff bound (see, e.g., Theorems 4.4 and 4.5 of [24]):

Lemma 2.1**.**

Let $A_{1},\dots,A_{n}$ be i.i.d random variables taking values in $[0,1]$. Let $A=\sum_{i=1}^{n}A_{i}$ and $\delta\in[0,1]$. Then

[TABLE]

Furthermore,

[TABLE]

We also have the following corollary, whose proof is in Appendix A.

Lemma 2.2**.**

Let $0<\alpha<\beta$. Let $A_{1},\dots,A_{n}$ be independent random variables taking values in $[0,\beta]$ such that, for all $i$, $\mathop{\mathbb{E}\/}[A_{i}]\leq\alpha$. For $\gamma\in[\alpha,2\alpha]$, we have

[TABLE]

3 Efficient codes for random deletions with $p$ approaching 1

3.1 Construction

We present a family of constant rate codes that decodes with high probability on a binary deletion channel with deletion fraction $p$ (BDCp). These codes have rate $c_{0}(1-p)$ for an absolute positive constant $c_{0}$, which is within a constant of the upper bound $(1-p)$, which even holds for the erasure channel. By Drinea and Mitzenmacher [7] the maximum known rate of a non-efficiently correctable binary deletion channel code is $(1-p)/9$.

We begin by borrowing a result from [13].

Lemma 3.1** (Corollary of Lemma 2.3 of [13]).**

Let $0<\delta<\frac{1}{2}$. For every binary string $c\in\{0,1\}^{m}$, there are at most $\delta m\binom{m}{(1-\delta)m}^{2}$ strings $c^{\prime}\in\{0,1\}^{m}$ such that $c$ and $c^{\prime}$ are confusable under $\delta m$ deletions.

The next lemma gives codes against a small fraction of adversarial deletions with an additional run-length constraint on the codewords.

Lemma 3.2**.**

Let $\delta>0$ and $m$ be a positive integer. There exists a length $m$ binary code of rate $\mathcal{R}=0.6942-2h(\delta)-O(\log(\delta m)/m)$ correcting a $\delta$ fraction of adversarial insertions and deletions such that each codeword contains only runs of size 1 and 2. Furthermore this code is constructible in time $\tilde{O}(2^{(0.6942+\mathcal{R})m})$.

Proof.

It is easy to show that the number of codewords with only runs of 1 and 2 is $F_{m}$, the $m$th Fibonacci number, and it is well known that $F_{m}=\varphi^{m}+o(1)\approx 2^{0.6942m}$ where $\varphi$ is the golden ratio. Now we construct the code by choosing it greedily. Each codeword is confusable with at most $\delta m\binom{m}{(1-\delta)m}^{2}$ other codewords, so the number of codewords we can choose is at least

[TABLE]

We can find all words of length $m$ whose run lengths are only 1 and 2 by recursion in time $O(F_{m})=O(2^{0.6942m})$. Running the greedy algorithm, we need to, for at most $F_{m}\cdot 2^{\mathcal{R}m}$ pairs of such words, determine whether the pair is confusable (we only need to check confusability of a candidate word with words already added to the code). Checking confusability of two words under adversarial deletions reduces to checking whether the longest common subsequence is at least $(1-\delta)m$, which can be done in time $O(m^{2})$. This gives an overall runtime of $O(m^{2}\cdot F_{m}\cdot 2^{\mathcal{R}m})=\tilde{O}(2^{(0.6942+\mathcal{R})m})$. ∎

Corollary 3.3**.**

There exists a constant $m_{0}^{*}$ such that for all $m\geq m_{0}^{*}$, there exists a length $m$ binary code of rate $\mathcal{R}=0.555$ correcting a $\delta=0.0083$ fraction of adversarial insertions and deletions such that each codeword contains runs of size 1 and 2 only and each codeword starts and ends with a 1. Furthermore this code is constructible in time $O(2^{1.25m})$.

Our construction utilizes the following result as a black box for efficiently coding against an arbitrary fraction of insertions and deletions with rate approaching capacity.

Theorem 3.4** (Theorem 1.1 of [16]).**

For any $0\leq\delta<1$ and $\varepsilon>0$, there exists a code $C$ over alphabet $\Sigma$, with $|\Sigma|=O_{\varepsilon}(1)$, with block length $n$, rate $1-\delta-\varepsilon$, and is efficiently decodable from $\delta n$ insertions and deletions. The code can be constructed in time $\operatorname*{poly}(n)$, encoded in time $O(n)$, and decoded in time $O(n^{2})$.

We apply Theorem 3.4 for small $\delta$, so we also could use the high rate binary code construction of [11] as an outer code.

We now turn to our code construction for Theorem 1.1.

The code. Throughout this construction, $n$, the length of the outer code, and $N$, the total length of the code, tend to $\infty$, and $B,p,\eta,\delta_{in},\delta_{out},\varepsilon_{out},\mathcal{R}_{in},|\Sigma|,m$ are absolute constants. Pick parameters $B=60,B^{*}=1.4\bar{3}B=86,\eta=\frac{1}{1000},\delta_{out}=\frac{1}{1000}$. Let $m_{0}=\max(\alpha\log(1/\delta_{out})/\eta,m_{0}^{*})$, where $\alpha$ is a sufficiently large constant and where $m_{0}^{*}$ is given by Corollary 3.3. Let $\varepsilon_{out}\in(0,\frac{1}{1000})$ be small enough such that the alphabet $\Sigma$, given by Theorem 3.4 with $\varepsilon=\varepsilon_{out}$ and $\delta=\delta_{out}$, satisfies $\frac{1}{\mathcal{R}_{in}}\log|\Sigma|\geq m_{0}$, and let $C_{out}$ be the corresponding code of length $n$.

Let $C_{in}:|\Sigma|\to\{0,1\}^{m}$ be the code given by Corollary 3.3, and let $m=\lceil{\frac{1}{\mathcal{R}_{in}}\log|\Sigma|}\rceil=O_{\varepsilon}(1)$ be the block length of the code, respectively. The code $C_{in}$ tolerates at least $\delta_{in}=0.0083$ fraction of adversarial insertions and deletions, and the rate is at least $\mathcal{R}_{in}=0.554$.111$\mathcal{R}_{in}$ and $\delta_{in}$ are given by Corollary 3.3. $\mathcal{R}_{in}$ is a little smaller because of rounding $m$ Each codeword of $C_{in}$ has runs of length 1 and 2 only, and each codeword starts and ends with a 1. This code is constructed greedily.

Our code is a modified concatenated code. We encode our message as follows.

• •

Outer Code. First, encode the message into the outer code, $C_{out}$, to obtain a word $c^{(out)}=\sigma_{1}\dots\sigma_{n}$.

• •

Concatenation with Inner Code. Encode each outer codeword symbol $\sigma_{i}\in\Sigma$ by the inner code $C_{in}$.

• •

Buffer. Insert a buffer of $\lceil{\eta m}\rceil$ 0s between adjacent inner codewords. Let the resulting word be $c^{(cat)}$. Let $c_{i}^{(in)}=C_{in}(\sigma_{i})$ denote the encoded inner codewords of $c^{(cat)}$.

• •

Duplication. After concatenating the codes and inserting the buffers, replace each bit (including bits in the buffers) with $\lceil{B/(1-p)}\rceil$ copies of itself to obtain a word of length $N\vcentcolon=(nm+(n-1)\lceil{\eta m}\rceil)\cdot\lceil{B/(1-p)}\rceil$. Let the resulting word be $c$, and the corresponding inner codewords be $\{c^{(dup)}_{i}\}$.

We emphasize that the same inner code can be used for all values of $n$ and $p$: the dependence of our code’s parameters on $n$ comes from the outer code, and the dependence on $p$ comes from the duplication step.

Rate. The rate of the outer code is $1-\delta_{out}-\varepsilon_{out}$, the rate of the inner code is $\mathcal{R}_{in}$, the buffer and duplications multiply the rate by no less than $\frac{1}{1+\eta+O(1/m)}$ and $(1-p)/(B+1)$, respectively. This gives a total rate that is greater than $(1-p)/120$.

Notation. Let $s$ denote the received word after the codeword $c$ is passed through the deletion channel. Note that (i) every bit of $c$ can be identified with a bit in $c^{(cat)}$, and (ii) each bit in the received word $s$ can be identified with a bit in $c$. Thus, we can define relations $f^{(dup)}:c^{(cat)}\to c$, and $f^{(del)}:c\to s$ (that is, relations on the indices of the strings). These are not functions because some bits may be mapped to multiple (for $f^{(dup)}$) or zero (for $f^{(del)}$) bits. Specifically, $f^{(del)}$ and $f^{(dup)}$ are the inverses of total functions. In this way, composing these relations (i.e. composing their inverse functions) if necessary, we can speak about the image and pre-image of bits or subwords of one of $c^{(cat)},c,$ and $s$ under these relations. For example, during the Duplication step of encoding, a bit $\langle b_{j}\rangle$ of $c^{(cat)}$ is replaced with $\lceil{B/(1-p)}\rceil$ copies of itself, so the corresponding string $\langle b_{j}\rangle^{\lceil{B/(1-p)}\rceil}$ in $c$ forms the image of $\langle b_{j}\rangle$ under $f^{(dup)}$, and conversely the pre-image of the duplicated string $\langle b_{j}\rangle^{\lceil{B/(1-p)}\rceil}$ is that bit $\langle b_{j}\rangle$.

Decoding algorithm.

• •

Decoding Buffer. First identify all runs of 0s in the received word with length at least $B\eta m/2$. These are our decoding buffers that divide the word into decoding windows, which we identify with subwords of $s$.

• •

Deduplication. Divide each decoding window into runs. For each run, if it has strictly more than $B^{*}$ copies of a bit, replace it with as two copies of that bit, otherwise replace it with one copy. For example, $\langle 0\rangle^{2B}$ is replaced with $\langle 00\rangle$ while $\langle 0\rangle^{B}$ is replaced with $\langle 0\rangle$. For each decoding window, concatenate these runs of length 1 and 2 in their original order in the decoding window to produce a deduplicated decoding window.

• •

Inner Decoding. For each deduplicated decoding window, decode an outer symbol $\sigma\in\Sigma_{out}$ from each decoding window by running the brute force deletion correction algorithm for $C_{in}$. That is, for each deduplicated decoding window $s_{*}^{(in)}$, find by brute force a codeword $c_{*}^{(in)}$ in $C_{in}$ that such that $\Delta_{i/d}(c_{*}^{(in)},s_{*}^{(in)})\leq\delta_{in}m$. If $c_{*}^{(in)}$ is not unique or does not exist, do not decode an outer symbol $\sigma$ from this decoding window. Concatenate the decoded symbols $\sigma$ in the order in which their corresponding decoding windows appear in the received word $s$ to obtain a word $s^{(out)}$.

• •

Outer Decoding. Decode the message $\mathfrak{m}$ from $s^{(out)}$ using the decoding algorithm of $C_{out}$ in Theorem 3.4.

For purposes of analysis, label as $s_{i}^{(dup)}$ the decoding window whose pre-image under $f^{(del)}$ contains indices in $c_{i}^{(dup)}$. If this decoding window is not unique (that is, the image of $c_{i}^{(dup)}$ contains bits in multiple decoding windows), then assign $s_{i}^{(dup)}$ arbitrarily. Note this labeling may mean some decoding windows are unlabeled, and also that some decoding windows may have multiple labels. In our analysis, we show both occurrences are rare. For a decoding window $s_{i}^{(dup)}$, denote the result of $s_{i}^{(dup)}$ after Deduplication to be $s_{i}^{(in)}$.

The following diagram depicts the encoding and decoding steps. The pair $(\{c_{i}^{(in)}\}_{i},c^{(cat)})$ indicates that, at that step of encoding, we have produced the word $c^{(cat)}$, and the sequence $\{c_{i}^{(in)}\}_{i}$ are the “inner codewords” of $c^{(cat)}$ (that is, the words in between what would be identified by the decoder as decoding buffers). The pair $(\{c_{i}^{(dup)}\}_{i},c)$ is used similarly.

[TABLE]

Runtime. The outer code is constructible in $\operatorname*{poly}(n)$ time and the inner code is constructible in time $O(2^{1.25m})=O_{\varepsilon}(1)$, which is a constant, so the total construction time is $\operatorname*{poly}(N)$.

Encoding in the outer code is linear time, each of the $n$ inner encodings is constant time, and adding the buffers and applying duplications each can be done in linear time. The overall encoding time is thus $O(N)$.

The Buffer step of the decoding takes linear time. The Deduplication step of each inner codeword takes constant time, so the entire step takes linear time. For each inner codeword, Inner Decoding takes time $O(m^{2}2^{m})=O_{\varepsilon}(1)$ by brute force search over the $2^{m}$ possible codewords: checking each of the $2^{m}$ codewords is a longest common subsequence computation and thus takes time $O(m^{2})$, giving a total decoding time of $O(m^{2}2^{m})$ for each inner codeword. We need to run this inner decoding $O(n)$ times, so the entire Inner Decoding step takes linear time. The Outer Decoding step takes $O(n^{2})$ time by Theorem 3.4. Thus the total decoding time is $O(N^{2})$.

Correctness. Note that, if an inner codeword is decoded incorrectly, then one of the following holds.

(Spurious Buffer) A spurious decoding buffer is identified in the corrupted codeword during the Buffer step. 2. 2.

(Deleted Buffer) A decoding buffer neighboring the codeword is deleted. 3. 3.

(Inner Decoding Failure) Running the Deduplication and Inner Decoding steps on $s_{i}^{(dup)}$ computes the inner codeword incorrectly.

We show that, with high probability, the number of occurrences of each of these events is small.

The last case is the most complicated, so we deal with it first, assuming the codeword contains no spurious decoding buffers and the neighboring decoding buffers are not deleted. In particular, we consider an $i$ such that our decoding window $s_{i}^{(dup)}$ whose pre-image under $f^{(del)}$ only contains bits in $c_{i}^{(dup)}$ (because no deleted buffer) and no bits in the image of $c_{i}^{(dup)}$ appear in any other decoding window (because no spurious buffer).

Recall that the inner code $C_{in}$ can correct against $\delta_{in}=0.0083$ fraction of adversarial insertions and deletions. Suppose an inner codeword $c_{i}^{(in)}=r_{1}\dots r_{k}\in C_{in}$ has $k$ runs $r_{j}$ each of length 1 or 2, so that $m/2\leq k\leq m$.

Definition 3.5**.**

A subword of $\alpha$ identical bits in the received word $s$ is

• •

type-0 if $\alpha=0$

• •

type-1 if $\alpha\in[1,B^{*}]$

• •

type-2 if $\alpha\in[B^{*}+1,\infty)$.

By abuse of notation, we say that a length 1 or 2 run $r_{j}$ of the inner codeword $c_{i}^{(in)}$ has type-$t_{j}$ if the image of $r_{j}$ in $s$ under $f^{(del)}\circ f^{(dup)}$ forms a type-$t_{j}$ subword.

Let $t_{1},\dots,t_{k}$ be the types of the runs $r_{1},\dots,r_{k}$, respectively. The image of a run $r_{j}$ under $f^{(del)}\circ f^{(dup)}$ has length distributed as $Z\sim\operatorname*{Binomial}(|r_{j}|\cdot\lceil{B/(1-p)}\rceil,1-p)$. Let $\delta=0.4\bar{3}$ and $\delta^{\prime}=0.426\dots$ be such that $B^{*}=(1+\delta)B=(1+\delta^{\prime})(B+1)-1$, so that $(1+\delta^{\prime})\mathop{\mathbb{E}\/}[Z]<B^{*}+1$. By the Chernoff bounds in Lemma 2.1, the probability that a run $r_{j}$ of length 1 is type-2 is

[TABLE]

Similarly, the probability that a run $r_{j}$ of length-2 is type-1 is at most

[TABLE]

The probability any run is type-0 is at most $\mathop{\bf Pr\/}_{Z\sim\operatorname*{Binomial}(\lceil{B/(1-p)}\rceil,1-p)}[Z=0]<e^{-B}<10^{-10}$.

We now have established that, for runs $r_{j}$ in $c_{i}^{(in)}$, the probability that the number of bits in the image of $r_{j}$ in $s$ under $f^{(del)}\circ f^{(dup)}$ is “incorrect” (between 1 and $B^{*}$ for length 2 runs, and greater than $B^{*}$ for length 1 runs), is less than $0.0082$, which is less than $\delta_{in}$. If the only kinds of errors in the Local Decoding step were runs of $c$ of length 1 becoming runs of length 2 and runs of length 2 become runs of length 1, then we have that, by concentration bounds, with probability $1-2^{-\Omega(m)}$, the number of insertions deletions needed to transform $s_{i}^{(in)}$ back into $c_{i}^{(in)}$ is at most $\delta_{in}m$, in which case $s_{i}^{(in)}$ gets decoded to the correct outer symbol using $C_{in}$.

However, we must also account for the fact that some runs $r_{j}$ of $c_{i}^{(in)}$ may become deleted completely after duplication and passing through the deletion channel. That is, the image of $r_{j}$ in $s$ under $f^{(del)}\circ f^{(dup)}$ is empty, or, in other words, $r_{j}$ is type-0. In this case the two neighboring runs $r_{j-1}$ and $r_{j+1}$ appear merged together in the Deduplication step of decoding. For example, if a run of 1s was deleted completely after duplication and deletion, its neighboring runs of 0s would be interpreted by the decoder as a single run. Fortunately, as we saw, the probability that a run is type-0 is extremely small ($<10^{-10}$), and we show each type-0 run only increases $\Delta_{i/d}(c_{i}^{(in)},s_{i}^{(in)})$ by a constant. We show this constant is at most 6.

To be precise, let $Y_{j}$ be a random variable that is [math] if $|r_{j}|=t_{j}$, 1 if $\{|r_{j}|,t_{j}\}=\{1,2\}$, and 6 if $t_{j}=0$. We claim $\sum_{j=1}^{k}Y_{j}$ is an upper bound on $\Delta_{i/d}(c_{i}^{(in)},s_{i}^{(in)})$. To see this, first note that if $t_{j}\neq 0$ for all $i$, then the number of runs of $c_{i}^{(in)}$ and $s_{i}^{(in)}$ are equal, so we can transform $c_{i}^{(in)}$ into $s_{i}^{(in)}$ by adding a bit to each length-1 type-2 run of $c_{i}^{(in)}$ and deleting a bit from each length-2 type-1 run of $s_{i}^{(in)}$.

Now, if some number, $\ell$, of the $t_{j}$ are [math], then at most $2\ell$ of the runs in $c_{i}^{(in)}$ become merged with some other run (or a neighboring decoding buffer) after duplication and deletion. Each set of consecutive runs $r_{j},r_{j+2},\dots,r_{j+2j^{\prime}}$ that are merged after duplication and deletion is replaced with 1 or 2 copies of the corresponding bit. For example, if $r_{1}=\langle 11\rangle,r_{2}=\langle 0\rangle,r_{3}=\langle 11\rangle$, and if after duplication and deletion, $2B$ bits remain in the image of each of $r_{1}$ and $r_{3}$, and $r_{2}$ is type-0, then the image of $r_{1}r_{2}r_{3}$ under $f^{(del)}\circ f^{(dup)}$ is $\langle 1\rangle^{4B}$, which gets decoded as $\langle 11\rangle$ in the Deduplication step because $\langle 1\rangle^{4B}$ is type-2. To account for the type-0 runs in transforming $c_{i}^{(in)}$ into $s_{i}^{(in)}$, we (i) delete at most two bits from each of the $\ell$ type-0 runs in $c_{i}^{(in)}$ and (ii) delete at most two bits for each of at most $2\ell$ merged runs in $c_{i}^{(in)}$. The total number of additional insertions and deletions required to account for type-0 runs of $c$ is thus at most $6\ell$, so we need at most $6$ insertions and deletions to account for each type-0 run.

Our analysis covers the case when some bits in the image of $c_{i}^{(in)}$ under $f^{(del)}\circ f^{(dup)}$ are interpreted as part of a decoding buffer. Recall that inner codewords start and end with a 1, so that $r_{1}\in\{\langle 1\rangle,\langle 11\rangle\}$ for every inner codeword. If, for example, $t_{1}=0$, that is, the image under $f^{(del)}\circ f^{(dup)}$ of the first run of 1s, $r_{1}$, is the empty string, then the bits of $r_{2}$ are interpreted as part of the decoding buffer. In this case too, our analysis tells us that the type-0 run $r_{1}$ increases $\Delta_{i/d}(c_{i}^{(in)},s_{i}^{(in)})$ by at most $6$.

We conclude $\sum_{j=1}^{k}Y_{j}$ is an upper bound for $\Delta_{i/d}(c_{i}^{(in)},s_{i}^{(in)})$.

Note that if $r_{j}$ has length $1$, then by (5) we have

[TABLE]

Similarly, if $r_{j}$ has length $2$, then by (6) we have

[TABLE]

Thus $\mathop{\mathbb{E}\/}[Y_{j}]<0.0082$ for all $i$. We know the word $s_{i}^{(in)}$ is decoded incorrectly (i.e. is not decoded as $\sigma_{i}$) in the Inner Decoding step only if $\Delta_{i/d}(c_{i}^{(in)},s_{i}^{(in)})>\delta_{in}m$. The $Y_{j}$ are independent, so Lemma 2.2 gives

[TABLE]

where the last inequality is given by $k\geq m/2$. Since our $m\geq\Omega(\log(1/\delta_{out}))$ is sufficiently large, we have that the probability $s_{i}^{(in)}$ is decoded incorrectly is at most $\delta_{out}/10$. If we let $Y_{j}^{(i)}$ denote the $Y_{j}$ corresponding to inner codeword $c_{i}^{(in)}$, the events $E_{i}$ given by $\sum_{j}Y_{j}^{(i)}\geq\delta_{in}m$ are independent. By concentration bounds on the events $E_{i}$, we conclude the probability that there are at least $\delta_{out}n/9$ incorrectly decoded inner codewords that are not already affected by spurious buffers and neighboring deleted buffers is $2^{-\Omega(n)}$.

Our aim is to show that the number of spurious buffers, deleted buffers, and inner decoding failures is small with high probability. So far, we have shown that, with high probability, assuming a codeword is not already affected by spurious buffers and neighboring deleted buffers, the number of inner decoding failures is small. We now turn to showing the number of spurious buffers is likely to be small.

A spurious buffer appears inside an inner codeword if many consecutive runs of 1s are type-0. A spurious buffer requires at least one of the following: (i) a codeword contains a sequence of at least $\eta m/5$ consecutive type-0 runs of 1s, (ii) a codeword contains a sequence of $\ell\leq\eta m/5$ consecutive type-0 runs of 1s, such that, for the $\ell+1$ consecutive runs of 0s neighboring these type-0 runs of 1s, their image under $f^{(del)}\circ f^{(dup)}$ has at least $0.5\eta m$ 0s. We show both happen with low probability within a codeword.

A set of $\ell$ consecutive type-0 runs of 1s occurs with probability at most $10^{-10\ell}$. Thus the probability an inner codeword has a sequence of at least $\eta m/5$ consecutive type-0 runs of 1s is at most $m^{2}\cdot 10^{-10\eta m/5}=\exp(-\Omega(\eta m))$. Now assume that in an inner codeword, each set of consecutive type-0 runs of 1s has size at most $\eta m/5$. Each set of $\ell$ consecutive type-0 runs of 1s merges $\ell+1$ consecutive runs of 0s in $c$, so that they appear as a single longer run in $s$. The sum of the lengths of these $\ell+1$ runs is some number $\ell^{*}$ that is at most $2\ell+2$. The number of bits in the image of these runs of $c_{i}^{(in)}$ under $f^{(del)}\circ f^{(dup)}$ is distributed as $\operatorname*{Binomial}(\ell^{*}\lceil{B/(1-p)}\rceil,1-p)$. This has expectation $\ell^{*}B\leq 0.41B\eta m$, so by concentration bounds, the probability this run of $s$ has length at least $0.5B\eta m$, i.e. is interpreted as a decoding buffer, is at most $\exp(-\Omega(\eta m))$. Hence, conditioned on each set of consecutive type-0 runs of 1s having size at most $\eta m/5$, the probability of having no spurious buffers in a codeword is at least $1-\exp(-\Omega(\eta m))$. Thus the overall probability there are no spurious buffers a given inner codeword is at least $(1-\exp(-\Omega(\eta m))(1-\exp(-\Omega(\eta m)))=1-\exp(-\Omega(\eta m))$. Since each inner codeword contains at most $m$ candidate spurious buffers (one for each type-0 run of 1s), the expected number of spurious buffers in an inner codeword is thus at most $m\cdot\exp(-\Omega(\eta m))$. By our choice of $m\geq\Omega(\log(1/\delta_{out})/\eta)$, this is at most $\delta_{out}/10$. The occurrence of conditions (i) and (ii) above are independent between buffers. The total number of spurious buffers thus is bounded by the sum of $n$ independent random variables each with expectation at most $\delta_{out}/10$. By concentration bounds, the probability that there are at least $\delta_{out}n/9$ spurious buffers is $2^{-\Omega(n)}$.

A deleted buffer occurs only when the image of the $\lceil{\eta m}\rceil$ 0s in a buffer under $f^{(del)}\circ f^{(dup)}$ is at most $B\eta m/2$. The number of such bits is distributed as $\operatorname*{Binomial}(\lceil{\eta m}\rceil\cdot\lceil{B/(1-p)}\rceil,1-p)$. Thus, for some constant $\zeta$ independent on $m$, each buffer is deleted with probability $\exp(-\zeta\cdot B\eta m)<\delta_{out}/10$ by our choice of $m\geq\Omega(\log(1/\delta_{out})/\eta)$. The events of a buffer receiving too many deletions are independent across buffers. By concentration bounds, the probability that there are at least $\delta_{out}n/9$ deleted buffers is thus $2^{-\Omega(n)}$.

Each inner decoding failure, spurious buffer, and deleted buffer increases the distance $\Delta_{i/d}(c_{i}^{(out)},s_{i}^{(out)})$ by at most $3$: each inner decoding failure causes up to 1 insertion and 1 deletion; each spurious buffer causes up to 1 deletion and 2 insertions; and each deleted buffer causes up to 2 deletions and 1 insertion. Our message is decoded incorrectly if $\Delta_{i/d}(c_{i}^{(out)},s_{i}^{(out)})>\delta_{out}n$. Thus, there is a decoding error in the outer code only if at least one of (i) the number of incorrectly decoded inner codewords without spurious buffers or neighboring deleted buffers, (ii) the number of spurious buffers, or (iii) the number of deleted buffers is at least $\delta_{out}n/9$. However, by the above arguments, each is greater than $\delta_{out}n/9$ with probability $2^{-\Omega(n)}$, so there is a decoding error with probability $2^{-\Omega(n)}$. This concludes the proof of Theorem 1.1.

3.2 Possible Alternative Constructions

As mentioned in the introduction, Drinea and Mitzenmacher [7, 8] proved that the capacity of the BDCp is at least $(1-p)/9$. However, their proof is non-explicit and they do not provide an efficient decoding algorithm.

One might hope that it is possible to use Drinea and Mitzenmacher’s construction as a black box. We could follow the approach in this paper, concatenating an outer code given by [16] with the rate $(1-p)/9$ random-deletion-correcting code as a black box inner code. The complexity of the Drinea and Mitzenmacher’s so-called jigsaw decoding is not apparent from [8]. However, the inner code has constant length, so construction, encoding, and decoding would be constant time. Thus, the efficiency of the inner code would not affect the asymptotic runtime.

The main issue with this approach is that, while the inner code can tolerate random deletions with probability $p$, inner codeword bits are not deleted in the concatenated construction according to a BDCp; the 0 bits closer to the buffers between the inner codewords are deleted with higher probability because they might be “merged” with a buffer. For example, if an inner codeword is $\langle 101111\rangle$, then because the codeword is surrounded by buffers of 0s, deleting the leftmost 1 effectively deletes two bits because the 0 is interpreted as part of the buffer. While this may not be a significant issue because the distributions of deletions in this deletion process and BDCp are quite similar, much more care would be needed to prove correctness.

Our construction does not run into this issue, because our transmitted codewords tend to have many 1s on each end of the inner codewords. In particular, each inner codeword of $C_{in}$ has either 1 or 11 on each end, so after the Duplication step each inner codeword has $\lceil{B/(1-p)}\rceil$ or $2\lceil{B/(1-p)}\rceil$ 1s on each end. The 1s on the boundary of the inner codeword will all be deleted with probability $\approx\exp(-B)$, which is small. Thus, in our construction, it is far more unlikely that bits are merged with the neighboring decoding buffer, than if we were to use a general inner code construction. Furthermore, we believe our construction based on bit duplication of a worst-case deletion correcting code is conceptually simpler than appealing to an existential code.

As a remark, we presented a construction with rate $\frac{(1-p)}{120}$, but using a randomized encoding we can improve the constant from 1/120 to 1/60. We can modify our construction so that, during the Duplication step of decoding, instead of replacing each bit of $c^{(cat)}$ with a fixed number $\lceil{B/(1-p)}\rceil$ copies of itself, we instead replaced each bit independently with $\operatorname*{Poisson}(B/(1-p))$ copies of itself. Then the image of a run $r_{j}$ under duplication and deletion is distributed as $\operatorname*{Poisson}(B)$, which is independent of $p$. Because we do not have a dependence on $p$, we can tighten our bounding in (5) and (6). To obtain a rate of $(1-p)/60$, we can take $B=28.12$ and set $B^{*}=40$, where $B^{*}$ is the threshold after which runs are decoded as two bits instead of one bit in the Deduplication step. The disadvantage of this approach is that we require our encoding to be randomized, whereas the construction presented above uses deterministic encoding.

4 Future work and open questions

A lemma due to Levenshtein [21] states that a code $C$ can decode against $pn$ adversarial deletions if and only if it can decode against $pn$ adversarial insertions and deletions. While this does not automatically preserve the efficiency of the decoding algorithms, all the recent efficient constructions of codes for worst-case deletions also extend to efficient constructions with similar parameters for recovering from insertions and deletions [1, 11].

In the random error model, decoding deletions, insertions, and insertions and deletions are not the same. Indeed, it is not even clear how to define random insertions. One could define insertions and deletions via the Poisson repeat channel where each bit is replaced with a Poisson many copies of itself (see [7, 23]). However, random insertions do not seem to share the similarity to random deletions that adversarial deletions share with adversarial insertions; we can decode against arbitrarily large Poisson duplication rates, whereas for codes of block length $n$ we can decode against a maximum of $n$ adversarial insertions or deletions [8]. Alternatively one can consider a model of random insertions and deletions where, for every bit, the bit is deleted with a fixed probability $p_{1}$, a bit is inserted after it with a fixed probability $p_{2}$, or it is transmitted unmodified with probability $1-p_{1}-p_{2}$ [27]. One could also investigate settings involving memoryless insertions, deletions, and substitutions [22].

There remain a number of open questions even concerning codes for deletions only. Here are a few highlighted by this work.

Can we close the gap between $\sqrt{2}-1$ and $\frac{1}{2}$ on the maximum correctable fraction of adversarial deletions? 2. 2.

Can we construct efficiently decodable codes for the binary deletion channel with better rate, perhaps reaching or beating the best known existential capacity lower bound of $(1-p)/9$? 3. 3.

Can we construct efficient codes for the binary deletion channel with rate $1-O(h(p))$ for $p\to 0$?

5 Acknowledgements

We thank anonymous referees for helpful feedback on earlier versions of this paper.

Appendix A Proof of Lemma 2.2

Proof.

For each $i$, we can find a random variable $B_{i}$ such that $B_{i}\geq A_{i}$ always, $B_{i}$ takes values in $[0,\beta]$, and $\mathop{\mathbb{E}\/}[B_{i}]=\alpha$. In the second part of Lemma 2.1, the inequality (2) can weakened to a useful form:

[TABLE]

To obtain this, use the approximation that $(1+\delta)\geq e^{\delta-\delta^{2}/3}$ for $\delta\in[0,1]$, so that

[TABLE]

Applying this weaker form of Lemma 2.1, we have

[TABLE]

Here, we applied Lemma 2.1 to the variables $\frac{B_{i}}{\beta}$ by setting $\delta=\frac{\gamma-\alpha}{\alpha}\in[0,1]$, and using that the expectation of $\sum_{i=1}^{n}\frac{B_{i}}{\beta}$ is $\frac{n\alpha}{\beta}$.