Clustering-Correcting Codes

TL;DR

This paper introduces clustering-correcting codes designed for DNA storage systems, enabling accurate strand clustering despite index errors, with theoretical bounds and a minimal redundancy construction.

Contribution

It proposes a novel coding scheme that links index similarity to data dissimilarity, improving error resilience in unordered DNA data storage.

Findings

Established bounds on code size for clustering-correcting codes

Provided an explicit construction with only one bit of redundancy

Demonstrated effectiveness in error-prone clustering scenarios

Abstract

A new family of codes, called clustering-correcting codes, is presented in this paper. This family of codes is motivated by the special structure of data that is stored in DNA-based storage systems. The data stored in these systems has the form of unordered sequences, also called strands, and every strand is synthesized thousands to millions of times, where some of these copies are read back during sequencing. Due to the unordered structure of the strands, an important task in the decoding process is to place them in their correct order. This is usually accomplished by allocating a part of the strand for an index. However, in the presence of errors in the index field, important information on the order of the strands may be lost. Clustering-correcting codes ensure that if the distance between the index fields of two strands is small, then there will be a large distance between their data fields. It is shown how this property enables to place the strands together in their correct clusters even in the presence of errors. We present lower and upper bounds on the size of clustering-correcting codes and an explicit construction of these codes which uses only a single bit of redundancy.

Equations

$${\mathcal{X}}_{M,L}=\{\{({\mathsf{ind}}_0,{\mathbf{u}}_0),\dots ,({\mathsf{ind}}_{M-1},{\mathbf{u}}_{M-1})\}|{\mathbf{u}}_j\in \{0,1{\}}^{L-\log (M)}\}.$$

$$r=M{L}_M-\log |\mathcal{C}|.\text{vspace}-1ex$$

$$A_{M,L}(e,t)⩾2^{M{L}_M}{\left(1-\frac{B_1{B}_2}{2^{L_M}}\right)}^{M-D}\text{vspace}-1ex$$

$$r_{M,L}(e,t)⩽\frac{\mathsf{le}\cdot (M-D)B_1{B}_2}{2^{L_M}-B_1{B}_2},$$

$$2^{L_M}-(B_{\log (M)}(e)-1)\cdot B_{L_M}(t-1)=2^{L_M}-B_1{B}_2$$

$$A_{M,L}(e,t)⩾2^{M{L}_M}{\left(1-\frac{B_1{B}_2}{2^{L_M}}\right)}^{M-D}.\text{vspace}-1ex$$

$$r_{M,L}(e,t)⩽\frac{\mathsf{le}\cdot (M-D)B_1{B}_2}{2^{L_M}-B_1{B}_2},$$

$$r_{M,L}(1,t)⩽\frac{\mathsf{le}\cdot M\log (M)B_2}{2^{L_M+1}-2\log (M)B_2}.$$

$$L_M\mathcal{H}\left(\frac{t-1}{L_M}\right)$$

$$⩽L_M+1-\log (\mathsf{le}\cdot M+2)-\log \log (M).$$

$$A_{M,L}(e,t)⩽2^{M{L}_M}{\left(1-\frac{B_2}{2^{L_M}}\right)}^{M-1},\text{vspace}-1ex$$

$$A_{M,L}(1,t)⩽2^{M{L}_M}{\left(1-\frac{\log (M)B_2}{2^{L_M}}\right)}^{M/2}(1+\delta ),$$

$$r_{M,L}(1,t)⩾\frac{M\log (M)B_2}{2^{L_M+1}-2\log (M)B_2}-\log (1+\delta ).$$

$${\mathcal{S}}_{\text{even}}=({\mathbf{u}}_i{)}_{i:w_H({\mathsf{ind}}_i)\text{ is even}}\in (\{0,1{\}}^{L_M}{)}^{M/2}\triangleq {\Sigma }_{M,L}$$

$${\mathcal{C}}_{\mathbf{v}}=\{\mathcal{S}\in \mathcal{C}|{\mathcal{S}}_{\text{even}}=\mathbf{v}\},\text{vspace}-1ex$$

$$X_{\text{bad}}$$

$$2^{L_M}-\log (M)\cdot B_2$$

$$|\mathcal{C}|$$

$$⩽X_{\text{good}}{\left(2^{L_M}-\log (M)B_2\right)}^{\frac{M}{2}}+X_{\text{bad}}{\left(2^{L_M}\right)}^{\frac{M}{2}}$$

$$⩽2^{\frac{M{L}_M}{2}}{\left(2^{L_M}-\log (M)B_2\right)}^{\frac{M}{2}}+X_{\text{bad}}{2}^{\frac{M{L}_M}{2}}$$

$$⩽2^{M{L}_M}{\left(1-\frac{\log (M)B_2}{2^{L_M}}\right)}^{\frac{M}{2}}+\frac{M(\log (M){)}^2{B}_3{2}^{M{L}_M}}{2^{L_M}}$$

$$=2^{M{L}_M}{\left(1-\frac{\log (M)B_2}{2^{L_M}}\right)}^{\frac{M}{2}}\left(1+\frac{M(\log (M){)}^2{B}_3}{2^{L_M}\cdot {\left(1-\frac{\log (M)\cdot B_2}{2^{L_M}}\right)}^{\frac{M}{2}}}\right).$$

