Coded trace reconstruction

TL;DR

This paper introduces coded trace reconstruction, designing high-rate codes that can be efficiently decoded from few traces with deletions, advancing DNA storage reliability with provable guarantees.

Contribution

It presents the first provably robust coded trace reconstruction methods with explicit constructions and analysis for DNA storage systems.

Findings

Codes with $O(n/\log n)$ redundancy reconstructed from exponential number of traces.

Codes with $O(\log n)$ redundancy reconstructed from polynomial number of traces under small deletion probability.

Combined approach yields efficient codes with $O(n/\log n)$ redundancy from polynomially many traces.

Abstract

Motivated by average-case trace reconstruction and coding for portable DNA-based storage systems, we initiate the study of \emph{coded trace reconstruction}, the design and analysis of high-rate efficiently encodable codes that can be efficiently decoded with high probability from few reads (also called \emph{traces}) corrupted by edit errors. Codes used in current portable DNA-based storage systems with nanopore sequencers are largely based on heuristics, and have no provable robustness or performance guarantees even for an error model with i.i.d.\ deletions and constant deletion probability. Our work is a first step towards the design of efficient codes with provable guarantees for such systems. We consider a constant rate of i.i.d.\ deletions, and perform an analysis of marker-based code-constructions. This gives rise to codes with redundancy $O(n/\log n)$ (resp.\ $O(n/\log\log n)$) that can be efficiently reconstructed from $\exp(O(\log^{2/3}n))$ (resp.\ $\exp(O(\log\log n)^{2/3})$) traces, where $n$ is the message length. Then, we give a construction of a code with $O(\log n)$ bits of redundancy that can be efficiently reconstructed from $\textrm{poly}(n)$ traces if the deletion probability is small enough. Finally, we show how to combine both approaches, giving rise to an efficient code with $O(n/\log n)$ bits of redundancy which can be reconstructed from $\textrm{poly}(\log n)$ traces for a small constant deletion probability.

Equations

$$|\mathrm{Pr}[X_{i_i}=x_1,\dots ,X_{i_k}=x_k]-2^{-k}|\le ϵ$$

$$P(i,j)=\left(\genfrac{}{}{0ex}{}{i-1}{j-1}\right)(1-d{)}^j{d}^{i-j}.$$

$$\mathrm{Pr}[V_j=1]$$

$$={ϵ}_i(x)+\sum _{r=i-v}^{i-v+0.1w}\mathrm{Pr}[R=r]\mathrm{Pr}[V_j=1|R=r]$$

$$={ϵ}_i(x)+\sum _{r=i-v}^{i-v+0.1w}\mathrm{Pr}[R=r]\sum _{\ell =r+1}^{n}P(\ell -r,j)x_{\ell }$$

$$={ϵ}_i(x)+\sum _{r=i-v}^{i-v+0.1w}\mathrm{Pr}[R=r]\sum _{\ell =r+1}^{i-1}P(\ell -r,j)x_{\ell }$$

$$\displaystyle+\sum_{r=i-v}^{i-v+0.1w}\Pr[R=r]\mathopen{}\mathclose{{}\left(P(i-r,j)x_{i}+\sum_{\ell=i+1}^{n}P(\ell-r,j)x_{\ell}}\right),$$

$$x_i=0⟹\mathrm{Pr}[V_j=1]\le {ϵ}_i(x)+\sum _{r=i-v}^{i-v+0.1w}\mathrm{Pr}[R=r]\sum _{\ell =r+1}^{i-1}P(\ell -r,j)x_{\ell }+\frac{1}{2}\sum _{r=i-v}^{i-v+0.1w}\mathrm{Pr}[R=r]P(i-r,j)$$

$$x_i=1⟹\mathrm{Pr}[V_j=1]\ge {ϵ}_i(x)+\sum _{r=i-v}^{i-v+0.1w}\mathrm{Pr}[R=r]\sum _{\ell =r+1}^{i-1}P(\ell -r,j)x_{\ell }+\sum _{r=i-v}^{i-v+0.1w}\mathrm{Pr}[R=r]P(i-r,j).$$

$$x=x^{(1)}||x^{(2)}||\cdots ||x^{(n/{\log }^{2}n)};$$

$$\mathsf{Enc}(x)=1^{\ell }||{\overline{x}}^{(1)}||M||{\overline{x}}^{(2)}||M||\cdots ||M||{\overline{x}}^{(n/{\log }^{2}n)}||0^{\ell }.$$

$$|\mathsf{Enc}(x)|\leq\frac{n}{\log^{2}n}(|M|+|\overline{x}^{(1)}|)=n+O\mathopen{}\mathclose{{}\left(\frac{n}{\log n}}\right)+\frac{nr}{\log^{2}n}.$$

$$\mathrm{Pr}[L_0>10\log n,L_1>0]\ge 1-n^{-3}.$$

$$\Pr[L_{0}\leq 10\log n]=\Pr[L_{0}\leq\mathds{E}[L_{0}]-15\log n]\leq\exp\mathopen{}\mathclose{{}\left(-\frac{15^{2}\log^{2}n}{2\mathds{E}[L_{0}]}}\right)\geq n^{-4}.$$

$$\mathrm{Pr}[E_{\mathsf{all}}]\ge 1-t/n^2>1-1/n.$$

$$\mathrm{Pr}[E_{\mathsf{fail}}]$$

$$=\mathrm{Pr}[(\exists i:E_{\mathsf{indFail}}^{(i)}),(\forall i:E_{\mathsf{split}}^{(i)})]+\mathrm{Pr}[\neg E_{\mathsf{all}}]$$

$$\le \mathrm{Pr}[\exists i:E_{\mathsf{indFail}}^{(i)}]+1/n$$

$$\le \sum _{i=1}^{n/{\log }^{2}n}\mathrm{Pr}[E_{\mathsf{indFail}}^{(i)}]+1/n.$$

$$\mathrm{Pr}[E_{\mathsf{fail}}]\le n\cdot \exp (-2{\log }^{2}n)+1/n<2/n.$$

$$\mathrm{Pr}[w(Y[a,a+w))<0.4w]$$

$$\le \sum _{y:w(y)<0.4w}(2^{-w}+2^{3w}ϵ)$$

$$\le 2^{wh(0.4)}\cdot 2^{-w+1}$$

$$\le \frac{2}{m^2}.$$

$${\mathsf{Enc}}_0=\mathsf{Enc}\circ {\mathsf{Enc}}_{\mathsf{Ham}}.$$

$$y=y^{(1)}||y^{(2)}||\cdots ||y^{(m/{\log }^{2}m)}.$$

$${\mathsf{Enc}}^{\prime }(y)=M^{\prime }||{\overline{y}}^{(1)}||M^{\prime }||{\overline{y}}^{(2)}||M^{\prime }||\cdots ||M^{\prime }||{\overline{y}}^{(m/{\log }^{2}m)}||M^{\prime }.$$

$$|\mathsf{Enc}^{\prime}(y)|=m+\frac{m}{\log^{2}m}\cdot\mathopen{}\mathclose{{}\left(|M^{\prime}|+O\mathopen{}\mathclose{{}\left(\log\log m}\right)}\right)=m+O\mathopen{}\mathclose{{}\left(\frac{m}{\log m}}\right).$$

$$O\mathopen{}\mathclose{{}\left(\frac{n}{\log n}}\right)+O\mathopen{}\mathclose{{}\left(\frac{n\log^{2}n}{\log^{2}n\cdot\log\log n}}\right)=O\mathopen{}\mathclose{{}\left(\frac{n}{\log\log n}}\right).$$

$$w(s)\ge 0.4w\cdot |s|/w-{\ell }^{\prime }\ge 0.39|s|,$$

$$1^{\ell }||{\mathsf{Enc}}^{\prime }(y)||0^{\ell }=1^{\ell }||M^{\prime }||{\overline{y}}^{(1)}||M^{\prime }||\cdots ||M^{\prime }||{\overline{y}}^{(m/{\log }^{2}m)}||M^{\prime }||0^{\ell },$$

$$\mathrm{Pr}[L_0>10\log m,L_1>0]\ge 1-m^{-3}.$$

$$m\cdot \exp (-\Omega ({\log }^{2}m))+1/m<2/m.$$

$$\mathrm{Pr}[E_{\mathsf{fail}}]$$

$$\displaystyle=\Pr\mathopen{}\mathclose{{}\left[\sum_{i=1}^{n/\log^{2}n}I^{(i)}_{\mathsf{indFail}}>\frac{n}{\log^{2}n}\cdot\frac{10}{\log^{2}n_{0}},\forall i:E^{(i)}_{\mathsf{split}}}\right]+\Pr[\neg E_{\mathsf{all}}]$$

$$\displaystyle\leq\Pr\mathopen{}\mathclose{{}\left[\sum_{i=1}^{n/\log^{2}n}I^{(i)}_{\mathsf{indFail}}>\frac{n}{\log^{2}n}\cdot\frac{10}{\log^{2}n_{0}}}\right]+1/n_{0}.$$

Full text

1 Introduction

Trace reconstruction was originally introduced by Batu, Kannan, Khanna, and McGregor [1], motivated by problems in sequence alignment, phylogeny, and computational biology. The setting for the problem is as follows: There is an unknown string $x\in\{0,1\}^{n}$, and our goal is to reconstruct it. Towards this goal, we are allowed to ask for traces of $x$, which are obtained by sending $x$ through a deletion channel. This channel independently deletes bits of $x$ with a given deletion probability $d$. As a result, each trace corresponds to a subsequence of $x$. We wish to minimize the number of traces required for reconstructing $x$ with high probability.

Since its introduction, the problem of trace reconstruction has been studied from several different perspectives. Two of the main perspectives correspond to worst-case trace reconstruction [1, 2, 3, 4, 5], where the reconstruction algorithm must work simultaneously for all strings in $\{0,1\}^{n}$, and average-case trace reconstruction [1, 2, 3, 6, 7, 8], where the reconstruction algorithm is only required to work with high probability, taken over the choice of string and the randomness of the reconstruction algorithm for a uniformly random string. The number of traces required for average-case trace reconstruction is, as expected, much smaller than that required for worst-case trace reconstruction. The problem in question has also been studied from a combinatorial coding perspective [9, 10, 11, 12].

The above described results on average-case trace reconstruction can be interpreted from a coding-theoretic perspective: They state that there exist very large codebooks which can be reconstructed efficiently from relatively few traces. However, no efficient encoders are known for such codes, and it may be possible to further reduce the number of traces required for reconstruction by relaxing the size of the code.

This point of view naturally leads to the problem of coded trace reconstruction: The goal is to design high rate, efficiently encodable codes whose codewords can be efficiently reconstructed with high probability from very few traces with constant deletion probability. Here, “high rate” refers to a rate approaching $1$ as the block length increases. We remark that in such a case, the number of traces must grow with the block length of the code. Coded trace reconstruction is also closely related to and motivated by the read process in portable DNA-based data storage systems, which we discuss below.

Motivation

A practical motivation for coded trace reconstruction comes from portable DNA-based data storage systems using DNA nanopores, first introduced in [13]. In DNA-based storage, a block of user-defined data is first encoded over the nucleotide alphabet $\{A,C,G,T\}$, and then transformed into moderately long strands of DNA through a DNA synthesis process. For ease of synthesis, the DNA strands are usually encoded to have balanced $GC$-content, so that the fraction of $\{{A,T\}}$ and $\{{G,C\}}$ bases is roughly the same. To recover the block of data, the associated strand of DNA is sequenced with nanopores, resulting in multiple corrupted reads of its encoding. Although the errors encountered during nanopore sequencing include both deletions/insertions as well as substitution errors, careful read preprocessing alignment [13] allows the processed reads to be viewed as traces of the data block’s encoding. As a result, recovering the data block in question can be cast in the setting of trace reconstruction. Due to sequencing delay constraints111Current Oxford nanopore sequencers can process roughly 450 nucleotides per second., it is of great interest to minimize the number of reads required to reconstruct the data block.

The trace reconstruction procedures associated to the codes used by practical portable DNA-based storage systems [13, 14] are largely based on heuristics. The trace reconstruction algorithm proposed in [13] operates on carefully designed coded strings, but makes use of multiple sequence alignment algorithms which are notoriously difficult to analyze rigorously. The trace reconstruction algorithm from [14] does not make use of specific read-error correction codes and is a variation of the Bitwise Majority Alignment (BMA) algorithm originally introduced in [1]. However, the BMA algorithm is only known to be robust when the errors correspond to i.i.d. deletions and the fraction of errors is at most $O(1/\log n)$, where $n$ denotes the blocklength of the code. Moreover, the proposed codes have been designed only for a fixed blocklength. As a result, the codes from [13, 14] have no robustness or performance guarantees for trace reconstruction even under i.i.d. deletions with constant deletion probability. Consequently, our work on coded trace reconstruction is a first step towards the development of codes with provable robustness guarantees and good performance for trace reconstruction in portable DNA-based data storage systems.

1.1 Related work

Recently, there has been significant interest both in trace reconstruction and coding for settings connected to DNA-based data storage.

