Guess & Check Codes for Deletions, Insertions, and Synchronization

TL;DR

This paper introduces Guess & Check (GC) codes, a new family of explicit, systematic codes with polynomial-time encoding and decoding, capable of correcting multiple deletions or insertions with high probability, relaxing the zero-error requirement.

Contribution

The paper presents GC codes that can correct multiple deletions or insertions with high probability, extending beyond the single deletion correction of VT codes, and applies them to file synchronization.

Findings

GC codes correct multiple deletions with high probability.

GC codes have polynomial-time encoding and decoding algorithms.

Application demonstrated in file synchronization scenarios.

Abstract

We consider the problem of constructing codes that can correct $\delta$ deletions occurring in an arbitrary binary string of length $n$ bits. Varshamov-Tenengolts (VT) codes, dating back to 1965, are zero-error single deletion $(\delta=1)$ correcting codes, and have an asymptotically optimal redundancy. Finding similar codes for $\delta \geq 2$ deletions remains an open problem. In this work, we relax the standard zero-error (i.e., worst-case) decoding requirement by assuming that the positions of the $\delta$ deletions (or insertions) are independent of the codeword. Our contribution is a new family of explicit codes, that we call Guess & Check (GC) codes, that can correct with high probability up to a constant number of $\delta$ deletions (or insertions). GC codes are systematic; and have deterministic polynomial time encoding and decoding algorithms. We also describe the application of GC codes to file synchronization.

Tables

Table 1. TABLE I : The table shows the code rate R = k / n 𝑅 𝑘 𝑛 R=k/n and the probability of decoding failure P ​ r ​ ( F ) 𝑃 𝑟 𝐹 Pr(F) of GC codes for different message lengths k 𝑘 k and different number of deletions δ 𝛿 \delta . The results shown are for c = δ + 1 𝑐 𝛿 1 c=\delta+1 and ℓ = log ⁡ k ℓ 𝑘 \ell=\log k . The results of P ​ r ​ ( F ) 𝑃 𝑟 𝐹 Pr(F) are averaged over 10000 10000 10000 runs of simulations. In each run, a message 𝐮 𝐮 \mathbf{u} chosen uniformly at random is encoded into the codeword 𝐱 𝐱 \mathbf{x} . δ 𝛿 \delta bits are then deleted uniformly at random from 𝐱 𝐱 \mathbf{x} , and the resulting string is decoded.

Config.	$\delta$
	$2$		$3$		$4$
$k$	$R$	$Pr\left(F\right)$	$R$	$Pr\left(F\right)$	$R$	$Pr\left(F\right)$
256	$0.78$	$1.3e^{-3}$	$0.67$	$4.0e^{-4}$	$0.56$	$0$
512	$0.86$	$3.0e^{-4}$	$0.78$	$0$	$0.69$	$0$
1024	$0.92$	$2.0e^{-4}$	$0.86$	$0$	$0.80$	$0$

Table 2. TABLE II : Results are averaged over 1000 1000 1000 runs. In each run, a string of size 1 Mb is chosen uniformly at random, and the file to be synchronized is obtained by deleting d 𝑑 d bits from it uniformly at random. The total communication cost is expressed in bits. The number of center bits used is 25.

	Number of rounds		Total communication cost
$d$	Sync-VT	Sync-GC	Sync-VT	Sync-GC
100	$14.52$	$10.15$	$5145.29$	$4900.88$
150	$16.45$	$10.48$	$7735.32$	$7199.20$
200	$17.97$	$10.88$	$10240.60$	$9332.68$
250	$18.93$	$11.33$	$12785.20$	$11415.90$
300	$20.29$	$11.70$	$15318.20$	$13397.80$

Equations

$$\mathbf{u}=1110000011010001.$$

$$\mathbf{u}=\underbrace{\overbracket{1~{}1~{}1~{}0}^{\text{block 1}}}_{\alpha^{11}}~{}\underbrace{\overbracket{0~{}0~{}0~{}0}^{\text{block 2}}}_{0}~{}\underbrace{\overbracket{1~{}1~{}0~{}1}^{\text{block 3}}}_{\alpha^{13}}~{}\underbrace{\overbracket{0~{}0~{}0~{}1}^{\text{block 4}}}_{1}\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}.$$

$$\mathbf{U}=(\alpha^{11},0,\alpha^{13},1\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}).$$

$$\mathbf{X}$$

$$\displaystyle=(\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}\alpha^{11},0,\alpha^{13},1,\color[rgb]{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}\alpha,\alpha^{10}\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}).$$

$$\mathbf{x}=\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}\underbrace{1~{}1~{}1~{}0}~{}\underbrace{0~{}0~{}0~{}0}~{}\underbrace{1~{}1~{}0~{}1}~{}\underbrace{0~{}0~{}0~{}1}~{}\color[rgb]{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}\underbrace{\color[rgb]{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}0~{}0~{}1~{}0}~{}\color[rgb]{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}\underbrace{\color[rgb]{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}0~{}1~{}1~{}1}\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}.$$

$$\mathbf{x}=\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}1~{}1~{}1~{}0~{}0~{}0~{}0~{}0~{}1~{}1~{}0~{}1~{}0~{}\textbf{\text@underline{0}}~{}0~{}1~{}\color[rgb]{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}0~{}0~{}1~{}0~{}0~{}1~{}1~{}1\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}.$$

$$\mathbf{y}=\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}1~{}1~{}1~{}0~{}0~{}0~{}0~{}0~{}1~{}1~{}0~{}1~{}0~{}0~{}1~{}\color[rgb]{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}0~{}0~{}1~{}0~{}0~{}1~{}1~{}1\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}.$$

$$\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}\underbrace{1~{}1~{}1}_{\mathcal{E}}~{}\underbrace{0~{}0~{}0~{}0}_{0}~{}\underbrace{0~{}1~{}1~{}0}_{\alpha^{5}}~{}\underbrace{1~{}0~{}0~{}1}_{\alpha^{14}}~{}\color[rgb]{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}\underbrace{0~{}0~{}1~{}0}_{\alpha}~{}\underbrace{0~{}1~{}1~{}1}_{\alpha^{10}}\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}.$$

$$\mathbf{Y_{1}}=(\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}\alpha^{13},0,\alpha^{5},\alpha^{14}\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}).$$

$$\mathbf{y_{1}}=\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}\underbrace{1~{}1~{}0~{}1}_{\alpha^{13}}~{}\underbrace{0~{}0~{}0~{}0}_{0}~{}\underbrace{0~{}1~{}1~{}0}_{\alpha^{5}}~{}\underbrace{1~{}0~{}0~{}1}_{\alpha^{14}}\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}.$$

$$\left(\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}\alpha^{13},0,\alpha^{5},\alpha^{14}\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\right)\left(1,\alpha,\alpha^{2},\alpha^{3}\right)^{T}=\alpha\neq\color[rgb]{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}\alpha^{10}.$$

$$\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}\underbrace{1~{}1~{}1~{}0}_{\alpha^{11}}~{}\underbrace{0~{}0~{}0}_{\mathcal{E}}~{}\underbrace{0~{}1~{}1~{}0}_{\alpha^{5}}~{}\underbrace{1~{}0~{}0~{}1}_{\alpha^{14}}~{}\color[rgb]{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}\underbrace{0~{}0~{}1~{}0}_{\alpha}~{}\underbrace{0~{}1~{}1~{}1}_{\alpha^{10}}\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}.$$

$$\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}\underbrace{1~{}1~{}1~{}0}_{\alpha^{11}}~{}\underbrace{0~{}0~{}0~{}0}_{0}~{}\underbrace{1~{}1~{}0}_{\mathcal{E}}~{}\underbrace{1~{}0~{}0~{}1}_{\alpha^{14}}~{}\color[rgb]{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}\underbrace{0~{}0~{}1~{}0}_{\alpha}~{}\underbrace{0~{}1~{}1~{}1}_{\alpha^{10}}\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}.$$

$$\mathbf{y_{3}}=\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}\underbrace{1~{}1~{}1~{}0}_{\alpha^{11}}~{}\underbrace{0~{}0~{}0~{}0}_{0}~{}\underbrace{0~{}1~{}0~{}1}_{\alpha^{8}}~{}\underbrace{1~{}0~{}0~{}1}_{\alpha^{14}}~{}\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}.$$

$$\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}\underbrace{1~{}1~{}1~{}0}_{\alpha^{11}}~{}\underbrace{0~{}0~{}0~{}0}_{0}~{}\underbrace{1~{}1~{}0~{}1}_{\alpha^{13}}~{}\underbrace{0~{}0~{}1}_{\mathcal{E}}~{}\color[rgb]{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}\underbrace{0~{}0~{}1~{}0}_{\alpha}~{}\underbrace{0~{}1~{}1~{}1}_{\alpha^{10}}\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}.$$

