Coding for Deletion Channels with Multiple Traces

TL;DR

This paper introduces low-complexity coding schemes for deletion channels using multiple traces, inspired by DNA storage, enabling efficient reconstruction with linear encoding and decoding complexities.

Contribution

It proposes simple, explicit codes based on VT codes that leverage multiple traces to improve deletion correction in DNA storage applications.

Findings

Codes are based on VT codes split into blocks.

Multiple traces help identify deletion-free blocks.

Encoding is linear; decoding is linear in length, quadratic in deletions and traces.

Abstract

Motivated by the sequence reconstruction problem from traces in DNA-based storage, we consider the problem of designing codes for the deletion channel when multiple observations (or traces) are available to the decoder. We propose simple binary and non-binary codes based on Varshamov-Tenengolts (VT) codes. The proposed codes split the codeword in blocks and employ a VT code in each block. The availability of multiple traces helps the decoder to identify deletion-free copies of a block, and to avoid mis-synchronization while decoding. The encoding complexity of the proposed scheme is linear in the codeword length; the decoding complexity is linear in the codeword length, and quadratic in the number of deletions and the number of traces. The proposed scheme offers an explicit low-complexity technique for correcting deletions using multiple traces.

Equations

$$1\underline{0}001110\underline{1}101010⟶{\mathbf{y}}_1=1001110101010$$

$$100011\underline{10}110101\underline{0}⟶{\mathbf{y}}_2=100011110101$$

$$\text{syn}(\mathbf{x})=\sum _{j=1}^{n}j{x}_j(\text{mod}(n+1)).$$

$$\mathcal{V}\mathcal{T}_{s}(n)=\big{\{}\bm{x}\in\{0,1\}^{n}:\textsf{syn}(\bm{x})=s\big{\}},$$

