String Matching Problem Research Articles

Approximate String Matching Using Deformed Fuzzy Automata: A Learning Experience

Deformed fuzzy automata are complex structures that can be used for solving approximate string matching problems when input strings are composed by fuzzy symbols. Different string similarity definitions are obtained by the appropriate selection of fuzzy operators and parameters involved in the calculus of the automaton transitions. In this paper, we apply a genetic algorithm to adjust the automaton parameters for selecting the ones best fit to a particular application. This genetic approach overcomes the difficulty of using common optimizing techniques like gradient descent, due to the presence of non-derivable functions in the calculus of the automaton transitions. Experimental results, obtained in a text recognition experience, validate the proposed methodology.

On exact string matching of unique oligonucleotides

Unique, gene-specific oligonucleotides are used for many genetic investigations such as polymerase chain reaction, gene cloning, microarray technology and antisense DNA studies. It is a computationally demanding task to extract these oligonucleotides from DNA databases. We studied the problem from the point of view of the string matching problem. We implemented and tested several exact string matching algorithms and modified the implementations to be as effective as possible. Ten different implementations were tested on yeast genomic sequence data. The run times for the best algorithms were significantly improved compared to conventional approaches, while in principle, i.e. in respect of theoretical time complexity, these algorithms do not actually differ essentially from each other.

Practical and flexible pattern matching over Ziv–Lempel compressed text

We address the problem of string matching on Ziv–Lempel compressed text. The goal is to search for a pattern in a text without uncompressing it. This is a highly relevant issue to keep compressed text databases where efficient searching is still possible. We develop a general technique for string matching when the text comes as a sequence of blocks. This abstracts the essential features of Ziv–Lempel compression. We then apply the scheme to each particular type of compression. We present an algorithm to find all the matches of a pattern in a text compressed using LZ77. When we apply our scheme to LZ78, we obtain a much more efficient search algorithm, which is faster than uncompressing the text and then searching it. Finally, we propose a new hybrid compression scheme which is between LZ77 and LZ78, being in practice as good to compress as LZ77 and as fast to search as LZ78. We show also how to search for some extended patterns on Ziv–Lempel compressed text, such as classes of characters and approximate string matching.

Some string matching problems from Bioinformatics which still need better solutions

Bioinformatics, the discipline which studies the computational problems arising from molecular biology, poses many interesting problems to the string searching community. We will describe two problems arising from Bioinformatics, their preliminary solutions, and the more general problem that they pose. The first problem is searching for α-helices in protein sequences. This particular instance of the search is based on matching of hydrophobicity/hydrophilicity. We find an algorithm which is linear in the sequence length for fixed helix length and is O( nlog n) for any helix length. The second problem is on matching probabilistic sequences against sequences or against other probabilistic sequences. In both cases we derive efficient formulas to compute scores according to a Markovian model of evolution.

String-matching with OBDDs

Ordered binary decision diagrams (OBDDs) are a very popular graph representation for Boolean functions. They can be viewed as finite automata recognizing sets of strings of a fixed length, where the letters of the input strings are read at most once in a predefined ordering. The string matching problem with string w as pattern, consists of determining, given an input string, whether or not it contains w as substring. We show that for a fraction of orderings tending to 1 when n increases arbitrarily, the minimal size of an OBDD solving the string matching problem for strings of length n has a growth which is an exponential in n.

Overlap matching

We propose a new paradigm for string matching, namely structural matching . In structural matching, the text and pattern contents are not important. Rather, some areas in the text and pattern, such as intervals, are singled out. A “match” is a text location where a specified relation between the text and pattern areas is satisfied. In particular we define the structural matching problem of overlap ( parity ) matching . We seek the text locations where all overlaps of the given pattern and text intervals have even length. We show that this problem can be solved in time O( n log m ), where the text length is n and the pattern length is m. As an application of overlap matching, we show how to reduce the string matching with swaps problem to the overlap matching problem. The string matching with swaps problem is the problem of string matching in the presence of local swaps. The best deterministic upper bound known for this problem was O( nm 1/3 log m log σ ) for a general alphabet Σ , where σ =min( m ,| Σ |). Our reduction provides a solution to the pattern matching with swaps problem in time O( n log m log σ ).