Regarding trace reconstruction, a chain of works [1, 2, 3, 6, 7, 8] has succeeded in substantially reducing the number of traces required for average-case trace reconstruction. The state-of-the-art result, proved by Holden, Pemantle, and Peres [8], states that $\exp(\log^{1/3}n)$ traces suffice to reconstruct a random $n$-bit string under arbitrary constant deletion probability. Much less is known about the worst-case trace reconstruction problem. The current best upper bound of $\exp(O(n^{1/3}))$ traces was proved concurrently by De, O’Donnell, and Servedio [4] and Nazarov and Peres [5] through algorithms that rely only on single-bit statistics from the trace. They also showed that this upper bound is tight for this restricted type of algorithms. The gap between upper and lower bounds for trace reconstruction for both the average- and worst-case settings is still almost exponential. The state-of-the-art lower bounds, obtained by Chase [15] and improving on the previous best lower bounds by Holden and Lyons [16], are close to $\log^{5/2}n$ traces for average-case trace reconstruction and $n^{3/2}$ traces in the worst-case setting. Trace reconstruction has also been studied over a large class of sticky channels [17], motivated by nanopore sequencers. A channel is said to be sticky if it preserves the block structure of the input, i.e., no input runs are completely deleted, and no new runs are added to it. In particular, the deletion channel is not a sticky channel.

Another line of work has focused on combinatorial settings related to coded trace reconstruction [9, 10, 11, 12]. The reported works study the number of traces required for exact reconstruction when each trace is subjected to a bounded number of adversarial edit errors, and the string may be assumed to belong to a code from some general class. We note that Levenshtein [9] also studies a version of probabilistic trace reconstruction where the string is sent through a memoryless channel, but the deletion channel is not included in this family of channels. Other closely related combinatorial reconstruction problems consist in recovering a string from a subset of its substrings [22, 23, 24].

Coded trace reconstruction is also related to the multi-use deletion channel. In fact, the decoding problem for this channel can be interpreted as coded trace reconstruction with a fixed number of traces. Some results are known about the capacity of this channel for small deletion probability [25], and about maximum likelihood decoding [26].

Some recent works have focused on coding for other channel models inspired by DNA-based storage. The model studied in [27, 28, 29, 30] views codewords as sets comprised of several sequences over some alphabet, and the (adversarial) errors consist of erasure and insertion of sequences in the set, as well as deletions, insertions, or substitutions within some of the sequences. Each sequence in the set corresponds to a different DNA strand whose contents are reconstructed via high throughput sequencing-based procedures that introduce errors. The goal is to recover the whole set from the erroneous sequences. This is fundamentally different from our model, as we focus on the correct reconstruction of a long single strand of DNA from multiple sequencing attempts and high probabilistic deletion error rates, which is especially relevant for portable nanopore DNA-based data storage systems. Another model similar to the one described above, motivated by the permutation channel, is studied in [31]. However, codewords there consist of multisets of symbols in some alphabet, and errors are comprised of deletions, insertions, substitutions, and erasures of symbols in the multiset. An information-theoretic treatment of related but abstracted models of DNA-based data storage may be found in [32, 33]. Very recently, a model for clustering sequencing outputs according to the relevant DNA strand and codes that allow for correct clustering have been studied in [34].

Although we focus on portable DNA-based storage systems with nanopore sequencers [13, 14], there has also been significant activity on practical aspects of other types of DNA-based storage, e.g., [35, 36, 37]. General overviews of the field can be found in [38, 39].

To conclude this section, we note that some novel results on trace reconstruction have been developed concurrently to this work. Davies, Racz, and Rashtchian [18] study trace reconstruction over trees (in the graph-theoretic sense), where standard trace reconstruction corresponds to recovering a path. Ban et al. [19] consider the problem of trace reconstruction of distributions over small sets of strings (a setting commonly known as population recovery). Krishnamurthy et al. [20] explore alternative and generalized forms of trace reconstruction (e.g., trace reconstruction over matrices and sparse strings). As mentioned before, Chase [15] improved on the trace reconstruction lower bounds by Holden and Lyons [16]. Finally, the problem of coded trace reconstruction has also been studied concurrently and independently in a similar setting by Abroshan et al. [21]. They consider a code obtained by concatenating several blocks, each block being a codeword of a Varshamov-Tenengolts code correcting one deletion.

1.2 Channel model

The channel model used for representing nanopore systems may be summarized as follows. For a given input string $x\in\{0,1\}^{n}$, a deletion probability $d$, and an integer $t(n)$, the channel returns $t(n)$ traces of $x$. Each trace of $x$ is obtained by sending $x$ through a deletion channel with deletion probability $d$, i.e., the deletion channel deletes each bit of $x$ independently with probability $d$, and outputs a subsequence of $x$ containing all bits of $x$ that were not deleted in order. The $t(n)$ traces are independent and identically distributed as outputs of the deletion channel for input $x$.

Given a code $\mathcal{C}\subseteq\{0,1\}^{n}$, we say that $\mathcal{C}$ can be efficiently reconstructed from $t(n)$ traces if there exists a polynomial $p(n)$ and a polynomial-time algorithm that recovers every $c\in\mathcal{C}$ from $t(n)$ traces of $c$ with probability at least $1-1/p(n)$ over the probability distribution of the traces.

1.3 Our contributions

We initiate the study of coded trace reconstruction for efficient, high-rate codes against a constant rate of deletions. More specifically:

• •

We analyze the performance of marker-based constructions coupled with worst-case trace reconstruction algorithms. These constructions have the advantage that they can be easily adapted to work with a large range of inner codes.

At a high level, the construction operates by splitting an $n$-bit message into short blocks of length $O(\log^{2}n)$, encoding each block with an inner code satisfying a certain constraint, and adding markers of length $O(\log n)$ between the blocks. The structure of the markers and the property of the inner code imply that, with high probability, we can split the traces into many shorter sub-traces associated with substrings of length $O(\log^{2}n)$, and then apply the worst-case trace reconstruction algorithm on the sub-traces. Our main result in this context is Theorem 1.

Theorem 1**.**

For every constant deletion probability $d<1$, there exists an efficiently encodable code $\mathcal{C}\subseteq\{0,1\}^{n+r}$ with redundancy $r=O(n/\log n)$ that can be efficiently reconstructed from $\exp(O(\log^{2/3}n))$ traces.

We significantly improve on this simple construction for small constant deletion probabilities with a more involved approach described in the second part of the paper. The above construction is relevant as it shows that we can instantiate the marker-based construction with any inner code satisfying a simple constraint and iterate the marker-based construction by further dividing each block of length $\log^{2}n$ into blocks of length $(\log\log n)^{2}$ and adding markers of length $O(\log\log n)$ between them. In this setting, it is almost guaranteed that reconstruction of a small fraction of blocks will fail. Nevertheless, this problem can be easily resolved by adding error-correction redundancy to the string to be encoded. This leads to the following result, which can be extended beyond two marker levels.

Theorem 2**.**

For every constant deletion probability $d<1$, there exists an efficiently encodable code $\mathcal{C}\subseteq\{0,1\}^{n+r}$ with redundancy $r=O(n/\log\log n)$ that can be efficiently reconstructed from $\exp(O(\log\log n)^{2/3})$ traces.

• •

We take advantage of the fact that we can instantiate the marker-based constructions with a large range of inner codes to construct high-rate marker-based codes over the $\{A,C,G,T\}$ alphabet with two important properties: The codes have balanced $GC$-content and provably require few traces to be efficiently reconstructed. We follow the same ideas as the marker-based constructions above, but with different markers and an inner code over a larger alphabet and with stronger constraints. In this context, we obtain the following results.

Theorem 3**.**

For every constant deletion probability $d<1$, there exists an efficiently encodable code $\mathcal{C}\subseteq\{A,C,G,T\}^{n+r}$ with redundancy $r=O(n/\log n)$ and balanced $GC$-content that can be efficiently reconstructed from $\exp(O(\log^{2/3}n))$ traces.

Theorem 4**.**

For every constant deletion probability $d<1$, there exists an efficiently encodable code $\mathcal{C}\subseteq\{A,C,G,T\}^{n+r}$ with redundancy $r=O(n/\log\log n)$ and balanced $GC$-content that can be efficiently reconstructed from $\exp(O(\log\log n)^{2/3})$ traces.

• •

The result of Theorem 1 may be further improved by considering a more careful design of the high-rate inner code to be used in the marker-based constructions, provided that the deletion probability is a small enough constant. This allows for using a modified version of an algorithm for average-case trace reconstruction described in [2] which leads to a substantial reduction in the number of traces required for reconstruction and barely any rate changes. As a first step towards achieving this goal, we first design a low-redundancy code that can be efficiently reconstructed from polynomially many traces. The proposed coding scheme relies on the fact that we can efficiently encode $n$-bit messages into strings that are almost subsequence-unique (see Definition 11) via explicit constructions of almost $k$-wise independent spaces (see Section 2.2). The average-case trace reconstruction algorithm from [2] operates on subsequence-unique strings, and a simple adaptation of the algorithm suffices for our approach. In summary, we have the following result.

Theorem 5**.**

If the deletion probability is a small enough constant, there exists an efficiently encodable code $\mathcal{C}\subseteq\{0,1\}^{n+r}$ with redundancy $r=O(\log n)$ that can be efficiently reconstructed from $\textnormal{poly}(n)$ traces.

An important step in our analysis is to show how to adapt this code for use as an inner code in the marker-based construction. Some care is needed, since the global structure of the strings we deal with changes significantly due to the presence of the markers. In particular, the bootstrapping method in the trace reconstruction algorithm from [2] no longer works, and we must find a way to circumvent this issue. Our findings for this scenario are described in the next theorem.

Theorem 6**.**

If the deletion probability is a small enough constant, there exists an efficiently encodable code $\mathcal{C}\subseteq\{0,1\}^{n+r}$ with redundancy $r=O(n/\log n)$ that can be efficiently reconstructed from $\textnormal{poly}(\log n)$ traces.

For simplicity, our exposition mostly focuses on constructions of binary codes, although it provides some guidelines and simple coding procedures for quaternary codes. One should note that coded trace reconstruction is inherently harder for smaller alphabets.

1.4 Organization

The paper is organized as follows: In Section 2, we define relevant notation and discuss known results that we find useful in our subsequent derivations. We describe and analyze general marker-based constructions in Section 3. Then, we show how to reduce the number of traces required for a small deletion probability in Section 4. We discuss some open problems in Section 5.

2 Notation and preliminaries

2.1 Notation

We denote the length of a string $x$ by $|x|$, and its Hamming weight by $w(x)=|\{i:x_{i}\neq 0\}|$. Given two strings $x$ and $y$ over the same alphabet, we denote their concatenation by $x||y$. For a string $x$, we define $x[a,b)=(x_{a},x_{a+1},\dots,x_{b-1})$ and $x[a,b]=(x_{a},x_{a+1},\dots,x_{b})$. If $|x|=n$, we define $x[a,\cdot]=(x_{a},x_{a+1},\dots,x_{n})$. We say that $y$ is a subsequence of $x$ if there exist indices $i_{1}<i_{2}<\cdots<i_{|y|}$ such $x_{i_{j}}=y_{j}$. Moreover, $y$ is said to be a substring of $x$ if $y=x[a,a+|y|)$ for some $1\leq a\leq|x|-|y|+1$. Given two strings $x,y\in\{0,1\}^{n}$, we write $x+y$ for the bitwise XOR of $x$ and $y$. A run of length $\ell$ in a string $x$ is a substring of $x$ comprising $\ell$ identical symbols. Sets are denoted by calligraphic letters such as $\mathcal{S},\mathcal{T}$. Random variables are denoted by uppercase letters such as $X$, $Y$, and $Z$. The uniform distribution over $\{0,1\}^{t}$ is denoted by $U_{t}$, and the binomial distribution on $n$ trials with success probability $p$ is denoted by $\mathsf{Bin}(n,p)$. The binary entropy function is denoted by $h$ and all logarithms $\log$ are taken with respect to the base $2$.

2.2 Almost $k$-wise independent spaces

We start by defining almost $k$-wise independence and present a related result that we will find useful in our future derivations.

Definition 7** ($\epsilon$-almost $k$-wise independent random variable).**

A random variable $X\in\{0,1\}^{m}$ is said to be $\epsilon$-almost $k$-wise independent if for all sets of $k$ distinct indices $i_{1},i_{2},\dots,i_{k}$ we have

[TABLE]

for all $(x_{1},\dots,x_{k})\in\{0,1\}^{k}$.

The following result gives an efficient construction of an $\epsilon$-almost $k$-wise independent space which can be generated from few uniformly random bits.

Lemma 8** ([40]).**

For every $m$, $k$, and $\epsilon$ there exists an efficiently computable function $g:\{0,1\}^{t}\to\{0,1\}^{m}$ with t=O\mathopen{}\mathclose{{}\left(\log\mathopen{}\mathclose{{}\left(\frac{k\log m}{\epsilon}}\right)}\right) such that $g(U_{t})$ is an $\epsilon$-almost $k$-wise independent random variable over $\{0,1\}^{m}$, where $U_{t}$ denotes the uniform distribution over $\{0,1\}^{t}$.

