[Paper Review] Optimal $k$-Deletion Correcting Codes

Jin Sima, Jehoshua Bruck|arXiv (Cornell University)|Oct 27, 2019

DNA and Biological Computing15 references4 citations

TL;DR

This paper presents the first deterministic $k$-deletion correcting code with optimal redundancy $O(k\log n)$, achieved through a novel concatenated code structure using constrained sequences, a synchronization pattern for block separation, and redundancy-optimized outer and inner codes. The encoding and decoding complexity is $O(n^{2k+1})$ and $O(n^{k+1})$ respectively, solving a longstanding open problem in coding theory since Levenshtein's 1966 work.

ABSTRACT

Levenshtein introduced the problem of constructing $k$-deletion correcting codes in 1966, proved that the optimal redundancy of those codes is $O(k\log N)$, and proposed an optimal redundancy single-deletion correcting code (using the so-called VT construction). However, the problem of constructing optimal redundancy $k$-deletion correcting codes remained open. Our key contribution is a solution to this longstanding open problem. We present a $k$-deletion correcting code that has redundancy $8k\log n +o(\log n)$ and encoding/decoding algorithms of complexity $O(n^{2k+1})$ for constant $k$.

Motivation & Objective

• To resolve the long-standing open problem of constructing a deterministic $k$-deletion correcting code with optimal redundancy $O(k\log n)$.
• To design an encoding and decoding scheme with polynomial-time complexity for constant $k$.
• To generalize the Varshamov-Tenengolts (VT) construction for single-deletion codes to $k$ deletions using constrained sequences with minimum distance $k$ between 1s.
• To enable block separation in concatenated codes using a single, deletable synchronization pattern that can be destroyed or generated by deletions.
• To achieve redundancy close to the theoretical lower bound of $k\log n + o(\log n)$ while maintaining correct decoding under $k$ deletions.

Proposed method

• Generalize the VT construction to $k$-deletion correction by constraining sequences to have at least $k$ zeros between any two 1s, enabling higher-order parity checks to correct $k$ deletions.
• Use a synchronization pattern of length $3k + \lceil\log k\rceil + 4$ that ends with $\lceil\log k\rceil + 5$ consecutive 1s and has no other run of 1s of that length, to mark block boundaries.
• Apply a transformation $T(\mathbf{c})$ to the input sequence to create a $k$-dense sequence, which allows recovery from $k$ deletions using the synchronization vector and hash function.
• Use a Reed-Solomon-like outer code and a repetition-based inner code $Rep_{k+1}(H(R'))$ to protect the redundancy bits $R'$, ensuring recovery from $k$ deletions.
• Recover the original sequence by first reconstructing the redundancy $R'$ from $k$-deletion subsequence using $R''$, then recovering $T(\mathbf{c})$ from $R'$ and the synchronization vector, and finally inverting $T$ to recover $\mathbf{c}$.
• Employ brute-force search for the prime $p(T(\mathbf{c}))$ during encoding and for the synchronization vector during decoding, leading to $O(n^{2k+1})$ and $O(n^{k+1})$ complexity respectively.

Experimental results

Research questions

• RQ1 Can a deterministic $k$-deletion correcting code be constructed with redundancy matching the theoretical lower bound of $O(k\log n)$?
• RQ2 Can the block separation in concatenated $k$-deletion codes be achieved using a single, deletable synchronization pattern without requiring marker preservation?
• RQ3 Is it possible to generalize the VT construction to correct $k$ deletions by constraining sequences to have a minimum distance of $k$ between 1s?
• RQ4 Can redundancy be reduced to $O(k\log n)$ while maintaining polynomial-time encoding and decoding for constant $k$?
• RQ5 What is the minimal redundancy achievable for a deterministic $k$-deletion code, and can it be achieved with efficient algorithms?

Key findings

• The paper constructs a $k$-deletion correcting code with redundancy $8k\log n + o(\log n)$, matching the optimal order $O(k\log n)$.
• The encoding complexity is $O(n^{2k+1})$ and decoding complexity is $O(n^{k+1})$, both polynomial in $n$ for constant $k$.
• The code uses a novel synchronization pattern of length $3k + \lceil\log k\rceil + 4$ that can be destroyed or generated by deletions, enabling robust block separation.
• The construction generalizes the VT code by applying higher-order parity checks to $k$-constrained sequences (minimum $k$-distance between 1s), enabling $k$-deletion correction.
• The redundancy $R'$ is protected by a repetition code $R'' = Rep_{k+1}(H(R'))$, allowing recovery of $H(R')$ from $k$ deletions in $R''$.
• The decoding process reverses the encoding steps by first recovering $H(R')$ from $R''$, then $R'$ from $R''$ and $H(R')$, and finally reconstructing $T(\mathbf{c})$ and $\mathbf{c}$ using the synchronization vector and hash function.