$${\alpha }_j=\{\begin{array}{ll}1& \text{if }{x}_j\ge x_{j-1}\\ 0& \text{if }{x}_j<x_{j-1}\end{array}$$

$$\mathsf{sum}(\mathbf{x})=\sum _{j=1}^n{x}_j(\text{mod }q).$$

$$\mathcal{V}\mathcal{T}_{a,c}(n)=\big{\{}\bm{x}\in\mathcal{X}^{n}:\textsf{syn}(\bm{\alpha}(\bm{x}))=a,\ \mathsf{sum}(\bm{x})=c\big{\}},$$

$$R=1-\lceil \log (n_b+1)\rceil /n_b.$$

$$R\ge \log q-(\log n_b+\log q)/n_b.$$

$$\mathbf{x}=010011100111111$$

$$01\underline{00}11100111111⟶{\mathbf{y}}_1=0111100111111$$

$$01001\underline{1}100\underline{1}11111⟶{\mathbf{y}}_2=0100110011111$$

$$\text{syn}({\mathbf{y}}_1(1:5))=2\text{ and }\text{syn}({\mathbf{y}}_2(1:5))=1.$$

$$\mathbf{x}=10001111000011101100.$$

$$100\underline{0}111\underline{1}000011011100⟶{\mathbf{y}}_1=100111000011011100$$

$$\underline{1}000111100001\underline{1}011100⟶{\mathbf{y}}_2=000111100001011100$$

$$\mathbf{x}$$

$$1110\underline{0}1\underline{0}00110001\underline{0}101\underline{0}\to {\mathbf{y}}_1$$

$$11100100\underline{0}1100010\underline{1}0\underline{1}0\to {\mathbf{y}}_2$$

$${\mathsf{P}}_{e_2}$$

$$\displaystyle\leq l\Big{(}(1-p_{0}-p_{1})^{t}+\left((1-p_{0})^{2}-p_{1}p_{1}^{\prime}\right)^{t}+\frac{(1-p_{0})^{3t}}{1-(1-p_{0})^{t}}\Big{)}$$

$$p_s=\frac{\left(\genfrac{}{}{0ex}{}{(k-s)+(l-1)-1}{k-s}\right)}{\left(\genfrac{}{}{0ex}{}{k+l-1}{k}\right)},\text{ and }{p}_1^{\prime }=\frac{\left(\genfrac{}{}{0ex}{}{(k-2)+(l-2)-1}{k-2}\right)}{\left(\genfrac{}{}{0ex}{}{(k-1)+(l-1)-1}{k-1}\right)}.$$

$${\mathsf{P}}_{e_2}$$

$$\displaystyle\leq l\Big{(}(1-p_{0}-p_{1})^{t}+\left((1-p_{0})^{2}-p_{1}p^{\prime}_{1}\right)^{t}+\sum_{r=3}^{k-1}(1-p_{0})^{rt}\Big{)}$$

$$\displaystyle\leq l\Big{(}(1-p_{0}-p_{1})^{t}+\left((1-p_{0})^{2}-p_{1}p_{1}^{\prime}\right)^{t}+\frac{(1-p_{0})^{3t}}{1-(1-p_{0})^{t}}\Big{)}$$

$$p_s=\frac{\left(\genfrac{}{}{0ex}{}{(k-s)+(l-1)-1}{k-s}\right)}{\left(\genfrac{}{}{0ex}{}{k+l-1}{k}\right)},$$

$$p_1^{\prime }=\frac{\left(\genfrac{}{}{0ex}{}{(k-2)+(l-2)-1}{k-2}\right)}{\left(\genfrac{}{}{0ex}{}{(k-1)+(l-1)-1}{k-1}\right)}.$$

$$Z=\sum _{r=1}^{k-1}\sum _{i=1}^l\frac{1}{r}{Z}_{i,r}.$$

$$\mathbb{P}(Z\ge 1)$$

$$\mathbb{E}[Z_{i,1}]\le (1-p_0-p_1{)}^t.$$

$$q_r\le (1-p_0{)}^r.$$

$$q_{u+1}$$

$$=\sum _{s=u}^k{q}_u(s)\left(1-\frac{l-u-1}{(k-s)+(l-u-1)}\right)$$

$$\le \sum _{s=u}^k{q}_u(s)\left(1-\frac{l-1}{k+l-1}\right)$$

$$=\sum _{s=u}^k{q}_u(s)\left(1-p_0\right)$$

Full text

I Introduction

We consider the problem of coding for a deletion channel which, given an input sequence, produces $t$ output sequences. Each output sequence, known as a trace, is produced by deleting $k$ symbols from the length $n$ input sequence. The deletion pattern for each trace is assumed to be independent, and the locations of the deletions within a trace are uniformly random. (Therefore it is possible that two or more traces are identical.)

The problem of recovering coded information from multiple traces is relevant in DNA-based storage systems [1]. When retrieving information by sequencing stored DNA, each trace may contain errors that are a combination of deletions, insertions, and substitutions. In this paper, using the stylized model of a channel that introduces only deletions, we aim to understand the coding advantage obtained by having multiple traces. In particular, we show how one can use simple codes with efficient encoding and decoding to achieve small probability of error under suitable assumptions.

The problem of reconstructing a sequence using traces from a deletion channel has been studied in several works, with the goal being either exact recovery of the sequence [2, 3, 4], or an estimate [5]. In these papers, the sequence can be an arbitrary one from the underlying alphabet, i.e., it need not originate from a codebook. A few recent works study the reconstruction of a coded sequence under different trace models. The paper [6] analyzes the minimum number of deletion channel traces required to recover a sequence drawn from a single-deletion correcting code, and [7] considers a similar problem for the insertion channel. The problem of reconstructing a coded sequence from the multiset of its substrings is studied in [8]. From an information-theoretic perspective, [9] characterizes the capacity of the multiple trace i.i.d. deletion channel as the deletion probability $p\to 0$. Recently, coding for the multiple trace i.i.d. deletion channel was independently studied in [10]. The construction proposed in [10] is based on marker codes, and is shown to achieve vanishing error probability with redundancy $O(n/\log n)$ and $\exp\left(O(\log^{2/3}n)\right)$ traces.

Overview of the coding scheme: Our code construction is based on the family of Varshamov-Tenengolts (VT) codes [11, 12]. VT codes are single deletion correcting codes, and can be constructed for any finite alphabet and any block length. (VT codes will be reviewed in the next section). Each codeword in our code is a concatenation of blocks, with each block drawn from a predetermined VT codebook.

We illustrate the idea using the following binary example, which shows a codeword $\bm{x}$ of length $15$ with three blocks, each of which is a sequence from a length $5$ binary VT code. The channel produces two traces, $\bm{y}_{1}$ and $\bm{y}_{2}$, by deleting the underlined bits:

[TABLE]

The decoder operates in two phases. In phase 1, it identifies blocks that are deletion-free in at least one of the traces. Each block for which a deletion-free copy is identified in one of the traces is recovered by inserting the required bits in the other traces. In the example above, block $1$ has no deletions in $\bm{y}_{2}$, so $\bm{y}_{2}$ is used to correct the first block of $\bm{y}_{1}$; similarly, block $3$ has no deletions in $\bm{y}_{1}$. Assuming that there were no errors, at the end of this phase the decoder has corrected all blocks which are deletion-free in at least one trace. We call the remaining blocks ‘congested’. In the example, block $2$ is congested as both traces have bits deleted in this block.

In phase 2, the decoder attempts to correct the congested blocks, i.e., blocks for which no clean copy was found in phase 1. In the example, since $\bm{y}_{1}$ has one deletion in block $2$, the block can be corrected using the VT decoder. Since blocks $1$ and $3$ were corrected in phase 1, $\bm{x}$ is recovered.

However, decoding errors may occur in either phase. In phase $1$, we may wrongly identify a block as deletion-free in a trace, which leads to errors in the starting positions of other blocks. In phase $2$, a congested block (or set of consecutive congested blocks) may not be correctable with the VT code, because of too many deletions in each trace. In phase $1$, wrongly identifying a trace as having a deletion-free copy of a block will lead to an unusually large number of insertions when correcting the other traces using this copy. This can be used to discard accidental matches in phase $1$. We show via numerical simulations that the probability of phase 1 error decreases with $n_{b}$, the length of each block. For the phase 2 error, under the assumption that the locations of the deletions within each trace are uniformly random, we obtain a bound that decreases exponentially with the number of traces.

The rate of the code is equal to the rate of a VT code of length $n_{b}$, which is close to $\log q-{\log n_{b}}/{n_{b}}$, where $q\geq 2$ is the alphabet size. (The precise values are given in Section II.) The decoding complexity is $\mathcal{O}(t^{2}k^{2}n)$. Therefore the proposed scheme offers an explicit, efficient technique for recovering from deletions using multiple traces. Due to its low-complexity, it can be well suited to a variety of applications, including DNA-based storage.

Notation: Sequences are denoted using bold letters, and scalars with plain font. For $\bm{x}=x_{1}x_{2}\cdots x_{n}$, the subsequence $x_{i}x_{i+1}\cdots x_{j}$ is denoted by $\bm{x}(i:j)$.

II Code Construction

We first review the family of VT codes, and then present the code construction.

Binary VT codes: The VT syndrome of a binary sequence $\bm{x}=x_{1}x_{2}\cdots x_{n}$ is defined as

[TABLE]

For positive integers $n$ and $0\leq s\leq n$, we define the VT code of length $n$ and syndrome $s$, denoted by

[TABLE]

as the set of sequences $x$ of length $n$ for which $\textsf{syn}(\bm{x})=s$. The $(n+1)$ sets $\mathcal{V}\mathcal{T}_{s}(n)\subset\{0,1\}^{n}$, for $0\leq s\leq n$, partition the set of all binary sequences of length $n$. Each of these sets $\mathcal{V}\mathcal{T}_{s}(n)$ is a zero-error single-deletion correcting code. The VT encoding and decoding complexity is linear in the code length $n$ [13, 14].

Non-binary VT codes: VT codes were extended to non-binary alphabets in [12]. Let the alphabet be $\mathcal{X}=\{0,\ldots,q-1\}$, with $q>2$. For each sequence $\bm{x}\in\mathcal{X}^{n}$, define a length $(n-1)$ auxiliary binary sequence $\bm{\alpha}(\bm{x})=\alpha_{2},\dotsc,\alpha_{n}$ as follows. For $2\leq j\leq n$,

[TABLE]

We also define the modular sum as

[TABLE]

A $q$-ary VT code with length $n$ and parameters $(a,c)$ is defined as [12]

[TABLE]

for $0\leq a\leq n-1$ and $c\in\mathcal{X}$. Similarly to the binary case, the sets $\mathcal{V}\mathcal{T}_{a,c}(n)$ partition the space $\mathcal{X}^{n}$ of all $q$-ary sequences of length $n$ into $qn$ sets. Each set is a single deletion correcting code. The complexity of the encoding and decoding $q$-ary VT codes is linear in the code length $n$ [12, 15].

II-A Code construction

Codewords of length $n$ are constructed by concatenating $l$ blocks of VT codewords from the relevant alphabet. Each block has length $n_{b}$ (therefore $n=ln_{b}$).

Binary code: Each block $i$ ($1\leq i\leq l$) is a binary VT codeword with a predetermined VT syndrome $a_{i}$, known to both the encoder and the decoder. To encode each block, one can use the systematic VT encoder in [14] that maps $n_{b}-\lceil\log(n_{b}+1)\rceil$ bits to a length $n_{b}$ VT sequence with the desired syndrome. The rate of the code will be

[TABLE]

Non-binary code: The code construction is very similar to the binary case. Each block is encoded separately, and belongs to a known non-binary VT class, as defined in (5). There are $qn_{b}$ non-binary VT classes, so there exists a class with at least $\frac{q^{n_{b}}}{qn_{b}}$ sequences. Using this class for encoding each block induces the following lower bound for the rate of the code:

[TABLE]

The VT syndrome/class for each of the $l$ blocks can be arbitrarily chosen. Choosing the largest of the VT classes of length $n_{b}$ sequences maximises the rate of the code.

III Decoding

The goal of the decoder is to reconstruct $\bm{x}$ using the traces $\bm{y}_{1},\bm{y}_{2},\cdots,\bm{y}_{t}$, each obtained by deleting $k$ symbols from $\bm{x}$. We describe the binary decoder, and then outline the main differences for the non-binary case. We explain the main ideas using examples, and then specify the decoding algorithm in detail. We remark that the same decoding algorithm can be applied when the number of deletions in one or more traces is less than $k$.

III-A Phase 1

Consider block $i$ of the codeword, for $1\leq i\leq l$. If the starting position of block $i$ within each trace is known, then the decoder can compute the VT syndrome of the length $n_{b}$ sequence from the starting position, for each trace. If there is a trace for which the computed syndrome matches with $a_{i}$ (the correct syndrome for block $i$), then the trace can be used to correct this block within other traces. The following example illustrates this idea.

Example 1

Consider a codeword with $l=3$ blocks, with each block of length $n_{b}=5$. Thus $n=15$. Let

[TABLE]

be the transmitted codeword. The VT syndromes of the blocks are $a_{1}=1$, $a_{2}=2$, and $a_{3}=3$. Suppose that the decoder receives two traces, each with $k=2$ deletions. The underlined bits are deleted from $\bm{x}$ to produce $\bm{y}_{1}$ and $\bm{y}_{2}$:

[TABLE]

The decoder first computes the VT syndromes of $\bm{y}_{1}(1:5)$ and $\bm{y}_{2}(1:5)$. We have

[TABLE]

Since $a_{1}=1$, the decoder assumes that $\bm{y}_{2}(1:5)$ is the first block of $\bm{x}$, and uses it to correct the first block of $\bm{y}_{1}$ by inserting the two missing bits. The decoder then considers the second block, whose starting position is now known for each trace. Finding that $\textsf{syn}(\bm{y}_{1}(4:8))=a_{2}=2$, it assumes this sequence is the second block of $\bm{x}$, and uses it to correct $\bm{y}_{2}$ by inserting two bits. Since there are no deletions in the third block, the decoder finds $\textsf{syn}(\bm{y}_{1}(9:13))=\textsf{syn}(\bm{y}_{2}(9:13))=a_{3}=3$, and stops.

A decoding error may occur if the VT syndrome of a block in a trace accidentally matches the correct value. In this case, an incorrect sequence will be used to correct the block in all other traces, potentially introducing multiple errors. The following example shows that how other traces can help to identify and discard such accidental matches.

Example 2

Consider a codeword with $l=2$ blocks, with each block of length $n_{b}=10$. The VT syndromes of the blocks are $a_{1}=a_{2}=5$. Let the transmitted codeword be

[TABLE]

There are two traces, each with $k=2$ deletions (underlined bits are deleted):

[TABLE]

The decoder finds that $\textsf{syn}(\bm{y}_{1}(1:10))=5$ (this is an instance of an accidental match), and $\textsf{syn}(\bm{y}_{2}(1:10))=0$. It assumes that $\bm{y}_{1}(1:10)$ is the correct block, and uses it to fix $\bm{y}_{2}$. It does this by comparing $\bm{y}_{1}(1:10)$ with $\bm{y}_{2}$, and inserting the required bits to get $\hat{\bm{y}}_{2}(1:10)=\underline{1}00\underline{111}0\underline{000}$. Since there are two deletions in $\bm{y}_{2}$, exactly two inserted bits are required to recover the codeword. However, since $7$ bits need to be inserted into $\bm{y}_{2}$ to get $\bm{y}_{1}(1:10)$ and $k=2$, the decoder realizes that $\bm{y}_{1}(1:10)$ is an accidental match.

The above example shows that when an accidentally matched block is used as the model to correct other traces, the number of inserted bits is likely to be large. Hence the decoder can distinguish between an accidental match and a correct match in most cases.

Congested blocks and resynchronization. There may be blocks that have undergone at least one deletion in each of the traces. These blocks are called congested, as a correct match for them cannot be found in any of the traces. In Example 2, the first block is congested as there are deleted bits in both of the traces. As the decoder proceeds from left to right in phase 1, it needs to resynchronize whenever it identifies a congested block. It does so by testing all possible starting positions for the next block in each trace.

Assume block $i$ is congested, and consider a trace for which that the decoder has inferred that there are $d<k$ deletions up to block $(i-1)$. The decoder needs to test $(k-d)$ possible starting positions for block $(i+1)$ in this trace. It computes the VT syndromes of the length $n_{b}$ sequences starting from each of these positions, and checks for a match with the correct syndrome $a_{i+1}$. If a match is found, it is used to correct the other traces. It repeats this process for each trace, testing all possible starting positions for block $(i+1)$, and checking whether a match is found for the correct VT syndrome. If the decoder finds one or more syndrome matches among those tested, it chooses the one that requires the minimum number of insertions (across all traces) for correcting block $(i+1)$.

When block $i$ is identified as congested, it is possible that block $(i+1)$ is also congested (i.e., has deletions in all the traces). In this case, no matches may be found among all the tested starting positions for block $(i+1)$. The decoder then tries to synchronize by testing all possible starting positions for block $(i+2)$.

III-B Phase 2

At the end of phase $1$, if there are no errors, the decoder has corrected all blocks for which there is at least one trace with a deletion-free copy of the block. Each remaining block is congested, and is either: i) isolated, i.e., the bits corresponding to the block in each trace are known, or ii) part of an isolated set of consecutive congested blocks.

