DoDo-Code: an Efficient Levenshtein Distance Embedding-based Code for 4-ary IDS Channel

With the emergence of new storage and communication methods, the insertion, deletion, and substitution (IDS) channel has attracted considerable attention. However, many topics on the IDS channel and the associated Levenshtein distance remain open, making the invention of a novel IDS-correcting code a hard task. Furthermore, current studies on single-IDS-correcting code misalign with the requirements of applications which necessitates the correcting of multiple errors. Compromise solutions have involved shortening codewords to reduce the chance of multiple errors. However, the code rates of existing codes are poor at short lengths, diminishing the overall storage density. In this study, a novel method is introduced for designing high-code-rate single-IDS-correcting codewords through deep Levenshtein distance embedding. A deep learning model is utilized to project the sequences into embedding vectors that preserve the Levenshtein distances between the original sequences. This embedding space serves as a proxy for the complex Levenshtein domain, within which algorithms for codeword search and segment correcting is developed. While the concept underpinning this approach is straightforward, it bypasses the mathematical challenges typically encountered in code design. The proposed method results in a code rate that outperforms existing combinatorial solutions, particularly for designing short-length codewords.

💡 Research Summary

The paper addresses the problem of designing high‑rate error‑correcting codes for the insertion‑deletion‑substitution (IDS) channel over a 4‑ary alphabet, with a particular focus on short block lengths where existing combinatorial constructions suffer from excessive redundancy. Traditional IDS‑correcting codes, largely based on Varshamov‑Tenengolts (VT) constructions, guarantee a minimum Levenshtein distance of three to correct a single IDS error, but their redundancy grows as log n + log log n + O(1) bits. This overhead becomes prohibitive when n is small, leading to low storage density. Moreover, segment‑based approaches that split a long sequence into independently corrected blocks inherit the same low rate because each segment uses a short‑length code.

DoDo‑Code proposes a fundamentally different methodology: instead of tackling the combinatorial geometry of Levenshtein balls directly, the authors learn a deep embedding that maps each length‑n 4‑ary sequence to an m‑dimensional real vector such that the squared Euclidean distance between vectors approximates the true Levenshtein distance between the original sequences. The embedding is realized with a Siamese network consisting of ten 1‑D convolutional layers followed by batch normalization. Training minimizes a modified Poisson negative log‑likelihood loss: for pairs at true distance 1 the loss forces the predicted distance to be accurate, while for pairs at distance ≥ 2 the loss only requires the prediction to be larger than 2. This “truncated” objective simplifies learning because the code construction only needs reliable discrimination within a Levenshtein radius of two.

Once the embedding function f(·) is trained, the entire candidate set A = {0,1,2,3}ⁿ is passed through f to obtain embeddings U. Empirically, the vectors follow a multivariate normal distribution N(0, Σ̂), where Σ̂ is estimated from U. The probability density of a vector u under this Gaussian is proportional to exp(−½ uᵀΣ̂⁻¹u). Consequently, vectors with large quadratic form uᵀΣ̂⁻¹u lie in low‑density regions, meaning their corresponding sequences have relatively few Levenshtein neighbors. The greedy codebook construction repeatedly selects the sequence whose embedding maximizes uᵀΣ̂⁻¹u, adds it to the codebook, and removes from the candidate set all sequences within Levenshtein distance ≤ 2 of the chosen one. This process continues until the candidate set is empty, guaranteeing that any two codewords are at Levenshtein distance at least three, i.e., the code can correct a single IDS error.

Decoding (segment correction) traditionally requires exhaustive Levenshtein distance computation between the received segment and every codeword, leading to O(n²·|C|) time. DoDo‑Code sidesteps this by building a K‑d tree over the embedding vectors of the final codebook C. When a possibly corrupted segment ˆc arrives, its embedding ˆv = f(ˆc) is queried in the K‑d tree to retrieve the nearest neighbor v = f(c). The associated codeword c is then verified (optionally by a single Levenshtein distance calculation) and returned as the corrected segment. The K‑d tree query costs O(log |C|), and the one‑time verification makes the overall decoding complexity effectively O(n), a dramatic reduction compared with brute‑force methods.

Experimental evaluation spans block lengths n = 8, 10, 12, 14, 16, 18, 20. DoDo‑Code’s code rates consistently exceed those of the best known order‑optimal VT‑based constructions, with improvements ranging from 12 % to 18 % for the shortest lengths and approaching the theoretical optimum for n ≤ 12. The single‑error correction success probability exceeds 99.9 %, confirming that the learned embedding preserves the essential Levenshtein geometry. Decoding latency is reduced by one to two orders of magnitude relative to exhaustive search, making the approach viable for real‑time storage or communication systems.

The paper’s contributions can be summarized as follows: (1) a novel use of deep metric learning to embed the discrete Levenshtein space into a continuous Euclidean space, enabling statistical estimation of neighbor density; (2) a density‑driven greedy algorithm that constructs large, minimum‑distance‑3 codebooks for short block lengths, thereby achieving higher rates than any known combinatorial method; (3) an efficient nearest‑neighbor decoding scheme based on K‑d trees that brings decoding complexity down to linear in the block length. Limitations include dependence on the 4‑ary alphabet (extension to larger alphabets would require retraining and possibly higher embedding dimensions), potential degradation of the minimum‑distance guarantee if embedding errors become large, and the O(4ⁿ) memory requirement for exhaustive candidate enumeration, which may be prohibitive for very large n. Future work is suggested on dimensionality reduction, online codebook updates, and generalization to higher‑order alphabets or channels with asymmetric IDS error probabilities.