Guess & Check Codes for Deletions and Synchronization

TL;DR

This paper introduces Guess & Check (GC) codes, a new family of codes capable of correcting multiple random deletions with high probability, achieving near-optimal redundancy and efficient encoding/decoding, with applications in file synchronization.

Contribution

The paper presents GC codes, a novel approach that extends deletion correction capabilities to multiple deletions with high probability, using MDS codes and achieving asymptotically optimal redundancy.

Findings

GC codes can correct multiple deletions with high probability.

GC codes have redundancy of approximately a(delta \, ext{log} \, n)

The encoding and decoding algorithms are deterministic and polynomial-time.

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 can correct all possible single deletions $(\delta=1)$ with an asymptotically optimal redundancy. Finding similar codes for $\delta \geq 2$ deletions is an open problem. We propose a new family of codes, that we call Guess & Check (GC) codes, that can correct, with high probability, a constant number of deletions $\delta$ occurring at uniformly random positions within an arbitrary string. The GC codes are based on MDS codes and have an asymptotically optimal redundancy that is $\Theta(\delta \log n)$. We provide deterministic polynomial time encoding and decoding schemes for these codes. We also describe the applications 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 of P ​ r ​ ( F ) 𝑃 𝑟 𝐹 Pr(F) are averaged over 10000 10000 10000 runs of simulations.

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 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}=\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}.$$

$$\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}.$$

$$\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~{}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}.$$

$${\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(F)<\frac{2}{k^{c-2}\log k}.$$

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

$$\le \sum _{j=2}^{k/\log k}Pr\left({\mathcal{Y}}_{\mathbf{j}}\in \mathrm{A},{\mathcal{Y}}_{\mathbf{j}}\ne {\mathcal{Y}}_1|{\mathcal{P}}_1=p_1\right)$$

$$\le \sum _{j=2}^{k/\log k}Pr\left({\mathcal{Y}}_{\mathbf{j}}\in \mathrm{A}|{\mathcal{P}}_1=p_1\right)$$

$$=\sum _{j=2}^{k/\log k}\sum _{\mathbf{Y}\in \mathrm{A}}Pr\left({\mathcal{Y}}_{\mathbf{j}}=\mathbf{Y}|{\mathcal{P}}_1=p_1\right)$$

$$\le \sum _{j=2}^{k/\log k}\left|\mathrm{A}\right|\frac{2}{q^{\frac{k}{\log k}-1}}$$

$$<\frac{2}{k^{c-2}\log k}.$$

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 the deletion channel has also been a challenging task. Varshamov-Tenengolts (VT) codes [1] are the only deletion codes with asymptotically optimal redundancy and can correct only a single deletion. The study of the deletion channel has many applications such as file synchronization [2, 3] and DNA-based storage [4].

The capacity of the deletion channel has been studied in the probabilistic model where the deletions are i.i.d. 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 [5] that the capacity is at least $(1-p)/9$. Extensive work in the literature has focused on determining lower and upper bounds on the capacity [5, 6, 7, 8]. We refer interested readers to the comprehensive survey by Mitzenmacher [9].

A separate line of work has focused on constructing codes that can correct a given number of deletions. In this work we are interested in binary codes that correct a constant number of deletions $\delta$. Levenshtein showed in [10] that VT codes [1] are capable of correcting a single deletion ($\delta=1$), with an asymptotically optimal redundancy ($\log(n+1)$ bits). VT codes have been used to construct codes that can correct a combination of a single deletion and multiple adjacent tranpositions [4]. However, finding VT-like codes for multiple deletions ($\delta\geq 2$) is an open problem. In [10], Levenshtein provided bounds showing that the asymptotic number of redundant bits needed to correct $\delta$ bit deletions in an $n$ bit codeword is $\Theta(\delta\log n)$, i.e., $c~{}\delta\log n$ for some constant $c>0$. Levenshtein’s bounds were later generalized and improved in [11].

The simplest 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 [12] are a generalization of VT codes for multiple deletions. These codes can correct mutiple deletions but their redundancy is at least linear in $n$ even for two deletions. Schulman and Zuckerman in [13] presented codes that can correct a constant fraction of deletions. Their construction was improved in [14], but the redundancies in these constructions are $\mathcal{O}(n)$. Recently in [15], Brakensiek et al. provide an explicit encoding and decoding scheme, for fixed $\delta$, that has $\mathcal{O}(\delta^{2}\log\delta\log n)$ redundancy and a near-linear complexity. But the crux of the approach in [15] is that the scheme is limited to a specific family of strings, which the authors in [15] refer to as pattern rich strings. In summary, even for the case of two deletions, there are no known explicit codes for arbitrary strings, with $\mathcal{O}(\delta\log n)$ redundancy.

Contributions: While the work on codes that correct multiple deletions in [12, 13, 14, 15] focuses on zero-error codes, in our approach we relax this requirement and allow an asymptotically vanishing probability of decoding failure111The term decoding failure means that the decoder cannot make a correct decision and outputs a “failure to decode” error message.. Our contributions are the following: (i) we propose new explicit codes, which we call Guess & Check (GC) codes, that can correct, with high probability, and in polynomial time, a constant number of deletions222The GC code construction can be modified to correct $\delta$ insertions (instead of $\delta$ deletions). However, we focus here only on deletions. $\delta$ occurring at uniformly random positions within an arbitrary binary string. The GC codes have an asymptotically optimal redundancy of value $c(\delta+1)\log k\approx c(\delta+1)\log n$ (asymptotically), where $k$ and $n$ are the lengths of the message and codeword, respectively, and $c>\delta$ is a constant integer; (ii) GC codes enable different trade-offs between redundancy, decoding complexity, and probability of decoding failure; (iii) we provide numerical simulations on the decoding failure of GC codes. Moreover, we describe how to use them for file synchronization as part of the interactive algorithm proposed by Venkataramanan et al. in [2] and provide simulation results highlighting the resulting savings in number of rounds and total communication cost.

II Notation

Let $k$ and $n$ be the lengths in bits of the message and codeword, respectively. Let $\delta$ be the number of deletions. We assume WLOG that $k$ is a power of $2$. Our code is based on a $q-$ary systematic $\left(\left\lceil k/\log k\right\rceil+c,\left\lceil k/\log k\right\rceil\right)$ MDS code, where $q=k>\left\lceil k/\log k\right\rceil+c$ and $c>\delta$ is a code parameter representing the number of MDS parity symbols. 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 i.i.d. 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.

Theorem 1**.**

The Guess & Check (GC) code can correct in polynomial time up to a constant number of $\delta$ deletions occurring at uniformly random positions 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+2}}{\log^{\delta}k}\right)$. 3. 3.