A sequence walking system for genome analysis

AbstractWith the development of the human genome analysis project, it is becoming possible to utilize large‐scale genome sequence data. One genome analysis method based on large‐scale sequence data is genome sequence walking. Applying sequence walking to the segment sequence database, it is possible to estimate the whole sequence of the gene to which the query sequence belongs by using the gene segment. By sequence walking, the researcher can estimate the genome sequence without going through biological experiments. This saves time and expense in sequence determination. Sequence walking has been performed using the well‐known BLAST. BLAST, however, is a tool based on similarity search, and is not adequate in sequence walking in which the same gene segments are connected, both from the viewpoint of efficiency and from the viewpoint of accuracy. In this study, it is shown that genome sequence walking is not a problem of similarity search, but is a string matching problem permitting error. A system dedicated to sequence walking is constructed by improving the string matching algorithm, which is more suited to sequence walking. The result has been publicized on the WWW. The proposed sequence walking system can realize sequence walking that is faster and more accurate than the conventional sequence walking by BLAST, thus reducing the burden on the researcher. © 2002 Wiley Periodicals, Inc. Electron Comm Jpn Pt 2, 86(1): 64–72, 2003; Published online in Wiley Interscience (www.interscience.wiley.com). DOI 10.1002/ecjb.10113

VECTOR ALGORITHMS FOR APPROXIMATE STRING MATCHING

Vector algorithms allow the computation of an output vector r = r1 r2 ⋯ rm given an input vector e = e1 e2 ⋯ em in a bounded number of operations, independent of m the length of the vectors. The allowable operations are usually restricted to bit-wise operations available in processors, including shifts and binary addition with carry. These restrictions imple that the existence of a vector algorithm for a particular problem opens the way to extremely fast implementations, using the inherent parallelism of bit-wise operations. This paper presents general results on the existence and construction of vertor algorithms, with a particular focus on problems arising from computational biology. We show that efficient vector algorithms exist for the problem of approximate string matching with arbitrary weighted distances, generalizing a previous result by G. Myers. We also characterize a class of automata for which vector algorithms can be automatically derived from the transition table of the automata.

HIRSCHBERG’S ALGORITHM FOR APPROXIMATE MATCHING

The Hirschberg algorithm was devised to solve the longest common subsequence problem. The paper discusses the way o f adopting the algorithm to solve the string matching problem in linear space to determine edit distancefor two strings and their alignment.

STRING MATCHING ARTIFICIAL NEURAL NETWORKS

Three artificial neural networks (ANNs) are proposed for solving a variety of on- and off-line string matching problems. The ANN structure employed as the building block of these ANNs is derived from the harmony theory (HT) ANN, whereby the resulting string matching ANNs are characterized by fast match-mismatch decisions, low computational complexity, and activation values of the ANN output nodes that can be used as indicators of substitution, insertion (addition) and deletion spelling errors.

A guided tour to approximate string matching

We survey the current techniques to cope with the problem of string matching that allows errors. This is becoming a more and more relevant issue for many fast growing areas such as information retrieval and computational biology. We focus on online searching and mostly on edit distance, explaining the problem and its relevance, its statistical behavior, its history and current developments, and the central ideas of the algorithms and their complexities. We present a number of experiments to compare the performance of the different algorithms and show which are the best choices. We conclude with some directions for future work and open problems.

Automata-driven efficient subterm unification