2.3 Nearly-optimal systematic codes for edit errors

We require systematic codes that are robust against edit errors (deletions and insertions). Nearly-optimal systematic codes for adversarial edit errors have been recently constructed using optimal protocols for deterministic document exchange [41, 42]. The following result is relevant to our analysis.

Lemma 9** ([41, 42]).**

For every $m$ and $t<m$ there exists an efficiently encodable and decodable systematic code $\mathcal{C}_{\mathsf{edit}}\subseteq\{0,1\}^{m+r}$ with encoder $\mathsf{Enc}_{\mathsf{edit}}:\{0,1\}^{m}\to\{0,1\}^{m+r}$ and redundancy r=O\mathopen{}\mathclose{{}\left(t\log^{2}\frac{m}{t}+t}\right) that can efficiently correct up to $t$ edit errors. In particular, if $t=\Theta(m)$ then the redundancy is $r=O(m)$.

2.4 Trace reconstruction

Next, we discuss several results pertaining to the worst-case and average-case trace reconstruction problem that will be useful for our constructions.

2.4.1 Worst-case trace reconstruction

For worst-case reconstruction, the state-of-the-art result used in Section 3 is summarized below.

Lemma 10** ([4, 5]).**

For every $n$ and constant deletion probability $d$ there exists an algorithm that reconstructs an arbitrary string $x\in\{0,1\}^{n}$ with probability at least $1-\exp(-2n)$ from $\exp(O(n^{1/3}))$ traces in time $\exp(O(n^{1/3}))$.

2.4.2 Trace reconstruction of subsequence-unique strings

One of the key tools for our constructions in Section 4 is a modified version of the efficient trace reconstruction algorithm [2] for what we refer to as subsequence-unique strings. This algorithm may also be used for average-case trace reconstruction. We start by defining subsequence-unique strings.

Definition 11** ($w$-subsequence-unique string).**

A string $x\in\{0,1\}^{n}$ is said to be $w$-subsequence-unique if for every $a$ and $b$ such that either $a<b$ or $b+1.1w<a+w$ we have that the substring $x[a,a+w)$ is not a subsequence of $x[b,b+1.1w)$.

Note that these strings have been under the name “substring-unique” in [2]. We proposed the name change to avoid confusion with a different definition under the same name, described in [24]. The following result about subsequence-unique strings was established in [2].

Lemma 12** ([2, Theorem 2.5]).**

For $w=100\log n$ and a small enough constant deletion probability $d$, there exists an algorithm that reconstructs every $w$-subsequence-unique string $x\in\{0,1\}^{n}$ with probability $1-1/\textnormal{poly}(n)$ from $\textnormal{poly}(n)$ traces in time $\textnormal{poly}(n)$.

Since a uniformly random string is $w$-subsequence-unique with high probability, Lemma 12 applies to average-case trace reconstruction. As we make explicit use of the algorithm behind Lemma 12, for the sake of clarity we provide next a more in-depth discussion of the method. However, before we proceed to the actual description of the algorithm, we briefly introduce some definitions and basic related results.

Given integers $i$ and $j$ and a deletion probability $d$, we denote the probability that the $i$-th bit of a string appears as the $j$-th bit of its trace by $P(i,j)$. Then, we have

[TABLE]

The following lemma states some useful properties of $P(i,j)$.

Lemma 13** ([2, Lemma 2.2]).**

If $j\leq(1-3d)i$, then $P(i,j)\geq 2\sum_{i^{\prime}>i}P(i^{\prime},j)$. Furthermore, if $(1-4d)i<j<(1-3d)i$, we have $P(i,j)\geq\exp(-6di)$.

Intuitively, the second part of Lemma 13 means that we have a good idea of the position of $x_{i}$ in the trace if $i$ is small. The following result makes use of this. It states that we can recover the first $O(\log n)$ bits of an arbitrary string with $\textnormal{poly}(n)$ traces, which is required to bootstrap the trace reconstruction algorithm from [2].

Lemma 14** ([2, Theorem 2.1]]).**

Fix a string $x\in\{0,1\}^{n}$, and suppose that we know $x_{1},\dots,x_{h-1}$. Then, there is an algorithm that recovers $x_{h}$ from $\exp(O(hd\log(1/d)))$ traces of $x$ with probability $1-o(1)$, provided that $d<1/3$.

In the second part of the algorithm, we must look for matchings of certain strings within the traces. To this end, we introduce the following definition.

Definition 15** (Matching).**

Fix a string $x\in\{0,1\}^{n}$, and let $T$ denote its trace. Then, we say that there is a matching of $x[a,b)$ in $T$ if there exists some $u$ such that $T[u-(b-a),u)=x[a,b)$.

Matchings of $w$-subsequence-unique strings have useful properties, as formalized in the following lemma.

Lemma 16** ([2, Lemma 2.4]).**

If $x$ is $w$-subsequence-unique and there is a matching of $x[a,a+w)$ in $T$, say at $T[u-w,u)$, then the probability that $T_{u-1}$ does not come from $x[a+w,a+1.1w)$ is at most $nd^{0.001w}$.

We are now in a position to describe the algorithm introduced in [2]. We begin by setting $w=100\log n$, $v=w/d$, and $j=(v-0.1w)(1-3d)$. Then, to recover a $w$-subsequence-unique string $x$ we proceed with two steps: First, we use the algorithm from Lemma 14 to recover the first $v$ bits of $x$ with $\textnormal{poly}(n)$ traces. Now, suppose we have recovered $x_{1},\dots,x_{i-1}$ for $i-1\geq v$. Our next goal is to recover $x_{i}$ with $\textnormal{poly}(n)$ traces. Note that if $i$ is relatively large, we cannot use the algorithm from Lemma 14 to recover $x_{i}$ anymore, as it would require more than $\textnormal{poly}(n)$ traces. To achieve our goal, we instead focus on finding matchings of the substring $x[i-v-w,i-v)$ within the trace. Let $T$ denote a trace of $x$, and suppose there is a matching of $x[i-v-w,i-v)$ in $T$ at positions $T[u-w,u)$. Then, we set $V=T[u,\cdot]$, i.e., we let $V$ be the suffix of the trace following the matching. The key property is that $\Pr[V_{j}=1]$ satisfies a threshold property depending on the value of $x_{i}$. More precisely, there exist two positive values $B_{1}>B_{0}$ sufficiently far apart such that $\Pr[V_{j}=1]\leq B_{0}$ if $x_{i}=0$ and $\Pr[V_{j}=1]\geq B_{1}$ if $x_{i}=1$. Moreover, all terms in these inequalities can be estimated with a small error from $\textnormal{poly}(n)$ traces of $x$. As a result, we can reliably estimate $x_{i}$ by checking whether $\Pr[V_{j}=1]\leq B_{0}$ or $\Pr[V_{j}=1]\geq B_{1}$.

We prove next the threshold property for $\Pr[V_{j}=1]$. Let $R$ denote the position in $x$ of the bit appearing in position $u-1$ in the trace $T$ of the matching for $x[i-v-w,i-v)$. In other words, $R$ denotes the position in $x$ of the last bit appearing in the matching in $T$. We may write

[TABLE]

where the second equality follows from Lemma 16 with $0\leq\epsilon_{i}(x)\leq nd^{-0.001w}$. Using the first part of Lemma 13, we conclude that $\sum_{\ell=i+1}^{n}P(\ell-r,j)\leq\frac{1}{2}P(i-r,j)$. As a result, we have

[TABLE]

and

[TABLE]

By the second part of Lemma 13, since $i-r\leq v$ and $v=w/d$, we have $P(i-r,j)\geq 2^{-9w}$. Combining this with Lemma 16 for $d$ small enough means that the gap between the right hand side of (1) and (2) is at least $2^{-(9w+1)}$. To finalize the argument, we note that (i) we can efficiently approximate $\Pr[V_{j}=1]$ to within an error of, say, $2^{-100w}$ with high probability from $\textnormal{poly}(n)$ traces of $x$, and (ii) we can efficiently approximate $\Pr[R=r|R<i]$ to within the same error given that we know $x_{1},\dots,x_{i-1}$, provided $d$ is small enough. Since $\Pr[R<i]\geq 1-nd^{-0.001w}$ by Lemma 16, we can further efficiently approximate $\Pr[R=r]$ to within an error of, say, $2^{-50w}$ with high probability. From these observations it follows that we can estimate $x_{i}$ correctly with high probability from $\textnormal{poly}(n)$ traces, where the degree of the polynomial is independent of $i$, as desired.

3 Marker-based constructions

We start with simple constructions of high-rate codes that can be efficiently reconstructed from a few traces. The idea behind the approach is the following: Each codeword contains markers, consisting of sufficiently long runs of [math]’s and $1$’s. Between two consecutive markers, we add a short block containing a codeword from an inner code satisfying a mild constraint.

Intuitively, the runs in the markers will still be long in the trace, and so we hope to be able to correctly identify the positions of all markers in a trace with high probability. After this is done, we can effectively split the trace into many shorter, independent sub-traces corresponding to a block (and possibly some bits from the two markers delimiting it). Then, we can apply worst-case trace reconstruction algorithms to the sub-traces. The savings in the number of traces required for reconstruction stem from the fact that sub-traces are short, and that each trace can be utilized simultaneously (and independently) by all blocks. This idea for reconstruction almost works as is, except that the process of identifying the markers in a trace may be affected by long runs of [math]’s originating from a block between two markers. However, this can be easily solved by requiring that all runs of [math]’s in each block are short enough. Many codes, including codes with low redundancy, satisfy the desired property, and hence make for good candidates for the inner code.

We describe and analyze a code based on the idea discussed above in Section 3.1. Then, we consider a follow-up construction in Section 3.2 which requires fewer traces, at the expense of a decrease in the rate. At a high-level, this second code is obtained by introducing two levels of markers and adding some simple error-correction redundancy to the message prior to other encodings. Finally, in Section 3.3 we extend these ideas to the $\{A,C,G,T\}$ alphabet in order to obtain high-rate codes with desireable properties for use in DNA-based storage. Namely, these codes have balanced $GC$-content and can be reconstructed from few traces. Such codes are designed by exploiting the fact that the marker-based constructions can be instantiated with a large range of inner codes, and we can make the inner code satisfy stronger constraints than before.

3.1 A simple construction

Here we provide a precise description of the encoder $\mathsf{Enc}$ for our code $\mathcal{C}$ and prove Theorem 1. For simplicity, we consider $d=1/2$ throughout.

Let $\ell=50\log n$, and define two strings $M_{0}=0^{\ell}$ and $M_{1}=1^{\ell}$. Then, a marker $M$ is a string of length $2\ell$ of the form $M=M_{0}||M_{1}=0^{\ell}||1^{\ell}$. We also require an efficiently encodable and decodable inner code $\mathcal{C}^{\prime}\subseteq\{0,1\}^{m+r}$ with encoder $\mathsf{Enc}^{\prime}:\{0,1\}^{m}\to\{0,1\}^{m+r}$, where $m=\log^{2}n$ and $r$ is the redundancy, satisfying the following property.

Property 17**.**

For all $c\in\mathcal{C}$ and substrings $s$ of $c$ with $|s|=\sqrt{m}$, it holds that $w(s)\geq|s|/3$.

In other words, every codeword of $\mathcal{C}^{\prime}$ has many $1$’s in all short enough substrings. Such efficient codes exist with redundancy $r=O(\log m)=O(\log\log n)$, which is enough for our needs. We provide a simple construction in Section 3.1.1.

Suppose we wish to encode an $n$-bit message $x\in\{0,1\}^{n}$. The encoder $\mathsf{Enc}$ on input $x$ proceeds through the following steps:

Split $x$ into $n/\log^{2}n$ blocks, each of length $\log^{2}n$

[TABLE] 2. 2.

Encode each block $x^{(i)}$ under the inner code $\mathcal{C}^{\prime}$ to obtain $\overline{x}^{(i)}=\mathsf{Enc}^{\prime}(x^{(i)})\in\{0,1\}^{\log^{2}n+r}$; 3. 3.

Set the encoding of $x$, denoted by $\mathsf{Enc}(x)$, to be

[TABLE]

We remark that the first run $1^{\ell}$ and the last run $0^{\ell}$ are superfluous, and are added only to make the analysis simpler. Computing $\mathsf{Enc}(x)$ from $x$ and decoding $x$ from $\mathsf{Enc}(x)$ can both be done efficiently if the inner code $\mathcal{C}^{\prime}$ is efficiently encodable and decodable.

We now compute the redundancy of $\mathcal{C}$. It is straightforward to see that

[TABLE]

As mentioned before, we have $r=O(\log\log n)$. Therefore, $\mathcal{C}$ can be made to have redundancy O\mathopen{}\mathclose{{}\left(\frac{n}{\log n}}\right). In the remainder of this section, we prove Theorem 1 using $\mathcal{C}$ via a sequence of lemmas. For convenience, we restate the theorem below.

Theorem 18** (Theorem 1, restated).**