$$\mathbf{y_{4}}=\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}\underbrace{1~{}1~{}1~{}0}_{\alpha^{11}}~{}\underbrace{0~{}0~{}0~{}0}_{0}~{}\underbrace{1~{}1~{}0~{}1}_{\alpha^{13}}~{}\underbrace{0~{}0~{}0~{}1}_{1}~{}\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}.$$

$$\mathbf{u}=1~{}1~{}0~{}1~{}0~{}0~{}0~{}0~{}1~{}0~{}0~{}0~{}0~{}1~{}0~{}1\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}.$$

$$\mathbf{X}=(\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}\alpha^{13},0,\alpha^{3},\alpha^{8},\color[rgb]{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}0,\alpha^{8}\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}).$$

$$\mathbf{x}=\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}1~{}1~{}0~{}1~{}0~{}0~{}0~{}0~{}1~{}0~{}0~{}0~{}0~{}\textbf{\text@underline{1}}~{}0~{}1~{}\color[rgb]{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}0~{}0~{}0~{}0~{}0~{}1~{}0~{}1\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}.$$

$$\mathbf{y}=\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}1~{}1~{}0~{}1~{}0~{}0~{}0~{}0~{}1~{}0~{}0~{}0~{}0~{}0~{}1~{}\color[rgb]{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}0~{}0~{}0~{}0~{}0~{}1~{}0~{}1\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}.$$

$${\mathbf{Y}}_1$$

$${\mathbf{Y}}_4$$

$$t\triangleq \left(\genfrac{}{}{0ex}{}{k/\log k+\delta -1}{\delta }\right).$$

$$\left(\genfrac{}{}{0ex}{}{k/\log k+\delta -1}{\delta }\right)=\mathcal{O}\left(\frac{k^{\delta }}{{\log }^{\delta }k}\right).$$

$$\mathcal{O}\left(\frac{k^{\delta +1}}{{\log }^{\delta -1}k}\right),$$

$${\mathrm{A}}_{\mathrm{r}}$$

$$\mathrm{A}$$

$$\left|{\mathrm{A}}_{\mathrm{r}}\right|=q^{\frac{k}{\log k}-1}\text{ and}\left|\mathrm{A}\right|=q^{\frac{k}{\log k}-c}.$$

$$Pr\left({\mathcal{Y}}_{\mathbf{i}}=\mathbf{Y}|{\mathcal{P}}_1=p_1\right)\le \frac{2}{q^{\frac{k}{\log k}-1}}.$$

$$Pr(F)<\frac{2}{k^{c-2}\log k}.$$

$$Pr\left(F|{\mathcal{P}}_1=p_1\right)$$

Full text

I Introduction

The deletion channel is probably the most notorious example of a point-to-point channel whose capacity remains unknown. The bits that are deleted by this channel are completely removed from the transmitted sequence and their locations are unknown at the receiver (unlike erasures). For example, if $1010$ is transmitted, the receiver would get $00$ if the first and third bits were deleted. Constructing efficient codes for correcting deletions has also been a challenging task. Varshamov-Tenengolts (VT) codes [2] are the only deletion codes with asymptotically optimal redundancy and can correct only a single deletion. The study of deletion correcting codes has many applications such as file synchronization [3, 4, 5, 6, 7] and DNA-based storage [8].

In this work, we are particularly motivated by applications of deletion correcting codes to remote file synchronization. Consider the setting where two remote nodes (servers) are connected by a noiseless communication link and have different copies of the same file, where one copy is an edited version of the other. The edits in general include deletions and insertions. We start our discussion by focusing on edits caused by deletions only111Insertions are discussed in subsequent sections of the paper.. The goal is to synchronize the two files with minimal number of communicated bits. If a deletion correcting code is systematic, then it can be used to synchronize the files in the following way. One node uses the code to compute the parity bits of its file and transfers these bits to the other node. Then, the other node uses these parity bits to decode the deletions. In this paper, we construct a new family of explicit codes for multiple deletions, which we call Guess & Check (GC) codes, that satisfy the systematic property. To the best of our knowledge, the existing multiple deletion correcting codes in the literature (e.g., [9, 10, 11]) are non-systematic and non-linear222The non-linearity implies that these codes cannot be made systematic by a linear transformation., and hence cannot be applied to remote file synchronization333For non-systematic codes, the whole file in addition to the redundant bits would need to be transmitted, which is inefficient for remote file synchronization applications..

I-A Related work

The capacity of the deletion channel has been studied in the probabilistic model. In the model where the deletions are iid and occur with a fixed probability $p$, an immediate upper bound on the channel capacity is given by the capacity of the erasure channel $1-p$. Mitzenmacher and Drinea showed in [12] that the capacity of the deletion channel in the iid model is at least $(1-p)/9$. Extensive work in the literature has focused on determining lower and upper bounds on the capacity [12, 13, 14, 15, 16, 17]. We refer interested readers to the comprehensive survey by Mitzenmacher [18]. Ma et al. [7] also studied the capacity in the bursty model of the deletion channel, where the deletion process is modeled by a Markov chain.

A separate line of work has focused on constructing zero-error codes that can correct a given number of deletions $\delta$. Levenshtein showed in [19] that VT codes [2] are capable of correcting a single deletion ($\delta=1$) with zero-error. The redundancy of VT codes is asymptotically optimal ($\log(n+1)$ bits). More information about the VT codes and other properties of single deletion codes can be found in [20]. VT codes have also been used to construct codes that can correct a combination of a single deletion and multiple adjacent transpositions [8]. However, finding VT-like codes for multiple deletions ($\delta\geq 2$) is an open problem. In [19], Levenshtein provided bounds showing that the asymptotic number of redundant bits needed to correct $\delta$ bit deletions in an $n$ bit codeword is $c~{}\delta\log n$ for some constant $c>0$. Levenshtein’s bounds were later generalized and improved in [21]. The simplest zero-error code for correcting $\delta$ deletions is the $(\delta+1)$ repetition code, where every bit is repeated $(\delta+1)$ times. However, this code is inefficient because it requires $\delta n$ redundant bits, i.e., a redundancy that is linear in $n$. Helberg codes [22, 23] are a generalization of VT codes for multiple deletions. These codes can correct multiple deletions but their redundancy is at least linear in $n$ even for two deletions. Some of the works in the literature also studied the problem in the regime where the number of deletions is a constant fraction of $n$ [24, 25, 26, 27] (rather than a constant number). The codes constructed for this regime have $\mathcal{O}(n)$ redundancy. Recently in [9], Brakensiek et al. constructed zero-error codes with logarithmic redundancy, and polynomial time encoding and decoding, that can decode $\delta$ deletions ($\delta$ fixed) in so-called “pattern rich” strings, which are a special family of strings that exist for large block lengths (beyond $10^{6}$ bits for 2 deletions).

The results mentioned above [2, 19, 22, 23, 24, 25, 26, 9] focus on correcting deletions with zero-error, which corresponds to correcting worst-case adversarial deletions. There has also been some work on codes that correct random deletions. Davey and Mackay [10] constructed watermark codes that can correct iid deletions and insertions. Ratzer [11] constructed marker codes and showed that these codes can outperform watermark codes for low deletion/insertion probabilities.

I-B Contributions

In this paper, we construct systematic codes that can correct multiple deletions with logarithmic redundancy. The systematic property of these codes enables their application to remote file synchronization. Since file synchronization algorithms are probabilistic in general (e.g., [3, 4, 5, 6, 7]), we relax the zero-error (worst-case) requirement and construct codes that have a low probability of decoding failure444A decoding failure event corresponds to the decoder not being able to decode the transmitted sequence and outputting “failure to decode” error message. When the decoder does not output the error message, the decoded string is guaranteed to be the correct one.. To this end, we assume that the information message is uniform iid, and that the positions of the deletions are independent of the codeword, i.e., oblivious deletions555Codes that can correct $\delta$ oblivious deletions can also correct $\delta$ deletions that are randomly distributed based on any particular distribution.. To the best of our knowledge, this is the first work to construct systematic codes for multiple deletions.