Probability of decoding failure: $Pr(F)=\mathcal{O}\left(\frac{k^{2\delta-c}}{\log^{\delta}k}\right)$.

GC codes enable trade-offs between the properties above, this will be highlighted later in Remark 1. These properties show that: (i) the code rate, $R=k/(k+c(\delta+1)\log k)$, is asymptotically optimal and approaches one 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

The GC code we propose 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 simplicity333VT codes can correct one deletion with zero-error. However, GC codes are generalizable to multiple deletions..

Example 1** (Encoding).**

*Consider a message $\mathbf{u}$ of length $k=16$ given by $\mathbf{u}=1110000011010001$. $\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$. 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, we obtain \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})\in GF(16)^{4}.

$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 first parity is the sum of the systematic symbols and the encoding vector for the second parity is chosen to be $\left(1,\alpha,\alpha^{2},\alpha^{3}\right)$. The encoded string is \mathbf{X}=(\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}).

$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 \mathbf{x}=\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}1110~{}0000~{}1101~{}0001~{}\color[rgb]{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}0010~{}\color[rgb]{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}0111\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}. 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. The decoder receives the following $23$ bit string \mathbf{y}=\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}111000001101001\color[rgb]{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}00100111\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}. 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 is \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}). Its equivalent in binary is \mathbf{y_{1}}=\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}1101~{}0000~{}0110~{}1001\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}. 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 \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}. This shows that $\mathbf{Y_{1}}$ does not satisfy the second parity. We deduce that our assumption on the deletion location is wrong. 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:* 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 string is $\mathbf{y_{4}}=1110000011010001$. 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 \mathbf{u}=1101000010000101\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}. Following the same encoding steps as before, the $q-$ary codeword is given by \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}). Suppose that the $14^{th}$ bit of the binary codeword $\mathbf{x}$ gets deleted. The decoder receives \mathbf{y}=\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}110100001000001\color[rgb]{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}00000101\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}. The decoding is carried out as explained in Example 2. The $q-$ary strings decoded in cases 1 and 4 are given by \mathbf{Y_{1}}=(\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}\alpha^{13},\alpha^{3},\alpha^{2},1\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}) and \mathbf{Y_{4}}=(\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}\alpha^{13},0,\alpha^{3},\alpha^{8}\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}), respectively. 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.