$${\left(1-\frac{\log (M)B_2}{2^{L_M}}\right)}^{\frac{M}{2}}⩾2^{-\frac{\mathsf{le}\cdot \log (M)B_2(M/2)}{2^{L_M}-\log (M)B_2}}.$$

$$\underset{L_M\to \infty }{\lim }\frac{\mathsf{le}\cdot \log (M)B_2(M/2)}{2^{L_M}-\log (M)B_2}⩽\underset{L_M\to \infty }{\lim }\frac{\mathsf{le}\cdot \log (M)2^{L_M\mathcal{H}\left(\frac{t-1}{L_M}\right)}{2}^{\beta L-1}}{2^{L_M}-\log (M)2^{L_M\mathcal{H}\left(\frac{t-1}{L_M}\right)}}$$

$$=\underset{L_M\to \infty }{\lim }\frac{\mathsf{le}\cdot \log (M)2^{L_M\mathcal{H}\left(\frac{t-1}{L_M}\right)}{2}^{\beta L-1}}{2^{L_M}}=0,$$

$$\underset{L_M\to \infty }{\lim }\frac{M(\log (M){)}^2{B}_3}{2^{L_M}}⩽\underset{L_M\to \infty }{\lim }\frac{M(\log (M){)}^2{2}^{L_M\mathcal{H}\left(\frac{2(t-1)}{L_M}\right)}}{2^{L_M}}$$

$$=\underset{L\to \infty }{\lim }\frac{2^{\beta L}(\beta L{)}^2{2}^{(1-2\beta -{ϵ}^{\prime })L}}{2^{(1-\beta )L}}=\underset{L\to \infty }{\lim }\frac{(\beta L{)}^2}{2^{{ϵ}^{\prime }L}}=0,$$

$$\ell +\log \log (M)+(t-1)\log (L_M)+1⩽L_M-\log (M).\text{vspace}-1ex$$

$$L-2\log (M)⩾\ell +\log (B_{\log (M)}(e)\cdot B_{L_M}(t-1))+1.$$

$$2^{\ell }>|S_{[\log (M),\ell ]}|\cdot B_{\ell }(t-1).$$

$$\ell (e,t,M)⩽et\cdot \log \log (M).$$

$$\ell +\log (B_{\log (M)}(e)\cdot B_{L_M}(t-1))+1⩽L_M-\log (M).$$

$$et\cdot \log \log (M)+\log ((\log (M){)}^e\cdot {L_M}^{t-1})⩽L_M-\log (M),$$

$$t(\log (L_M)+e\log \log (M))⩽L_M-\log (M)-e\log \log (M)+\log (L_M).\text{vspace}-1ex$$

Full text

Clustering-correcting codes ensure that if the distance between the index fields of two strands is small, then there will be a large distance between their data fields. It is shown how this property enables to place the strands together in their correct clusters even in the presence of errors. We present lower and upper bounds on the size of clustering-correcting codes and an explicit construction of these codes which uses only a single bit of redundancy.

I Introduction

Progress in synthesis and sequencing technologies have paved the way for the development of a non-volatile data storage based on DNA molecules. The first large-scale experiments that demonstrated the potential of in vitro DNA storage were reported by Church et al. who recovered 643 KB of data [5] and Goldman et al. who accomplished the same task for a 739 KB message [9]. However, in both of these works the data was not recovered successfully due to the lack of using the appropriate coding solutions to correct errors. Since then, several more groups have demonstrated the ability to successfully store data of large scale using DNA molecules; see e.g. [3, 2, 6, 14, 19]. Other works developed coding solutions which are specifically targeted to correct the special types of errors inside DNA-based storage systems [11, 12, 15, 19, 13, 17, 18].

A DNA storage system consists of three steps. First, the strands containing the encoded data are synthesized. They are then stored inside a storage container, and finally a DNA sequencer reads back the strands. The encoding and decoding are two external processes to the system that convert the data to DNA strands and back. The structure of a DNA storage system is different from all other existing storage systems. Since the strands are stored unordered, it is unclear what part of the data each strand represents, even if no error occurred. For more details we refer the reader to [10, 12] and referencers therein.

Storing DNA strands in a way that will allow to reconstruct them back in the right order is an important task. The common solution to address this problem is to use indices, that are stored as part of the strand. Each strand is prefixed with some nucleotides that indicate the strand’s location, with respect to all other strands. Although using indices is a simple solution it has several drawbacks. One of them is that in case of an error within the index, important information on the strand’s location is lost as well as the ability to place it in the correct position between the other strands. In this paper a new coding scheme, called clustering-correcting codes, is presented which enables to combat errors with minimal redundancy.

