Anchor-Based Correction of Substitutions in Indexed Sets

TL;DR

This paper introduces an anchor-based coding scheme for error correction in unordered indexed sets, inspired by DNA data storage, achieving near-optimal redundancy with efficient correction of substitution errors.

Contribution

It proposes a novel anchoring mechanism for correcting substitutions in unordered sets with indices, enabling the use of standard codes and reducing redundancy.

Findings

Redundancy close to theoretical minimum.

Less redundancy needed for index correction than data correction.

Effective correction of substitution errors in unordered sets.

Abstract

Motivated by DNA-based data storage, we investigate a system where digital information is stored in an unordered set of several vectors over a finite alphabet. Each vector begins with a unique index that represents its position in the whole data set and does not contain data. This paper deals with the design of error-correcting codes for such indexed sets in the presence of substitution errors. We propose a construction that efficiently deals with the challenges that arise when designing codes for unordered sets. Using a novel mechanism, called anchoring, we show that it is possible to combat the ordering loss of sequences with only a small amount of redundancy, which allows to use standard coding techniques, such as tensor-product codes to correct errors within the sequences. We finally derive upper and lower bounds on the achievable redundancy of codes within the considered channel model and verify that our construction yields a redundancy that is close to the best possible achievable one. Our results surprisingly indicate that it requires less redundancy to correct errors in the indices than in the data part of vectors.

Equations

$$\mathcal{S}=\{(\mathbf{I}(1),{\mathbf{u}}_1),(\mathbf{I}(2),{\mathbf{u}}_2),\dots ,(\mathbf{I}(M),{\mathbf{u}}_M)\}\subseteq {\Sigma }_2^L,$$

$$\mathcal{I}_{M}^{L}=\left\{\begin{array}[]{l}\mathcal{S}=\{(\boldsymbol{I}(1),\boldsymbol{u}_{1}),(\boldsymbol{I}(2),\boldsymbol{u}_{2}),\dots,(\boldsymbol{I}(M),\boldsymbol{u}_{M})\}:\\ \boldsymbol{u}_{i}\in\Sigma_{2}^{L_{M}}\;\forall\,i=1,\dots,M\end{array}\right\},$$