Syntactic unification has widespread use in computing. There are several operations used in deductive computing such as critical pair generation, paramodulation and narrowing that require unifying a term s with every subterm of another term p. This subterm unification problem can be solved naively by repeatedly unifying s with each subterm of p in isolation. The drawback of doing unification in isolation is that commonality among subterms of p is ignored. We present an algorithm for efficient subterm unification by exploiting this commonality. The central idea used in our algorithm is to reduce the common part computation in unification into a string-matching problem and solve it efficiently using a string-matching automaton. The automaton succinctly captures the commonality between subterms of p. The string-matching approach, in conjunction with two new techniques called bidirectional-reduce and marking enables efficient unification of s with every subterm of p.

A fast bit-vector algorithm for approximate string matching based on dynamic programming

The approximate string matching problem is to find all locations at which a query of length m matches a substring of a text of length n with k -or-fewer differences. Simple and practical bit-vector algorithms have been designed for this problem, most notably the one used in agrep . These algorithms compute a bit representation of the current state-set of the k -difference automaton for the query, and asymptotically run in either O ( nm/w ) or O ( nm log σ/ w ) time where w is the word size of the machine (e.g., 32 or 64 in practice), and σ is the size of the pattern alphabet. Here we present an algorithm of comparable simplicity that requires only O ( nm/w) time by virtue of computing a bit representation of the relocatable dynamic programming matrix for the problem. Thus, the algorithm's performance is independent of k , and it is found to be more efficient than the previous results for many choices of k and small m . Moreover, because the algorithm is not dependent on k , it can be used to rapidly compute blocks of the dynamic programming matrix as in the 4-Russians algorithm of Wu et al.(1996). This gives rise to an O(kn/w) expected-time algorithm for the case where m may be arbitrarily large. In practice this new algorithm, that computes a region of the dynamic progr amming (d.p.) matrx w entries at a time using the basic algorithm as a subroutine is significantly faster than our previous 4-Russians algorithm, that computes the same region 4 or 5 entries at a time using table lookup. This performance improvement yields a code that is either superior or competitive with all existing algorithms except for some filtration algorithms that are superior when k/m is sufficiently small.

Constant-space string-matching in sublinear average time

Given two strings: pattern P of length m and text T of length n. The string-matching problem is to find all occurrences of the pattern P in the text T. We present a string-matching algorithms which works in o( n) average time and constant additional space for one-dimensional texts and two-dimensional arrays. This is a first attempt to the small-space string-matching problem in which sublinear time algorithms are achieved. We show that all occurrences of one- or two-dimensional patterns can be found in O( n r ) average time with constant memory, where r is the repetition size of P (size of the longest repeated subword of P).

Calign: aligning sequences with restricted affine gap penalties.

Given a genomic DNA sequence, it is still an open problem to determine its coding regions, i.e. the region consisting of exons and introns. The comparison of cDNA and genomic DNA helps the understanding of coding regions. For such an application, it might be adequate to use the restricted affine gap penalties which penalize long gaps with a constant penalty. Several techniques developed for solving the approximate string-matching problem are employed to yield efficient algorithms for computing the optimal alignment with restricted affine gap penalties. In particular, efficient algorithms can be derived based on the suffix automaton with failure transitions and on the diagonalwise monotonicity of the cost tables. We have implemented the above methods in C on Sun workstations running SunOS Unix. Preliminary experiments show that these approaches are very promising for aligning a cDNA sequence with a genomic DNA sequence. Calign is available free of charge by anonymous ftp at: iubio.bio. indiana.edu, directory: molbio/align, files: calign.driver.c calign. c. Another URL reference for the files is http://iubio.bio.indiana.edu/soft/molbio/align/+ ++calign.c.

Partitionable Bus-based String-matching Algorithm for Run-length Coded Strings With VLDCs