In DNA storage systems, every strand is synthesized thousands of times (or even millions) and thus more than a single copy of each strand is read back upon sequencing. Thus, the first task based upon the sequencer’s input is to partition all the reads into clusters such that all read strands at each cluster are copies of the same information strand. A possible solution is to use the indices in order to identify the strands and cluster them together, but in the presence of errors, this may result with mis-clustered strands which can cause errors in the recovered data. Hence, finding codes and algorithms for the clustering process is an important challenge. A naive solution is to add redundancy to the index part in order to correct potential errors in the index [4]. However, this will incur an unavoidable reduction in the storage rate of the DNA storage system. We will show in this paper how clustering-correcting codes can enable one to cluster all strands in the right clusters even with the presence of errors in the indices (see Fig. 1), while the redundancy is minimized. In fact, for a large range of parameters this can be done with only a single bit of redundancy for all the strands together.

The rest of the paper is organized as follows. In Section II, the family of clustering-correcting codes is presented as well as other useful definitions that will be used throughout the paper. In Section III, we present explicit and asymptotic lower and upper bounds on the size of clustering-correcting codes. In Section IV, we present an explicit construction of these codes which uses only a single bit of redundancy. Due to the lack of space, some of the proofs are omitted in the paper.

II Definitions and Preliminaries

For a positive integer $n$, the set $\{0,1,\ldots,n-1\}$ is denoted by $[n]$. For two vectors ${\boldsymbol{x}},{\boldsymbol{y}}\in\{0,1\}^{n}$ of the same length, we denote the $i$-th symbol of ${\boldsymbol{x}}$ by $x_{i}$. The subvector of ${\boldsymbol{x}}$ starting at the $i$-th index of length $\ell$ is denoted by ${\boldsymbol{x}}_{[i,\ell]}$. The Hamming distance between ${\boldsymbol{x}}$ and ${\boldsymbol{y}}$ is denoted by $d_{H}({\boldsymbol{x}},{\boldsymbol{y}})$ and the Hamming weight of ${\boldsymbol{x}}$ is $w_{H}({\boldsymbol{x}})$. The radius-$r$ ball of a vector ${\boldsymbol{x}}\in\{0,1\}^{n}$ is $B_{r}({\boldsymbol{x}})=\{{\boldsymbol{y}}\ |d_{H}({\boldsymbol{x}},{\boldsymbol{y}})\leqslant r\}$ and its size is denoted by $B_{n}(r)\triangleq\sum_{i=0}^{r}\binom{n}{i}$. The function ${\cal H}(x)$ for $0\leqslant x\leqslant 1$ denotes the binary entropy function, and the inverse function ${\cal H}^{-1}(x)$ for $0\leqslant x\leqslant 1$ is defined to return values between 0 and 1/2. We study here the binary case while extensions to the non-binary case are straightforward.

Assume $M$ strands are stored in a DNA-based storage system where the size of every strand is $L$. We will assume that $M=2^{\beta L}$ for some $0<\beta<1$ and for simplicity, it is assumed that $M$ is a power of $2$. For any integer $i\in[M]$, its binary representation of length $\log(M)$ is denoted by $\mathsf{ind}_{i}$. Every length-$L$ strand $s$ that will be stored in the system is of the form $s=(\mathsf{ind},{\boldsymbol{u}})$, where $\mathsf{ind}$ is the length-$\log(M)$ index field of the strand (the binary representation of a number between [math] and $M-1$) and ${\boldsymbol{u}}$ is the data field of $L-\log(M)$ bits that are used to store the information or the redundancy of an error-correcting code. Every stored message will have $M$ strands of this form and the space of all possible messages that can be stored in the DNA storage system is

[TABLE]

Clearly, $|\mathcal{X}_{M,L}|=2^{M(L-\log(M))}$. Under this setup, a code $\mathcal{C}$ will be a subset of $\mathcal{X}_{M,L}$, where each codeword $\mathcal{S}$ of $\mathcal{C}$ is a subset of the form $\mathcal{S}=\{(\mathsf{ind}_{0},{\boldsymbol{u}}_{0}),\ldots,(\mathsf{ind}_{M-1},{\boldsymbol{u}}_{M-1})\}$. For shorthand, the term $L-\log(M)$ will be abbreviated by ${L_{M}}$.

When a set $\mathcal{S}=\{(\mathsf{ind}_{0},{\boldsymbol{u}}_{0}),\ldots,(\mathsf{ind}_{M-1},{\boldsymbol{u}}_{M-1})\}$ is synthesized, each of its strands $(\mathsf{ind}_{i},{\boldsymbol{u}}_{i})$, which are called the input strands, has thousands to millions of copies and during the sequencing process a subset of these copies is read. Hence, the sequencer’s output is another set $G$ of some $N$ strands, called the output strands, where $N$ is significantly larger than $M$. Each output strand in the set $G$ is a copy of one of the input strands in $\mathcal{S}$, however with some potential errors. A DNA-based storage system is called a $(\tau,\rho)$-DNA system if it satisfies the following property: If the output strand $(\mathsf{ind}^{\prime},{\boldsymbol{u}}^{\prime})\in G$ is a noisy copy of the input strand $(\mathsf{ind},{\boldsymbol{u}})\in S$, then $d_{H}(\mathsf{ind},\mathsf{ind}^{\prime})\leqslant\tau$ and $d_{H}({\boldsymbol{u}},{\boldsymbol{u}}^{\prime})\leqslant\rho$. That is, the index field has at most $\tau$ Hamming errors while the data field has at most $\rho$ Hamming errors. We consider in this work only substitution errors while extensions for deletions, insertions, and more generally the edit distance will be analyzed in the full version of the paper.

