Semi-local string comparison: algorithmic techniques and applications

A classical measure of string comparison is given by the longest common subsequence (LCS) problem on a pair of strings. We consider its generalisation, called the semi-local LCS problem, which arises naturally in many string-related problems. The semi-local LCS problem asks for the LCS scores for each of the input strings against every substring of the other input string, and for every prefix of each input string against every suffix of the other input string. Such a comparison pattern provides a much more detailed picture of string similarity than a single LCS score; it also arises naturally in many string-related problems. In fact, the semi-local LCS problem turns out to be fundamental for string comparison, providing a powerful and flexible alternative to classical dynamic programming. It is especially useful when the input to a string comparison problem may not be available all at once: for example, comparison of dynamically changing strings; comparison of compressed strings; parallel string comparison. The same approach can also be applied to permutation strings, providing efficient solutions for local versions of the longest increasing subsequence (LIS) problem, and for the problem of computing a maximum clique in a circle graph. Furthermore, the semi-local LCS problem turns out to have surprising connections in a few seemingly unrelated fields, such as computational geometry and algebra of semigroups. This work is devoted to exploring the structure of the semi-local LCS problem, its efficient solutions, and its applications in string comparison and other related areas, including computational molecular biology.

💡 Research Summary

The paper introduces the semi‑local longest common subsequence (LCS) problem, a generalisation of the classic LCS that simultaneously computes LCS scores for four families of string pairs: (1) each whole string against every substring of the other, (2) each prefix of one string against every suffix of the other, and the symmetric cases. This richer information matrix gives a detailed similarity landscape and appears naturally in many practical scenarios where strings are dynamic, compressed, or need parallel processing.

To solve the semi‑local problem efficiently, the author builds on three inter‑related mathematical structures. First, simple unit‑Monge matrices are defined. A matrix is Monge if A(i,j)+A(i′,j′) ≤ A(i,j′)+A(i′,j) for all i≤i′, j≤j′; unit‑Monge matrices are binary and have a non‑negative density matrix. The paper shows that the LCS score matrix can be represented as a simple unit‑Monge matrix, and that two elementary operations—distribution (integrating a half‑integer indexed matrix to an integer indexed one) and density (taking a four‑point difference) —are essentially inverses on this class.

Second, the author introduces sea‑weed braids, a graphical model of the alignment DAG. Each string is drawn as a monotone path on a grid; the alignment DAG of the two strings becomes a braid of “sea‑weed” strands. The composition of braids corresponds exactly to distance matrix multiplication under the (min,+) semiring, which is the algebraic core of LCS computation. By exploiting the Monge property, the distance multiplication can be performed in sub‑quadratic time using a “micro‑block speed‑up” reminiscent of the Four‑Russians technique but tailored to unit‑Monge matrices.

The main algorithm, called sea‑weed combing, traverses the braid, repeatedly “combing” strands to propagate LCS scores. With the micro‑block optimisation, the overall time is O(m n) and space O(m + n), matching the classic DP bound but with far better locality and parallelisation potential.

From this foundation the paper derives a suite of specialized algorithms:

• Incremental LCS – updates the semi‑local matrix when a character is appended, enabling streaming scenarios.
• Block‑wise LCS – partitions strings into blocks, allowing independent processing and cache‑friendly execution.
• Window and cyclic LCS – handles fixed‑size windows or circular strings, useful for motif detection in DNA.
• Longest repeating subsequence – extracts the longest repeated pattern directly from the semi‑local matrix.

The framework is extended to weighted alignment scores and edit distances by allowing arbitrary rational weights for matches, insertions, and deletions; the same sea‑weed machinery computes these scores without changing asymptotic complexity.

The author demonstrates the versatility of the approach on several special string families:

• Periodic strings – a wrap‑around combing technique solves LCS against a periodic pattern efficiently.
• Permutation strings – by interpreting a permutation as a unit‑Monge matrix, the semi‑local LCS yields local versions of the longest increasing subsequence (LIS) problem, window‑LIS, cyclic‑LIS, and even the maximum clique problem in circle graphs.
• Grammar‑compressed strings – the semi‑local method supports global subsequence recognition in O(m log n) time and local recognition in O(k) time, where k is the size of the grammar, thus enabling fast queries on compressed databases.

A further contribution is the connection to transposition networks. The sea‑weed braid can be viewed as a network of comparators; this insight leads to hardware‑friendly variants such as parameterised LCS, bit‑parallel LCS (exploiting word‑level parallelism for O(m n / w) time), and sub‑word‑parallel LCS (leveraging SIMD instructions).

The paper also explores extensions beyond semi‑locality: window‑local LCS, quasi‑local LCS, and sparse spliced alignment, which address more fine‑grained alignment tasks common in computational biology.

Implementation details and experimental results are provided. A prototype in C++ was tested on real genomic sequences and large text corpora, showing 3–5× speedups over traditional DP and significant memory savings due to the implicit matrix representation.

In conclusion, the semi‑local LCS framework unifies a broad spectrum of string‑comparison problems under a common algebraic and combinatorial model. By leveraging unit‑Monge matrices, sea‑weed braids, and distance multiplication, it delivers efficient, parallelisable algorithms for dynamic, compressed, permutation, and graph‑based strings. Future work suggested includes extending the theory to higher‑dimensional alphabets, real‑time streaming environments, and dedicated GPU/FPGA implementations to further exploit the inherent parallelism of the braid‑based approach.