String matching (SM) problem is to find the occurrences of a pattern within a text. A vanable length don't care (VLDC) is a special symbol, not belonging to a finite alphabet ∑ but in ∑*. Each VLDC in the pattern can match any substring in the text. Given a run-length coded text of length 2n over ∑ and a run-length coded pattern of length 2m over ∑*, this paper first presents an O(1) time parallel SM algorithm for run-length coded strings with VLDCs on a reconfigurable mesh (RM) using O(nm) processors. Consider the hardware limitation in VLSI implementation. In order to be suitable for VLSI modular implementation, a partitionable parallel algorithm on the RM with limited processors is further presented. For N < n and M < m, the SM for run-length coded strings with VLDCs can be solved in O(X^Y^) time on the RM using O(NM)(= O((nm)/((X^Y^))) processors, where X^ = [(n – 1)/(N – 1)] and Y^ = [(m – 1)/(M – 1)].

Two-Dimensional Periodicity in Rectangular Arrays

String matching is rich with a variety of algorithmic tools. In contrast, multidimensional matching has had a rather sparse set of techniques. This paper presents a new algorithmic technique for two-dimensional matching: periodicity analysis. Its strength appears to lie in the fact that it is inherently two-dimensional. Periodicity in strings has been used to solve string matching problems. Multidimensional periodicity, however, is not as simple as it is in strings and was not formally studied or used in pattern matching. In this paper, we define and analyze two-dimensional periodicity in rectangular arrays. One definition of string periodicity is that a periodic string can self-overlap in a particular way. An analogous concept is true in two dimensions. The self-overlap vectors of a rectangle generate a regular pattern of locations where the rectangle may originate. Based on this regularity, we define four categories of periodic arrays--- nonperiodic, lattice periodic, line periodic, and radiant periodic---and prove theorems about the properties of the classes. We give serial and parallel algorithms that find all locations where an overlap originates. In addition, our algorithms find a witness proving that the array does not self-overlap in any other location. The serial algorithm runs in time O(m2 ) (linear time) when the alphabet size is finite, and in O(m2 log m) otherwise. The parallel algorithm runs in time O(log m) using O(m2 ) CRCW processors.

Optimal neural network algorithm for on-line string matching

We consider an online string matching problem in which we find all the occurrences of a pattern of m characters in a text of n characters, where all the characters of the pattern are available before processing, while the characters of the text are input one after the other. We propose a space-time optimal parallel algorithm for this problem using a neural network approach, This algorithm uses m McCulloch-Pitts neurons connected as a linear array. It processes every input character of the text in one step and hence it requires at most n iteration steps.

Constant-Time Randomized Parallel String Matching

Given a pattern string of length m for the string-matching problem, we design an algorithm that computes deterministic samples of a sufficiently long substring of the pattern in constant time. This problem used to be the bottleneck in the pattern preprocessing for one- and two-dimensional pattern matching. The best previous time bound was O(log2m / log log m). We use this algorithm to obtain the following results (all algorithms below are optimal parallel algorithms on a CRCW PRAM): a deterministic string-matching algorithm which takes O(log log m) time for preprocessing and constant time for text search, which are the best possible in both preprocessing and text search; a constant-time deterministic string-matching algorithm in the case where the text length n satisfies $n=\Omega(m^{1+\epsilon})$ for a constant $\epsilon > 0$; a simple string-matching algorithm that has constant time with high probability for random input; the main result: a constant-expected-time Las Vegas algorithm for computing the period of the pattern and all witnesses and thus for string matching itself; in both cases, an $\Omega(\log\log m)$ lower bound is known for deterministic algorithms.

Parallel Suffix–Prefix-Matching Algorithm and Applications

Our main result in this paper is a parallel algorithm for suffix--prefix- (s--p-) matching that has optimal speedup on a concurrent-read/concurrent-write parallel random-access machine (CRCW PRAM). Given a string of length $m$, the algorithm runs in time $O(\log m)$ using $m/ \log m$ processors. This algorithm is important because we utilize s--p matching as a fundamental building block to solve several pattern- and string-matching problems, such as the following: {1. string matching; 2. multitext/multipattern string matching; 3. multidimensional pattern matching; 4. pattern-occurrence detection; 5. on-line string matching.} In particular, our techniques and algorithms are the first to preserve optimal speedup in the context of pattern matching in higher dimensions and are the only known ones to do so for dimensions $d > 2$.