Namely, we make the following contributions: (i) We construct new explicit systematic codes, which we call Guess & Check (GC) codes, that can correct, with high probability, and in polynomial time, up to a constant number of deletions $\delta$ (or insertions) occurring in a binary string. The encoding and decoding algorithms of GC codes are deterministic. Moreover, these codes have logarithmic redundancy of value $n-k=c(\delta+1)\log k$, where $k$ and $n$ are the lengths of the message and the codeword, respectively, and $c>\delta$ is a code parameter that is independent of $k$; (ii) GC codes enable different trade-offs between redundancy, decoding complexity, and probability of decoding failure; (iii) We implemented GC codes and the programming code can be found and tested online on the link in [28]. Based on our implementations, we provide numerical simulations on the decoding failure of GC codes and compare these simulations to our theoretical results. For instance, we observe that a GC code with rate 0.8 can correct up to 4 deletions in a message of length 1024 bits with no decoding failure detected within 10000 runs of simulations; (iv) We demonstrate how GC codes can be used as a building block for file synchronization algorithms by including these codes as part of the synchronization algorithm proposed by Venkataramanan et al. in [3, 4]. As a result, we provide numerical simulations highlighting the savings in number of rounds and total communication cost.

I-C Organization

The paper is organized as follows. In Section II, we introduce the necessary notations used throughout the paper. We state and discuss the main result of this paper in Section III. In Section IV, we provide encoding and decoding examples on GC codes. In Section V, we describe in detail the encoding and decoding schemes of GC codes. The proof of the main result of this paper is given in Section VI. In Section VII, we explain the trade-offs achieved by GC codes. In Section VIII, we explain how these codes can be used to correct $\delta$ insertions instead of $\delta$ deletions. The results of the numerical simulations on the decoding failure of GC codes and their application to file synchronization are shown in Sections IX and X, respectively. We conclude with some open problems in Section XI.

II Notation

Let $k$ and $n$ be the lengths in bits of the message and codeword, respectively. Let $\delta$ be a constant representing the number of deletions. Without loss of generality, we assume that $k$ is a power of $2$. GC codes are based on $q-$ary systematic $\left(\left\lceil k/\log k\right\rceil+c,\left\lceil k/\log k\right\rceil\right)$ MDS codes, where $q=k>\left\lceil k/\log k\right\rceil+c$ and $c>\delta$ is a code parameter representing the number of MDS parity symbols666Explicit constructions of systematic Reed-Solomon codes (based on Cauchy or Vandermonde matrices) always exist for these parameters.. We will drop the ceiling notation for $\left\lceil k/\log k\right\rceil$ and simply write $k/\log k$. All logarithms in this paper are of base $2$. The block diagram of the encoder is shown in Fig. 1. We denote binary and $q-$ary vectors by lower and upper case bold letters respectively, and random variables by calligraphic letters.

III Main Result

Let $\mathbf{u}$ be a binary vector of length $k$ with iid Bernoulli$(1/2)$ components representing the information message. The message $\mathbf{u}$ is encoded into the codeword $\mathbf{x}$ of length $n$ bits using the Guess & Check (GC) code illustrated in Fig. 1. The GC decoder, explained in Section V, can either decode successfully and output the decoded string, or output a “failure to decode” error message because it cannot make a correct decision. The latter case is referred to as a decoding failure, and its corresponding event is denoted by $F$.

Theorem 1**.**

Guess & Check (GC) codes can correct in polynomial time up to a constant number of $\delta$ deletions occurring within $\mathbf{x}$. Let $c>\delta$ be a constant integer. The code has the following properties:

Redundancy: $n-k=c(\delta+1)\log k$ bits. 2. 2.

Encoding complexity is $\mathcal{O}(k\log k)$, and decoding complexity is $\mathcal{O}\left(\frac{k^{\delta+1}}{\log^{\delta-1}k}\right)$. 3. 3.

For any $\delta$ deletion positions chosen independently of $\mathbf{x}$, the probability that the decoding fails for a uniform iid message is: $Pr(F)=\mathcal{O}\left(\frac{k^{2\delta-c}}{\log^{\delta}k}\right)$.

The result on the probability of decoding failure in Theorem 1 applies for any $\delta$ deletion positions which are chosen independently of the codeword $\mathbf{x}$. Hence, the same result can be also obtained for any random distribution over the $\delta$ deletion positions (like the uniform distribution for example), by averaging over all the possible positions of the $\delta$ deletions.

GC codes enable trade-offs between the code properties shown in Theorem 1, this will be highlighted later in Section VII. The code properties show the following: (i) the redundancy is logarithmic in $k$, and the code rate, $R=k/(k+c(\delta+1)\log k)$, is asymptotically optimal in $k$ (approaches $1$ as $k$ goes to infinity); (ii) the order of complexity is polynomial in $k$ and is not affected by the constant $c$; (iii) the probability of decoding failure goes to zero polynomially in $k$ if $c>2\delta$; and exponentially in $c$ for a fixed $k$. Note that the decoder can always detect when it cannot decode successfully. This can serve as an advantage in models which allow feedback. There, the decoder can ask for additional redundancy to be able to decode successfully.

IV Examples

Guess & Check (GC) codes can correct up to $\delta$ deletions with high probability. We provide examples to illustrate the encoding and decoding schemes. The examples are for $\delta=1$ deletion just for the sake of simplicity777VT codes can correct one deletion with zero-error. However, GC codes are generalizable to multiple deletions..

Example 1** (Encoding).**

Consider a binary message $\mathbf{u}$ of length $k=16$ given by

[TABLE]

$\mathbf{u}$* is encoded by following the different encoding blocks illustrated in Fig. 1.

$1)$ Binary to $q-$ary (Block I, Fig. 1). The message $\mathbf{u}$ is chunked into adjacent blocks of length $\log k=4$ bits each,*

[TABLE]

Each block is then mapped to its corresponding symbol in $GF(q)$, $q=k=2^{4}=16$, by considering its leftmost bit as its most significant bit. This results in a string $\mathbf{U}$ which consists of $k/\log k=4$ symbols in $GF(16)$. The extension field used here has a primitive element $\alpha$, with $\alpha^{4}=\alpha+1$. Hence, $\mathbf{U}\in GF(16)^{4}$ is given by

[TABLE]

$2)$* Systematic MDS code (Block II, Fig. 1). $\mathbf{U}$ is then coded using a systematic $(k/\log k+c,k/\log k)=(6,4)$ MDS code over $GF(16)$, with $c=2>\delta$. The encoded string is denoted by $\mathbf{X}\in GF(16)^{6}$ and is given by multiplying $\mathbf{U}$ by the following code generator matrix,*

[TABLE]

$3)$* $Q-$ary to binary (Block III, Fig. 1). The binary codeword corresponding to $\mathbf{X}$, of length $n=k+2\log k=24$ bits, is*

[TABLE]

For simplicity we skip the last encoding step (Block IV) intended to protect the parity bits and assume that deletions affect only the systematic bits.

The high level idea of the decoding algorithm is to: (i) make an assumption on in which block the bit deletion has occurred (the guessing part); (ii) chunk the bits accordingly, treat the affected block as erased, decode the erasure and check whether the obtained sequence is consistent with the parities (the checking part); (iii) go over all the possibilities.

Example 2** (Successful Decoding).**

Suppose that the $14^{th}$ bit of $\mathbf{x}$ gets deleted,

[TABLE]

The decoder receives the following $23$ bit string $\mathbf{y}$,

[TABLE]

*The decoder goes through all the possible $k/\log k=4$ cases, where in each case $i$, $i=1,\ldots,4$, the deletion is assumed to have occurred in block $i$ and $\mathbf{y}$ is chunked accordingly. Given this assumption, symbol $i$ is considered erased and erasure decoding is applied over $GF(16)$ to recover this symbol. Furthermore, given two parities, each symbol $i$ can be recovered in two different ways. Without loss of generality, we assume that the first parity $p_{1}$, $p_{1}=\alpha$, is the parity used for decoding the erasure. The decoded $q-$ary string in case $i$ is denoted by $\mathbf{Y_{i}}\in GF(16)^{4}$, and its binary representation is denoted by $\mathbf{y_{i}}\in GF(2)^{16}$. The four cases are shown below:

Case 1: The deletion is assumed to have occurred in block 1, so $\mathbf{y}$ is chunked as follows and the erasure is denoted by $\mathcal{E}$,*

[TABLE]

Applying erasure decoding over $GF(16)$, the recovered value of symbol 1 is $\alpha^{13}$. Hence, the decoded $q-$ary string $\mathbf{Y_{1}}\in GF(16)^{4}$ is

[TABLE]

Its equivalent in binary $\mathbf{y_{1}}\in GF(2)^{16}$ is

[TABLE]

Now, to check our assumption, we test whether $\mathbf{Y_{1}}$ is consistent with the second parity $p_{2}=\alpha^{10}$. However, the computed parity is

[TABLE]

*This shows that $\mathbf{Y_{1}}$ does not satisfy the second parity. Therefore, we deduce that our assumption on the deletion location is wrong, i.e., the deletion did not occur in block $1$. Throughout the paper we refer to such cases as impossible cases.