In the second phase, the decoder uses the VT syndromes to correct as many congested blocks as possible. For each congested set of $r$ consecutive blocks ($r\geq 1$, with $r=1$ corresponding to a single congested block), the decoder can infer the number of deleted bits within each trace. It uses this information, and attempts to correct the congested blocks as follows. For a congested set of $r$ consecutive blocks ($r\geq 1$), the decoder looks for a trace with exactly $r$ deletions. If such a trace exists, then this set of blocks can be corrected using that trace and the known VT syndromes of the $r$ blocks. On the other hand, a congested set of $r$ consecutive blocks cannot be corrected if it has at least $(r+1)$ deletions in each trace.

Example 3

Consider a codeword with $l=4$ blocks, each of length $n_{b}=5$. The VT syndromes are $a_{1}=a_{2}=a_{3}=a_{4}=0$, and

[TABLE]

There are two traces, with $4$ deletions in the first and $3$ in the second:

[TABLE]

The first block is recovered using $\bm{y}_{2}$, using which the block is corrected in $\bm{y}_{1}$. The second block is congested, and neither trace provides a match for its VT syndrome. The decoder therefore tests the possible starting positions for the third block. Consider the first trace, which has a total of $4$ deletions. Since there was one deletion in the first block, there are three possible starting positions for the third block: bits $7,8$ and $9$ of $\bm{y}_{1}$. Similarly, bits $8,9$ and $10$ of $\bm{y}_{2}$ are the possible starting positions for the third block.