V General Decoding of GC codes

The encoding and decoding steps for $\delta>1$ deletions are a direct generalization of the steps for $\delta=1$ described previously. WLOG, we assume that exactly $\delta$ deletions have occurred. Then, the length of the string received by the decoder is $n-\delta$ bits. Now, we explain in details the 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. Therefore, for the remaining steps we will assume WLOG 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 $t=\binom{k/\log k+\delta-1}{\delta}.$ 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,\ldots,t$, is said to be possible if it satisfies the following two criteria simultaneously. Criterion 1: the decoded $q-$ary string in case $i$ satisfies the last $c-\delta$ parities simultaneously. Criterion 2: the binary representations of all the decoded erasures are supersequences of their corresponding sub-blocks (for a given decoded erasure of length $\log k$ bits, the complexity of this is $\mathcal{O}(\log^{2}k)$ using the Wagner-Fischer algorithm).

$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, a decoding failure is declared.

Remark 1** (Trade-offs).**

GC codes enable two trade-offs. (1) Decoding complexity and redundancy trade-off: We chose to chunk the message into blocks of $\log k$ bits in order to achieve an asymptotically optimal redundancy given by Levenshtein’s bound. If the message is chunked into blocks of length $\ell$ bits, the redundancy becomes $c(\delta+1)\ell$ and the number of cases becomes $t=\binom{k/\ell+\delta-1}{\delta}$. The number of cases is the dominant factor in the decoding complexity. Therefore, by increasing $\ell$ the decoding complexity can be decreased while increasing the redundancy. Note that the probability of failure would still go to zero if $\ell=\Omega(\log k)$. (2) Probability of failure and redundancy trade-off: The choice of the constant $c$ presents a trade-off between the redundancy and the probability of decoding failure. In fact, for a fixed $k$, by increasing $c$ the redundancy $c(\delta+1)\log k$ increases linearly while the probability of decoding failure $Pr(F)=\mathcal{O}\left(\frac{k^{2\delta-c}}{\log^{\delta}k}\right)$ decreases exponentially. Note that the order of complexity of the scheme is not affected by the choice of $c$.

VI Proof of Theorem 1

In this section, we prove the upper bound on the probability of decoding failure $Pr(F)$ in Theorem 1 for $\delta=1$ deletion. The complete and general proof follows similar steps and can be found in the extended version of this paper [16]. The probability of decoding failure for $\delta=1$ is computed over all possible $k-$bit messages and all possible single deletions. Recall that the bits of the message $\mathbf{u}$ are i.i.d. Bernoulli$(1/2)$ and the position of the deletion is uniformly random. 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}}$. The crux of the proof relies on the next claim and its generalization. The claim gives an upper bound on the probability mass function of $\bm{\mathcal{Y}_{i}}$ for $\delta=1$ deletion. Its proof can be found in [16].

Claim 1**.**

For any case $i$, $i=1,2,\ldots,k/\log k$, $Pr\left(\bm{\mathcal{Y}_{i}}=\mathbf{Y}|\mathcal{P}_{1}=p_{1}\right)\leq\frac{2}{q^{\frac{k}{\log k}-1}}$.

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}}$. Next, we use this claim to show that 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]

(4) follows from applying the union bound. (5) 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$. (7) follows from Claim 1. (8) follows from (1) and the fact that $q=k$ in the coding scheme. The proof of (2) is completed using (8) and averaging over all values of $p_{1}$.

VII 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. The average decoding time 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 $k$ and $\delta$ are relatively small and decoding can be practical.

VIII Application to File Synchronization

In this section, we describe how our 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 [2, 3]. In this section, we modify the synchronization algorithm by Venkataramanan et al. [2], and study the improvement that can be achieved by including our code as a black box inside the algorithm. The key idea in [2] is to use center bits to divide a large string, affected by $d$ deletions, into shorter segments, such that each segment is affected by only one deletion. Then, use VT codes to correct these 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 the GC code to correct the segments affected by more than one deletion. We set $c=\delta+1$, 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 [2] 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 communication cost.

IX Acknowledgments

The authors would like to thank Kannan Ramchandran for valuable discussions related to an earlier draft of this work.