Case 2: The deletion is assumed to have occurred in block 2, so the sequence is chunked as follows*

[TABLE]

Applying erasure decoding, the recovered value of symbol 2 is $\alpha^{4}$. Now, before checking whether the decoded string is consistent with the second parity $p_{2}$, one can notice that the binary representation of the decoded erasure $(0011)$ is not a supersequence of the sub-block $(000)$. So, without checking $p_{2}$, we can deduce that this case is impossible.

Definition 1**.**

*We restrict this definition to the case of $\delta=1$ deletion with two MDS parity symbols in $GF(q)$. A case $i$, $i=1,2,\ldots,k/\log k$, is said to be possible if it satisfies the two criteria below simultaneously.

Criterion 1: The $q-$ary string decoded based on the first parity in case $i$, denoted by $\mathbf{Y_{i}}$, satisfies the second parity.

Criterion 2: The binary representation of the decoded erasure is a supersequence of its corresponding sub-block.

If any of the two criteria is not satisfied, the case is said to be impossible.*

*The two criteria mentioned above are both necessary. For instance, in this example, case 2 does not satisfy Criterion 2 but it is easy to verify that it satisfies Criterion 1. Furthermore, case 1 satisfies Criterion 1 but does not satisfy Criterion 2. A case is said to be possible if it satisfies both criteria simultaneously. *

Case 3:* The deletion is assumed to have occurred in block 3, so the sequence is chunked as follows*

[TABLE]

In this case, the decoded binary string is

[TABLE]

*By following the same steps as cases 1 and 2, it is easy to verify that both criteria are not satisfied in this case, i.e., case 3 is also impossible. *

Case 4:* The deletion is assumed to have occurred in block 4, so the sequence is chunked as follows*

[TABLE]

In this case, the decoded binary string is

[TABLE]

*Here, it is easy to verify that this case satisfies both criteria and is indeed possible. *

After going through all the cases, case 4 stands alone as the only possible case. So the decoder declares successful decoding and outputs $\mathbf{y_{4}}$ ($\mathbf{y_{4}}=\mathbf{u}$).

The next example considers another message $\mathbf{u}$ and shows how the proposed decoding scheme can lead to a decoding failure. The importance of Theorem 1 is that it shows that the probability of a decoding failure vanishes a $k$ goes to infinity.

Example 3** (Decoding failure).**

Let $k=16,\delta=1$ and $c=2$. Consider the binary message $\mathbf{u}$ given by

[TABLE]

Following the same encoding steps as before, the $q-$ary codeword $\mathbf{X}\in GF(16)^{6}$ is given by

[TABLE]

We still assume that the deletion affects only the systematic bits. Suppose that the $14^{th}$ bit of the binary codeword $\mathbf{x}\in GF(2)^{24}$ gets deleted

[TABLE]

The decoder receives the following $23$ bit binary string $\mathbf{y}\in GF(2)^{23}$,

[TABLE]

The decoding is carried out as explained in Example 2. The $q-$ary strings decoded in case $1$ and case $4$ are

[TABLE]

It is easy to verify that both cases $1$ and $4$ are possible cases. The decoder here cannot know which of the two cases is the correct one, so it declares a decoding failure.

Remark 1**.**

In the previous analysis, each case refers to the assumption that a certain block is affected by the deletion. Hence, among all the cases considered, there is only one correct case that corresponds to the actual deletion location. That correct case always satisfies the two criteria for possible cases (Definition 1). So whenever there is only one possible case (like in Example 2), the decoding will be successful since that case would be for sure the correct one. However, in general, the analysis may yield multiple possible cases. Nevertheless, the decoding can still be successful if all these possible cases lead to the same decoded string. An example of this is when the transmitted codeword is the all [math]’s sequence. Regardless of the deletion position, this sequence will be decoded as all [math]’s in all the cases. In fact, whenever the deletion occurs within a run of [math]’s or $1$’s that extends to multiple blocks, the cases corresponding to these blocks will all be possible and lead to the same decoded string. However, sometimes the possible cases can lead to different decoded strings like in Example 3, thereby causing a decoding failure.

V General Encoding and Decoding of GC Codes

In this section, we describe the general encoding and decoding schemes that can correct up to $\delta$ deletions. The encoding and decoding steps for $\delta>1$ deletions are a direct generalization of the steps for $\delta=1$ described in the previous section. For decoding, we assume without loss of generality that exactly $\delta$ deletions have occurred. Therefore, the length of the binary string $\mathbf{y}$ received by the decoder is $n-\delta$ bits.

V-A Encoding Steps

The encoding steps follow from the block diagram that was shown in Fig. 1.

$1)$ Binary to $q-$ary (Block I, Fig. 1). The message $\mathbf{u}$ is chunked into adjacent blocks of length $\log k$ bits each. Each block is then mapped to its corresponding symbol in $GF(q)$, where $q=2^{\log k}=k$. This results in a string $\mathbf{U}$ which consists of $k/\log k$ symbols in $GF(q)$ 888After chunking, the last block may contain fewer than $\log k$ bits. In order to map the block to its corresponding symbol, it is first padded with zeros to a length of $\log k$ bits. Hence, $\mathbf{U}$ consists of $\left\lceil k/\log k\right\rceil$ symbols. We drop the ceiling notation throughout the paper and simply write $k/\log k$..

$2)$ Systematic MDS code (Block II, Fig. 1). $\mathbf{U}$ is then coded using a systematic $(k/\log k+c,k/\log k)$ MDS code over $GF(q)$, where $c>\delta$ is a code parameter. The $q-$ary codeword $\mathbf{X}$ consists of $k/\log k+c$ symbols in $GF(q)$.

$3)$ $Q-$ary to binary (Block III, Fig. 1). The binary representations of the symbols in $\mathbf{X}$ are concatenated respectively.

$4)$ Coding parity bits by repetition (Block IV, Fig. 1). Only the parity bits are coded using a $(\delta+1)$ repetition code, i.e., each bit is repeated $(\delta+1)$ times. The resulting binary codeword $\mathbf{x}$ to be transmitted is of length $n=k+c\left(\delta+1\right)\log k$.

V-B Decoding Steps

$1)$ Decoding the parity symbols of Block II (Fig. 1): these parities are protected by a $(\delta+1)$ repetition code, and therefore can be always recovered correctly by the decoder. A simple way to do this is to examine the bits of $\mathbf{y}$ from right to left and decode deletions instantaneously until the total length of the decoded sequence is $c(\delta+1)$ bits (the original length of the coded parity bits). Therefore, for the remaining steps we will assume without loss of generality that all the $\delta$ deletions have occurred in the systematic bits.

$2)$ The guessing part: the number of possible ways to distribute the $\delta$ deletions among the $k/\log k$ blocks is

[TABLE]

We index these possibilities by $i,i=1,\ldots,t,$ and refer to each possibility by case $i$.

The decoder goes through all the $t$ cases (guesses).

$3)$ The checking part: for each case $i$, $i=1,\ldots,t$, the decoder (i) chunks the sequence according to the corresponding assumption; (ii) considers the affected blocks erased and maps the remaining blocks to their corresponding symbols in $GF(q)$; (iii) decodes the erasures using the first $\delta$ parity symbols; (iv) checks whether the case is possible or not based on the criteria described below.

Definition 2**.**

*For $\delta$ deletions, a case $i$, $i=1,2,\ldots,t$, is said to be possible if it satisfies the two criteria below simultaneously.

Criterion 1: the decoded $q-$ary string in case $i$, denoted by $\mathbf{Y_{i}}\in GF(q)^{k/\log k}$, satisfies the last $c-\delta$ parities simultaneously.

Criterion 2: The binary representations of all the decoded erasures in $\mathbf{Y_{i}}$ are supersequences of their corresponding sub-blocks.

If any of these two criteria is not satisfied, the case is said to be impossible.*

$4)$ After going through all the cases, the decoder declares successful decoding if (i) only one possible case exists; or (ii) multiple possible cases exist but all lead to the same decoded string. Otherwise, the decoder declares a decoding failure.

VI Proof of Theorem 1

VI-A Redundancy

The $(k/\log k+c,k/\log k)$ $q-$ary MDS code in step $2$ of the encoding scheme adds a redundancy of $c\log k$ bits. These $c\log k$ bits are then coded using a $(\delta+1)$ repetition code. Therefore, the overall redundancy of the code is $c(\delta+1)\log k$ bits.

VI-B Complexity

