Constrained Sequence Alignment Problem Research Articles

An A⁎ search algorithm for the constrained longest common subsequence problem

The constrained longest common subsequence (CLCS) problem was introduced as a specific measure of similarity between molecules. It is a special case of the constrained sequence alignment problem and of the longest common subsequence (LCS) problem, which are both well-studied problems in the scientific literature. Finding similarities between sequences plays an important role in the fields of molecular biology, gene recognition, pattern matching, text analysis, and voice recognition, among others. The CLCS problem in particular represents an interesting measure of similarity for molecules that have a putative structure in common. This paper proposes an exact A⁎ search algorithm for effectively solving the CLCS problem. This A⁎ search is guided by a tight upper bound calculation for the cost-to-go for the LCS problem. Our computational study shows that on various artificial and real benchmark sets this algorithm scales better with growing instance size and requires significantly less computation time to prove optimality than earlier state-of-the-art approaches from the literature.

Practical regular expression constrained sequence alignment

The regular expression constrained sequence alignment problem is that of producing an optimal score alignment of two sequences which, at the same time, has aligned portions that are both described by a regular expression.In this article we introduce a series of improvements over existing algorithms to solve the problem when the regular expression has no Kleene closures. This is the case of biological patterns, such as those described by PROSITE and other databases. Such improvements include the construction of more compact ϵ-free NFAs for patterns and a significant reduction on automata transitions tracking during the alignment. The time complexity of our solution is O(nmk2), improving on the best known solution O(nmk3|Σ|3/log⁡(k|Σ|)), where n and m are sequence lengths, k is the number of single elements in a PROSITE pattern and Σ is the alphabet.Our experiments have shown that practical running time is significantly smaller than the theoretical worst case mentioned above, and that the solution may be used efficiently in practice for solving the regular expression constrained alignment problem for biological sequences.

Algorithms for path-constrained sequence alignment

We define a novel variation on the constrained sequence alignment problem in which the constraint is given in the form of a regular expression. Given two sequences, an alphabet Γ describing pairwise sequence alignment operations, and a regular expression R over Γ, the problem is to compute the highest scoring sequence alignment A of the given sequences, such that A∈Γ⁎L(R)Γ⁎.Two algorithms are given for solving this problem. The first basic algorithm is general and solves the problem in O(nmrlog2r) time and O(min{n,m}r) space, where m and n are the lengths of the two sequences and r is the size of the NFA for R. The second algorithm is restricted to rigid patterns and exploits this restriction to reduce the NFA size factor r in the time complexity to a smaller factor corresponding to the length of the rigid pattern. A rigid pattern P is a regular expression of the form P=P1∪⋯∪Pk, where Pi does not contain the Kleene-closure star or union. |P| is compacted by supporting alignment patterns P that do not contain the Kleene-closure star, and exploits this constraint to reduce the NFA size factor r in the time complexity to a smaller factor |P|. |P| is compacted by supporting alignment patterns extended by meta-characters including general insertion, deletion and match operations, as well as some cases of substitutions. meta-characters used in P. {m,i}⁎ or P∈(Γ∪{m,d})⁎, the problem can be solved in time O(nm), while for a pattern P∈(Γ∪{m,i,d})⁎, the problem can be solved in time O(nmlog|P|). For a pattern P∈(Γ∪{m,s,i,d})⁎, the problem can be solved in time O(nmlog|P|) in some cases: one case is for scoring functions Score for which there exists Score′:Σ→R such that Score(ν,σ)=Score′(ν)+Score′(σ) for every ν≠σ, and the other is when occs(P)=O(log(max{n,m})). For a rigid pattern P=P1∪⋯∪Pk, these time bounds range from O(knm) to O(knmlog(max{|Pi|})), depending on the meta-characters used in P.An additional result obtained along the way is an extension of the algorithm of Fischer and Paterson for String Matching with Wildcards. Our extension allows the input strings to include “negation symbols” (that match all letters but a specific one) while retaining the original time complexity.We implemented both algorithms and applied them to data-mine new miRNA seeding patterns in C. elegans Clip-seq experimental data.