There is an efficient algorithm that recovers every $c\in\mathcal{C}$ from $\exp(O(\log^{2/3}n))$ traces in time $\textnormal{poly}(n)$ with probability $1-1/\textnormal{poly}(n)$.

To prove Theorem 1 we proceed in steps: First, we show that the markers $M$ still contain long enough runs after they are sent through the deletion channel. Then, we show that no long runs of [math]’s originate from the sub-traces associated with each block. This implies that we can correctly identify the position of the “01” string of each marker in the trace. Finally, we show that we can apply the worst-case trace reconstruction algorithm from Lemma 10 to recover each block with high probability and with the desired number of traces.

We start by proving that the markers $M$ still contain long runs after they are sent through the deletion channel.

Lemma 19**.**

Let $0^{L_{0}}1^{L_{1}}$ be the output of the deletion channel on input $M$. Then,

[TABLE]

Proof.

The result follows by a standard application of the Chernoff bound. More precisely, we have $\mathds{E}[L_{0}]=25\log n$, and hence

[TABLE]

To conclude the proof, we note that $\Pr[L_{1}=0]=2^{-\ell}=n^{-50}$, and that the two events in question are independent. ∎

We now show that no long runs of [math]’s originate from the sub-traces associated with each block.

Lemma 20**.**

Let $c\in\mathcal{C}^{\prime}$. Then, a trace of $c$ does not contain a run of [math]’s of length at least $10\log n$ with probability at least $1-n^{-3}$.

Proof.

Since $c\in\mathcal{C}^{\prime}$, a run of [math]’s of length at least $10\log n$ in the trace of $c$ requires that at least $10\times\frac{\log n}{3}-1$ consecutive $1$’s are deleted in $c$. The probability that this happens for a fixed sequence of $10\times\frac{\log n}{3}-1$ consecutive $1$’s is at most $n^{-3.3}$. Since there are at most $O(\log^{2}n)$ such sequences in $c$, by the union bound it follows that the desired probability is at most $n^{-3}$. ∎

The next lemma follows immediately by combining Lemmas 19 and 20 with the union bound over the $n/\log^{2}n$ blocks.

Lemma 21**.**

Consider the following event $E$: We correctly identify the separation between the traces of $0^{\ell}$ and $1^{\ell}$ from every marker in the trace of $\mathsf{Enc}(x)$ by looking for all $1$’s that appear immediately after a run of at least $10\log n$ [math]’s.

Then, $E$ happens with probability at least $1-n^{-2}$ over the randomness of the trace.

We are now ready to prove Theorem 1. Let $E$ denote the event described in Lemma 21. Then, Lemma 21 implies that, conditioned on $E$ happening, we can split a trace $T$ of $\mathsf{Enc}(x)$ into $n/\log^{2}n$ strings $T^{(1)},\dots,T^{(n/\log^{2}n)}$ satisfying the following:

• •

The strings $T^{(i)}$ are independent;

• •

Each string $T^{(i)}$ is distributed like a trace of $1^{\ell}||\overline{x}^{(i)}||0^{\ell}$ conditioned on the high probability event $E$.

In fact, each string $T^{(i)}$ can be identified by looking for the $(i-1)$-th and $i$-th runs of [math] of length at least $10\log n$ in the trace $T$, and picking every bit in $T$ immediately after the $(i-1)$-th run up to and including the $i$-th run.

Observe that $1^{\ell}||\overline{x}^{(i)}||0^{\ell}$ has length $O(\log^{2}n)$. Suppose that we have $t=\exp(O(\log n)^{2/3})$ independent traces $T_{1},\dots,T_{t}$ of $\mathsf{Enc}(x)$. Let $E_{\mathsf{all}}$ denote the event that $E$ holds for all $T_{i}$ simultaneously. Combining Lemma 21 with a union bound yields

[TABLE]

Fix some trace reconstruction algorithm $\mathcal{A}$, and let $E^{(i)}_{\mathsf{indFail}}$ denote the event that $\mathcal{A}$ fails to recover a fixed string $y^{(i)}=1^{\ell}||\overline{x}^{(i)}||0^{\ell}$ from $t$ independent traces of $y^{(i)}$. Assuming that $E_{\mathsf{all}}$ holds, the strings $T^{(i)}_{1},\dots,T^{(i)}_{t}$ are distributed as $t$ independent traces of $y^{(i)}$, each also satisfying the conditions that the first run $1^{\ell}$ is not completely deleted, the last run $0^{\ell}$ has length at least $10\log n$ in the trace, and there is no run of [math]’s of length at least $10\log n$ in the trace of $\overline{x}^{(i)}$. We denote the event that these conditions hold for all of the $t$ independent traces of $y^{(i)}$ by $E^{(i)}_{\mathsf{split}}$. Finally, we let $E_{\mathsf{fail}}$ denote the event that we fail to recover $\mathsf{Enc}(x)$ from the $t$ i.i.d. traces $T_{1},\dots,T_{t}$. Then, we have

[TABLE]

The first equality follows from the discussion in the previous paragraph, the second inequality follows from (4), and the third inequality follows by the union bound. Instantiating $\mathcal{A}$ with the worst-case trace reconstruction algorithm from Lemma 10, we conclude from (6) that

[TABLE]

As a result, we can successfully recover $x$ from $\exp(O(\log n)^{2/3})$ traces of $\mathsf{Enc}(x)$ with probability at least $1-2/n$. To conclude the proof, we note that we can repeat the process $O(\log n)$ times and take the majority vote to boost the success probability to $1-1/p(n)$ for any fixed polynomial $p$ of our choice. The total number of traces required is still $\exp(O(\log^{2/3}n))$. Since recovering each $\overline{x}^{(i)}$ from the associated traces takes time $\exp(O(\log^{2/3}n))$ and the inner code $\mathcal{C}^{\prime}$ has an efficient decoder, the whole procedure is efficient.

3.1.1 Instantiating the inner code

What remains to be done is to instantiate the inner code $\mathcal{C}^{\prime}$ with the appropriate parameters and properties. To this end, we present a simple construction of an efficiently encodable and decodable inner code $\mathcal{C}^{\prime}$ with encoder $\mathsf{Enc}^{\prime}:\{0,1\}^{m}\to\{0,1\}^{m+r}$ and redundancy $r=O(\log m)$. We can then obtain the desired code by setting $m=\log^{2}n$. The starting point is the following result.

Lemma 22**.**

Let $g:\{0,1\}^{t}\to\{0,1\}^{m}$ be the function whose existence is guaranteed by Lemma 8 with $k=3w$ and $\epsilon=2^{-10w}$ for $w=100\log m$ (hence $t=O(\log m)$). Fix some $x\in\{0,1\}^{m}$ and consider the random variable $Y=x+g(U_{t})$. Then, with probability at least $1-2/m$, we have that $Y$ satisfies the following property:

Property 23**.**

$w(Y[a,a+w))\geq 0.4w$* simultaneously for all $1\leq a\leq m-w+1$.*

Proof.

Fix some $a$. Then, we have

[TABLE]

The first inequality follows because $Y$ is $\epsilon$-almost $k$-wise independent, and the second inequality follows from a standard bound on the volume of the Hamming ball and the fact that $2^{3w}\epsilon<2^{-w}$. Since there are at most $m$ choices for $a$, by the union bound we conclude that $Y$ fails to satisfy the desired property with probability at most $m\cdot 2/m^{2}=2/m$, as desired. ∎

Given $x\in\{0,1\}^{m}$, we evaluate $\mathsf{Enc}^{\prime}(x)$ as follows: We iterate over all $z\in\{0,1\}^{t}$ until we find $z$ such that $y=x+g(z)$ satisfies $w(s[a,a+w))\geq 0.4w$. Such a string $z$ is known to exist by Lemma 22 and can be found in time $\textnormal{poly}(m)$ since $t=O(\log m)$. Then, we set $\mathsf{Enc}^{\prime}(x)=z||x+g(z)$.

Observe that the redundancy of $\mathcal{C}^{\prime}$ is exactly $|z|=t=O(\log m)$, and that we have encoders and decoders for $\mathcal{C}^{\prime}$ running in time $\textnormal{poly}(m)$ since $t=O(\log m)$. To see that $\mathcal{C}^{\prime}$ satisfies the property required in this section, fix some substring $s$ of $\mathsf{Enc}^{\prime}(x)$ such that $|s|=\sqrt{m}$. Then, $w(s)\geq 0.4w\cdot|s|/w-t\geq 0.39|s|$ provided that $m$ is large enough.

Finally, we remark that the code used in this marker-based construction is just an example of a viable inner code $\mathcal{C}^{\prime}$. Any structured family of codes satisfying Property 17 may be used instead, and one may envision adding more constraints to $\mathcal{C}^{\prime}$, depending on the application constraints at hand. We exploit this fact in Sections 3.2 and 3.3. For example, in Section 3.3 we will require that $\mathcal{C}^{\prime}$ is a code over $\{A,C,G,T\}$ satisfying an analogue of Property 17 while also having balanced $GC$-content.

3.2 Adding a second level of markers

In our next construction, we exploit the fact that the marker-based construction from Section 3.1 can be instantianted with a large range of inner codes to prove Theorem 2. To do so, we show that we can iterate the marker-based construction so that we can split a trace into even smaller sub-traces with high probability. This leads to a code requiring fewer traces, but with a penalty in the redundancy. We restate Theorem 2 for convenience.

Theorem 24** (Theorem 2, restated).**

There exists an efficiently encodable code $\mathcal{C}_{0}\subseteq\{0,1\}^{n_{0}+r_{0}}$ with encoder $\mathsf{Enc}_{0}:\{0,1\}^{n_{0}}\to\{0,1\}^{n_{0}+r_{0}}$ and redundancy $r_{0}=O(n_{0}/\log\log n_{0})$ that can be efficiently reconstructed from $\exp(O(\log\log n_{0})^{2/3})$ traces with probability at least $1-2/n_{0}$.

As before, for simplicity we set $d=1/2$ throughout the section. We will use the same construction blueprint as in Section 3.1, except for the following differences:

• •

We assume the $n$-bit message $x$ belongs to a binary code $\mathcal{C}_{\mathsf{Ham}}\subseteq\{0,1\}^{n}$ with encoder $\mathsf{Enc}_{\mathsf{Ham}}:\{0,1\}^{n_{0}}\to\{0,1\}^{n}$ and relative (Hamming) distance222The relative Hamming distance of a code is defined as its minimum Hamming distance normalized by its block length. $30/\log^{2}n_{0}$. In particular, we have $x=\mathsf{Enc}_{0}(x_{0})$ for some $x_{0}\in\{0,1\}^{n_{0}}$.

Such efficiently encodable and decodable codes are known to exist with redundancy n-n_{0}=O\mathopen{}\mathclose{{}\left(n_{0}\frac{\log\log n_{0}}{\log n_{0}}}\right) (see Appendix A for a proof). The reasons for using this encoding will be made clear later;

• •

The inner code $\mathcal{C}^{\prime}$ differs from the one used in Section 3.1.1.

If $\mathcal{C}$ denotes the code obtained via the reasoning of Section 3.1 and $\mathsf{Enc}$ corresponds to its encoder, then the encoder $\mathsf{Enc}_{0}:\{0,1\}^{n_{0}}\to\{0,1\}^{n_{0}+r_{0}}$ for our final code $\mathcal{C}_{0}$ is obtained by composing the encoders of $\mathcal{C}_{\mathsf{Ham}}$ and $\mathcal{C}$, i.e.,

[TABLE]

We proceed to describe the encoder $\mathsf{Enc}^{\prime}$ for the inner code $\mathcal{C}^{\prime}$ of $\mathcal{C}$. Given $y\in\{0,1\}^{m}$, where $m=\log^{2}n$, we split $y$ into $m/\log^{2}m$ blocks of length $\log^{2}m$,

[TABLE]

Then, we take $\mathcal{C}^{\prime\prime}\subseteq\{0,1\}^{m^{\prime}+r^{\prime}}$ with encoder $\mathsf{Enc}^{\prime\prime}:\{0,1\}^{m^{\prime}}\to\{0,1\}^{m^{\prime}+r^{\prime}}$ as the efficiently encodable and decodable code constructed in Section 3.1.1 with message length $m^{\prime}=\log^{2}m$ and redundancy $r^{\prime}=O(\log m^{\prime})=O(\log\log m)$. For each $i$, we define $\overline{y}^{(i)}=\mathsf{Enc}^{\prime\prime}(y^{(i)})$. Moreover, we let $\ell^{\prime}=50\log m$, and define the marker $M^{\prime}=0^{\ell^{\prime}}||1^{\ell^{\prime}}$. Then, we define $\mathsf{Enc}^{\prime}(y)$ as

[TABLE]

Observe that we can efficiently decode $y$ from $\mathsf{Enc}^{\prime}(y)$ provided that $\mathcal{C}^{\prime\prime}$ is efficiently decodable.

We first compute the redundancy of the inner code $\mathcal{C}^{\prime}$ and the resulting code $\mathcal{C}$ obtained as in Section 3.1. We have

[TABLE]