i) Encoding Complexity: The complexity of mapping a binary string to its corresponding $q-$ary symbol (step $1$), or vice versa (step $3$), is $\mathcal{O}(k)$. Furthermore, the encoding complexity of a $(k/\log k+c,k/\log k)$ $q-$ary systematic MDS code is quantified by the complexity of computing the $c$ MDS parity symbols. Computing one MDS parity symbol involves $k/\log k$ multiplications of symbols in $GF(q)$. The complexity of multiplying two symbols in $GF(q)$ is $\mathcal{O}(\log^{2}q)$. Recall that in our code $q=k$. Therefore, the complexity of step $2$ is $\mathcal{O}(\log^{2}k\cdot c\cdot k/\log k)=\mathcal{O}(c\cdot k\log k)$. Step $4$ in the encoding scheme codes $c\log k$ bits by repetition, its complexity is $\mathcal{O}(c\log k)$. Therefore, the encoding complexity of GC codes is $\mathcal{O}(c\cdot k\log k)=\mathcal{O}(k\log k)$ since $c>\delta$ is a constant.

ii) Decoding Complexity: The computationally dominant step in the decoding algorithm is step $3$, that goes over all the $t$ cases and decodes the erasures in each case999The complexity of checking whether a decoded erasure, of length $\log k$ bits, is a supersequence of its corresponding sub-block is $\mathcal{O}(\log^{2}k)$ using the Wagner-Fischer algorithm. Hence, Criterion 2 (Definition 2) does not affect the order of decoding complexity.. Since the erasures to be decoded are within the systematic bits, then decoding $\delta$ erasures in each case can be done by performing the following steps: (a) multiplying the unerased systematic symbols by the corresponding $\delta$ MDS encoding vectors; (b) subtracting the obtained results from the values of the corresponding MDS parities; (c) inverting a $\delta\times\delta$ matrix. Since $\delta$ is a constant, the complexity of the previous steps is $\mathcal{O}(\log^{2}q\cdot k/\log k)=\mathcal{O}(k\log k)$. Now since the erasure decoding is performed for all the $t$ cases, the total decoding complexity is $\mathcal{O}\left(t\cdot k\log k\right)$. The number of cases $t$ is given by

[TABLE]

(1) follows from the fact that $\binom{b}{a}\leq b^{a}$ for all integer values of $a$ and $b$ such that $1\leq a\leq b$. Therefore, the overall decoding complexity is

[TABLE]

which is polynomial in $k$ for constant $\delta$.

VI-C Proof of the probability of decoding failure for $\delta=1$

To prove the upper bound on the probability of decoding failure, we first introduce the steps of the proof for $\delta=1$ deletion. Then, we generalize the proof to the case of $\delta>1$.

The probability of decoding failure for $\delta=1$ is computed over all possible $k-$bit messages. Recall that the bits of the message $\mathbf{u}$ are iid Bernoulli$(1/2)$. The message $\mathbf{u}$ is encoded as shown in Fig. 1. For $\delta=1$, the decoder goes through a total of $k/\log k$ cases, where in a case $i$ it decodes by assuming that block $i$ is affected by the deletion. Let $\bm{\mathcal{Y}_{i}}$ be the random variable representing the $q-$ary string decoded in case $i$, $i=1,2,\ldots,k/\log k$, in step 3 of the decoding scheme. Let $\mathbf{Y}\in GF(q)^{k/\log k}$ be a realization of the random variable $\bm{\mathcal{Y}_{i}}$. We denote by $\mathcal{P}_{r}\in GF(q),r=1,2,\ldots,c,$ the random variable representing the $r^{th}$ MDS parity symbol (Block II, Fig. 1). Also, let $\mathbf{G_{r}}\in GF(q)^{k/\log k}$ be the MDS encoding vector responsible for generating $\mathcal{P}_{r}$. Consider $c>\delta$ arbitrary MDS parities $p_{1},\ldots,p_{c}$, for which we define the following sets. For $r=1,\ldots,c,$

[TABLE]

$\mathrm{A_{r}}$ and $\mathrm{A}$ are affine subspaces of dimensions $k/\log k-1$ and $k/\log k-c$, respectively. Therefore,

[TABLE]

Recall that the correct values of the MDS parities are recovered at the decoder, and that for $\delta=1$, $\bm{\mathcal{Y}_{i}}$ is decoded based on the first parity. Hence, for a fixed MDS parity $p_{1}$, and for $\delta=1$ deletion, $\bm{\mathcal{Y}_{i}}$ takes values in $\mathrm{A_{1}}$. Note that $\bm{\mathcal{Y}_{i}}$ is not necessarily uniformly distributed over $\mathrm{A_{1}}$. For instance, if the assumption in case $i$ is wrong, two different message inputs can generate the same decoded string $\bm{\mathcal{Y}_{i}}\in\mathrm{A_{1}}$. We illustrate this later through Example 4. The next claim gives an upper bound on the probability mass function of $\bm{\mathcal{Y}_{i}}$ for $\delta=1$ deletion.

Claim 1**.**

For any case $i$, $i=1,2,\ldots,k/\log k$,

[TABLE]

Claim 1 can be interpreted as that at most $2$ different input messages can generate the same decoded string $\bm{\mathcal{Y}_{i}}\in\mathrm{A_{1}}$. We assume Claim 1 is true for now and prove it later in Section VI-E. Next, we use this claim to prove the following upper bound on the probability of decoding failure for $\delta=1$,

[TABLE]

In the general decoding scheme, we mentioned two criteria which determine whether a case is possible or not (Definition 2). Here, we upper bound $Pr(F)$ by taking into account Criterion $1$ only. Based on Criterion $1$, if a case $i$ is possible, then $\bm{\mathcal{Y}_{i}}$ satisfies all the $c$ MDS parities simultaneously, i.e., $\bm{\mathcal{Y}_{i}}\in\mathrm{A}$. Without loss of generality, we assume case $1$ is the correct case, i.e., the deletion occurred in block $1$. A decoding failure is declared if there exists a possible case $j$, $j=2,\ldots,k/\log k$, that leads to a decoded string different than that of case $1$. Namely, $\bm{\mathcal{Y}_{j}}\in\mathrm{A}$ and $\bm{\mathcal{Y}_{j}}\neq\bm{\mathcal{Y}_{1}}$. Therefore,

[TABLE]

(5) follows from applying the union bound. (6) follows from the fact that $Pr\left(\bm{\mathcal{Y}_{j}}\neq\bm{\mathcal{Y}_{1}}|\bm{\mathcal{Y}_{j}}\in\mathrm{A},\mathcal{P}_{1}=p_{1}\right)\leq 1$. (8) follows from Claim 1. (10) follows from (2). (12) follows from the fact that $q=k$ in the coding scheme. Next, to complete the proof of (3), we use (12) and average over all values of $p_{1}$.

[TABLE]

VI-D Proof of the probability of decoding failure for $\delta$ deletions

We now generalize the previous proof for $\delta>1$ deletions and show that

[TABLE]

For $\delta$ deletions the number of cases is given by

[TABLE]

Consider the random variable $\bm{\mathcal{Y}_{i}}$ which represents the $q-$ary string decoded in case $i$, $i=1,2,\ldots,t$. The next claim generalizes Claim 1 for $\delta>1$ deletions.

Claim 2**.**

There exists a deterministic function $h$ of $\delta$, $h(\delta)$ independent of $k$, such that for any case $i$, $i=1,2,\ldots,t$,

[TABLE]

We assume Claim 2 is true for now and prove it later (see Appendix A). To bound the probability of decoding failure for $\delta$ deletions, we use the result of Claim 2 and follow the same steps of the proof for $\delta=1$ deletion while considering $t$ cases instead of $k/\log k$. Some of the steps will be skipped for the sake of brevity.

[TABLE]

Furthermore,

[TABLE]

Therefore,

[TABLE]

(16) follows from Claim 2. (19) follows from (17). (21) follows from (13), (20) and the fact that $h(\delta)$ is constant (independent of $k$) for a constant $\delta$.

VI-E Proof of Claim 1

We focus on case $i$ ($i$ fixed) that assumes that the deletion has occurred in block $i$. We observe the output $\mathcal{Y}_{i}$ of the decoder in step $3$ of the decoding scheme for all possible input messages, for a fixed deletion position and a given parity $p_{1}$. Recall that $\bm{\mathcal{Y}_{i}}$ is a random variable taking values in $\mathrm{A_{1}}$. Claim 1 gives an upper bound on the probability mass function of $\bm{\mathcal{Y}_{i}}$ for any $i$ and for a given $p_{1}$. We distinguish here between two cases. If case $i$ is correct, i.e., the assumption on the deletion position is correct, then $\bm{\mathcal{Y}_{i}}$ is always decoded correctly and it is uniformly distributed over $\mathrm{A_{1}}$. If case $i$ is wrong, then $\bm{\mathcal{Y}_{i}}$ is not uniformly distributed over $\mathrm{A_{1}}$ as illustrated in the next example.