The decoder therefore computes the VT syndrome of $\bm{y}_{1}(9:13),\bm{y}_{1}(8:12),\bm{y}_{1}(7:12)$, and $\bm{y}_{2}(10:14)$, $\bm{y}_{2}(9:13)$, $\bm{y}_{2}(8:12)$. Among these, the only one that satisfies the correct syndrome $a_{3}=0$ is $\bm{y}_{1}(9:13)=\bm{y}_{2}(10:14)=10001$. This indicates that there is one deletion in the second block, in each of the traces. Thus the second block can be recovered using the VT decoder in phase 2. With the first three blocks synchronized, the decoder attempts to correct the fourth. The fourth block has two deletions in both traces. As the VT decoder can only correct a single deletion, the decoder declares an error due to an unresolvable congestion.

In the next section, we derive a bound (Propositon 2) on the probability of phase 2 error, caused by an unresolvable congestion like the one above.

III-C Decoding algorithm (for binary alphabet)

We now describe the decoder in detail. Denote the number of deletions in the $j$th trace by $k_{j}$, recalling that $k_{j}\leq k$ for $1\leq j\leq t$.

Phase 1

Block 1: Compute the VT syndrome of $\bm{y}_{j}(1:n_{b})$, for $1\leq j\leq t$. If the computed syndrome for trace $j$ is equal to $a_{1}$, consider $\bm{y}_{j}(1:n_{b})$ as a candidate for the first block of the codeword, and use it to correct the other traces. In the process, if the total number of bits inserted into any trace exceeds the number of deletions in it, discard $\bm{y}_{j}$ from the list of candidates. If the final list of candidates is non-empty, pick one that leads to the fewest total insertions in the other traces. If the final list of candidates is empty, declare block $1$ congested and proceed to the second block.