Regular Language Constrained Sequence Alignment Revisited

Imposing constraints in the form of a finite automaton or a regular expression is an effective way to incorporate additional a priori knowledge into sequence alignment procedures. With this motivation, the Regular Expression Constrained Sequence Alignment Problem was introduced, which proposed an O(n²t⁴) time and O(n²t²) space algorithm for solving it, where n is the length of the input strings and t is the number of states in the input non-deterministic automaton. A faster O(n²t³) time algorithm for the same problem was subsequently proposed. In this article, we further speed up the algorithms for Regular Language Constrained Sequence Alignment by reducing their worst case time complexity bound to O(n²t³)/log t). This is done by establishing an optimal bound on the size of Straight-Line Programs solving the maxima computation subproblem of the basic dynamic programming algorithm. We also study another solution based on a Steiner Tree computation. While it does not improve the worst case, our simulations show that both approaches are efficient in practice, especially when the input automata are dense.

Efficient algorithms for regular expression constrained sequence alignment

Imposing constraints is an effective means to incorporate biological knowledge into alignment procedures. As in the PROSITE database, functional sites of proteins can be effectively described as regular expressions. In an alignment of protein sequences it is natural to expect that functional motifs should be aligned together. Due to this motivation, Arslan introduced the regular expression constrained sequence alignment problem and proposed an algorithm which, if implemented naïvely, can take time and space up to O ( | Σ | 2 | V | 4 n 2 ) and O ( | Σ | 2 | V | 4 n ) , respectively, where Σ is the alphabet, n is the sequence length, and V is the set of states in an automaton equivalent to the input regular expression. In this paper we propose a more efficient algorithm solving this problem which takes O ( | V | 3 n 2 ) time and O ( | V | 2 n ) space in the worst case. If | V | = O ( log n ) we propose another algorithm with time complexity O ( | V | 2 log | V | n 2 ) . The time complexity of our algorithms is independent of Σ, which is desirable in protein applications where the formulation of this problem originates; a factor of | Σ | 2 = 400 in the time complexity of the previously proposed algorithm would significantly affect the efficiency in practice.

Regular expression constrained sequence alignment

We introduce regular expression constrained sequence alignment as the problem of finding the maximum alignment score between given strings S 1 and S 2 over all alignments such that in these alignments there exists a segment where some substring s 1 of S 1 is aligned to some substring s 2 of S 2 , and both s 1 and s 2 match a given regular expression R, i.e. s 1 , s 2 ∈ L ( R ) where L ( R ) is the regular language described by R. For complexity results we assume, without loss of generality, that n = | S 1 | ⩾ | m | = | S 2 | . A motivation for the problem is that protein sequences can be aligned in a way that known motifs guide the alignments. We present an O ( n m r ) time algorithm for the regular expression constrained sequence alignment problem where r = O ( t 4 ) , and t is the number of states of a nondeterministic finite automaton N that accepts L ( R ) . We use in our algorithm a nondeterministic weighted finite automaton M that we construct from N. M has O ( t 2 ) states where the transition-weights are obtained from the given costs of edit operations, and state-weights correspond to optimum alignment scores we compute using the underlying dynamic programming solution for sequence alignment. If we are given a deterministic finite automaton D accepting L ( R ) with t d states then our construction creates a deterministic finite automaton M d with t d 2 states. In this case, our algorithm takes O ( t d 2 n m ) time. Using M d results in faster computation than using M when t d < t 2 . If we only want to compute the optimum score, the space required by our algorithm is O ( t 2 n ) ( O ( t d 2 m ) if we use a given M d ). If we also want to compute an optimal alignment then our algorithm uses O ( t 2 m + t 2 | s 1 | | s 2 | ) space ( O ( t d 2 m + t d 2 | s 1 | | s 2 | ) space if we use a given M d ) where s 1 and s 2 are substrings of S 1 and S 2 , respectively, s 1 , s 2 ∈ L ( R ) , and s 1 and s 2 are aligned together in the optimal alignment that we construct. We also show that our method generalizes for the case of the problem with affine gap penalties, and for finding optimal regular expression constrained local sequence alignments.