Thus, $\mathcal{C}^{\prime}$ has redundancy $r=O(m/\log m)$. Plugging $r$ into (3) and recalling that $m=\log^{2}n$, we conclude that $\mathcal{C}$ has redundancy

[TABLE]

As a result, since n=n_{0}+O\mathopen{}\mathclose{{}\left(n_{0}\frac{\log\log n_{0}}{\log n_{0}}}\right), the code $\mathcal{C}_{0}$ has redundancy $r_{0}=O(n_{0}/\log\log n_{0})$, as desired.

We now show that $\mathcal{C}^{\prime}$ satisfies Property 17. First, we observe that $\mathcal{C}^{\prime\prime}$ satisfies Property 23 with $m^{\prime}$ in place of $m$. Then, since each $M^{\prime}$ has weight $0.5|M^{\prime}|$, we conclude that every substring $s$ of $\mathsf{Enc}^{\prime}(y)$ such that $|s|=\sqrt{m}$ satisfies

[TABLE]

provided $m$ is large enough, since $\ell^{\prime}=O(\log m)$. As a result, Lemma 21 holds for this choice of inner code, and we can hence focus solely on the trace reconstruction problem for strings of the form

[TABLE]

where $\ell=O(\log n)=O(\sqrt{m})$, and provided the number of traces used is significantly smaller than $n$.

We now give a trace reconstruction algorithm for strings of the form (7) that requires $\exp(O(\log^{2/3}m))=\exp(O(\log\log n_{0})^{2/3})$ traces and time, and succeeds with probability at least $1-1/\textnormal{poly}(m)=1-1/\textnormal{poly}(\log n_{0})$. We have the following two lemmas whose proofs are analogous to those of Lemmas 19 and 20 and hence omitted.

Lemma 25**.**

Let $0^{L_{0}}1^{L_{1}}$ be the output of the deletion channel on input $M^{\prime}$. Then,

[TABLE]

Lemma 26**.**

Let $c\in\mathcal{C}^{\prime\prime}$. Then, a trace of $c$ does not contain a run of [math]’s of length at least $10\log m$ with probability at least $1-m^{-3}$.

Combining Lemmas 25 and 26 with the union bound leads to the following analogue of Lemma 21.

Lemma 27**.**

Consider the following event $E^{\prime}$: We correctly identify the separation between the traces of $0^{\ell^{\prime}}$ and $1^{\ell^{\prime}}$ from every marker in the trace of $\mathsf{Enc}^{\prime}(x)$ by looking for all $1$’s that appear immediately after a run of at least $10\log m$ [math]’s.

Then, $E^{\prime}$ happens with probability at least $1-m^{-2}$ over the randomness of the trace.

As in Section 3.1, Lemma 27 implies that, conditioned on $E^{\prime}$ happening for a trace $T$ of $1^{\ell}||\mathsf{Enc}^{\prime}(y)||0^{\ell}$, we can split $T$ into independent sub-traces $T^{(i)}$ each distributed like a trace of $1^{\ell^{\prime}}||\mathsf{Enc}^{\prime\prime}(y^{(i)})||0^{\ell^{\prime}}$ conditioned on the high probability event $E^{\prime}$.

Let $\mathcal{A}$ denote the worst-case trace reconstruction algorithm from Lemma 10 for strings of length $O(m^{\prime})=O(\log^{2}m),$ with failure probability at most $\exp(-\Omega(\log^{2}m))$. A reasoning similar to that preceding (6) with Lemma 27 in place of Lemma 21, and the code $\mathcal{C}^{\prime}$ designed in this section in place of $\mathcal{C}$ shows that, using algorithm $\mathcal{A}$, we fail to recover $\mathsf{Enc}^{\prime}(y)$ from $\exp(O(\log^{2/3}m))$ i.i.d. traces of $1^{\ell}||\mathsf{Enc}^{\prime}(y)||0^{\ell}$ with probability at most

[TABLE]

Let $\mathcal{A}^{\prime}$ denote the algorithm that recovers $\mathsf{Enc}^{\prime}(y)$ from $\exp(O(\log^{2/3}m))$ i.i.d. traces of $1^{\ell}||\mathsf{Enc}^{\prime}(y)||0^{\ell}$ with failure probability at most $2/m$ as described above. We hope to instantiate (6) directly with $\mathcal{A}^{\prime}$ to obtain the desired upper bound on the reconstruction failure probability for $\mathcal{C}$. However, this approach does not produce a satisfactory result as the failure probability of $\mathcal{A^{\prime}}$ is $2/m=1/\textnormal{poly}(\log n)$, which is too large to be used in the union bound.

Recall from Section 3.1 that, given $x\in\{0,1\}^{n}$, the codeword $\mathsf{Enc}(x)$ of $\mathcal{C}$ is obtained by splitting $x$ into $n/\log^{2}n$ blocks $x^{(i)}$ and encoding each block with the encoder $\mathsf{Enc}^{\prime}$ associated with $\mathcal{C}^{\prime}$. From the discussion in the previous paragraph, a fraction of blocks $x^{(i)}$ will be reconstructed with errors. Below we argue that this fraction is of size at most $10/\log^{2}n_{0}$ with probability at least $1-2/n_{0}$. The reasoning is similar in spirit to that used to derive (5), and it suffices to complete the proof of Theorem 2. In fact, suppose we recovered $\tilde{x}$, which is a guess of $x$ with at most a $(10/\log^{2}n_{0})$-fraction of incorrect blocks. In particular, the relative Hamming distance between $\tilde{x}$ and $x$ is at most $10/\log^{2}n_{0}$. Since the relative distance of $\mathcal{C}_{\mathsf{Ham}}$ is at least $30/\log^{2}n_{0}$ and we assumed that $x\in\mathcal{C}_{\mathsf{Ham}}$, it follows that $\mathsf{Dec}_{\mathsf{Ham}}(\tilde{x})=\mathsf{Dec}_{\mathsf{Ham}}(x)=x_{0}$. Therefore, we conclude that we can recover the underlying message $x_{0}$ with probability at least $1-2/n_{0}$ from $\exp(O(\log^{2/3}m))=\exp(O(\log\log n_{0})^{2/3})$ i.i.d. traces of $\mathsf{Enc}_{0}(x)$. This proves Theorem 2.

As the last step, we show that the fraction of bad blocks is small enough with high probability. Suppose that we have access to $t=\exp(O(\log^{2/3}m))$ i.i.d. traces $T_{1},\dots,T_{t}$ of $\mathsf{Enc}(x)$, where $\mathsf{Enc}$ is the encoder associated with $\mathcal{C}$. Let $E$ denote the event from Lemma 21, and let $E_{\mathsf{all}}$ denote the event that $E$ holds for all $T_{i}$ simultaneously. As before, assuming that $E_{\mathsf{all}}$ holds, the strings $(T^{(i)}_{1},\dots,T^{(i)}_{t})_{1\leq i\leq n/\log^{2}n}$ are independent between all $i$, and each tuple of strings $T^{(i)}_{1},\dots,T^{(i)}_{t}$ is distributed as $t$ independent traces of $1^{\ell}||\mathsf{Enc}^{\prime}(x^{(i)})||0^{\ell}$, each $T^{(i)}_{j}$ also satisfying the conditions that the first run $1^{\ell}$ is not completely deleted, the last run $0^{\ell}$ has length at least $10\log n$ in the trace, and no run of [math]’s has length at least $10\log n$ in the trace of $\mathsf{Enc}^{\prime}(x^{(i)})$. Denote the event that both these conditions hold for $t$ independent traces of $1^{\ell}||\mathsf{Enc}^{\prime}(x^{(i)})||0^{\ell}$ by $E^{(i)}_{\mathsf{split}}$. Invoking the trace reconstruction algorithm $\mathcal{A^{\prime}}$ defined above, let $I^{(i)}_{\mathsf{indFail}}$ denote the indicator random variable of the event that $\mathcal{A^{\prime}}$ fails to recover $1^{\ell}||\mathsf{Enc}^{\prime}(x^{(i)})||0^{\ell}$ from $t$ independent traces of $1^{\ell}||\mathsf{Enc}^{\prime}(x^{(i)})||0^{\ell}$. Taking into account the previous discussion, we let $E_{\mathsf{fail}}$ denote the probability that more than a $(10/\log^{2}n_{0})$-fraction of blocks $x^{(i)}$ is recovered with errors. Then, we have

[TABLE]

The first equality follows from the discussion in the previous paragraph, and the second inequality follows from Lemma 21 and the fact that $n>n_{0}$. Recalling (8), which asserts that the failure probability for $\mathcal{A^{\prime}}$ is at most $2/m$, shows that

[TABLE]

holds for every $i$. Since the $I^{(i)}_{\mathsf{indFail}}$ are independent for all $i$, a standard application of the Chernoff bound yields the following lemma.

Lemma 28**.**

We have

[TABLE]

We remark that the Chernoff bound yields a stronger upper bound than the one featured in Lemma 28. However, for simplicity we use a weaker upper bound that still suffices for our needs. Combining (3.2) with Lemma 28 allows us to conclude that $\Pr[E_{\mathsf{fail}}]<2/n_{0}$, as desired.

3.3 A code for DNA-based data storage decodable from a few traces

We describe next how to adapt the ideas from Sections 3.1 and 3.2 and combine them with techniques from [43] in order to construct codes over the alphabet $\{A,C,G,T\}$ that have balanced $GC$-content and provably require few traces for reconstruction. As already pointed out, strings with balanced $GC$-content are significantly easier to synthesize than their non-balanced counterparts. Therefore, constructions accomodating this constraint are well-suited for use in DNA-based data storage.

The constructions follow those outlined in Sections 3.1 and 3.2. The only modifications are the choice of markers and the definition of the inner code. We focus on discussing these changes and their properties within the setting of Section 3.1. The full argument and the extension for the two-level marker-based construction of Section 3.2 follow in a straightforward manner.

We first describe the modified markers. The marker $M$ used throughout the section is of the form $M=(AC)^{\ell}||(TG)^{\ell}$, where $\ell=25\log n$ and $n$ is the message length. Observe that this marker has the same length as the original marker in Section 3.1. Moreover, $M$ has balanced $GC$-content.

In order to proceed as in Section 3.1 we need to design an efficiently encodable and decodable inner code $\mathcal{C}^{\prime}\subseteq\{A,C,T,G\}^{m^{\prime}}$ with balanced $GC$-content which satisfies a property analogous to Property 17.

Suppose that $\mathcal{C}^{\prime}$ has encoder $\mathsf{Enc}^{\prime}:\{0,1\}^{m}\to\{A,C,T,G\}^{m^{\prime}}$ and that $m^{\prime}=m/2+r$, where $m=\log^{2}n$ as in Section 3.1 and $r$ denotes the redundancy to be determined. Given the composition of $M$, the property we wish $\mathcal{C}^{\prime}$ to satisfy is the following:

Property 29**.**

For all $c\in\mathcal{C}^{\prime}$ and substrings $s$ of $c$ with $|s|=\sqrt{m}$, it holds that at least $|s|/3$ symbols of $s$ are $T$ or $G$.

Similarly to Lemma 20, it can be shown that if $\mathcal{C}^{\prime}$ satisfies Property 29, then with high probability a trace of $c\in\mathcal{C}^{\prime}$ will not contain long runs consisting only of symbols $A$ and $C$. As a result, with high probability we can easily split a trace into many sub-traces associated with different blocks as in Section 3.1. This is accomplished by looking for all long substrings of the trace consisting only of $A$’s and $C$’s in the trace. The reason is that, with high probability, each such substring consists of the trace of an $(AC)^{\ell}$ substring from a marker $M$ possibly with some extra symbols prepended. In that case we can correctly identify the separation between the traces of $(AC)^{\ell}$ and $(TG)^{\ell}$ in all markers by looking for the first $T$ or $G$ after every sufficiently long substring of $A$’s and $C$’s.

We proceed to describe the encoder $\mathsf{Enc}^{\prime}$ of the inner code $\mathcal{C}^{\prime}$ that has redundancy $r=O(\log m)$. We combine a technique from [43] with the code from Section 3.1.1. As an additional ingredient in the construction, we require an efficiently encodable and decodable binary balanced code $\mathcal{C}_{1}$ with encoder $\mathsf{Enc}_{1}:\{0,1\}^{m/2}\to\{0,1\}^{m/2+r_{1}}$. Nearly-optimal constructions of such codes are known, and they have redundancy $r_{1}=O(\log m)$ [44, 45]. Let $\mathcal{C}_{2}\subseteq\{0,1\}^{m/2+r_{2}}$ denote the code from Section 3.1.1 with encoder $\mathsf{Enc}_{1}:\{0,1\}^{m/2}\to\{0,1\}^{m/2+r_{2}}$ and redundancy $r_{2}=O(\log m)$. By padding one of $\mathcal{C}_{1}$ or $\mathcal{C}_{2}$ appropriately, we may assume that $r_{1}=r_{2}=r$, i.e., that both codes have the same block length. Similarly to [43], we define the bijection $\Psi:\{0,1\}^{n}\times\{0,1\}^{n}\to\{A,C,G,T\}^{n}$ as