Example 4**.**

Let the length of the binary message $\mathbf{u}$ be $k=16$ and consider $\delta=1$ deletion. Let the first MDS parity $p_{1}$ be the sum of the $k/\log k=4$ message symbols. Consider the previously defined set $\mathrm{A_{1}}$ with $p_{1}=0$. Consider the messages,

[TABLE]

For the sake of simplicity, we skip the last encoding step (Block IV, Fig. 1), and assume that $p_{1}$ is recovered at the decoder. Therefore, the corresponding codewords to be transmitted are

[TABLE]

Now, assume that the $3^{rd}$ bit of $\mathbf{x_{1}}$ and $\mathbf{x_{2}}$ was deleted, and case $4$ (wrong case) is considered. It easy to verify that in this case, for both codewords, the $q-$ary output of the decoder will be

[TABLE]

This shows that there exists a wrong case $i$, where the same output can be obtained for two different inputs and a fixed deletion position. Thereby, the distribution of $\bm{\mathcal{Y}_{i}}$ over $\mathrm{A_{1}}$ is not uniform.

The previous example suggests that to find the bound in Claim 1, we need to determine the maximum number of different inputs that can generate the same output for an arbitrary fixed deletion position and a given parity $p_{1}$. We call this number $\gamma$. Once we obtain $\gamma$ we can write

[TABLE]

where $\mathcal{D}\in\{1,\ldots,n\}$ is the random variable representing the position of the deleted bit. We will explain our approach for determining $\gamma$ by going through an example for $k=16$ that can be easily generalized for any $k$. We denote by $b_{z}\in GF(2)$, $z=1,2,\ldots,k$, the bit of the message $\mathbf{u}$ in position $z$.

Example 5**.**

Let $k=16$ and $\delta=1$. Consider the binary message $\mathbf{u}$ given by

[TABLE]

The extension field used here has a primitive element $\alpha$, with $\alpha^{4}=\alpha+1$. Assume that $b_{3}$ was deleted and case $4$ is considered. Hence, the binary string received at the decoder is chunked as follows

[TABLE]

where the erasure is denoted by $\mathcal{E}$, and $S_{1},S_{2}$ and $S_{3}$ are the first 3 symbols of $\bm{\mathcal{Y}_{4}}$ given by

[TABLE]

The fourth symbol $S_{4}$ of $\bm{\mathcal{Y}_{4}}$ is to be determined by erasure decoding. Suppose that there exists another message $\mathbf{u^{\prime}}\neq\mathbf{u}$ such that $\mathbf{u}$ and $\mathbf{u^{\prime}}$ lead to the same decoded string $\bm{\mathcal{Y}_{4}}=(S_{1},S_{2},S_{3},S_{4})$. Since these two messages generate the same values of $S_{1}$, $S_{2}$ and $S_{3}$, then they should have the same values for the following bits

[TABLE]

We refer to these $k-\log k=12$ bits by “fixed” bits. The only bits that can be different in $\mathbf{u}$ and $\mathbf{u^{\prime}}$ are $b_{14}$, $b_{15}$ and $b_{16}$ which correspond to the erasure, and the deleted bit $b_{3}$. We refer to these $\log k=4$ bits by “free” bits. Although these “free” bits can be different in $\mathbf{u}$ and $\mathbf{u^{\prime}}$, they are constrained by the fact that the first parity in their corresponding $q-$ary codewords $\mathbf{X}$ and $\mathbf{X^{\prime}}$ should have the same value $p_{1}$. Next, we express this constraint by a linear equation in $GF(16)$. Without loss of generality, we assume that $p_{1}\in GF(16)$ is the sum of the $k/\log k=4$ message symbols. Hence, $p_{1}$ is given by

[TABLE]

Rewriting the previous equation by having the “free” bits on the LHS and the “fixed” bits and $p_{1}$ on the RHS we get

[TABLE]

where $p^{\prime}\in GF(16)$ and is given by $p^{\prime}=p_{1}+\alpha^{3}\left(b_{1}+b_{5}+b_{9}+b_{13}\right)+\alpha^{2}\left(b_{2}+b_{6}+b_{10}\right)+\alpha\left(b_{7}+b_{11}\right)+\left(b_{4}+b_{8}+b_{12}\right)$. The previous equation can be written as the following linear equation in $GF(16)$,

[TABLE]

Now, to determine $\gamma$, we count the number of solutions of (24). If the unknowns in (24) were symbols in $GF(16)$, then the solutions of (24) would span an affine subspace of size $q^{k/\log k-1}=16^{3}$. However, the unknowns in (24) are binary, so we show next that it has at most $2$ solutions. Let

[TABLE]

be the polynomial representation of $p^{\prime}$ in $GF(16)$ where $(a_{3},a_{2},a_{1},a_{0})\in GF(2)^{4}$. Every element in $GF(16)$ has a unique polynomial representation of degree at most $3$. Comparing (24) and (25), we obtain the following system of equations

[TABLE]

If $a_{3}\neq 0$, then (24) has no solution. If $a_{3}=0$, then (24) has $2$ solutions because $b_{3}+b_{15}=a_{1}$ has $2$ solutions. Therefore, (24) has at most $2$ solutions, i.e., $\gamma\leq 2$.

The analysis in Example 5 can be directly generalized for messages of any length $k$. In general, the analysis yields $\log k$ “free” bits and $k-\log k$ “fixed” bits. Now, we generalize (24) and show that $\gamma\leq 2$ for any $k$. Without loss of generality, we assume that $p_{1}\in GF(q)$ is the sum of the $k/\log k$ symbols of the $q-$ary message $\mathbf{U}$. Consider a wrong case $i$ that assumes that the deletion has occurred in block $i$. Let $d_{j}$ be a fixed bit position in block $j$, $j\neq i$, that represents the position of the deletion. Depending on whether the deletion occurred before or after block $i$, the generalization of (24) is given by one of the two following equations in $GF(q)$.

If $j<i$,

[TABLE]

If $j>i$,

[TABLE]

where $\ell=(i-1)\log k+1$, $m=\log k-1$, $w=j\log k-b_{j}$ and $p^{\prime\prime}\in GF(q)$ (the generalization of $p^{\prime}$ in Example 5) is the sum of $p_{1}$ and the part corresponding to the “fixed” bits. Suppose that $j<i$. Note that $1\leq w\leq m$, so (26) can be written as

[TABLE]

where $o$ is an integer such that $1\leq o\leq m$. Hence, by the same reasoning used in Example 5 we can conclude that (28) has at most $2$ solutions. The same reasoning applies for (27), where $j>i$. Therefore, $\gamma\leq 2$ and from (22) we have

[TABLE]

The bound in (29) holds for arbitrary $d$. Therefore, the upper bound on the probability of decoding failure in (3) holds for any deletion position picked independently of the codeword. Moreover, for any given distribution on $\mathcal{D}$ (like the uniform distribution for example), we can apply the total law of probability with respect to $\mathcal{D}$ and use the result from (29) to get

[TABLE]

VII Trade-offs

As previously mentioned, the first encoding step in GC codes (Block I, Fig. 1) consists of chunking the message into blocks of length $\log k$ bits. In this section, we generalize the results in Theorem 1 by considering chunks of arbitrary length $\ell$ bits $(\ell\leq k)$ 101010For $\ell=k$ and $c=1$, the code is equivalent to a $(\delta+1)$ repetition code., instead of $\log k$ bits. We show that if $\ell=\Omega(\log k)$, then GC codes have an asymptotically vanishing probability of decoding failure. This generalization allows us to demonstrate two trade-offs achieved by GC codes, based on the code properties in Theorem 2.

Theorem 2**.**

Guess & Check (GC) codes can correct in polynomial time up to a constant number of $\delta$ deletions. Let $c>\delta$ be a constant integer. The code has the following properties:

Redundancy: $n-k=c(\delta+1)\ell$ bits. 2. 2.

Encoding complexity is $\mathcal{O}(k\ell)$, and decoding complexity is $\mathcal{O}\left(\frac{k^{\delta+1}}{\ell^{\delta-1}}\right)$. 3. 3.

For any $\delta$ deletion positions chosen independently of the codeword, the probability that the decoding fails for a uniform iid message is: $Pr(F)=\mathcal{O}\left(\frac{(k/\ell)^{\delta}}{2^{\ell(c-\delta)}}\right)$.

Proof.

See Appendix B. ∎

The code properties in Theorem 2 enable two trade-offs for GC codes:

$1)$ Trade-off A: By increasing $\ell$ for a fixed $k$ and $c$, we observe from Theorem 2 that the redundancy increases linearly while the decoding complexity decreases as a polynomial of degree $\delta$. Moreover, increasing $\ell$ also decreases the probability of decoding failure as a polynomial of degree $\delta$. Therefore, trade-off A shows that by paying a linear price in terms of redundancy, we can simultaneously gain a degree $\delta$ polynomial improvement in both decoding complexity and probability of decoding failure.

$2)$ Trade-off B: By increasing $c$ for a fixed $k$ and $\ell$, we observe from Theorem 2 that the redundancy increases linearly while the probability of decoding failure decreases exponentially. Here, the order of complexity is not affected by $c$. Therefore, trade-off B shows that by paying a linear price in terms of redundancy, we can gain an exponential improvement in probability of decoding failure, without affecting the order of complexity. This trade-off is of particular importance in models which allow feedback, where asking for additional parities (increasing $c$) will highly increase the probability of successful decoding.

VIII Correcting $\delta$ Insertions

In this section we show that by modifying the decoding scheme of GC codes, and keeping the same encoding scheme, we can obtain codes that can correct $\delta$ insertions, instead of $\delta$ deletions. In fact, the resulting code properties for $\delta$ insertions (Theorem 3), are the same as that of $\delta$ deletions. Recall that $\ell$ (Section VII) is the code parameter representing the chunking length, i.e., the number of bits in a single block. For correcting $\delta$ insertions, we keep the same encoding scheme as in Fig. 1, and for decoding we only modify the following: (i) Consider the assumption that a certain block $B$ is affected by $\delta^{\prime}$ insertions, then while decoding we chunk a length of $\ell+\delta^{\prime}$ at the position of block $B$ (compared to chunking $\ell-\delta^{\prime}$ bits when decoding deletions); (ii) The blocks assumed to be affected by insertions are considered to be erased (same as the deletions problem), but now for Criterion 2 (Definition 2) we check if the decoded erasure is a subsequence of the chunked super-block (of length $\ell+\delta^{\prime}$). The rest of the details in the decoding scheme stay the same.

Theorem 3**.**

Guess & Check (GC) codes can correct in polynomial time up to a constant number of $\delta$ insertions. Let $c>\delta$ be a constant integer. The code has the following properties:

Redundancy: $n-k=c(\delta+1)\ell$ bits. 2. 2.

Encoding complexity is $\mathcal{O}(k\ell)$, and decoding complexity is $\mathcal{O}\left(\frac{k^{\delta+1}}{\ell^{\delta-1}}\right)$. 3. 3.

For any $\delta$ insertion positions chosen independently of the codeword, the probability that the decoding fails for a uniform iid message is: $Pr(F)=\mathcal{O}\left(\frac{(k/\ell)^{\delta}}{2^{\ell(c-\delta)}}\right)$.

We omit the proof of Theorem 3 because the same analysis applies as in the proof of Theorem 1. More specifically, the redundancy and the encoding complexity are the same as in Theorem 1 because we use the same encoding scheme. The decoding complexity is also the same as in Theorem 1 because the total number of cases to be checked by the decoder is unchanged. The proof of the upper bound on the probability of decoding failure also applies similarly using the same techniques.

IX Simulation Results

We simulated the decoding of GC codes and compared the obtained probability of decoding failure to the upper bound in Theorem 1. We tested the code for messages of length $k~{}=~{}256,512$ and $1024$ bits, and for $\delta=2,3$ and $4$ deletions.

To guarantee an asymptotically vanishing probability of decoding failure, the upper bound in Theorem 1 requires that $c>2\delta$. Therefore, we make a distinction between two regimes, (i) $\delta<c<2\delta:$ Here, the theoretical upper bound is trivial. Table I gives the results for $c=\delta+1$ with the highest probability of decoding failure observed in our simulations being of the order of $10^{-3}$. This indicates that GC codes can decode correctly with high probability in this regime, although not reflected in the upper bound; (ii) $c>2\delta:$ The upper bound is of the order of $10^{-5}$ for $k=1024,\delta=2$, and $c=2\delta+1$. In the simulations no decoding failure was detected within $10000$ runs for $\delta+2\leq c\leq 2\delta+1$. In general, the simulations show that GC codes perform better than what the upper bound indicates. This is due to the fact that the effect of Criterion 2 (Definition 2) is not taken into account when deriving the upper bound in Theorem 1. These simulations were performed on a personal computer and the programming code was not optimized. The average decoding time111111These results are for $\ell=\log k$, the decoding time can be decreased if we increase $\ell$ (trade-off A, Section VII). is in the order of milliseconds for $(k=1024,\delta=2)$, order of seconds for $(k=1024,\delta=3)$, and order of minutes for $(k=1024,\delta=4)$. Going beyond these values of $k$ and $\delta$ will largely increase the running time due to the number of cases to be tested by the decoder. However, for the file synchronization application in which we are interested (see next section) the values of $k$ and $\delta$ are relatively small and decoding can be practical.

X Application to File Synchronization

In this section, we describe how GC codes can be used to construct interactive protocols for file synchronization. We consider the model where two nodes (servers) have copies of the same file but one is obtained from the other by deleting $d$ bits. These nodes communicate interactively over a noiseless link to synchronize the file affected by deletions. Some of the most recent work on synchronization can be found in[3, 4, 5, 6, 7]. In this section, we modify the synchronization algorithm by Venkataramanan et al. [3, 4], and study the improvement that can be achieved by including GC codes as a black box inside the algorithm. The key idea in [3, 4] is to use center bits to divide a large string, affected by $d$ deletions, into shorter segments, such that each segment is affected by one deletion at most. Then, use VT codes to correct these shorter segments. Now, consider a similar algorithm where the large string is divided such that the shorter segments are affected by $\delta$ $(1<\delta\ll d)$ or fewer deletions. Then, use GC codes to correct the segments affected by more than one deletion121212VT codes are still used for segments affected by only one deletion.. We set $c=\delta+1$ and $\ell=\log k$, and if the decoding fails for a certain segment, we send one extra MDS parity at a time within the next communication round until the decoding is successful. By implementing this algorithm, the gain we get is two folds: (i) reduction in the number of communication rounds; (ii) reduction in the total communication cost. We performed simulations for $\delta=2$ on files of size 1 Mb, for different numbers of deletions $d$. The results are illustrated in Table II. We refer to the original scheme in [3, 4] by Sync-VT, and to the modified version by Sync-GC. The savings for $\delta=2$ are roughly $43\%$ to $73\%$ in number of rounds, and $5\%$ to $14\%$ in total communication cost.

Note that the interactive algorithm in [3, 4] also deals with the general file synchronization problem where the edited file is affected by both deletions and insertions. There, the string is divided into shorter segments such that each segment is either: (i) not affected by any deletions/insertions; or (ii) affected by only one deletion; or (iii) affected by only one insertion. Then, VT codes are used to correct the short segments. GC codes can also be used in a similar manner when both deletions and insertions are involved. In this case, the string would be divided such that the shorter segments are affected by: (i) $\delta$ or fewer deletions; or (ii) $\delta$ or fewer insertions.

XI Conclusion

In this paper, we introduced a new family of systematic codes, that we called Guess & Check (GC) codes, that can correct multiple deletions (or insertions) with high probability. We provided deterministic polynomial time encoding and decoding schemes for these codes. We validated our theoretical results by numerical simulations. Moreover, we showed how these codes can be used in applications to remote file synchronization. In conclusion, we point out some open problems and possible directions of future work:

GC codes can correct $\delta$ deletions or $\delta$ insertions. Generalizing these constructions to deal with mixed deletions and insertions (indels) is a possible future direction. 2. 2.

In our analysis, we declare a decoding failure if the decoding yields more than one possible candidate string. A direction is to study the performance of GC codes in list decoding. 3. 3.

Developing faster decoding algorithms for GC codes is also part of the future work. 4. 4.

From the proof of Theorem 1, it can be seen that bound on the probability of decoding failure of GC codes holds if the deletion positions are chosen by an adversary that does not observe the codeword. It would be interesting to study the performance of GC codes under more powerful adversaries which can observe part of the codeword, while still allowing a vanishing probability of decoding failure.

Appendix A Proof of Claim 2

Claim 2 is a generalization of Claim 1 for $\delta>1$ deletions. Recall that the decoder goes through $t$ cases where in each case corresponds to one possible way to distribute the $\delta$ deletions among the $k/\log k$ blocks. Claim 2 states that there exists a deterministic function $h$ of $\delta$, $h(\delta)$ independent of $k$, such that for any case $i$, $i=1,2,\ldots,t$,

