Avivit Levy

Pattern matching with address errors: rearrangement distances

Historically, approximate pattern matching has mainly focused at coping with errors in the data, while the order of the text/pattern was assumed to be more or less correct. In this paper we consider a class of pattern matching problems where the content is assumed to be correct, while the locations may have shifted/changed. We formally define a broad class of problems of this type, capturing situations in which the pattern is obtained from the text by a sequence of rearrangements. We consider several natural rearrangement schemes, including the analogues of the l 1 and l 2 distances, as well as two distances based on interchanges. For these, we present efficient algorithms to solve the resulting string matching problems.

On the Cost of Interchange Rearrangement in Strings

Consider the following optimization problem: given two strings over the same alphabet, transform one into another by a succession of interchanges of two elements. In each interchange the two participating elements exchange positions. An interchange is given a weight that depends on the distance in the string between the two exchanged elements. The object is to minimize the total weight of the interchanges. This problem is a generalization of a classical problem on permutations (where every element appears once). The generalization considers general strings with possibly repeating elements, and a function assigning weights to the interchanges. The generalization to general strings (with unit weights) was mentioned by Cayley in the 19th century, and its complexity has been an open question since. We solve this open problem and consider various weight functions as well.

Pattern matching with address errors: Rearrangement distances

Historically, approximate pattern matching has mainly focused at coping with errors in the data, while the order of the text/pattern was assumed to be more or less correct. In this paper we consider a class of pattern matching problems where the content is assumed to be correct, while the locations may have shifted/changed. We formally define a broad class of problems of this type, capturing situations in which the pattern is obtained from the text by a sequence of rearrangements. We consider several natural rearrangement schemes, including the analogues of the l1 and l2 distances, as well as two distances based on interchanges. For these, we present efficient algorithms to solve the resulting string matching problems.

Approximate String Matching with Address Bit Errors

A string Si¾? Σmcan be viewed as a set of pairs S= { (i¾? i , i) : ii¾? { 0,..., mi¾? 1} }. We consider approximate pattern matching problems arising from the setting where errors are introduced to the location component (i), rather than the more traditional setting, where errors are introduced to the content itself (i¾? i ). In this paper, we consider the case where bits of imay be erroneously flipped, either in a consistent or transient manner. We formally define the corresponding approximate pattern matching problems, and provide efficient algorithms for their resolution, while introducing some novel techniques.

On the cost of interchange rearrangement in strings

An underlying assumption in the classical sorting problem is that the sorter does not know the index of every element in the sorted array. Thus, comparisons are used to determine the order of elements, while the sorting is done by interchanging elements. In the closely related interchange rearrangement problem, final positions of elements are already given, and the cost of the rearrangement is the cost of the interchanges. This problem was studied only for the limited case of permutation strings, where every element appears once. This paper studies a generalization of the classical and well-studied problem on permutations by considering general strings input, thus solving an open problem of Cayley from 1849, and examining various cost models.

Longest Common Subsequence in k Length Substrings

In this paper we define a new problem, motivated by computational biology, LCSk aiming at finding the maximal number of k length substrings, matching in both input string while preserving their order of appearance in the input strings. The traditional LCS definition is a spacial case of our problem, where k = 1. We provide an algorithm, solving the general case in On 2 time, where n is the length of the input, equaling the time required for the special case of k = 1. The space requirement is Okn. In order to enable backtracking of the solution On 2 space is needed.

Interchange rearrangement: The element-cost model

Abstract Given an input string S and a target string T when S is a permutation of T , the interchange rearrangement problem is to apply on S a sequence of interchanges, such that S is transformed into T . The interchange operation exchanges the position of the two elements on which it is applied. The goal is to transform S into T at the minimum cost possible, referred to as the distance between S and T . The distance can be defined by several cost models that determine the cost of every operation. There are two known models: The Unit-cost model and the Length-cost model. In this paper, we suggest a natural cost model: The Element-cost model. In this model, the cost of an operation is determined by the elements that participate in it. Though this model has been studied in other fields, it has never been considered in the context of rearrangement problems. We consider both the special case where all elements in S and T are distinct, referred to as a permutation string, and the general case, referred to as a general string. An efficient optimal algorithm for the permutation string case and efficient approximation algorithms for the general string case, which is N P -hard, are presented. The study is broadened to include the transposition rearrangement problem under the Element-cost model and under the other known models, in order to provide additional perspective on the new model.

Cycle detection and correction

Assume that a natural cyclic phenomenon has been measured, but the data is corrupted by errors. The type of corruption is application-dependent and may be caused by measurements errors, or natural features of the phenomenon. We assume that an appropriate metric exists, which measures the amount of corruption experienced. This article studies the problem of recovering the correct cycle from data corrupted by various error models, formally defined as the period recovery problem. Specifically, we define a metric property which we call pseudolocality and study the period recovery problem under pseudolocal metrics. Examples of pseudolocal metrics are the Hamming distance, the swap distance, and the interchange (or Cayley) distance. We show that for pseudolocal metrics, periodicity is a powerful property allowing detecting the original cycle and correcting the data, under suitable conditions. Some surprising features of our algorithm are that we can efficiently identify the period in the corrupted data, up to a number of possibilities logarithmic in the length of the data string, even for metrics whose calculation is NP-hard. For the Hamming metric, we can reconstruct the corrupted data in near-linear time even for unbounded alphabets. This result is achieved using the property of separation in the self-convolution vector and Reed-Solomon codes. Finally, we employ our techniques beyond the scope of pseudo-local metrics and give a recovery algorithm for the non-pseudolocal Levenshtein edit metric.

Range LCP

In this paper, we define the Range LCP problem as follows. Preprocess a string S, of length n, to enable efficient solutions of the following query: Given

Efficient computations of l 1 and l ∞ rearrangement distances

[i,j],\ \ 0 , compute max l, k∈{i,…,j}LCP(Sl, Sk), where LCP(Sl, Sk) is the length of the longest common prefix of the suffixes of S starting at locations l and k. This is a natural generalization of the classical LCP problem. Surprisingly, while it is known how to preprocess a string in linear time to enable LCP computation of two suffixes in constant time, this seems quite difficult in the Range LCP problem. It is trivial to answer such queries in time O(|j−i|2) after a linear-time preprocessing and easy to show an O(1) query algorithm after an O(|S|2) time preprocessing. We provide algorithms that solve the problem with the following complexities: 1 Preprocessing Time:O(|S|), Space:O(|S|), Query Time:O(|j−i|loglogn). Preprocessing Time: no preprocessing, Space:O(|j−i|log|j−i|), Query Time:O(|j−i|log|j−i|). However, the query just gives the pairs with the longest LCP, not the LCP itself. Preprocessing Time:O(|S|log2 |S|), Space:O(|S|log1+e |S|) for arbitrary small constant e, Query Time:O(loglog|S|).