Block $i>1$: There are two possibilities:

If block $(i-1)$ is not congested: The starting position of the $i$th block is known in each trace. As in block 1, for each trace compute the VT syndrome for the length $n_{b}$ sequence from the starting position, and compare with $a_{i}$. Each sequence whose VT syndrome matches $a_{i}$ is a candidate. Use each candidate sequence to correct the other traces; if the total number of bits inserted in any trace (up to this point in decoding) exceeds the number of deletions in it, discard the sequence from the list of candidates. If the final list of candidates is non-empty, pick one that leads to the fewest total insertions in the other traces. If the final list list of candidates is empty, declare block $i$ congested, and proceed to the next block. 2. 2.

If block $(i-1)$ is congested: The starting position of block $i$ is not known. Suppose that blocks $(i-1)$ to $(i-c)$ are congested (where $c\geq 1$). Since block $(i-c-1)$ is not congested, for each trace the decoder can infer the total number of deletions up to block $(i-c-1)$. Denote this number by $d_{j}$ for trace $j$. Then the starting position of the block $i$ in trace $j$ is a number between $(i-1)n_{b}-c-d_{j}+1$ and $(i-1)n_{b}-k_{j}+1$, where $k_{j}$ is the total number of deletions in trace $j$. Compute the VT syndrome for each of these $(k_{j}-c-d_{j}+1)$ possibilities, and compare with $a_{i}$. If there is a sequence whose syndrome matches, add it to the list of candidates and correct the other traces using this sequence. Since the starting position of block $i$ is not known, when correcting using a candidate sequence, we need to consider all the possible starting positions of block $i$ in the other traces. Pick the starting position that results in the minimum number of inserted bits. (If there is more than one starting position that gives the minimum, we pick the rightmost one.) As before, discard a candidate if the number of bits inserted in trace $j$ is larger than $k_{j}-c-d_{j}$ for some $j$.