[TABLE]

where $\bm{\mathcal{Y}_{i}}$ is the random variable representing the $q-$ary string decoded in case $i$, $i=1,2,\ldots,t$, and $\mathcal{P}_{r},r=1,\ldots,c$, is the random variable representing the $r^{th}$ MDS parity symbol.

To prove the claim, we follow the same approach used in the proof of Claim 1. Namely, we count the maximum number of different inputs (messages) that can generate the same output (decoded string) for $\delta$ fixed deletion positions ($d_{1},\ldots,d_{\delta}$) and $\delta$ given parities ($p_{1},\ldots,p_{\delta}$). Again, we call this number $\gamma$. Recall that, for $\delta$ deletions, $\bm{\mathcal{Y}_{i}}$ is decoded based on the first $\delta$ parities131313The underlying assumption here is that the $\delta$ deletions affected exactly $\delta$ blocks. In cases where it is assumed that less than $\delta$ blocks are affected, then less than $\delta$ parities will be used to decode $\bm{\mathcal{Y}_{i}}$, and the same analysis applies.. Hence, $\bm{\mathcal{Y}_{i}}\in\mathrm{A^{\delta}}$, where

[TABLE]

for $r=1,\ldots,\delta$ 141414The set $\mathrm{A^{\delta}}$ is the generalization of set $\mathrm{A_{1}}$ for $\delta=1$.. We are interested in showing that $\gamma$ is independent of the binary message length $k$. To this end, we upper bound $\gamma$ by a deterministic function of $\delta$ denoted by $h(\delta)$. Hence, we establish the following bound

[TABLE]

We will now explain the approach for bounding $\gamma$ through an example for $\delta=2$ deletions.

Example 6**.**

Let $k=32$ and $\delta=2$. Consider the binary message $\mathbf{u}$ given by

[TABLE]

Its corresponding $q-$ary message $\mathbf{U}$ consists of $7$ symbols (blocks) of length $\log k=5$ bits each. The message $\mathbf{u}$ is encoded into a codeword $\mathbf{x}$ using the GC code (Fig. 1). We assume that the first parity is the sum of the systematic symbols and the encoding vector for the second parity is $(1,\alpha,\alpha^{2},\alpha^{3},\alpha^{4},\alpha^{5},\alpha^{6})$ 151515The extension field used is $GF(32)$ and has a primitive element $\alpha$, with $\alpha^{5}=\alpha^{2}+1$.. Moreover, we assume that the actual deleted bits in $\mathbf{x}$ are $b_{1}$ and $b_{7}$, but the chunking is done based on the assumption that deletions occurred in the $3^{rd}$ and $5^{th}$ block (wrong case). Similar to Example 5, it can be shown that the “free” bits are constrained by the following system of two linear equations in $GF(32)$,

[TABLE]

To upper bound $\gamma$, we upper bound the number of solutions of the system given by (33). Equation (33) can be written as follows

[TABLE]

where $B_{1}$ and $B_{2}$ are two symbols in $GF(32)$ given by

[TABLE]

Notice that the coefficients of $B_{1}$ and $B_{2}$ in (34) originate from the MDS encoding vectors. Hence, for given bit values of $b_{1}$, $b_{7}$ and $b_{16}$, the MDS property implies that (34) has a unique solution for $B_{1}$ and $B_{2}$. Furthermore, since $B_{1}$ and $B_{2}$ have unique polynomial representations in $GF(32)$ of degree at most 4, for given values of $B_{1}$ and $B_{2}$, (35) and (36) have at most one solution for $b_{13},b_{14},b_{15},b_{22},b_{23},b_{24}$ and $b_{25}$. We think of bits $b_{13},b_{14},b_{15},b_{22},b_{23},b_{24}$ and $b_{25}$ as “free” bits of type I, and bits $b_{1},b_{7},b_{16}$ as “free” bits of type II. The previous reasoning indicates that for given values of the bits of type II, (33) has at most one solution. Therefore, an upper bound on $\gamma$ is given by the number of possible choices of the bits of type II. Hence, $\gamma\leq 2^{3}=8$.

Now, we generalize the previous example and upper bound $\gamma$ for $\delta>2$ deletions. Without loss of generality, we assume that the $\delta$ deletions occur in $\delta$ different blocks. Then, the “free” bits are constrained by a system of $\delta$ linear equations in $GF(q)$, where $q=k$. Let $\nu_{(.)}$ and $\mu_{(.)}$ be non-negative integers of value at most $k$. Each of the $\delta$ equations has the following form

[TABLE]

where $\beta$ is the number of “free” bits of type II, $B_{j}\in GF(q)$ is a linear combination of part of the bits in block $j$ (“free” bits of type I), and $p^{\prime}\in GF(q)$. The coefficients of $B_{j}$, $j=1,\ldots,\delta$, originate from the MDS code generator matrix. Hence, for given values of the bits of type II, the system of $\delta$ equations has a unique solution for $B_{j}$, $j=1,\ldots,\delta$. Furthermore, the linear combination of the bits that gives $B_{j}$, $j=1,\ldots,\delta$, has the following form

[TABLE]

where $m<\log k$ is an integer, and $\lambda_{j}$ is the number of “free” bits of type I in $B_{j}$. Notice that (38) corresponds to a polynomial representation in $GF(q)$, $q=k$, of degree less than $\log k$. Hence, for a given $B_{j}$, (38) has at most one solution. Therefore, $\gamma$ is upper bounded by the number of possible choices of the bits of type II, i.e., $\gamma\leq 2^{\beta}$. Recall that, when it is assumed that the block $j$ is affected by deletions, a sub-block of bits is chunked at the position of block $j$. However, because of the shift caused by the $\delta$ deletions, that sub-block may contain bits which do not originate from block $j$. The $\lambda_{j}$ “free” bits of type I in $B_{j}$, $b_{j_{1}},\ldots,b_{j_{\lambda_{j}}}$, are the bits of the sub-block which do originate from block $j$. Since the shift at block $j$ is at most $\delta$ positions, it is easy to see that for any $j=1,\ldots,\delta$, we have $\lambda_{j}\geq\log k-\delta$. Therefore, since $\beta=\delta\log k-\sum_{j=1}^{\delta}\lambda_{j}$, we can use the lower bound on $\lambda_{j}$ to show that $\beta\leq\delta^{2}$. Hence, we obtain $\gamma\leq 2^{\delta^{2}}\triangleq h(\delta)$ 161616If the $\delta$ deletions occur in $z<\delta$ blocks, then $\beta=z\log k-\sum_{j=1}^{z}\lambda_{j}$, and the upper bound $\beta\leq\delta^{2}$ would still hold.. In summary, we have shown that $\gamma$ is upper bounded by a deterministic function of $\delta$ that is independent of $k$.

Since the bound in (32) holds for arbitrary deletion positions ($d_{1},\ldots,d_{\delta}$), the upper bound on the probability of decoding failure in Theorem 1 holds for any $\delta$ deletion positions picked independently of the codeword. Moreover, for any given random distribution on the $\delta$ deletion positions (like the uniform distribution for example), we can apply the total law of probability and use the result from (32) to get

[TABLE]

Appendix B Proof of Theorem 2

We consider the same encoding scheme illustrated in Fig. 1 with the only modification that the message is chunked into blocks of length $\ell$ bits, and the field is size is $q=2^{\ell}$. Taking this modification into account, the proof of Theorem 2 follows the same steps of the proof of Theorem 1. It is easy to see from Fig. 1 that the redundancy here becomes $c(\delta+1)\ell$ bits. Also, the number of $q-$ary systematic symbols becomes $k/\ell$. Therefore, the total number of cases to be checked by the decoder is

[TABLE]

Furthermore, from the proof of Theorem 1 we have that the encoding complexity is

[TABLE]

and the decoding complexity is

[TABLE]

As for the probability of decoding failure, the same intermediary steps of the proof of Theorem 1 apply for chunks of length $\ell$ instead of $\log k$. In particular, the key property used in the proofs of Claim 1 and Claim 2, is that each binary vector is mapped to a unique element in $GF(q)$. This property also applies here because the field size is $q=2^{\ell}$. Hence, from (20) we have

[TABLE]

From (42) we can see that the probability of decoding failure vanishes asymptotically if

[TABLE]

which holds if $\ell=\Omega(\log k)$.

Acknowledgment

The authors would like to thank the reviewers for their valuable comments and suggestions that helped to improve the paper. The authors would also like to thank Kannan Ramchandran for valuable discussions related to an earlier draft of this work; and Ramezan Paravi Torghabeh for his help with the simulations related to the work in [3, 4].