[TABLE]

The code $\mathcal{C}^{\prime}$ is defined via an encoding $\mathsf{Enc}^{\prime}:\{0,1\}^{m}\to\{A,C,G,T\}^{m/2+r}$ of the form

[TABLE]

where $x=x^{(1)}||x^{(2)}\in\{0,1\}^{m/2}\times\{0,1\}^{m/2}$. It is clear that decoding $x$ from $\mathsf{Enc}^{\prime}(x)$ can be performed efficiently. We hence have the following lemma.

Lemma 30**.**

The inner code $\mathcal{C}^{\prime}$ has balanced $GC$-content and satisfies Property 29.

Proof.

Suppose that $c=\Psi(c_{1},c_{2}),$ where $c_{1}\in\mathcal{C}_{1}$ and $c_{2}\in\mathcal{C}_{2}$. To see that $c$ has balanced $GC$-content, note that the number of $C$’s and $G$’s in $c$ equals the weight of $c_{1}$. We have $w(c_{1})=|c_{1}|/2$ since $\mathcal{C}_{1}$ is a balanced code, and hence $c$ has balanced $GC$-content. To verify that $\mathcal{C}$ satisfies Property 29, note that the number of $T$’s and $G$’s within a substring $c[i,j]$ equals $w(c_{2}[i,j])$. Since $\mathcal{C}_{2}$ satisfies Property 17, the proof follows. ∎

Given Lemma 30, we can now proceed along the steps described in Section 3.1 by splitting a trace of $\mathcal{C}$ into many short sub-traces associated with different blocks, and then applying a worst-case trace reconstruction algorithm on each block. We remark that although the algorithm from Lemma 10 works for worst-case trace reconstruction over binary strings, it can be easily adapted for quaternary strings. In fact, if $t$ traces suffice for a worst-case trace reconstruction algorithm to reconstruct a string in $\{0,1\}^{n}$ with high probability, then a simple modification of this procedure recovers any quaternary string in $\{A,C,G,T\}^{n}$ with $2t$ traces. This is achieved by mapping the symbols in the first $t$ traces over $\{A,C,G,T\}$ to traces over $\{0,1\}$ according to, say, $A\mapsto 0,C\mapsto 0,G\mapsto 1,T\mapsto 1$, and the symbols in the last $t$ traces according to $A\mapsto 0,C\mapsto 1,G\mapsto 0,T\mapsto 1$. We can now run the binary worst-case algorithm on both sets of $t$ traces, and recover the original string over $\{A,C,G,T\}$ from the two outputs.

Taking into account the previous discussion, applying the reasoning from Section 3.1 to the marker $M$ and inner code $\mathcal{C}^{\prime}$ defined in this section leads to Theorem 3, which we restate for completeness.

Theorem 31** (Theorem 3, restated).**

For every deletion probability $d<1$, there exists an efficiently encodable code $\mathcal{C}\subseteq\{A,C,G,T\}^{n+r}$ with redundancy $r=O(n/\log n)$ and balanced $GC$-content that can be efficiently reconstructed from $\exp(O(\log n)^{2/3})$ traces.

Following the reasoning from Section 3.2 with the modified markers and $\mathcal{C}^{\prime\prime}$ instantiated with the inner code $\mathcal{C}^{\prime}$ we designed in this section proves Theorem 4, which we also restate for completeness.

Theorem 32** (Theorem 4, restated).**

For every constant deletion probability $d<1$, there exists an efficiently encodable code $\mathcal{C}\subseteq\{A,C,G,T\}^{n+r}$ with redundancy $r=O(n/\log\log n)$ and balanced $GC$-content that can be efficiently reconstructed from $\exp(O(\log\log n)^{2/3})$ traces.

Finally, two comments are in place regarding the choice of markers. First, the marker sequence $M=(AC)^{\ell}||(TG)^{\ell}$ may lead to hairpin formations when single stranded DNA is used. Hairpins are double-stranded folds, but may be easily controlled through addition of urea or through temperature increase. Second, repeats such as marker repeats are undesirable as they may lead to issues during DNA synthesis. To mitigate this issue, one can alternate marker sequences. For example, two valid marker options are $(AC)^{\ell}||(TG)^{\ell}$ and $(AG)^{\ell}||(TC)^{\ell}$, and any other marker where the sets of symbols used in each side are disjoint and $C$ and $G$ do not appear in the same side is appropriate for use in the construction.

Note that alternating markers in turn requires alternating the inner codes used between markers. This can be accommodated in a straightforward manner. Suppose that the block $x^{(i)}$ precedes an $(AC)^{\ell}||(TG)^{\ell}$ marker. Then, we encode $x^{(i)}$ as usual with $\mathsf{Enc}^{\prime}$ as defined in this section. However, if $x^{(i)}$ precedes an $(AG)^{\ell}||(TC)^{\ell}$ marker, then we encode $x^{(i)}$ by first computing $\mathsf{Enc}^{\prime}(x^{(i)})$, and then swapping all $G$’s and $C$’s in the encoding. Observe that in both cases the encoding has balanced $GC$-content. Moreover, since $\mathcal{C}^{\prime}$ satisfies Property 29, with high probability the trace of each block’s encoding will not have long substrings containing only $A$’s and $C$’s (resp. $A$’s and $G$’s) before an $(AC)^{\ell}||(TG)^{\ell}$ marker (resp. $(AG)^{\ell}||(TC)^{\ell}$ marker). As before, this means that, with high probability, we can correctly split the full trace into the relevant sub-traces by alternately looking for long substrings composed of $A$’s and $C$’s only, and of $A$’s and $A$’s and $G$’s only. In fact, the end of such long substrings corresponds to the beginning of the traces of the $(TG)^{\ell}$ and $(TC)^{\ell}$ substrings of the marker, respectively.

4 Reducing the number of traces for small constant deletion probability

In Section 3, we gave a construction of marker-based codes that require a few traces for reconstruction. A simple property of the inner code ensured that we can correctly identify all markers with high probability, effectively dividing the global trace into many independent, shorter traces. After this, we applied the state-of-the-art worst-case trace reconstruction algorithm from Lemma 10 on each short trace in order to obtain the desired codes.

It seems plausible, however, that one could design the inner code more carefully so that many fewer traces are needed to recover the short codewords contained between the markers. This is the main problem we address in this section. We design a code that, when used as the inner code in the construction from Section 3, leads to an almost exponential reduction of the number of traces required for reconstruction with only a slight decrease in the code rate, provided that the deletion probability is a sufficiently small constant. The trace reconstruction algorithm we use is a variation of the algorithm for average-case trace reconstruction described in [2, Section 2.3].

Our starting point is a low redundancy code with the property that it can be reconstructed from $\textnormal{poly}(n)$ traces. We discuss this construction in Section 4.1. Then, in Section 4.2 we show how to adapt this code so that it can be successfully used as an inner code in the marker-based construction introduced in Section 3.

4.1 Low redundancy codes reconstructable from polynomially many traces

In what follows, we prove Theorem 5. We restate the result for convenience.

Theorem 33** (Theorem 5, restated).**

For small enough deletion probability $d$, there exists an efficiently encodable code $\mathcal{C}\subseteq\{0,1\}^{n+r}$ with encoder $\mathsf{Enc}:\{0,1\}^{n}\to\{0,1\}^{n+r}$ and redundancy $r=O(\log n)$ that can be efficiently reconstructed from $\textnormal{poly}(n)$ traces with probability at least $1-\exp(-n)$.

The code we construct to prove Theorem 5 will be the starting point for the proof of Theorem 6 in Section 4.2. Roughly speaking, our code encodes $n$-bit messages into codewords that are almost $w$-subsequence-unique for $w=O(\log n)$, in the sense that all but the first $O(\log n)$ bits of the codeword comprise a $w$-subsequence-unique string. This is possible because an $\epsilon$-almost $k$-wise independent random variable over $\{0,1\}^{n}$ with the appropriate parameters is $w$-subsequence-unique with high probability. We make this statement rigorous in the following lemma. We note that the technique in the lemma below has already been used in [42] to obtain strings satisfying related properties, such as substring-uniqueness, with high probability.

Lemma 34**.**

Let $g:\{0,1\}^{t}\to\{0,1\}^{m}$ be the function guaranteed by Lemma 8 with $k=3w$ and $\epsilon=2^{-10w}$ for $w=100\log m$ (hence $t=O(\log m)$). Fix some $x\in\{0,1\}^{m}$ and define the random variable $Y=x+g(U_{t})$. Then, with probability at least $1-1/\textnormal{poly}(m)$ it holds that $Y$ is $w$-subsequence-unique.

Proof.

First, note that $Y$ is $\epsilon$-almost $k$-wise independent. This proof follows along the same lines as the proof that a random string is $w$-subsequence-unique with high probability found in [2, Lemma 2.6] with a few simple modifications.

Without loss of generality, fix $a$ and $b$ such that $a<b$, and fix distinct indices $i_{1},\dots,i_{w}\in[b,\dots,b+1.1w)$. For convenience, let $\mathcal{S}=\{i_{1},\dots,i_{w}\}$, $\mathcal{S}^{\prime}=[b,b+1.1w)-\mathcal{S}$, and $u=\min(a+w,b)$. Then,

[TABLE]

We now show that $Y[a,u)$ and $Y_{\mathcal{S}^{\prime}}$ completely determine $Y_{\mathcal{S}}$ under the constraint $Y_{\mathcal{S}}=Y[a,a+w)$. This can be seen by induction. First, we must have $Y_{i_{1}}=Y_{a}$, and $Y_{a}$ is determined by $Y[a,u)$ since $a<u$. Now, suppose that $Y_{i_{1}},\dots,Y_{i_{j}}$ are determined by $Y[a,u)$ and $Y_{\mathcal{S}^{\prime}}$. It must be the case that $Y_{i_{j+1}}=Y_{a+j}$. If $a+j<u$ or $a+j\in\mathcal{S}^{\prime}$, then $Y_{i_{j+1}}$ is determined by $Y[a,u)$ or $Y_{\mathcal{S}^{\prime}}$, respectively. On the other hand, if $a+j\geq u$ and $a+j\not\in\mathcal{S}^{\prime}$, then $Y_{a+j}=Y_{i_{d}}$ for some $d<j+1$. By the induction hypothesis, $Y_{i_{d}}$ is determined by $Y[a,u)$ and $Y_{\mathcal{S}^{\prime}}$, and hence $Y_{i_{j+1}}$ is, too.

As a result, we conclude that there exists a string $\overline{y}=(\overline{y}_{1},\dots,\overline{y}_{w})$ completely determined by $y$ and $y^{\prime}$ such that

[TABLE]

Since $Y$ is $\epsilon$-almost $3w$-wise independent and fewer than $3w$ coordinates are fixed, we have

[TABLE]

for all $y$ and $y^{\prime}$. Combining (10), (11), and (12), we conclude that

[TABLE]

since $u-a\leq w$ and $\epsilon=2^{-10w}$. Since there are $\binom{1.1w}{w}$ choices for $\mathcal{S}$ for each pair $(a,b)$ and fewer than $m^{2}$ possible pairs $(a,b)$, the probability that $Y$ is not $w$-subsequence-unique is at most

[TABLE]

as desired. ∎

Lemma 34 naturally leads to a simple, efficient candidate construction of the encoder $\mathsf{Enc}$: Given $x\in\{0,1\}^{n}$, we first iterate over all $z\in\{0,1\}^{t}$ until we find $z$ such that $x+g(z)$ is $w$-subsequence-unique. Most strings $z$ satisfy this, according to Lemma 34. Moreover, since $t=O(\log n)$, we can iterate over all such $z$ in time $\textnormal{poly}(n)$, and verify whether $x+g(z)$ is $w$-subsequence-unique for each $z$ in $\textnormal{poly}(n)$ time. To recover $x$ from $x+g(z)$ we need to provide $z$ to the receiver. Therefore, the encoder $\mathsf{Enc}$ for $\mathcal{C}$ maps a message $x\in\{0,1\}^{n}$ to the codeword

[TABLE]

where $z$ is the first string (in lexicographic order) such that $x+g(z)$ is $w$-subsequence-unique. Observe that the redundancy of $\mathcal{C}$ is exactly $t=O(\log n)$.

4.1.1 The trace reconstruction algorithm

In this section, we describe an efficient trace reconstruction algorithm for $\mathcal{C}$ that works whenever the deletion probability is a small enough constant, thus proving Theorem 5. This algorithm works very similarly to the one introduced in [2] and described in Section 2.4.2. As before, we shall set $w=100\log n$, $v=w/d=O(\log n)$ and $j=(v-0.1w)(1-3d)=O(\log n)$. Given a codeword $c=\mathsf{Enc}(x)=z||x+g(z)$, we proceed as follows: First, we apply the algorithm from Lemma 14 to recover $z$ and the first $2v+w=O(\log n)$ bits of $y=x+g(z)$ with $\textnormal{poly}(n)$ traces (repeating the process $O(n)$ times if necessary) and success probability $1-\exp(-\Omega(n))$. Now, suppose that we know $y_{1},\dots,y_{i-1}$ for $i-1\geq 2v+w$. We show how to find $y_{i}$ with probability $1-\exp(-\Omega(n))$ from $\textnormal{poly}(n)$ traces, which concludes the proof of Theorem 5.

