Draft, Verify, Repair: Reading DNA Archives with Fewer Sequencing Reads

Data stored in synthetic DNA is written as thousands of short strands mixed in one tube. Reading it means copying the strands with PCR (the polymerase chain reaction, which roughly doubles every strand each heating cycle) and sequencing a random sample of the copies. Strands do not copy equally well. Gimpel et al. tracked 12,000 strands over 90 cycles. They found that strands carrying self-priming motifs lose half their relative abundance every 14 cycles, and that a few percent difference in copying efficiency is enough to make a strand vanish. The usual fix is to sequence far deeper than the file size requires, until nearly every strand has been seen. This proposal takes the view of a distributed storage engineer instead. A vanished strand is a failed storage node. Strands that share a bad motif fail together, like disks on one rack. And the cost that matters is not network traffic but sequencing reads.

The core claim is that a DNA file protected by an outer erasure code never needs to see every strand. Each codeword only needs its best $k$ strands to be decodable. So the right retrieval procedure has three steps. First, sequence shallowly, which serves as a cheap draft. Second, check each codeword's parity equations, which act as an exact verifier. Third, spend extra reads only on the codewords that fail the check, recovering all of their missing strands together in one targeted amplification. Codeword layout and the size of each targeted top-up are set by predicted copying efficiency: a sequence-based efficiency model, recalibrated per run with a cheap real-time PCR measurement. We expect this to recover a file at fixed reliability with substantially fewer total reads than fixed-depth sequencing. It should also keep working in cases where design-time filtering of bad sequences cannot help.

Core Claim

The idea borrows from three places and stops short of copying any of them. From speculative decoding it borrows the loop of cheap guess, parallel check, and fall back only where the check fails, the draft-then-verify loop that Blockwise Parallel Decoding introduced and the survey by Xia et al. catalogs. The contrast with Principled Coarse-Grained Acceptance for speech is instructive. That work had to invent relaxed, group-level acceptance because no exact check exists for whether an acoustic token is "right." In coded DNA storage, an exact check is free: the parity equations either hold or they do not. Relaxed acceptance is therefore unnecessary here, and the tension the research file raises between probabilistic drafting and exact algebraic decoding goes away.

From multi-node failure recovery the proposal borrows the observation that repairing several failures jointly is cheaper than repairing them one by one. The trace-projection and subspace-polynomial schemes (Dau et al., Berman et al.) and centralized multi-node repair by Rawat et al. keep repair cost per failed node flat as the number of failures grows. We do not reuse their field-level tricks. A sequencer reads whole strands, so fractional "sub-packet" downloads have no cheap molecular analogue. What we reuse is the accounting: one targeted amplification of a failing codeword repairs all of its missing strands at once, so the cost of the reads spreads across all failures in that codeword. We also reuse the practice of grouping correlated failures into separate failure domains.

A simple order-statistics argument says why layout matters. Let $a_{c,(k)}$ be the $k$-th largest post-PCR abundance share among the $n$ strands of codeword $c$. Let $r$ be the number of reads needed to call a strand reliably. Then the sequencing depth needed to make every codeword decodable is approximately

$$D_{\text{coded}} \approx \frac{r}{\min_c a_{c,(k)}}, \qquad D_{\text{uncoded}} \approx \frac{r}{\min_i a_i},$$

where $a_i$ is the abundance share of strand $i$. The approximation follows because the expected number of reads of a strand is its share times the depth. Coding moves the bottleneck from the single worst strand to the $k$-th best strand of the worst codeword.

Random assignment of strands to codewords leaves some codewords with a cluster of poor copiers, which lowers $\min_c a_{c,(k)}$. Assigning strands to codewords stratified by predicted efficiency raises that minimum. The size of the gain depends on codeword length, on how much efficiencies vary, and on how accurate the predictor is. All three are measured in this proposal rather than assumed.

Research Program

The work has four components, each testable on its own.

The first is a failure-domain layout. Strands are ranked by predicted efficiency and dealt into codewords so that each codeword receives a balanced mix of efficiencies. Each codeword also gets a primer pair, so it can be amplified alone. Primer-based random access of this kind is standard in the DNA storage literature reviewed by Milenkovic and Pan.

The second is the retrieval controller. It sequences the pool at a shallow draft depth and decodes each codeword, treating unseen or low-coverage strands as erasures. It accepts the codewords whose parity checks pass. For each codeword that fails, it schedules one targeted amplification plus a read budget. That budget is chosen so the expected number of observed strands clears $k$, based on the predicted abundances of that codeword's missing strands.

The third is the efficiency prior and its calibration. We start from the 1D convolutional network of Gimpel et al., which predicts per-strand efficiency from sequence alone. It then has to be adapted to a new pool, primer set, and polymerase. This is where the triplet-scarcity problem from speech translation reappears. Paired data here means a sequence, its per-cycle abundance trajectory, and its final read count. That kind of data is expensive: Gimpel et al. needed serial sequencing across 90 cycles to get it. Sequence-only data and pool-level real-time PCR curves, by contrast, are cheap.