Since the set $G$ contains several noisy copies of each input strand in $\mathcal{S}$, the first task in the decoding process is to partition the set of all $N$ output strands into $M$ cluster sets, such that the output strands in every cluster are noisy copies of the same input strand. Since every strand contains an index, the simplest way to operate this task is by partitioning the output strands into $M$ sets based upon the index field in every output strand. This process will indeed be successful if there are no errors in the index field of every output strand, however other solutions are necessary since the error rates in DNA storage systems are not negligible [10]. Another approach to cluster the strands is based upon the distances between every pair of output strands, as was studied in [15]. However, this approach suffers extremely high computational complexity.

In this work, we take a hybrid solution of these two approaches. First, we cluster the output strands based on the indices in the output strands. Then, we scan for output strands which were mis-clustered, that is, were placed in the wrong cluster. This is accomplished by checking the distances between the output strands in every cluster in order to either remove output strands that were incorrectly placed in a cluster due to errors in their index or move them to their correct cluster set. Since we compute the distances only between pairs of strands that were placed in the same cluster (and not between all pairs of strands), this step will result in a significantly lower complexity compared to the solution from [15]. However, in order to succeed in this new approach we need the strands stored in the set $\mathcal{S}$ to satisfy several constraints. These constraints will be met by the family of clustering-correcting codes which are presented in this paper. Another assumption taken in this model, which will be referred to as the majority assumption, assumes that in every cluster the majority of the strands have the correct index. Since the number of strands is very large this assumption holds with high probably if not in all cases.

The main idea to move strands which were misplaced in a cluster due to errors in their index field works as follows. Assume the strand $s_{i}=(\mathsf{ind}_{i},{\boldsymbol{u}}_{i})$ has a noisy copy of the form $s_{i}^{\prime}=(\mathsf{ind}^{\prime}_{i},{\boldsymbol{u}}^{\prime}_{i})$, and let $j$ be such that $s_{j}=(\mathsf{ind}_{j},{\boldsymbol{u}}_{j})$ and $\mathsf{ind}_{j}=\mathsf{ind}^{\prime}_{i}$. We need to make sure that the distance between ${\boldsymbol{u}}^{\prime}_{i}$ and ${\boldsymbol{u}}_{j}$ is large enough as this will allow to identify that the output strand $s_{i}^{\prime}$ is erroneous and therefore does not belong to the cluster of index $\mathsf{ind}_{j}$; see Fig. 1. We will be interested in either identifying that the output strand $s_{i}^{\prime}$ does not belong to this cluster or more than that, place it in its correct cluster. This motivates us to study the following family of codes.

Definition** 1**

. A word $\mathcal{S}=\{(\mathsf{ind}_{0},{\boldsymbol{u}}_{0}),\ldots,(\mathsf{ind}_{M-1},{\boldsymbol{u}}_{M-1})\}\in\mathcal{X}_{M,L}$ is said to satisfy the $(e,t)$-clustering constraint if for all $(\mathsf{ind}_{i},{\boldsymbol{u}}_{i}),(\mathsf{ind}_{j},{\boldsymbol{u}}_{j})\in\mathcal{S}$ in which $i\neq j$ and $d_{H}(\mathsf{ind}_{i},\mathsf{ind}_{j})\leqslant e$, it holds that $d_{H}({\boldsymbol{u}}_{i},{\boldsymbol{u}}_{j})\geqslant t$.

A code $\mathcal{C}\subseteq\mathcal{X}_{M,L}$ will be called an $(e,t)$-clustering-correcting code (CCC) if every $\mathcal{S}\in{\cal C}$ satisfies the $(e,t)$-clustering constraint.

The redundancy of a code $\mathcal{C}\subseteq\mathcal{X}_{M,L}$ will be defined by

[TABLE]

Our goal in this work is to find $(e,t)$-CCCs for all $e$ and $t$. We denote by $A_{M,L}(e,t)$ the size of the largest $(e,t)$-CCC in $\mathcal{X}_{M,L}$, and by $r_{M,L}(e,t)$ the optimal redundancy of an $(e,t)$-CCC, so $r_{M,L}(e,t)=M{L_{M}}-\log(A_{M,L}(e,t)).$

The clustering-correcting capabilities of CCCs are proved in the next theorem. We note that as a result of this theorem, if the number of errors is not too large, it is already possible to place every output strand in its correct cluster.

Theorem** 2**

. For fixed integers $M,L,e,t$, let ${\cal C}$ be an $(e,t)$-CCC. Assume that a set $\mathcal{S}\in{\cal C}$ is stored in a $(\tau,\rho)$-DNA system. The following properties hold:

If $\tau\leqslant e$ and $4\rho<t$ then every output strand can be detected to be placed in a wrong cluster. 2. 2.

If $\tau\leqslant e/2$ and $4\rho<t$ then every output strand can be placed in its correct cluster.

Proof:

We prove only the first statement while the proof of second one is similar. Let $(\mathsf{ind}_{i}^{\prime},{\boldsymbol{u}}_{i}^{\prime})$ be a noisy copy of the strand $(\mathsf{ind}_{i},{\boldsymbol{u}}_{i})$. Since the data is stored in a $(\tau,\rho)$-DNA system, it holds that $d_{H}(\mathsf{ind}_{i},\mathsf{ind}_{i}^{\prime})\leqslant\tau$, and therefore $d_{H}(\mathsf{ind}_{i},\mathsf{ind}_{i}^{\prime})\leqslant e$. Also $d_{H}({\boldsymbol{u}}_{i},{\boldsymbol{u}}_{i}^{\prime})\leqslant\rho$. Let $j\in[M]$ be such that $\mathsf{ind}_{j}=\mathsf{ind}_{i}^{\prime}$. From the fact that $S\in{\cal C}$ we derive that $d_{H}({\boldsymbol{u}}_{i},{\boldsymbol{u}}_{j})\geqslant t>4\rho$, and thus $d_{H}({\boldsymbol{u}}_{j},{\boldsymbol{u}}_{i}^{\prime})\geqslant d_{H}({\boldsymbol{u}}_{i},{\boldsymbol{u}}_{j})-d_{H}({\boldsymbol{u}}_{i},{\boldsymbol{u}}_{i}^{\prime})>3\rho.$ Let $(\mathsf{ind}_{j},{\boldsymbol{u}}_{j}^{\prime})$ be a noisy copy strand of $(\mathsf{ind}_{j},{\boldsymbol{u}}_{j})$, that is, errors might occur in the data field but not in the index field. So, $d_{H}({\boldsymbol{u}}_{j},{\boldsymbol{u}}_{j}^{\prime})\leqslant\rho$ which yields that $d_{H}({\boldsymbol{u}}_{i}^{\prime},{\boldsymbol{u}}_{j}^{\prime})>2\rho$. On the other hand, the distance between the data fields of the two strands that belong to the same cluster is at most $2\rho$. That is, under the majority assumption, a mis-clustered strand will have a distance of more than $2\rho$ from the majority of the strands in the cluster, and so it can be dropped instead of being mis-clustered.

∎

III Bounds

Upper and lower bounds on $A_{M,L}(e,t)$ are presented. Let $D_{n}(d)$ be the size of the largest $\textmd{length-}n$ error-correcting code $C\subseteq\{0,1\}^{n}$ and minimum Hamming distance $d$. For the rest of the paper, let $B_{1}=B_{\log(M)}(e)-1,B_{2}=B_{{L_{M}}}(t-1)$, ${\mathsf{le}}=\log(\exp(1))\approx 1.44$, and it is also assumed that $\beta<1/2$.

Theorem** 3**

. For all $M,L,e,$ and $t$ it holds that

[TABLE]

and hence

[TABLE]

where $D=D_{\log(M)}(e+1)$.

Proof:

In order to verify the lower bound, we construct an $(e,t)$-CCC ${\cal C}$ that will yield a lower bound on $A_{M,L}(e,t)$. Let $C_{1}\subseteq\{0,1\}^{\log(M)}$ be a length-$\log(M)$ code with minimum Hamming distance $e+1$ of size $D$. Each codeword $\mathcal{S}=\{(\mathsf{ind}_{0},{\boldsymbol{u}}_{0}),\ldots,(\mathsf{ind}_{M-1},{\boldsymbol{u}}_{M-1})\}\in{\cal C}$ is constructed in two steps. First, we choose the data field of strands with indices that belong to the code $C_{1}$, that is, all strands of the form $(\mathsf{ind},{\boldsymbol{u}})$ such that $\mathsf{ind}\in C_{1}$. There are $2^{{L_{M}}}$ options for each strand and thus $(2^{{L_{M}}})^{D}$ options for the first step. Since the Hamming distance between all pairs of indices of these strands is at least $e+1$, their data fields can be chosen independently.

For the rest of the strands we assume the worst case. That is, for each strand left, all of its neighbors are chosen and their radius-$(t-1)$ balls are mutually disjoint. Thus, there are at least

[TABLE]

options to choose the data field of each remaining strand. In conclusion, there are $2^{{L_{M}}D}\left(2^{{L_{M}}}-B_{1}B_{2}\right)^{M-D}$ options for choosing a valid set $\mathcal{S}\in{\cal C}$, and hence

[TABLE]

We can also deduce an upper bound on the redundancy

[TABLE]

where here the inequality $-\log(1-x)\leqslant{\mathsf{le}}\cdot\frac{x}{1-x}$ for all $0<x<1$ is used. ∎

The next corollary follows directly from Theorem 3.

Corollary** 4**

. If $t\leqslant{L_{M}}{\cal H}^{-1}\left(\frac{1-2\beta}{1-\beta}-\frac{\log(\beta L)}{(1-\beta)L}\right)$ then $r_{M,L}(1,t)\leqslant 1$.

Proof:

For $e=1$, $D_{\log(M)}(2)=M/2$. This is achieved by selecting all indices $\mathsf{ind}_{i}$ such that $w_{H}(\mathsf{ind}_{i})$ is even (or odd). Hence, from Theorem 3 it holds that