$$\mathcal{S}^{\prime}=\bigcup_{i=1}^{M}\left\{\begin{array}[]{ll}\boldsymbol{x}_{i},&\text{if }i\notin\mathcal{F},\\ \boldsymbol{x}_{i}+\boldsymbol{e}_{i},&\text{if }i\in\mathcal{F}\end{array}\right..$$

$$r(\mathcal{C})=M{L}_M-\log |\mathcal{C}|.$$

$$\mathcal{A}(l,t,\epsilon_{1},\epsilon_{2})=\left\{\begin{array}[]{l}(\boldsymbol{a}_{1},\dots,\boldsymbol{a}_{M})\in\Sigma_{2}^{Ml}:\;\forall i,j\in[M],i\neq j:\\ d(\boldsymbol{a}_{i},\boldsymbol{a}_{j})>2\epsilon_{2},\text{ if }d(\boldsymbol{I}(i),\boldsymbol{I}(j))\leq 2\epsilon_{1},\\ (\boldsymbol{a}_{1},\dots,\boldsymbol{a}_{M})\in\mathsf{MDS}[M,2t]\end{array}\right\}.$$

$$\mathsf{TPC}(t,\epsilon_{2})=\left\{\begin{array}[]{ll}(\boldsymbol{u}_{1},\dots,\boldsymbol{u}_{M})\in\Sigma_{2}^{ML_{M}}:\\ (\boldsymbol{s}_{1},\dots,\boldsymbol{s}_{M})\in\mathcal{C}_{2}\end{array}\right\},$$

$$\mathcal{C}_{\mathrm{A}}=\left\{\begin{array}[]{l}\mathcal{S}=\{(\boldsymbol{I}(1),\boldsymbol{a}_{1},\boldsymbol{v}_{1}),\dots,(\boldsymbol{I}(M),\boldsymbol{a}_{M},\boldsymbol{v}_{M})\}:\\ (\boldsymbol{a}_{1},\dots,\boldsymbol{a}_{M})\in\mathcal{A}(l,t,\epsilon_{1},\epsilon_{2}),\\ ((\boldsymbol{a}_{1},\boldsymbol{v}_{1}),\dots,(\boldsymbol{a}_{M},\boldsymbol{v}_{M}))\in\mathsf{TPC}(t,\epsilon_{2})\end{array}\right\}.$$

$$r({\mathcal{C}}_{\mathrm{A}})=r_{\mathrm{A}}+r_1{r}_2,$$

$$r({\mathcal{C}}_A)\le (4t+2\delta )\log M+2t{ϵ}_2\lceil \log L_M\rceil +1+o(1).$$

$$|\mathcal{A}(l,t,{ϵ}_1,{ϵ}_2)|\ge \frac{1}{2^{2tl}}(2^l-B_{2{ϵ}_1}(\log M)B_{2{ϵ}_2}(l){)}^M$$

$$|\mathcal{C}|\le \frac{2^{M{L}_M}}{\left(\genfrac{}{}{0ex}{}{M}{t}\right)(B_{{ϵ}_2}(L_M)-1{)}^t}.$$

$$r(\mathcal{C})\ge t\log M+t{ϵ}_2\log (L_M)-t\log (t{ϵ}_2^{{ϵ}_2}).$$

$$|B(\mathcal{S})\cap {\mathcal{I}}_M^L|\ge \left(\genfrac{}{}{0ex}{}{M}{t}\right)(B_{{ϵ}_2}(L_M)-1{)}^t,$$

$$|\mathcal{C}|\ge \frac{2^{M{L}_M}}{{\left(\genfrac{}{}{0ex}{}{M}{t}\right)}^2(B_{{ϵ}_2}(L_M){)}^{2t}(t{!}^2+\frac{t}{M-t}(B_{{ϵ}_1}(\log M){)}^{2t})}.$$

$$r(\mathcal{C})\le 2t\log M+2t{ϵ}_2\log L_M-2t\log {ϵ}_2!+o(1).$$

Full text

I Introduction

Consider a system where digital information is embodied in an unordered set of vectors and each vector holds a share of the whole data set. To combat the unordered nature of the data storage, such systems almost exclusively rely on indices, which are prepended to each vector and denote the position of that vector in the data set. An important example for a modern communication system of such a type is internet routing, where data is split into packets and transmitted over a network. Since packets can have different propagation times over the network, they might be received in a different order and hence the ordering of the packets is lost. Another important example for such a system is deoxyribonucleic acid (DNA)-based data storage, which is the main focus of this paper.

Data storage in DNA is a novel technology that, due to recent advancements in biochemical mechanisms of synthesizing and sequencing DNA molecules, has advanced to be a highly competitive candidate for long-term archival storage of digital data. This is since DNA-based storage has several important features that stand out with respect to conventional digital data storage systems, such as tapes and hard disk drives. These include outstandingly high data densities and long-term robustness. Due to its chemical structure, from a coding theoretic point of view, DNA can be seen as a vector over symbols {A,C,G,T}, which abbreviate the four nucleotides adenine (A), cytosine (C), guanine (G), and thymine (T). Single DNA strands can be synthesized chemically and modern DNA synthesizers can concatenate the four DNA nucleotides to form almost any possible sequence. This process enables the storage of digital data in DNA. The data can be read back with common DNA sequencers, while the most popular ones use DNA polymerase enzymes.

Using DNA as a storage medium for digital data was envisioned by Feynman in his famous speech “There’s plenty of room at the bottom” and also by Baum [1]. It took several decades until first experiments of Church et al. [4] and later Goldman et al.  [6] demonstrated the viability of in vitro DNA storage on a large scale. In the next years, many experiments followed, including Grass et al.  [7] who successfully employed error-correcting codes to recover the data. Since then, several more groups have elaborated the methods, storing ever larger amounts of data. For example, Erlich and Zielinski [5] stored 2.11MB of data in DNA, Blawat et al. [2] recovered a data archive of 22MB, and Organick et al. [12] stored 200MB of digital information. Yazdi et al. [20] developed a method that offers random read access and rewritable storage using constrained codes. On the other hand, coding theoretic aspects of DNA storage systems have received significant attention recently. The work of [9] discusses error-correcting codes for the DNA sequencing channel, where a possibly erroneous collection of substrings of the original strand is obtained. Codes over unordered sets of sequences, where sequences are affected by a certain number of point errors, such as insertions, deletions and substitutions, have been discussed in [11, 15, 16]. In [15], codes and bounds for a given number of substitutions have been proposed, which require a redundancy that is both logarithmic in the number of sequences and the length of the sequences. Based on a slight adaptation of the model in [11], the sequence-subset distance has been introduced and analyzed in [16] and Singleton-like and Plotkin-like code size upper bounds have been derived. In contrast, [10] proposes codes for errors that affect whole strands in a storage system that stores multiset of sequences. Recently, codes that can be equipped as primer addresses have been proposed in [18, 3]. A comprehensive survey for DNA-based storage can be found in [19].

From an information theoretic point of view DNA is fundamentally different than other storage media due to the fact that all information about the ordering of the DNA strands is lost during synthesis. One efficient and practical way to circumvent this limitation is to prepend an index to each strand that denotes the position of the strand in the archive. However, due to errors during synthesis or sequencing, these indices might be erroneous when reading the archive. A naive solution to combat these errors is to protect each index by an error-correcting code. Such an approach however already incurs a redundancy that grows linearly with the number of strands, which is suboptimal, especially for the practically important case, when not all sequences contain errors. In this paper we will analyze the approach of indexing sequences in the presence of errors inside the strands. We propose constructions that efficiently cope with these errors and only have a redundancy that is logarithmic in both the number and length of sequences. Note that the employment of indices is not a necessity and the more general setup of storing an arbitrary set of sequences has been analyzed in [11]. However, the discussion of indexed-based schemes is practically important due to its simplicity. In this work we study only substitution errors, while insertion and deletion errors are deferred for future work. Also, we present our results for the binary case, while the extension to non-binary alphabets is straightforward.

II Channel Model

In this work we study a system where user data is stored in an indexed set $\mathcal{S}=\{\boldsymbol{x}_{1},\dots,\boldsymbol{x}_{M}\}$ of $M$ unordered vectors $\boldsymbol{x}_{i}\in\Sigma_{2}^{L}$, where $i\in[M]\triangleq\{1,2,\dots,M\}$ and $\Sigma_{2}=\{0,1\}$. The vectors are also called sequences or strands in reference to the DNA-based storage system. Hereby, each vector $\boldsymbol{x}_{i}$ has the same length $L$. Throughout the paper, we use that $M=2^{\beta L}$ for some $0<\beta<1$ such that $\beta L\in\mathbb{N}$ is an integer. Mathematically, an indexed set is characterized as

[TABLE]

with sequences $\boldsymbol{x}_{i}=(\boldsymbol{I}(i),\boldsymbol{u}_{i})\in\Sigma_{2}^{L}$. Each sequence hereby consists of two parts. It begins with a prefix $\boldsymbol{I}(i)\in\Sigma_{2}^{\log M}$, also referred to as index, of length $\log M$. This prefix is a unique binary representation of the index $i$ and designates the position of this specific sequence in the data set $\mathcal{S}$. Note that in general it is possible to use any bijective map $\boldsymbol{I}(i):\{1,\dots,M\}\mapsto\Sigma_{2}^{\log M}$ as index, however in practice this map is usually realized by a standard decimal to binary conversion. The second part of each sequence, $\boldsymbol{u}_{i}\in\Sigma_{2}^{L-\log M}$, will be referred to as the data part of a sequence and can be filled arbitrarily by either user information or redundancy from an error-correcting code, as illustrated later. For convenience, we will abbreviate $L_{M}\triangleq L-\log M$ throughout the paper. The set of all indexed data sets is

[TABLE]

and their total number is $|\mathcal{I}_{M}^{L}|=2^{ML_{M}}$. Therefore, $\mathcal{I}_{M}^{L}$ denotes all feasible channel inputs of the channel, when using indexed sets. The stored set can be corrupted by substitution errors, caused by, e.g., synthesis or sequencing errors and we model the errors by a channel that takes an indexed set $\mathcal{S}\in\mathcal{I}_{M}^{L}$ as input and outputs an erroneous outcome of this set based on the following procedure as visualized in Fig. 1. When an indexed data set $\mathcal{S}=\{\boldsymbol{x}_{1},\dots,\boldsymbol{x}_{M}\}\in\mathcal{I}_{M}^{L}$ has been stored, $M-t$ strands are read correctly and $t$ strands are read in error. These sequences result from clustering and reconstructing a large number of sequences, which has been illustrated and discussed in [12, 11]. Denote by $\mathcal{F}=\{f_{1},f_{2},\dots,f_{t}\}\subseteq[M]$ with $1\leq f_{1}<f_{2}<\dots<f_{t}\leq M$ the ordered indices of the sequences that are received in error and $\boldsymbol{e}_{f_{1}},\dots,\boldsymbol{e}_{f_{t}}\in\Sigma_{2}^{L}$ the corresponding error patterns. The index $\boldsymbol{I}(i)$ of each erroneous sequence $\boldsymbol{x}_{i}$, $i\in\mathcal{F}$ is affected by at most $\epsilon_{1}$ substitution errors and the data part $\boldsymbol{u}_{i}$ is affected by at most $\epsilon_{2}$ substitutions. Therefore, each error vector is composed of two parts $\boldsymbol{e}_{f_{i}}=(\boldsymbol{e}^{I}_{f_{i}},\boldsymbol{e}^{D}_{f_{i}})$ of lengths $\log M$ and $L_{M}$, with Hamming weights $\mathrm{wt}(\boldsymbol{e}^{I}_{f_{i}})\leq\epsilon_{1}$ and $\mathrm{wt}(\boldsymbol{e}^{D}_{f_{i}})\leq\epsilon_{2}$ for all $i\in[t]$. The received set $\mathcal{S}^{\prime}\subseteq\Sigma_{2}^{L}$ can then be written as

[TABLE]

Throughout the paper the $(t,\epsilon_{1},\epsilon_{2})$-channel will refer to the entity which, given an input set $\mathcal{S}\in\mathcal{I}_{M}^{L}$, outputs a received set $\mathcal{S}^{\prime}$ resulting from arbitrary $\mathcal{F}$ and $\boldsymbol{e}_{f_{1}},\dots,\boldsymbol{e}_{f_{t}}$ as described above. This set of all possible channel outputs is denoted by $B(\mathcal{S})$. Note that when there are errors in the indices, the erroneous sequences $\boldsymbol{x}_{f_{j}}^{\prime}\triangleq\boldsymbol{x}_{f_{j}}+\boldsymbol{e}_{f_{j}}$, $j\in[t]$ are not necessarily distinct from each other or from the error-free sequences and in this case these sequences adjoin and appear as a single sequence at the receiver. Therefore the number of received sequences can be less than $M$, i.e., $M-t\leq|\mathcal{S}^{\prime}|\leq M$. In particular here it is also possible that the received set $\mathcal{S}^{\prime}\notin\mathcal{I}_{M}^{L}$, since some indices might not be present in the received set or others might appear multiple times. Another particularity of the channel is that different error patterns $\mathcal{F}$ and $\boldsymbol{e}_{f_{1}},\dots,\boldsymbol{e}_{f_{t}}$ might lead to the same channel output $\mathcal{S}^{\prime}$. We will use the following standard definition of an error-correcting code.

Definition 1** ($(t,\epsilon_{1},\epsilon_{2})$-indexed-set code).**

A code $\mathcal{C}\subseteq\mathcal{I}_{M}^{L}$ is called a $(t,\epsilon_{1},\epsilon_{2})$-indexed-set code, if $B(\mathcal{S}_{1})\cap B(\mathcal{S}_{2})=\emptyset$ for every pair $\mathcal{S}_{1},\mathcal{S}_{2}\in\mathcal{C}$ with $\mathcal{S}_{1}\neq\mathcal{S}_{2}$. Accordingly, the redundancy of an indexed-set code $\mathcal{C}\subseteq\mathcal{I}_{M}^{L}$ is defined to be

[TABLE]

By this definition, an indexed-set code is a set of codewords for which, for each channel output $\mathcal{S}^{\prime}\subseteq\Sigma_{2}^{L}$, there exists at most one codeword which could have resulted in this exact channel output $\mathcal{S}^{\prime}$. Note that here, each codeword is not a vector, as in the standard channel coding problem, but a set of indexed vectors. In this paper, we distinguish between errors in the index of sequences and data part of the sequences due to the following reasons. It is observed that the sequencing error rates at the beginning of DNA strands are lower with several sequencing technologies [5, 8, 12]. Second, from a theoretical point of view, errors inside the indices have a different character than those in the data part, as they do not affect data directly but hinder the correct identification of the strand order. We will also elaborate in this paper that the redundancy required to correct errors in the indices is significantly smaller than that in the data part of sequences. Finally, the channel model is strongly connected to the more general model presented in [11] as follows.

Each $(0,t,\epsilon)_{\mathbb{S}}$-correcting code [11] is a $(t,\epsilon_{1},\epsilon_{2})$-indexed-set code, if $\epsilon_{1}+\epsilon_{2}\leq\epsilon$. 2. 2.

Each $(t,\epsilon_{1},\epsilon_{2})$-indexed-set code is a $(0,t,\epsilon)_{\mathbb{S}}$-correcting code [11], if $\epsilon\leq\min(\epsilon_{1},\epsilon_{2})$.

III Construction

Finding codes that can correct errors from the DNA-storage channel, one faces two main challenges that have to be tackled. To begin with, substitution errors that are solely in the data part of the sequences can be corrected by standard error-correcting schemes, such as tensor-product codes [17], which we will discuss in more detail later. However, errors in the indices of sequences will corrupt the ordering of the sequences, which hinders the direct employment of tensor-product codes. We therefore will construct a code that first enables to reconstruct the correct ordering of the sequences using so called anchors, and then uses a tensor-product code to correct the errors in the data part of the sequences. The anchors are defined as follows.

Definition 2** (Anchor).**

Let $l,t,\epsilon_{1},\epsilon_{2}\in\mathbb{N}$ and $\boldsymbol{a}_{1},\dots,\boldsymbol{a}_{M}\in\Sigma_{2}^{l}$ be $M$ vectors of length $l$ with $2^{l}\geq M$. Further, denote by $\mathsf{MDS}[M,2t]$ a maximum-distance-separable (MDS) code of length $M$ and redundancy $2t$ over the field $\Sigma_{2^{l}}$. The set of anchor vectors $\mathcal{A}(l,t,\epsilon_{1},\epsilon_{2})$ is defined to be

[TABLE]

That is, if the indices $\boldsymbol{I}(i),\boldsymbol{I}(j)$ of two vectors $\boldsymbol{a}_{i},\boldsymbol{a}_{j}$ have distance at most $2\epsilon_{1}$, the vectors have distance more than $2\epsilon_{2}$. Further, the equivalents of the vectors $\boldsymbol{a}_{1},\dots,\boldsymbol{a}_{M}$ in $\Sigma_{2^{l}}$ are a codeword of an MDS code with minimum distance $2t+1$.

This definition implies that the anchor vectors have both a large intra-anchor distance between vectors of one anchor and a large inter-anchor distance between two anchors due to the MDS code. Note that for $2\epsilon_{1}=\log M$ and $t=0$ this definition is equivalent to a standard error-correcting code, which corrects $\epsilon_{2}$ errors. The redundancy required to force such a constraint on a collection of vectors will be calculated later. For the case of $t=0$, the set $\mathcal{A}(l,0,\epsilon_{1},\epsilon_{2})$ is called clustering-correcting code, and explicit constructions which require only one bit of redundancy and can be encoded and decoded efficiently can be found in [14]. The anchoring property will be used to reconstruct the ordering of the sequences. After the ordering of sequences is restored, it is possible to correct the errors in the sequences using tensor-product codes [17], which are defined as follows.

Definition 3** (Tensor-product code).**

Let $\mathcal{C}_{1}\subseteq\Sigma_{2}$ be a linear $[L_{M},L_{M}-r_{1},\epsilon_{2}]$ binary $\epsilon_{2}$-error-correcting code of length $L_{M}$, redundancy $r_{1}$ and parity-check matrix $\boldsymbol{H}_{1}\in\Sigma_{2}^{r_{1}\times L_{M}}$ and let $\mathcal{C}_{2}\subseteq\Sigma_{2^{r_{1}}}$ be a linear $[M,M-r_{2},t]$ code over the field $\Sigma_{2^{r_{1}}}$. The tensor-product code is then defined to be

[TABLE]

where $\boldsymbol{s}_{i}=\boldsymbol{u}_{i}\boldsymbol{H}_{1}^{\mathrm{T}}$ are syndromes whose equivalents in the finite field $\Sigma_{2^{r_{1}}}$ form a codeword of $\mathcal{C}_{2}$. The overall redundancy of the tensor-product code is $r_{1}r_{2}$ bits.

Correcting errors using the tensor-product code is done as follows [17]. Assume the word $\boldsymbol{U}=(\boldsymbol{u}_{1}^{\prime},\dots,\boldsymbol{u}_{M}^{\prime})$ is received, where at most $t$ vectors $\boldsymbol{u}_{i}^{\prime}$ have been affected by at most $\epsilon_{2}$ errors each. The receiver first computes the syndromes $\boldsymbol{s}_{i}^{\prime}=\boldsymbol{u}_{i}^{\prime}\boldsymbol{H}_{1}^{\mathrm{T}}$ of all vectors. Since there are at most $t$ syndromes corrupted, the correct syndromes $\boldsymbol{s}_{i}$ can be recovered using the code $\mathcal{C}_{2}$. Now, in each row, $\epsilon_{2}$ errors can be corrected using the knowledge of the correct syndrome $\boldsymbol{s}_{i}$ and the code $\mathcal{C}_{1}$. Combining the anchoring property with the tensor-product code leads to the following construction.

Construction 1**.**

Let $l,t,\epsilon_{1},\epsilon_{2}\in\mathbb{N}$ with $l\geq\log M$. Further, $\mathsf{TPC}(t,\epsilon_{2})$ denotes a tensor-product code over an array of size $M\times L_{M}$. We define the construction $\mathcal{C}_{\mathrm{A}}\subseteq\mathcal{I}_{M}^{L}$ as

[TABLE]

Note that with this construction, the anchors $\boldsymbol{a}_{1},\dots,\boldsymbol{a}_{M}$ can also contain user data. The correctness of Construction 1 and its decoding algorithm are presented in the following.

Lemma 1**.**

Construction 1 is a $(t,\epsilon_{1},\epsilon_{2})$-indexed-set code.

Proof.

We will prove the correctness of Construction 1 by providing an algorithm that can be used to correct errors from the $(t,\epsilon_{1},\epsilon_{2})$-channel. The decoding algorithm can be split into the following two steps.

Retrieve the correct order of sequences using the anchoring property of $\boldsymbol{a}_{1},\dots,\boldsymbol{a}_{M}$. 2. 2.

Correct errors inside the sequences using the tensor-product code $\mathsf{TPC}(t,\epsilon_{2})$.

Assume $\mathcal{S}=\{\boldsymbol{x}_{1},\dots,\boldsymbol{x}_{M}\}\in\mathcal{C}_{\mathrm{A}}$ has been stored and $\mathcal{S}^{\prime}=\{\boldsymbol{x}_{1}^{\prime},\dots,\boldsymbol{x}_{M}^{\prime}\}\in B(\mathcal{S})$ has been received after transmission over a $(t,\epsilon_{1},\epsilon_{2})$-channel. We will write $\boldsymbol{x}_{i}^{\prime}=(\boldsymbol{I}(i^{\prime}),\boldsymbol{a}_{i}^{\prime},\boldsymbol{v}_{i}^{\prime})$, which is either $\boldsymbol{x}_{i}^{\prime}=\boldsymbol{x}_{i}$, if the sequence was received correctly, i.e., $i\notin\mathcal{F}$, or $\boldsymbol{x}_{i}^{\prime}=\boldsymbol{x}_{i}+\boldsymbol{e}_{i}$, if the sequence was received in error, i.e., $i\in\mathcal{F}$. This correct ordering of received sequences is however only used to simplify notation and is not known to the receiver, as the indices $\boldsymbol{I}(i^{\prime})$ can be erroneous. Note that due to the anchoring property, it is guaranteed that an erroneous sequence can never adjoin with another sequence and therefore $|\mathcal{S}^{\prime}|=M$. The anchors can be fully recovered using their MDS property as follows. Declare all positions $i\in[M]$, where there is not exactly one index present, i.e., $i:|\{j:\boldsymbol{I}(j^{\prime})=\boldsymbol{I}(i)\}|\neq 1$ as erasures, and fill all remaining positions with the corresponding anchors $\boldsymbol{a}_{i}^{\prime}$. Although some anchors might have the wrong position, decoding the resulting vector of length $M$ with a unique decoding algorithm yields the correct anchors $\boldsymbol{a}_{1},\dots,\boldsymbol{a}_{M}$ (cf. [11, Con. 1]). Using the anchors, it is possible to assign each sequence $\boldsymbol{x}_{j}^{\prime}$ to its correct position $i$ by finding the single sequence $\boldsymbol{x}_{j}^{\prime}\in\mathcal{S}^{\prime}$ with $d(\boldsymbol{I}(i),\boldsymbol{I}(j^{\prime}))\leq\epsilon_{1}$ and $d(\boldsymbol{a}_{i},\boldsymbol{a}_{j}^{\prime})\leq\epsilon_{2}$. There is exactly one sequence $j=i$ with that property. Assume on the contrary, there is more than one sequence (apart from the correct sequence $\boldsymbol{x}_{i}^{\prime}$), which fulfills this property. Then, there would be a sequence $\boldsymbol{x}_{j}^{\prime}$, $j\neq i$ with $d(\boldsymbol{I}(i),\boldsymbol{I}(j^{\prime}))\leq\epsilon_{1}$ and $d(\boldsymbol{a}_{i},\boldsymbol{a}_{j}^{\prime})\leq\epsilon_{2}$, which implies that $d(\boldsymbol{I}(i),\boldsymbol{I}(j))\leq 2\epsilon_{1}$ and also $d(\boldsymbol{a}_{i},\boldsymbol{a}_{j})\leq 2\epsilon_{2}$, which contradicts the anchoring property. We therefore can reconstruct the array $((\boldsymbol{a}_{1}^{\prime},\boldsymbol{v}_{1}^{\prime}),\dots,(\boldsymbol{a}_{M}^{\prime},\boldsymbol{v}_{M}^{\prime}))$ in the correct order. Since each row $(\boldsymbol{a}_{1}^{\prime},\boldsymbol{v}_{1}^{\prime})$ has at most $\epsilon_{2}$ errors, these errors can be corrected using the tensor-product code, which completes the proof of the correctness of Construction 1. ∎

The redundancy of Construction 1 can be decomposed into the redundancy required for the anchoring property and the redundancy of the tensor-product code and is given as follows.

Theorem 1**.**

For any $t,\epsilon_{1},\epsilon_{2}$ the redundancy of $\mathcal{C}_{\mathrm{A}}$ is

[TABLE]

where $r_{\mathrm{A}}=2tl-M\log(1-2^{-l}B_{2\epsilon_{1}}(\log M)B_{2\epsilon_{2}}(l))$. Therefore, for fixed $t,\epsilon_{1},\epsilon_{2}$, and arbitrary small $\delta>0$, for $M\rightarrow\infty$ there exists an explicit construction $\mathcal{C}_{\mathrm{A}}$ with redundancy

[TABLE]

Proof.

From the cardinality of clustering-correcting codes [14] and the fact that the MDS code with redundancy $2t$ has $2^{2tl}$ cosets, there exists one coset of the MDS code with

[TABLE]

by the pigeonhole principle. From this follows the redundancy $r_{\mathrm{A}}$ required for the anchoring property. Next, the redundancy of the tensor-product codes is $r_{1}r_{2}$. Using alternant codes [13, ch. 5] $\mathcal{C}_{1}$ and $\mathcal{C}_{2}$, we obtain redundancies $r_{1}=\epsilon_{2}\lceil\log L_{M}\rceil$ and $r_{2}=2t\lceil\frac{\log M}{r_{1}}\rceil$, if $r_{1}\leq\log M$ and $r_{2}=2t$, otherwise. Using $l=(1+\delta)\log M$ yields $r_{\mathrm{A}}=2t(1+\delta)\log M+o(1)$ and the asymptotic bound follows. ∎

Note that for $t=1$, the construction can be improved by using a Hamming code for $\mathcal{C}_{2}$ and an $\mathsf{MDS}[M,1]$ code with redundancy $1$ for the anchors is sufficient, which yields a redundancy of approximately $2\log M+\epsilon_{2}\log L_{M}+o(1)$.

IV Sphere Packing Bound

The derivation of the sphere packing bound is based on the sets $B(\mathcal{S})$ of possible outputs of the channel, when $\mathcal{S}\in\mathcal{I}_{M}^{L}$ is the input. The bound is derived by using the fact that $B(\mathcal{S})$ must be distinct for different codewords $\mathcal{S}$ to guarantee unique decoding to one codeword. In this and the following section, we will abbreviate the size of the Hamming ball of radius $r$ by $B_{r}(n)\triangleq\sum_{i=0}^{n}\binom{n}{i}$. The main result is as follows.

Theorem 2**.**

The cardinality of any $(t,\epsilon_{1},\epsilon_{2})$-indexed-set code $\mathcal{C}\subseteq\mathcal{I}_{M}^{L}$ is at most

[TABLE]

Therefore, the redundancy is at least

[TABLE]

Proof.

Let $\mathcal{C}\subseteq\mathcal{I}_{M}^{L}$ be a $(t,\epsilon_{1},\epsilon_{2})$-indexed-set code. We consider first the case that $\epsilon_{1}=0$, i.e., there are only errors outside the indices and therefore all erroneous outcomes $\mathcal{S}^{\prime}\in B(\mathcal{S})\cap\mathcal{I}_{M}^{L}$ are again indexed sets. Due to the distinctness of error balls, every code $\mathcal{C}\subseteq\mathcal{I}_{M}^{L}$ satisfies $|\mathcal{C}|\cdot\min_{\mathcal{S}\in\mathcal{I}_{M}^{L}}|B(\mathcal{S})\cap\mathcal{I}_{M}^{L}|\leq|\mathcal{I}_{M}^{L}|$. Using this inequality we bound the code size $|\mathcal{C}|$ from above. Specifically, for all $\mathcal{S}\in\mathcal{I}_{M}^{L}$, we bound the number of erroneous outcomes $|B(\mathcal{S})\cap\mathcal{I}_{M}^{L}|$ which are again indexed sets from below. Distinct elements $\mathcal{S}^{\prime}\in B(\mathcal{S})\cap\mathcal{I}_{M}^{L}$ are obtained as follows. For $\epsilon_{1}=0$ the indices of each sequence can be omitted and the stored set can be viewed as a binary array of $M$ rows and $L_{M}$ columns, where each row corresponds to one sequence. The number of possible error patterns is therefore

[TABLE]

as there are $\binom{M}{t}$ ways to choose the erroneous rows and $B_{\epsilon_{2}}(L_{M})-1$ possible substitution patterns per row. Finally, the case $\epsilon_{1}=0$ is a special case of $\epsilon_{1}>0$, as there are up to $\epsilon_{1}$ errors inside the indices and thus the above bound also holds for arbitrary $\epsilon_{1}>0$ which concludes the proof. ∎

Note that by the definition of the channel it is possible that errors occur in the index of a sequence. However considering these errors for the sphere packing bound does not improve the bound, as we will illustrate in the following. Let us for simplicity assume that there has only been one error in the $i$-th sequence, and compare the two cases, where first, the error is in the data part, i.e., $t=\epsilon_{2}=1$ and $\epsilon_{1}=0$, and second, the error is in the index, i.e., $t=\epsilon_{1}=1$ and $\epsilon_{2}=0$. In the first case, it is sufficient to use a Hamming code of length $ML_{M}$ and redundancy $\log(ML_{M})$, which is able to correct the single substitution, as the receiver can correctly concatenate the received sequences. On the other hand, when the error occurs inside the index of sequence $i$, resulting in index $j$, the receiver will see two sequences with the same index $j$ and no sequence with index $i$. In this case, the receiver only has to decide which of the two sequences with the index $j$ belongs to the position $i$. As this is merely a binary decision, from a sphere packing point of view, a redundancy of roughly a single bit is sufficient to correct this error. This surprisingly indicates that errors inside indices of sequences are less harmful than those inside the data fields of sequences.

V Gilbert-Varshamov Bound

In the last section we have derived upper bounds on the cardinality of error-correcting codes for indexed-set codes. On the other hand, we will now show how to find lower bounds on the achievable size of such error-correcting indexed-set codes based on Gilbert-Varshamov-like sphere covering arguments. For convenience, in the following we denote by $V(\mathcal{S})$ the set of indexed sets $\tilde{\mathcal{S}}\in\mathcal{I}_{M}^{L}$ which have intersecting errors ball with $\mathcal{S}\in\mathcal{I}_{M}^{L}$, i.e., $B(\mathcal{S})\cap B(\tilde{\mathcal{S}})\neq\emptyset$.

Theorem 3**.**

There exists a $(t,\epsilon_{1},\epsilon_{2})$-indexed-set code $\mathcal{C}\subseteq\mathcal{I}_{M}^{L}$ with cardinality at least

[TABLE]

Therefore, for fixed $t,\epsilon_{1},\epsilon_{2}$ and $M\rightarrow\infty$, there exists a $(t,\epsilon_{1},\epsilon_{2})$-indexed-set code $\mathcal{C}\subseteq\mathcal{I}_{M}^{L}$ with redundancy at most

[TABLE]

Proof.

Based on an iterative procedure, it can be shown that there exists a $(t,\epsilon_{1},\epsilon_{2})$-indexed-set code $\mathcal{C}\subseteq\mathcal{I}_{M}^{L}$ with $|\mathcal{C}|\cdot\max_{\mathcal{S}\in\mathcal{I}_{M}^{L}}|V(\mathcal{S})|\geq|\mathcal{I}_{M}^{L}|$. Bounding $|V(\mathcal{S})|$ from above for all $\mathcal{S}\in\mathcal{I}_{M}^{L}$ will be the main task in the following. Let $B_{I}(\mathcal{S})\triangleq B(\mathcal{S})\cap\mathcal{I}_{M}^{L}$ be the set of erroneous sets which are indexed sets and $B_{N}(\mathcal{S})\triangleq B(\mathcal{S})\setminus B_{I}(\mathcal{S})$. Further distinguish between $V_{I}(\mathcal{S})\triangleq\{\tilde{\mathcal{S}}\in\mathcal{I}_{M}^{L}:B_{I}(\mathcal{S})\cap B(\tilde{\mathcal{S}})\neq\emptyset\}$ and $V_{N}(\mathcal{S})\triangleq V(\mathcal{S})\setminus V_{I}(\mathcal{S})$ and note that $V(\mathcal{S})=V_{I}(\mathcal{S})\cup V_{N}(\mathcal{S})$. We first count $|V_{I}(\mathcal{S})|$. To begin with, $|B_{I}(\mathcal{S})|\leq\binom{M}{t}t!(B_{\epsilon_{2}}(L_{M}))^{t}$, as there are $\binom{M}{t}$ ways to choose the erroneous sequences $\mathcal{F}$. For one fixed $\mathcal{F}$, there are at most $t!$ error patterns for the errors in the indices $\boldsymbol{e}_{f_{1}}^{(1)},\dots,\boldsymbol{e}_{f_{t}}^{(1)}$ that yield indexed sets, as any permutation of erroneous sequences is potentially possible. For each such choice there are again at most $(B_{\epsilon_{2}}(L_{M}))^{t}$ ways to distribute the errors in the data fields of the $t$ erroneous sequences. From each $\mathcal{S}^{\prime}\in B_{I}(\mathcal{S})$, there are again at most $|B_{I}(\mathcal{S}^{\prime})|$ ways to arrive at a valid set $\tilde{\mathcal{S}}\in\mathcal{I}_{M}^{L}$ and thus $|V_{I}(\mathcal{S})|\leq|B_{I}(\mathcal{S})|^{2}$. Next we count $|V_{N}(\mathcal{S})|$. The number of elements in the error ball is at most $|B_{N}(\mathcal{S})|\leq\binom{M}{t}B_{\epsilon_{1}}(\log M)B_{\epsilon_{2}}(L_{M})$, as this is the maximum number of error patterns. Let $\mathcal{S}^{\prime}\in B_{N}(\mathcal{S})$ and denote by $t_{N}(\mathcal{S}^{\prime})$ the number of indices that are not present in $\mathcal{S}^{\prime}$. Then the number of sets $\tilde{\mathcal{S}}\in\mathcal{I}_{M}^{L}$ with $\mathcal{S}^{\prime}\in B(\tilde{\mathcal{S}})$ is at most $(B_{\epsilon_{1}}(\log M))^{t}\binom{M}{t-t_{N}(\mathcal{S}^{\prime})}(B_{\epsilon_{2}}(L_{M}))^{t}$, as $t_{N}(\mathcal{S}^{\prime})$ sequences have to be distorted in a way such that their indices match the missing indices. And thus, there are only $B_{\epsilon_{1}}(\log M)$ options per missing index in $\mathcal{S}^{\prime}$. The remaining erroneous sequences can be chosen arbitrarily. Using $t_{N}(\mathcal{S}^{\prime})\geq 1$ for all $\mathcal{S}^{\prime}\in B_{N}(\mathcal{S})$ yields the theorem. ∎

VI Conclusion

In this paper, we have discussed codes, where each codeword is an indexed set of several vectors. The proposed construction significantly improves the redundancy $2tL$ from [11, Con. 1] to $4t\log M+2t\epsilon_{2}\log L_{M}$, and approaches the sphere-packing bound $t\log M+t\epsilon_{2}\log L_{M}$ up to a factor of $4$ and a factor of $2$ for $t=1$. Further, our results surprisingly indicate that errors within the index of sequences seem to be less harmful than errors in the data part of sequences. This is in sharp contrast to current technologies that often rely on extra codes, which only protect the index of sequences in order to guarantee correct ordering of sequences.