We follow the staged recipe of MSP-ST, which pretrains on abundant partial data and fine-tunes on scarce full data. Concretely, we pretrain on the Gimpel pool. We then recalibrate using the quantification cycle (the fractional cycle at which a sample's fluorescence crosses threshold) measured by real-time PCR for each codeword's sub-pool, together with the draft reads themselves. The analogy is loose, and we use only the staging idea, not MSP-ST's adapters.

The fourth is repeated access. Every read of the archive amplifies it again, so dropout accumulates. PERFECT PCR reports conventional pools reaching 92% error after 5 serial rounds, while its mismatch-cleaving enzyme holds error under 10%. That enzyme corrects substitutions. It cannot restore a strand that is gone. We study "refresh" operations for this case. A refresh rewrites only the strands missing from a codeword, computed from its parity, once real-time PCR monitoring suggests the number of dropped strands is approaching the codeword's parity count. This is the direct analogue of node repair before the failure threshold is crossed.

Baselines

The naive reference point is fixed-depth retrieval with a standard outer code and random codeword assignment. The whole pool is sequenced once, at the depth needed to decode every codeword with the target reliability. That depth is found by bisection on the same simulated or physical pool. Our method beats it if it reaches the same file-level decoding success at lower total read count.

The strongest existing method is design-time filtering from Gimpel et al.. Sequences predicted to copy poorly are replaced before synthesis, using a re-encoding seed. They report a fourfold reduction in the sequencing depth needed to recover 99% of amplicon sequences, and predictor scores of AUROC 0.88 and AUPRC 0.44. We run filtering with the same outer code and the same efficiency model as our layout, so the comparison isolates what each method does with the prediction. We also report filtering combined with our controller, because the two are not mutually exclusive. The proposal succeeds only if filter-plus-controller uses clearly fewer reads than filter-plus-fixed-depth. It must also retain an advantage on pools where filtering is unavailable, namely existing archives and repeatedly accessed pools. No reported result was found on Lacuna for reads-to-decode under outer erasure codes in multi-template PCR, so this baseline number must be produced in our own runs.

Two ablations isolate the key ingredients. The first keeps the draft-verify-repair controller but uses random layout and uniform top-up budgets, with no efficiency prior. It measures how much of the gain comes from the exact-verification loop alone. The second keeps the stratified layout but uses fixed-depth retrieval, which measures the contribution of layout alone. An oracle variant that uses measured rather than predicted efficiencies bounds how much a better predictor could add. No numerical results were found on Lacuna for the multi-node repair schemes, which are theoretical, so they serve as design inspiration rather than competitors.

Why not just…?

Why not just filter bad sequences at design time? This is the most serious threat, and it could make the layout component unnecessary. If filtering removes most poor copiers, the remaining efficiencies may be homogeneous enough that random assignment is fine. Two things argue against filtering as a complete answer. An AUPRC of 0.44 means many poor copiers pass the filter. And filtering cannot act on pools already synthesized, or on dropout that builds up through repeated access. The filter-plus-random versus filter-plus-stratified comparison settles the first question. The serial-access experiment settles the second. If stratification adds nothing after filtering, we drop it and keep only the controller.

Why not just sequence deeper with a standard code? Deeper sequencing is the fixed-depth baseline. The order-statistics argument predicts that it wastes reads on codewords that were decodable at shallow depth. Gimpel et al. also show that extra cycles make relative extinction worse rather than rescuing lagging strands. The read-count comparison measures the waste directly.

Why not just use random interleaving with more parity? With very long codewords, random assignment averages out heterogeneity, and a few extra parity strands may be cheaper than any modeling. We sweep codeword length and parity count. We report the break-even point at which stratification stops mattering, and state honestly whether realistic DNA storage codeword sizes fall above it.

Why not just use an error-correcting enzyme like PERFECT PCR? It reduces substitution errors from 0.67 to 0.06 errors per kilobase. But it addresses corrupted strands, not missing ones. We treat it as complementary and include it as a condition in the wet-lab runs.

Isn't the controller just classical erasure-and-error decoding with retries? Partly, yes. Decoding with erasures and asking for more data is old. The new parts are three. The retry is a targeted molecular amplification that repairs a whole codeword at once. The retry budget comes from a calibrated kinetic prior. And parity serves as an exact verifier inside a draft-verify loop. The first ablation shows how much of the gain is attributable to the classical part alone.

Proposed Experiments

The first stage is in silico and uses the 12,000-sequence pool of Gimpel et al.. This assumes their per-sequence efficiency estimates can be obtained with the paper. We simulate amplification with per-strand efficiencies over a range of cycle counts, followed by random sampling of reads. We overlay Reed-Solomon outer codes across a grid of codeword lengths and parity levels. For every layout and retrieval policy we measure total reads to decode the file at a fixed failure probability, draft acceptance rate, and top-up reads per failed codeword. The predictor is always evaluated on sequences it was not trained on.

The decisive check comes here. If $\min_c a_{c,(k)}$ under predicted-efficiency stratification is not clearly higher than under random layout at realistic codeword sizes, the layout claim fails.

The second stage is a wet-lab validation. We encode one of the PERFECT PCR benchmark payloads, the 101,376 bp image, with the outer code and codeword primers. We compare fixed-depth, filter-only, and controller retrieval on the same synthesized pool. We then repeat retrieval over five serial access rounds, with and without the PERFECT PCR enzyme. Throughout, real-time PCR quantification cycles are measured for each codeword sub-pool, both to test whether they predict which codewords will fail verification and to trigger refresh operations.

The proposal is judged successful if the controller cuts total reads relative to fixed-depth at equal reliability. It should also stay ahead of filtering once filtering is unavailable or dropout has drifted, and the real-time PCR signal should forecast codeword failure better than chance.