If the final list of candidates is non-empty, pick one that leads to the fewest total insertions in the other traces. This process also gives the starting positions for block $(i+1)$ in each trace. If the final list of candidates is empty, declare block $i$ congested, and proceed to the next block.

Phase 2

Consider each congested set of $r$ consecutive blocks separately, for $1\leq r\leq k$. For each of these congested sets, the decoder knows the number of deletions in each trace. For a congested set with $r$ blocks, if each trace has more than $r$ deletions in the congested set, the decoder declares an error. Otherwise the decoder finds a trace with exactly $r$ deletions in the congested set, i.e., exactly one deletion per block. The decoder corrects these blocks using the VT decoder, and uses them to correct the other traces by inserting the appropriate bits. During this process, if the number of inserted bits does not match the number of deletions in the trace within the congested set, the decoder declares an error.

III-D Non-binary alphabet

The decoding is similar to the binary case. The only difference is that the VT syndrome of a non-binary sequence is a pair of numbers. Therefore, when we comparing VT syndromes of two sequences in the first phase, both numbers in the pair should be compared. In the second phase, the decoder uses the non-binary VT decoder from [12] to recover a block with a single deletion.

III-E Decoding complexity

In phase 1, for a block for which the starting position is unknown, the decoder computes at most $k$ VT syndromes of length $n_{b}$ sequences in each of the $t$ traces. For each matched syndrome, the decoder needs to check inserted bits in at most $k$ blocks in the other $(t-1)$ traces. Since there are $l$ blocks, and $n=n_{b}l$, the complexity for the first phase is $\mathcal{O}(t^{2}k^{2}n)$.