[TABLE]

Hence, $r_{M,L}(1,t)\leqslant 1$ if $B_{2}\leqslant\frac{2^{{L_{M}}+1}}{\log(M)({\mathsf{le}}\cdot M+2)}.$ According to Lemma 4.7 in [16], $B_{2}\leqslant 2^{{L_{M}}{\cal H}\left(\frac{t-1}{{L_{M}}}\right)}$ and hence it is enough to require that $2^{{L_{M}}{\cal H}\left(\frac{t-1}{{L_{M}}}\right)}\leqslant\frac{2^{{L_{M}}+1}}{\log(M)({\mathsf{le}}\cdot M+2)},$ i.e.,

[TABLE]

For $M=2^{\beta L}$, this holds for all $t\leqslant{L_{M}}{\cal H}^{-1}\left(\frac{1-2\beta}{1-\beta}-\frac{\log(\beta L)}{(1-\beta)L}\right)$. ∎

A similar upper bound on $A_{M,L}(e,t)$ is presented next.

Theorem** 5**

. For all $M,L,e$ and $t$ it holds that

[TABLE]

and therefore $r_{M,L}(e,t)\geqslant\frac{{\mathsf{le}}\cdot(M-1)\cdot B_{2}}{2^{{L_{M}}}}.$ Furthermore, if ${t\geqslant{L_{M}}\cdot{\cal H}^{-1}\left(\frac{1-2\beta}{1-\beta}+\frac{\log({L_{M}})}{{L_{M}}}\right)+1}$ then $r_{M,L}(1,t)\geqslant 1$.

From Corollary 4 and Theorem 5 we get that for ${L_{M}}$ large enough and $t\approx{L_{M}}\cdot{\cal H}^{-1}\left(\frac{1-2\beta}{1-\beta}\right)$, we get that $r_{M,L}(1,t)\approx 1$. An asymptotic improvement to the upper bound from Theorem 5 for $e=1$ which matches the lower bound from Theorem 3 is proved in the next theorem.

Theorem** 6**

. For ${L_{M}}$ large enough, if $\frac{t}{{L_{M}}}<\frac{1}{2}{\cal H}^{-1}\left(\frac{1-2\beta}{1-\beta}\right)-\epsilon$, for some fixed $\epsilon>0$, then it holds that

[TABLE]

for $\delta$ small enough, and hence

[TABLE]

Proof:

Let ${\cal C}$ be a $(1,t)$-CCC of maximal size $A_{M,L}(1,t)$. For every set $\mathcal{S}=\{(\mathsf{ind}_{0},{\boldsymbol{u}}_{0}),\ldots,(\mathsf{ind}_{M-1},{\boldsymbol{u}}_{M-1})\}\in{\cal C}$, let

[TABLE]

be the vector projection of $\mathcal{S}$ to the data fields of the strands with indices of even weight and let $I_{\textmd{even}}\triangleq\{i\ |\ w_{H}(\mathsf{ind}_{i})\textmd{ is even}\}$.

The sets of the strands in the code ${\cal C}$ are partitioned according to their projection on the indices with even weight. More specifically, for every ${\boldsymbol{v}}\in{\Sigma_{M,L}}$, let ${\cal C}_{{\boldsymbol{v}}}$ be the subcode of ${\cal C}$,

[TABLE]

so it holds that ${\cal C}=\bigcup_{{\boldsymbol{v}}\in{\Sigma_{M,L}}}{\cal C}_{{\boldsymbol{v}}}$.

A vector ${\boldsymbol{v}}=({\boldsymbol{v}}_{i})_{i\in I_{\textmd{even}}}\in{\Sigma_{M,L}}$ is good if for all $i,j\in I_{\textmd{even}}$ such that $d_{H}(\mathsf{ind}_{i},\mathsf{ind}_{j})=2$ it holds that $B_{t-1}({\boldsymbol{v}}_{i})\cap B_{t-1}({\boldsymbol{v}}_{j})=\emptyset$, and otherwise it is bad. Denote by $X_{\textmd{good}},X_{\textmd{bad}}$ the number of good, bad vectors in ${\Sigma_{M,L}}$, respectively. If a vector ${\boldsymbol{v}}\in{\Sigma_{M,L}}$ is bad, then there are at least two indices $i,j\in I_{\textmd{even}}$ such that $d_{H}(\mathsf{ind}_{i},\mathsf{ind}_{j})=2$ and $B_{t-1}({\boldsymbol{v}}_{i})\cap B_{t-1}({\boldsymbol{v}}_{j})\neq\emptyset$, i.e., $d_{H}({\boldsymbol{v}}_{i},{\boldsymbol{v}}_{j})\leqslant 2t-2$. Hence, we get that

[TABLE]

where $B_{3}=B_{{L_{M}}}(2t-2)$.

Consider the size of ${\cal C}_{{\boldsymbol{v}}}$ when ${\boldsymbol{v}}$ is good. For every $\mathcal{S}\in{\cal C}_{{\boldsymbol{v}}}$, we only need to assign the data fields for strands of odd weight index. Since ${\boldsymbol{v}}$ is a good vector, for every index of odd weight, the radius-$(t-1)$ balls of all of its neighbor strands are mutually disjoint so there are exactly