Let $T$ denote a trace of $c$. As in Section 2.4.2, we will look for a matching of $y[i-v-w,i-v)$ within $T$. However, we shall discard matchings that occur too early in $T$. More precisely, suppose that $y[i-v-w,i-v)$ is matched with $T[u-w,u)$. We call such a matching good if $u-w>|z|$. If $T$ does not contain a good matching of $y[i-v-w,i-v)$, we discard it. Otherwise, if the first good matching occurs at $T[u-w,u)$, we let $V=T[u,\cdot]$ and discard the remaining bits of $T$. Our observations so far are summarized in the following lemmas.

Lemma 35**.**

For $d$ small enough, the probability that a good matching occurs in $T$ is at least $2^{-(w+1)}$.

Proof.

First, observe that the probability that no bit in $y[i-v-w,i-v)$ is deleted is exactly $(1-d)^{w}\geq 2^{-w}$. Given this, suppose that $y[i-v-w,i-v)$ shows up in positions $T[U-w,U)$. Then, the probability that the given matching is good equals $\Pr[U>|z|+w]$, and $|z|+w\leq Cw$ for a fixed constant $C>0$, since $|z|=O(\log n)$. Note that we may assume $i-v-w\geq v=w/d$ since we have already learned the first $2v+w$ bits of $y$. We may also choose $d<1/10$ small enough such that $v>Cw$. Then, we have

[TABLE]

where the last inequality follows from an application of the Chernoff bound. Concluding, the trace $T$ contains a good matching with probability at least $1/2\cdot 2^{-w}=2^{-(w+1)}$. ∎

Lemma 36**.**

The probability that the last bit of a good matching in $T$ does not come from $y[i-v,i-v+0.1w)$ is at most $nd^{-w/100}\leq 2^{-100w}$ if $d$ is small enough.

Proof.

The probability that the event in question happens is at most the probability that more than $0.1w$ bits are deleted from some substring $y[b,b+1.1w)$. To see this, first note that the bits in a good matching must come from $y$. If at most $0.1w$ bits are deleted from every substring $y[b,b+1.1w)$, then the $w$ bits of the good matching in $T$ for $y[i-v-w,i-v)$ must be a subsequence of $y[b,b+1.1w)$ for some $b$, which means $y[i-v-w,i-v)$ appears as a subsequence of $y[b,b+1.1w)$. Since $y$ is $w$-subsequence-unique, for this to happen we must have $b\leq i-v-w$ and $b+1.1w\geq i-v$. Now suppose that the last bit of the good matching in $T$ does not come from $y[i-v,i-v+0.1w)$. Then, it must be the case that $y[i-v-w,i-v)$ is a subsequence of $y[b,i-v-1)$. Since $i-v-1<i-v$, this violates the $w$-subsequence-uniqueness propery of $y$.

For a fixed $b$, the probability that more than $0.1w$ bits are deleted from $y[b,b+1.1w)$ is at most $d^{-w/100}$ for $d$ small enough. The result then follows by a union bound, since there are fewer than $n$ choices for $b$. ∎

Let $E_{\textsf{good}}$ denote the event that a good matching occurs in $T$. From Lemma 35 and the fact that we can efficiently check whether $E_{\textsf{good}}$ occurred for $T$, it follows that we can efficiently estimate

[TABLE]

to within an error of, say, $2^{-100w}$ from $\textnormal{poly}(n)$ traces, with probability at least $1-\exp(-\Omega(n))$. Then, we proceed similarly to Section 2.4.2. Let $R$ be the random variable denoting the coordinate in $y$ of the last bit appearing in the good matching within $T$. We may then write

[TABLE]

for $0\leq\epsilon_{i}(c)\leq 2^{-100w}$, by Lemma 36. The second equality follows because, once $R=r$ is fixed, $V$ does not depend on whether $E_{\textsf{good}}$ occurs or not, but only depends on the traces of $z$ and $y[1,r]$. Therefore, as in (1) and (2) we have

[TABLE]

and

[TABLE]

Similarly to what was done in Section 2.4.2, since $i-r\leq v$ and $v=w/d$, the second part of Lemma 13 implies that $P(i-r,j)\geq 2^{-9w}$. Combining this result with Lemma 36 shows that the gap between the right hand sides of (14) and (15) is at least $2^{-(9w+1)}$. Each term $\Pr[R=r|E_{\textsf{good}}]$ can be approximated to within an error of $2^{-90w}$ with probability at least $1-\exp(-\Omega(n))$ in time $\textnormal{poly}(n)$. This is accomplished by first using $z$ and the values $y_{1},\dots,y_{i-1}$ that we have already recovered to estimate $\Pr[R=r|E_{\textsf{good}},R<i]$ to within a small enough error and with high probability. Then, the fact that $\Pr[R<i|E_{\textsf{good}}]\geq 1-2^{-100w}$ and Lemma 36 imply that

[TABLE]

which in turn implies a good enough approximation for $\Pr[R=r|E_{\textsf{good}}]$.

Since we know $y_{1},\dots,y_{i-1}$, the discussion above suggests that we can approximate the right hand side of (14) and (15) to within an error of

[TABLE]

with high probability. As already mentioned, we can estimate $\Pr[V_{j}=1|E_{\textsf{good}}]$ to within error $2^{-100w}$ from $\textnormal{poly}(n)$ traces in time $\textnormal{poly}(n)$ with probability at least $1-\exp(-\Omega(n))$. Consequently, with probability $1-\exp(-\Omega(n))$ we can recover $y_{i}$ correctly from $\textnormal{poly}(n)$ traces, where the degree of this polynomial is independent of $i$. The success probability can be made at least $1-\exp(-Cn)$ for any fixed constant $C$ of our choice by repeating the process $O(n)$ times and taking the majority vote. Overall, we must recover fewer than $n$ positions of $y$, and each position requires $\textnormal{poly}(n)$ traces, where the degree of this polynomial is independent of the position of the bit. As a result, the total number of traces required is $\textnormal{poly}(n)$ and the overall success probability is $1-1/\textnormal{poly}(n)$. This proves Theorem 5.

4.2 Using the code within a marker-based construction

Next, we combine the constructions from Sections 3 and 4.1 with some additional modifications in order to prove Theorem 6, which we restate here.

Theorem 37** (Theorem 6, restated).**

For small enough deletion probability, there exists an efficiently encodable code $\mathcal{C}$ with encoder $\mathsf{Enc}:\{0,1\}^{n}\to\{0,1\}^{n+r}$ and redundancy r=O\mathopen{}\mathclose{{}\left(\frac{n}{\log n}}\right) that can be efficiently reconstructed from $\textnormal{poly}(\log n)$ traces with probability $1-1/\textnormal{poly}(n)$.

The basic idea is that we would like to use the code designed in Section 4.1 as the inner code $\mathcal{C}^{\prime}$ for the construction of $\mathcal{C}$ in Section 3. Then, we could apply the trace reconstruction algorithm from Section 4.1.1 on each sub-trace and mitigate the use of worst-case trace reconstruction algorithms. This idea does not work as is, but some modifications to the code from Section 4.1 will allow the construction to go through.

The first issue we have to address is for the inner code $\mathcal{C}^{\prime}$ to satisfy Property 17. If this property holds, then the reasoning of Section 3 implies that we can focus on the trace reconstruction problem for strings of the form

[TABLE]

where $c\in\mathcal{C}^{\prime}$ has length $O(\log^{2}n)$ and $\ell=O(\log n)$, as long as we use a sub-polynomial number of traces in $n$. From here onwards we focus solely on this setting. If we were to directly apply the trace reconstruction algorithm from Section 4.1.1, we would run into a problem. For the aforementioned algorithm to work, we need to bootstrap it by recovering the first few bits of $c$ using the procedure described in Lemma 14. However, in this case $c$ only appears after a run of length $\ell=O(\log n)$. Even though we know the previous bits, we still require $\textnormal{poly}(n)$ traces to recover the first bit of $c$ in this way, which is not acceptable as we want to use $\textnormal{poly}(\log n)$ traces. Consequently, we need an alternative bootstrapping method. Another issue we need to resolve is that the reconstruction algorithm from Section 4.1.1 assumed that all but the first few bits of $c$ lead to a subsequence-unique string. However, this is not the case here, as we must deal with a string of the form $c||0^{\ell}$.

Before we proceed to describe a modified version of our code from Section 4.1 that avoids the issues raised above, we first prove the following lemma.

Lemma 38**.**

Let $g:\{0,1\}^{t}\to\{0,1\}^{m}$ be the function guaranteed by Lemma 8 with $k=3w$ and $\epsilon=2^{-10w}$ for $w=100\log m$ (hence $t=O(\log m)$). For arbitrary $\ell$ and $x\in\{0,1\}^{m}$, define the random variable $Y=x+g(U_{t})||0^{\ell}$. Then, with probability at least $1-1/\textnormal{poly}(m)$ we have that $Y$ satisfies the following property.

Property 39**.**

For any $a$ and $b$ such that $a+w\leq\min(m+1,b)$, we have that $Y[a,a+w)$ is not a subsequence of $Y[b,b+1.1w)$.

Proof.

Fix a pair $(a,b)$ satisfying $a+w\leq\min(m+1,b)$ and let $\mathcal{S}\subseteq[b,b+1.1w)$ be a set of size $w$. Let $u=\min(m+1,b+1.1w)$. Then, we have

[TABLE]

Observing that $Y_{\mathcal{S}}$ is completely determined by $Y[b,u)$ and $Y[m+1,b+1.1w)$ and that $Y[m+1,b+1.1w)$ is fixed, we have

[TABLE]

for some $y^{\prime}$ determined by $y$. Since $x+g(U_{t})$ is $\epsilon$-almost $3w$-wise independent and fewer than $3w$ coordinates are fixed, we have

[TABLE]

Therefore, it follows that

[TABLE]

Since there are fewer than $m^{3}$ choices for pairs $(a,b)$ and $\binom{1.1w}{w}$ choices for $\mathcal{S}$, from the union bound we conclude similarly to what we did in the proof of Lemma 34 that the probability that the desired event does not happen is at most $m^{3}\binom{1.1w}{w}2^{-w+1}\leq m^{-45}$. ∎

Intuitively, Lemma 38 guarantees that $x+g(U_{t})$ satisfies a stronger form of subsequence-uniqueness with high probability. In fact, not only is $x+g(U_{t})$ $w$-subsequence-unique with high probability based on Lemma 34, but also is it impossible to find a substring of $x+g(U_{t})$ that is a subsequence of $x+g(U_{t})||0^{\ell}$ elsewhere.

We are now ready to describe our modified inner code $\mathcal{C}^{\prime}$ with encoder $\mathsf{Enc}^{\prime}:\{0,1\}^{m}\to\{0,1\}^{m+r^{\prime}}$. On an input message $x\in\{0,1\}^{m}$, $\mathsf{Enc}^{\prime}$ operates as follows:

Set $x^{\prime}=0^{\ell^{\prime}}||x$ for $\ell^{\prime}=10\ell=O(\sqrt{m})$. Let $m^{\prime}=|x^{\prime}|$ and set $w=100\log m^{\prime}$; 2. 2.

Iterate over all $z\in\{0,1\}^{t}$ for $t=O(\log m^{\prime})=O(\log m)$ until a $z$ such that $x^{\prime}+g(z)$ is $w$-subsequence-unique and simultaneously satisfies Properties 23 and 39 is found. Such a string $z$ is guaranteed to exist because all such properties hold for $x^{\prime}+g(U_{t})$ with probability $1-o(1)$ (see Lemmas 22, 34, and 38). Moreover, whether $x^{\prime}+g(z)$ satisfies all three properties can be checked in time $\textnormal{poly}(m)$; 3. 3.

Obtain $z^{\prime}$ from $z$ by setting $z^{\prime}=\mathsf{Enc}_{\mathsf{edit}}(0||z)$, where $\mathsf{Enc}_{\mathsf{edit}}$ is the encoder of the systematic code $\mathcal{C}_{\mathsf{edit}}$ from Lemma 9 robust against $|z|/2$ edit errors and with redundancy $O(|z|)=O(\log m)$. Here, $d$ is assumed to be a small enough constant so that $5d|z^{\prime}|<|z|/2$, i.e., $\mathcal{C}_{\mathsf{edit}}$ can correct a $5d$-fraction of edit errors in $z^{\prime}$. This is possible because $|z^{\prime}|=O(|z|)$; 4. 4.

Define $\mathsf{Enc}^{\prime}(x)=z^{\prime}||x^{\prime}+g(z)=z^{\prime}||y^{\prime}$.

For a given message $x\in\{0,1\}^{m}$, we can compute $\mathsf{Enc}^{\prime}(x)$ in time $\textnormal{poly}(m)$. Furthermore, recalling that $m=\log^{2}n$ in the construction of Section 3.1, the redundancy of $\mathcal{C}^{\prime}$ is