In phase 2, the VT decoder is used in at most $l$ blocks (each of length $n_{b}$), and then uses the recovered sequence to correct the block in the other traces. Since the VT decoder has linear complexity, the complexity for phase 2 is $\mathcal{O}(tn)$.

IV Error probability and Simulation results

IV-A Phase 1 errors

In the first phase of decoding, an error can occur in two ways. First, an accidental match may lead to a block being wrongly identified as deletion-free in a trace; this is then used to correct the block in other traces. Second, when a congested block is identified, the decoder may pick a wrong starting position for the next block. As shown in Example 2, an accidental match in a trace can be often detected by the decoder when it leads to a large number of inserted bits in the other traces. This detection feature makes it hard to derive a rigorous bound for the phase 1 error.

Without the detection feature, the probability of an accidental VT match in the binary case will be inversely proportional to $n_{b}$, the length of the block. Indeed, the family of $(n_{b}+1)$ VT codes partitions the space of length-$n_{b}$ binary sequences into approximately equal-sized sets of size $\sim 2^{n_{b}}/(n_{b}+1)$. Hence the probability that a binary sequence picked uniformly at random will match a given VT syndrome is close to $\frac{1}{(n_{b}+1)}$.

IV-B Phase 2 errors

Errors in the second phase of the decoding are due to unresolvable congestion. Recall that unresolvable congestion occurs if, for some $1\leq r\leq k$, there is a set of $r$ consecutive congested blocks with at least $(r+1)$ deletions in each trace. The following proposition bounds the probability of phase 2 error, denoted by ${\sf{P}}_{e_{2}}$.

Proposition 1

Consider a code with $l$ blocks, and a channel that introduces at most $k$ deletions in each of the $t$ traces. If $k<l$ and the locations of deletions within each trace are uniformly random, the probability of phase 2 error satisfies

[TABLE]

where, for $s=0,1$,

[TABLE]

We note that the phase 2 error probability (and the bound) depends only on $k$ and $l$, and on neither $n_{b}$ nor the alphabet size. The restriction $k<l$ is natural, as otherwise the expected number of deletions per block would be greater than $1$.

Proposition 2

Consider a code with $l$ blocks, and a channel that introduces at most $k$ deletions in each of the $t$ traces. If $k<l$ and the locations of deletions within each trace are uniformly random, the probability of phase 2 error satisfies

[TABLE]

where, for $s=0,1$,

[TABLE]

and

[TABLE]

We note that the phase 2 error probability (and the bound) depends only on $k$ and $l$. It does not depend on either $n_{b}$ or the alphabet size. The restriction $k<l$ is natural, since otherwise the expected number of deletions per block would be greater than $1$.

Proof:

For $1\leq i\leq l$ and $1\leq r\leq k$, let $Z_{i,r}$ be an indicator random variable with $Z_{i,r}=1$ if the $i$th block is in an unresolvable congestion of exactly $r$ consecutive blocks, and $Z_{i,r}=0$ otherwise. Let

[TABLE]

For each $r$, the inner sum in (13) counts the number of distinct sets of $r$ consecutive congested blocks. Therefore $Z$ is the total number of distinct congested sets, where a congested set is a set of of $r$ consecutive congested blocks, for some $r\geq 1$. Hence ${\sf{P}}_{e_{2}}=\mathbb{P}(Z\geq 1)$. Using Markov’s inequality,

[TABLE]

The probability that a given block has exactly $s$ deletions (for $0\leq s\leq k$) is given by $p_{s}$ in (11). Indeed, since the locations of the $k$ deletions are uniformly random, the probability of a block having $s$ deletions is the proportion of non-negative integer solutions of $x_{1}+x_{2}+\cdots+x_{l}=k$ with $x_{1}=s$.

A block can be in an unresolvable congestion only if it has more than one deletion in each of the traces. Therefore,

[TABLE]

To find an upper bound for $\mathbb{E}[Z_{i,r}]$ for $r\geq 2$, we need the following lemma.

Lemma 1

For a given trace and $r$ blocks ($1\leq r\leq k$), denote by $q_{r}$ the probability of at least one deletion occurring in each of the $r$ blocks. Then

[TABLE]

Proof:

We prove this by using induction on $r$. For $r=1$, we have $q_{1}=(1-p_{0})$. Now assume that (16) holds for $q_{u}$, for some $u<r$. For $s\geq u$, we write $q_{u}(s)$ for the probability of $s$ deletions occurring in a given set of $u$ consecutive blocks, with at least one deletion in each of them. Clearly, $q_{u}=\sum_{s=u}^{k}q_{u}(s)$. We then have

[TABLE]

In the chain above, it can be verified that (19) holds when $l>k$ and $s\geq r$. Eq. (21) is obtained using the induction hypothesis: $\sum_{s=u}^{k}q_{u}(s)=q_{u}\leq(1-p_{0})^{u}$. ∎

Using the lemma, the probability that two consecutive blocks, say $i$ and $(i+1)$, have at least three deletions in each trace (and are hence unresolvable) is bounded by $[(1-p_{0})^{2}-p_{1}p^{\prime}_{1}]^{t}$. Here $p_{1}^{\prime}$ defined in (12) is the probability of block $(i+1)$ having one deletion given that block $i$ has one deletion. Therefore, considering the event of unresolvable congestion either in the pair of blocks $\{(i-1),i\}$ or in blocks $\{i,(i+1)\}$, we have

[TABLE]

For $r>2$, consider a set of $r$ consecutive blocks, say $i,\ldots,(i+r-1)$. The probability of congestion in this set of blocks is $q_{r}^{t}$, which by (16) is bounded by $(1-p_{0})^{rt}$. Hence,

[TABLE]

where we use the fact that a given block $i$ is part of (up to) $r$ different sets of $r$ consecutive blocks. Using (15), (22), and (23) in (14) yields the result of the proposition. ∎

IV-C Numerical Simulations

Figure 1 shows the empirical error probability of the code for different values of $n_{b}$, for $q=2$ (binary) and for $q=4$. Each codeword consists of $l=7$ blocks, each of length $n_{b}$. There are $t=5$ traces, each with $k=4$ deletions at uniformly random locations. We note that both the code length and the rate (cf. (6), (7)) increase with $n_{b}$.

Figure 1 also shows the empirical phase 2 error (dashed line), which does not depend on either $n_{b}$ or the alphabet. Proposition 2 gives an upper bound of $3.41\times 10^{-4}$ for the phase 2 error, while the empirical value is $7.63\times 10^{-5}$. The difference between the overall and the phase 2 error probabilities can be (roughly) interpreted as the phase 1 error probability. The phase $1$ error caused by wrong matches of VT syndrome decreases with $n_{b}$, as explained in Sec. IV-A. Furthermore, we observe that the phase 1 error is smaller (and decreases faster with $n_{b}$) for $q=4$ than for $q=2$. There are two reasons for this. First, the number of potential VT syndromes for $q>2$ is $qn$, in contrast to the binary case where there are $(n+1)$ VT syndromes. Thus the probability of an accidental match is smaller for the non-binary code. Second, as $q$ increases we expect an accidental match to produce more insertions in the other traces, making it is less likely to be accepted as the correct block. This is because matching of two symbols is less likely in a larger alphabet.

Figure 2 shows how the error probability decreases with the number of traces $t$, for a rate $\frac{5}{6}$ binary code with code parameters held fixed. Each trace has $4$ deletions. As shown in Proposition 2, the phase 2 error decays exponentially with $t$. The overall error probability decays more slowly. Hence for larger values of $t$, phase 1 error becomes the dominant contribution to the overall error probability.

Figure 3 shows the probability of error for different $k$ for a rate $\frac{5}{6}$ binary code with $t=5$ traces. No errors were observed for $k=2$.

V Discussion and Future work

The coding scheme demonstrates that single-deletion correcting codes can be effective in correcting multiple deletions when several traces are available. Having multiple traces helps the decoder in two ways: to identify deletion-free copies of a block, and to avoid mis-synchronization.

The error performance of the coding scheme can be improved by using more complex decoding in either phase. In phase 1, when there are multiple syndrome matches for a block, the decoder could run the decoding procedure for a fixed number of these matches in parallel, using the “fewest insertions” rule to decide which candidates to retain. In phase 2, when unresolvable congestion occurs, the decoder could guess a subset of the bits in the block, use the VT decoder to recover the rest, and choose a guess that produces the correct number of insertions in other traces. Investigating these improved decoders is part of ongoing work. Another idea for future work is to replace the VT code in each block with a lower-rate code capable of correcting more than one deletion.