[TABLE]

options to choose the data field of the $i$-th strand. For every bad vector ${\boldsymbol{v}}\in{\Sigma_{M,L}}$, it is enough to take the loose bound in which $|{\cal C}_{{\boldsymbol{v}}}|\leqslant\left(2^{{L_{M}}}\right)^{\frac{M}{2}}$. In conclusion we get that

[TABLE]

According to $-\log(1-x)\leqslant{\mathsf{le}}\cdot\frac{x}{1-x}$ for all $0<x<1$ we get

[TABLE]

We use again the inequality $B_{2}\leqslant 2^{{L_{M}}{\cal H}\left(\frac{t-1}{{L_{M}}}\right)}$ and $B_{3}\leqslant 2^{{L_{M}}{\cal H}\left(\frac{2(t-1)}{{L_{M}}}\right)}$, while for $\frac{t}{{L_{M}}}<\frac{1}{2}{\cal H}^{-1}\left(\frac{1-2\beta}{1-\beta}\right)-\epsilon$ it holds

[TABLE]

and

[TABLE]

for some $\epsilon^{\prime}>0$. Thus, $\lim_{L\rightarrow\infty}\frac{ML^{2t}}{2^{{L_{M}}}\cdot\left(1-\frac{\log(M)\cdot B_{2}}{2^{{L_{M}}}}\right)^{\frac{M}{2}}}=0,$ which confirms the theorem’s statements.

∎

IV A Construction of CCCs

In this section we propose a construction of CCCs. It is shown that with a single bit of redundancy it is possible to construct CCCs for relatively large values of $t$.

The algorithm will use the following functions:

• •

The function $w_{\ell}(S,t)$ is defined over a set of vectors $S$ and a positive integer $t$ and outputs a vector ${\boldsymbol{w}}\in\{0,1\}^{\ell}$ which satisfies the following condition. For all ${\boldsymbol{v}}\in S$, $d_{H}({\boldsymbol{w}},{\boldsymbol{v}}_{[\log(M),\ell]})\geqslant t$. The value of $\ell$ will be determined later as a function of $e$, $t$, and $M$.

• •

The function $\Delta_{1}(\mathsf{ind}_{i},\mathsf{ind}_{j})$ encodes the difference between the two indices $i$ and $j$ of Hamming distance at most $e$ using $e\lceil\log(\log(M))\rceil$ bits which mark the positions where the indices $\mathsf{ind}_{i},\mathsf{ind}_{j}$ differ.

• •

The function $\Delta_{2}({\boldsymbol{u}}_{i},{\boldsymbol{u}}_{j})$ encodes the difference between the two data fields ${\boldsymbol{u}}_{i},{\boldsymbol{u}}_{j}\in\{0,1\}^{L_{M}}$ of Hamming distance at most $t-1$ using $(t-1)\log({L_{M}})$ bits which mark the positions where they differ.

The input to the algorithm is $M$ vectors ${\boldsymbol{v}}_{0},\ldots,{\boldsymbol{v}}_{M-1}$. All vectors are of length ${L_{M}}$ bits, except for ${\boldsymbol{v}}_{M-1}$ which has length of ${L_{M}}-1$ bits. The idea behind the presented algorithm is to find all pairs of vectors that do not satisfy the clustering constraint, and correct them in a way that they satisfy the constraint and yet the original data can be uniquely recovered. A bit is added to ${\boldsymbol{v}}_{M-1}$, hence, the code has a single bit of redundancy, to mark whether some vectors were altered by the algorithm.

For $i\in[M]$, the notation $S(e,i)$ in the algorithm will be used as a shortcut to the set $\{{\boldsymbol{u}}_{j}\ |\ d_{H}(\mathsf{ind}_{i},\mathsf{ind}_{j})\leqslant e\}$ of data fields corresponding to indices $\mathsf{ind}_{j}$ of Hamming distance at most $e$ from $\mathsf{ind}_{i}$. At any iteration of the while loop, when the $i$-th strand is corrected, the function $w_{\ell}(S(e,i),t)$ will be used to update the data field ${\boldsymbol{u}}_{i}$ such that it does not violate the constraint and yet can be decoded. In order to make room for the vector generated by the function $w_{\ell}(S(e,i),t)$, we will encode ${\boldsymbol{u}}_{i}$ based on its similarity to one of its close neighbors ${\boldsymbol{u}}_{j}$. These modifications are encoded together as a repelling vector of length $len=\ell+\log\log(M)+(t-1)\log({L_{M}})$, when $e=1$.

Theorem** 7**

. For any input vectors ${\boldsymbol{v}}_{0}\ldots,{\boldsymbol{v}}_{M-1}$ , Algorithm 1 returns a valid $(1,t)$-CCC codeword for any $t$ that satisfies:

[TABLE]

Furthermore, it is possible to decode the vectors ${\boldsymbol{v}}_{0}\ldots,{\boldsymbol{v}}_{M-1}$.

Proof:

After the initializing steps, in Step 5 the algorithm gathers the indices of all pairs of strands that both their index and data fields are too close to each other, hence, violating the constraint. The algorithm iterates over the set $B$, handling one pair at a time. In Step 12, this set is updated and the algorithm stops when the set $B$ is empty, i.e., there are no bad pairs and so $\{(\mathsf{ind}_{0},{\boldsymbol{u}}_{0}),\ldots,(\mathsf{ind}_{M-1},{\boldsymbol{u}}_{M-1})\}$ satisfies the constraint.

On each iteration of the while loop, the algorithm takes a pair of strands, say of indices $i$ and $j$, where $i<j$, which violates the constraint and changes the data field in the $i$-th strand. First, the flag at the end of the previous strand is changed to $1$ (Step 7). This denotes that it is not the last strand in the decoding chain. In Step 10, the algorithm calculates the vector ${\boldsymbol{w}}=w_{\ell}(S(1,i),t)$ and embeds it in the data field of the ${i\textmd{-th}}$ strand. The vector ${\boldsymbol{w}}$ satisfies that for all ${\boldsymbol{u}}\in S(1,i)$, $d_{H}({\boldsymbol{w}},{\boldsymbol{u}}_{[\log(M),\ell]})\geqslant t$. Then, for all ${\boldsymbol{u}}\in S(1,i)$ we have that $d_{H}(({{\boldsymbol{u}}_{i}})_{[\log(M),\ell]},{\boldsymbol{u}}_{[\log(M),\ell]})\geqslant t$ and lastly for all ${\boldsymbol{u}}\in S(1,i)$, $d_{H}({\boldsymbol{u}}_{i},{\boldsymbol{u}})\geqslant t$. Therefore the $i$-th and the $j$-th strands satisfy the constraint and thus do not belong to the set $B$ when it is updated in Step 12. In fact any bad pair of indices which includes the $i$-th strand will be removed as well from the set $B$. Furthermore, since the $i$-th strand has been updated in such a way that it satisfies the constraint with respect to all of its neighbors, and the $p$-th strand in this iteration already satisfies the constraint according to his last ${L_{M}}-\log(M)$ bits, no bad pairs have been created. That is, the size of the set $B$ decreases in each iteration, and the algorithm terminates. The constraint on $t$ guarantees that the data field is large enough in order to write the information required on each update step of the while loop.

The idea of the decoding process is to track the updates chain of the strands and then traverse the chain in the opposite direction while recovering the input vectors. ∎

Algorithm 1 can easily be extended to support larger values of $e$. In this case the constraint on $t$ is

[TABLE]

Next we discuss the function $w_{\ell}(S,t)$. This function takes a set of vectors $S$ as input, and outputs a vector ${\boldsymbol{w}}\in\{0,1\}^{\ell}$ such that for all ${\boldsymbol{v}}\in S_{[\log(M),\ell]}\triangleq\{{\boldsymbol{v}}_{[\log(M),\ell]}|{\boldsymbol{v}}\in S\}$, it holds that $d_{H}({\boldsymbol{w}},{\boldsymbol{v}})\geqslant t$. The length $\ell$ of the vector ${\boldsymbol{w}}$ is determined by the minimum value of $\ell$ for which

[TABLE]

That is, the minimum length that allows us to choose a vector that does not fall into any of the radius-$(t-1)$ balls of the vectors in the set $S_{[\log(M),\ell]}$. The size of $S_{[\log(M),\ell]}$ is at most $B_{\log(M)}(e)-1$, and we denote by $\ell(e,t,M)$ the smallest value of $\ell$ such that $2^{\ell}>(B_{\log(M)}(e)-1)\cdot B_{\ell}(t-1).$

Lemma** 8**

. For all $e,t,M$ such that $t\leqslant\frac{(\log(M))^{e}}{e\cdot\log\log(M)},$ it holds that

[TABLE]

Corollary** 9**

. For all $t\leqslant\frac{{L_{M}}-\log(M)-e\log\log(M)+\log({L_{M}})}{\log({L_{M}})+e\log\log(M)}$ there exists an explicit construction of an $(e,t)$-CCC using Algorithm 1 which uses a single bit of redundancy.

Proof:

From Lemma 8 we can use $w_{\ell}(S,t)$ in Algorithm 1 with $\ell=et\cdot\log\log(M)$. In addition, from Theorem 7 the value of $t$ should satisfy

[TABLE]

Thus, it is enough to show that

[TABLE]

while using $B_{\log(M)}(e)\leqslant(\log(M))^{e}$ and $B_{{L_{M}}}(t-1)\leqslant{L_{M}}^{t-1}$. Hence, it is enough for $t$ to satisfy

[TABLE]

∎

According to Section III, $r_{M,L}(1,t)=1$ when $t$ is approximately ${L_{M}}\cdot{\cal H}^{-1}\left(\frac{1-2\beta}{1-\beta}\right)$. However, this is not achieved by an explicit construction of such codes. Here, we presented an explicit construction for $e=1$ in which the maximum value of $t$ is roughly $\frac{{L_{M}}}{\log({L_{M}})}\frac{1-2\beta}{1-\beta}$. That is, at most only a factor of $\log({L_{M}})$ from the theoretical upper bound on $t$.