[TABLE]

If we use $\mathcal{C}^{\prime}$ as the inner code in the construction of $\mathcal{C}$ from Section 3.1, then according to (3) we obtain an overall redundancy r=O\mathopen{}\mathclose{{}\left(\frac{n}{\log n}}\right) for $\mathcal{C}$, as desired. It is also easy to see that $\mathcal{C}^{\prime}$ satisfies Property 17. By the choice of $z$, we have $w(y^{\prime}[a,a+w))\geq 0.4w$ for every $a$ and $w=100\log m^{\prime}$. Therefore, for any substring $s$ such that $|s|=\sqrt{m}$ we have

[TABLE]

provided $m$ is large enough, since $|z^{\prime}|=O(\log m)$. As a result, the reasoning used in Section 3.1 applies to this choice of $\mathcal{C}^{\prime}$. To prove Theorem 6, it remains to give a trace reconstruction algorithm to recover strings of the form $1^{\ell}||\mathsf{Enc}^{\prime}(x)||0^{\ell}$ from $\textnormal{poly}(m)=\textnormal{poly}(\log n)$ traces with probability, say, $1-n^{-10}$.

To address the problem, suppose we already have such an algorithm, and call it $\mathcal{A}$. Recall (6) and the definition of the event $E^{(i)}_{\mathsf{indFail}}$ from Section 3.1. Instantiating $E^{(i)}_{\mathsf{indFail}}$ with algorithm $\mathcal{A}$ leads to the bound $\Pr[E^{(i)}_{\mathsf{indFail}}]\leq n^{-10},$ for all $i$. Combining this observation with (6) allows us to conclude that the probability that we successfully recover $c\in\mathcal{C}$ from $\textnormal{poly}(\log n)$ i.i.d. traces of $c$ is at least $1-2/n$. Similarly to Section 3.1, we can boost the success probability to $1-1/p(n)$ for any fixed polynomial of our choice by repeating the process $O(\log n)$ times and by taking a majority vote.

4.2.1 The trace reconstruction algorithm

Next, we analyze an algorithm for recovering strings of the form $1^{\ell}||\mathsf{Enc}^{\prime}(x)||0^{\ell}$ from $\textnormal{poly}(m)=\textnormal{poly}(\log n)$ traces with probability $1-1/\textnormal{poly}(n)$. As discussed before, we proceed by adapting the algorithm from Section 4.1.1, which in turn is a modified version of the algorithm from [2] described in Section 2.4.2.

The main difference between the current and the two previously discussed settings is that the original bootstrapping technique cannot be applied, as $\mathsf{Enc}^{\prime}(x)$ is enclosed by two long runs. We start by showing that the structure of $\mathsf{Enc}^{\prime}$ allows for a simple alternative bootstrapping method.

Recall that $c=\mathsf{Enc}^{\prime}(x)=z^{\prime}||y^{\prime}$, where $y^{\prime}=x^{\prime}+g(z)$ and the first $O(\sqrt{m})$ bits of $x^{\prime}$ are zero. Therefore, if we can recover $z$ from a few traces of $1^{\ell}||c||0^{\ell}$, then we can recover the first $O(\sqrt{m})$ bits of $y^{\prime}$, which suffices for bootstrapping, by simply computing $g(z)$. The following lemma states that we can recover $z$ with high probability from $O(\log n)$ traces.

Lemma 40**.**

There is an algorithm that recovers $z$ from $O(\log n)$ traces of $1^{\ell}||c||0^{\ell}$ with probability at least $1-n^{-10}$.

Proof.

We begin by recalling that $z^{\prime}=\mathsf{Enc}_{\mathsf{edit}}(0||z)$, and that $\mathcal{C}_{\mathsf{edit}}$ is systematic. This means $z^{\prime}_{1}=0$, and so with probability $1-d$ the first [math] appearing in the trace will correspond to $z^{\prime}_{1}$.

Given a trace $T$ of $1^{\ell}||c||0^{\ell}$, we proceed as follows: Let $u$ denote the position of the first [math] in $T$. Then, we take $\tilde{z}=T[u,u+(1-d)|z^{\prime}|)$, feed $\tilde{z}$ into $\mathsf{Dec}_{\mathsf{edit}}$, and let the corresponding output be our guess for $z$. The probability that this procedure fails to yield $z$ is at most the probability that $z^{\prime}_{1}$ was deleted, plus the probability that $\tilde{z}$ is too far away in edit distance from $z^{\prime}$ given that $z^{\prime}_{1}$ was not deleted. We proceed to bound both probabilities. First, the probability that $z^{\prime}_{1}$ is deleted is exactly $d$. Second, we assume $z^{\prime}_{1}$ is not deleted and let $L$ denote the length of the trace of $z^{\prime}[2,\cdot]$ within $T$. We have $\mathds{E}[L]=(1-d)(|z^{\prime}|-1)$. Therefore, a Chernoff bound gives

[TABLE]

Since $d$ is a constant and $|z^{\prime}|=\Theta(\log m)$, we conclude that for $m$ large enough we have

[TABLE]

As a result, with probability at least $4/5$ we have that $\tilde{z}$ is within edit distance $5d|z^{\prime}|<|z|/2$ from $z^{\prime}$. If this distance condition holds, then $\mathsf{Dec}_{\mathsf{edit}}(\tilde{z})=z$.

In summary, the procedure fails to return $z$ with probability at most $d+1/5<1/4$ if $d$ is small enough. Repeating this procedure $O(\log n)$ times and taking the majority vote ensures via a Chernoff bound that we can recover $z$ from $O(\log n)$ traces with success probability at least $1-1/p(n),$ for $p$ any choice of a fixed polynomial. ∎

Once $z$ has been recovered, the bits of $1^{\ell}||c||0^{\ell}=1^{\ell}||z^{\prime}||y^{\prime}||0^{\ell}$ are known up to and including the first $\ell^{\prime}=O(\sqrt{m})$ bits of $y^{\prime}$. Our last task is to recover the remaining bits of $y^{\prime}$, and given that we have sufficiently many initial bits from $y^{\prime}$ we may to this end use the ideas from Section 4.1.1. The differences with respect to Section 4.1.1 are the following:

• •

Instead of $y$, we use $y^{\prime\prime}=y^{\prime}||0^{\ell}$;

• •

We are only interested in recovering $y^{\prime\prime}_{i}$ for $\ell^{\prime}<i\leq|y^{\prime}|$, since we already know all other bits of $y^{\prime\prime}$;

• •

We change the threshold used to declare that a matching is good: In this case, if $T$ is a trace of $1^{\ell}||c||0^{\ell}$ and $y^{\prime\prime}[i-v-w,i-v]$ is matched with $T[u-w,u]$, then the matching is said to be good if $u-w>\ell+|z^{\prime}|$. This change ensures that the bits in a good matching always come from $y^{\prime\prime}=y^{\prime}||0^{\ell}$.

Two key lemmas now follow from the previous discussion. Their statements and proofs are similar to the ones of Lemmas 35 and 36 from Section 4.1.1, respectively, and we hence only discuss relevant differences. Henceforth, we use $T$ to denote a trace of $1^{\ell}||c||0^{\ell}$.

Lemma 41**.**

The probability that a good matching occurs in $T$ is at least $2^{-(w+1)}$.

Lemma 42**.**

For $\ell^{\prime}<i\leq|y^{\prime}|$, the probability that the last bit of a good matching in $T$ does not come from $y^{\prime\prime}[i-v,i-v+0.1w]$ is at most $nd^{-w/100}\leq 2^{-100w}$ if $d$ is small enough.

Proof.

Similarly to the proof of Lemma 36, the probability of the event in the statement of the lemma is upper bounded by the probability that more than $0.1w$ bits are deleted from some substring $y^{\prime\prime}[b,b+1.1w)$. We explain next why this is true. First, note that the bits in a good matching must come from $y^{\prime\prime}$. Suppose that at most $0.1w$ bits are deleted from every substring $y^{\prime\prime}[b,b+1.1w)$. Then, $y^{\prime\prime}[i-v-w,i-v)$ must be a subsequence of $y^{\prime\prime}[b,b+1.1w)$ for some $1\leq b\leq|y^{\prime\prime}|-1.1w$. We distinguish two cases:

• •

$b+1.1w>|y^{\prime}|$:

Recalling that $v=w/d$, we have $i-v\leq|y^{\prime}|-w/d\leq|y^{\prime}|-1.1w\leq\min(|y^{\prime}|+1,b)$, and so Property 39 holds for $y^{\prime\prime}[i-v-w,i-v)$. Therefore, $y^{\prime\prime}[i-v-w,i-v)$ cannot be a subsequence of $y^{\prime\prime}[b,b+1.1w)$ for any $b$ such that $b+1.1w>|y^{\prime}|+1$. Consequently, we only need to consider values of $b$ such that $b+1.1w\leq|y^{\prime}|$;

• •

$b+1.1w\leq|y^{\prime}|$:

Since $y^{\prime}$ is $w$-subsequence-unique, we must have $b\leq i-v-w$ and $b+1.1w\geq i-v$. This implies the desired result as in the proof of Lemma 36;

The remainder of the proof follows along the lines of the proof of Lemma 36. ∎

Lemmas 41 and 42 imply that we can recover $y^{\prime\prime}_{i}$ with probability $1-1/\textnormal{poly}(n)$ via the same reasoning of Section 4.1.1 with the small differences described above. The number of traces required to recover $y^{\prime\prime}_{i}$ is polynomial in the length of $1^{\ell}||c||0^{\ell}$, which equals

[TABLE]

Since $m=\log^{2}n$, it follows that we can recover $y^{\prime\prime}_{i}$ with probability $1-1/\textnormal{poly}(n)$ from $\textnormal{poly}(\log n)$ traces. In particular, the success probability can be assumed to be at least $1-1/p(n)$ for a fixed polynomial of our choice since we can repeat the process $O(\log n)$ times and take the majority vote while still requiring $\textnormal{poly}(\log n)$ traces. Since Lemma 40 asserts that $O(\log n)$ traces suffice to recover $z$ with high probability, and we need to recover $m=\log^{2}n$ bits of $y^{\prime\prime}$, we overall require $\textnormal{poly}(\log n)$ traces to recover $1^{\ell}||c||0^{\ell}$ with probability $1-1/\textnormal{poly}(n)$. This concludes the proof of Theorem 6.

5 Open problems

The newly introduced topic of coded trace reconstruction can be extended in many different directions, in which the following problems are of interest:

• •

Coded trace reconstruction based on a more general set of edit errors. Our constructions only work against i.i.d. deletions. However, errors imposed by the nanopore sequencing process in DNA-based storage also include insertions and substitutions, and the errors may be symbol and context-dependent;

• •

Narrowing the gap between upper and lower bounds on the number of traces used in reconstruction. The current gap between lower and upper bounds for trace reconstruction is almost exponential in the string length, and there is no study of lower bounds on coded trace reconstruction as a function of the redundancy of the code. We suspect that our current construction of efficient codes are suboptimal;

• •

The main contributors to the redundancy in all but one of our constructions are the markers placed between blocks. It is of interest to find other constructions that either do not use markers, or that use shorter markers that can still be integrated into the trace reconstruction process.

Appendix A Tradeoff between redundancy and relative Hamming distance for efficiently encodable/decodable binary codes

We establish next the existence of efficiently encodable and decodable codes $\mathcal{C}_{\mathsf{Ham}}\subseteq\{0,1\}^{n}$ with encoder $\mathsf{Enc}_{\mathsf{Ham}}:\{0,1\}^{n_{0}}\to\{0,1\}^{n}$, relative Hamming distance at least $30/\log^{2}n_{0}$, and redundancy n-n_{0}=O\mathopen{}\mathclose{{}\left(n_{0}\frac{\log\log n_{0}}{\log n_{0}}}\right). We make use of the Zyablov bound [46, Sections 10.2], which states that an efficiently encodable and decodable binary code with rate $R$ and relative Hamming distance $\delta$ exists for $R$ and $\delta$ satisfying

[TABLE]

where $\epsilon>0$ is arbitrary. This bound is achieved by concatenating a Reed-Solomon outer code with an inner linear code lying on the Gilbert-Varshamov bound. The relevant generator matrices can be constructed in time polynomial in the block length of the concatenated code, and one can efficiently correct substitution errors up to half of its designed distance via generalized minimum distance decoding [46, Section 11.3].

We set $\delta=30/\log^{2}n_{0}$ and $\epsilon=1/\log^{2}n_{0}$. Then,

[TABLE]

for $n_{0}$ large enough. The inequality follows from the fact that $h(p)\leq-2p\log p$ for $p$ small enough. We set $r=1-\frac{\log\log n_{0}}{\log n_{0}}$ and observe that $r<1-h(\delta+\epsilon)$ for $n_{0}$ large enough. Moreover, we have

[TABLE]

As a result,

[TABLE]

Combining (A) with the previously described choice for $r$, it follows that

[TABLE]

and hence the corresponding redundancy is O\mathopen{}\mathclose{{}\left(n_{0}\frac{\log\log n_{0}}{\log n_{0}}}\right), as desired.