Lower bounds for text indexing with mismatches and differences

Cohen-Addad, Vincent; Feuilloley, Laurent; Starikovskaya, Tatiana

doi:10.1137/1.9781611975482.70

Cited by 11 publications

(9 citation statements)

References 27 publications

(45 reference statements)

Supporting

Mentioning

Contrasting

Order By: Relevance

“…This list does not include lower bounds that can be obtained as consequences of these lower bounds (e.g., through reductions). In addition, the pointer machine lower bound frameworks have been applied to some string problems [8,7,18] as well as to the I/O model (a.k.a the external memory model) [22,9]. In fact, the author has shown that under some very general settings, it is possible to directly translate a pointer machine lower bound to a lower bound for the same problem in the I/O model [1].…”

Section: Static Lower Boundsmentioning

confidence: 99%

A Lower Bound for Dynamic Fractional Cascading

Afshani¹

2021

Proceedings of the 2021 ACM-SIAM Symposium on Discrete Algorithms (SODA)

View full text Add to dashboard Cite

We investigate the limits of one of the fundamental ideas in data structures: fractional cascading. This is an important data structure technique to speed up repeated searches for the same key in multiple lists and it has numerous applications. Specifically, the input is a "catalog" graph, G cat , of constant degree together with a list of values assigned to every vertex of G cat . The goal is to preprocess the input such that given a connected subgraph G of G cat and a single query value q, one can find the predecessor of q in every list that belongs to G . The classical result by Chazelle and Guibas shows that in a pointer machine, this can be done in the optimal time of O(log n + |G |) where n is the total number of values. However, if insertion and deletion of values are allowed, then the query time slows down to O(log n + |G | log log n). If only insertions (or deletions) are allowed, then once again, an optimal query time can be obtained but by using amortization at update time.We prove a lower bound of Ω(log n √ log log n) on the worst-case query time of dynamic fractional cascading, when queries are paths of length O(log n). The lower bound applies both to fully dynamic data structures with amortized polylogarithmic update time and incremental data structures with polylogarithmic worst-case update time. As a side, this also proves that amortization is crucial for obtaining an optimal incremental data structure. This is the first non-trivial pointer machine lower bound for a dynamic data structure that breaks the Ω(log n) barrier. In order to obtain this result, we develop a number of new ideas and techniques that hopefully can be useful to obtain additional dynamic lower bounds in the pointer machine model.

show abstract

Section: Static Lower Boundsmentioning

confidence: 99%

A Lower Bound for Dynamic Fractional Cascading

Afshani¹

2021

Proceedings of the 2021 ACM-SIAM Symposium on Discrete Algorithms (SODA)

View full text Add to dashboard Cite

show abstract

“…More efficient solutions for k = 1 are known (see [10] and references therein). Cohen-Addad et al [31] showed that, under SETH, for k = Θ(log n) any indexing data structure that can be constructed in polynomial time cannot have O(n 1−δ ) query time, for any δ > 0. They also showed that in the pointer machine model, for k = o(log n), exponential dependency on k either in the space or in the query time cannot be avoided (for the reporting version of the problem).…”

Section: Other Related Workmentioning

confidence: 99%

Faster Algorithms for Longest Common Substring

Charalampopoulos,

Kociumaka,

Pissis

et al. 2021

Preprint

View full text Add to dashboard Cite

In the classic longest common substring (LCS) problem, we are given two strings S and T , each of length at most n, over an alphabet of size σ, and we are asked to find a longest string occurring as a fragment of both S and T . Weiner, in his seminal paper that introduced the suffix tree, presented an O(n log σ)-time algorithm for this problem [SWAT 1973]. For polynomially-bounded integer alphabets, the linear-time construction of suffix trees by Farach yielded an O(n)-time algorithm for the LCS problem [FOCS 1997]. However, for small alphabets, this is not necessarily optimal for the LCS problem in the word RAM model of computation, in which the strings can be stored in O(n log σ/ log n) space and read in O(n log σ/ log n) time. We show that, in this model, we canWe then lift our ideas to the problem of computing a k-mismatch LCS, which has received considerable attention in recent years. In this problem, the aim is to compute a longest substring of S that occurs in T with at most k mismatches. Flouri et al. showed how to compute a 1-mismatch LCS in O(n log n) time [IPL 2015]. Thankachan et al. extended this result to computing a k-mismatch LCS in O(n log k n) time for k = O(1) [J. Comput. Biol. 2016]. We show an O(n log k−1/2 n)-time algorithm, for any constant k > 0 and irrespective of the alphabet size, using O(n) space as the previous approaches. We thus notably break through the well-known n log k n barrier, which stems from a recursive heavy-path decomposition technique that was first introduced in the seminal paper of Cole et al. [STOC 2004] for string indexing with k errors.

show abstract

“…There are conditional lower bounds for approximate similarity search under edit distance based on the strong exponential hypothesis (SETH). In short, as the approximation factor c → 1, the strong exponential time hypothesis implies that any approximate similarity search algorithm with polynomial preprocessing time must approach linear search time [29,57].…”

Section: Related Workmentioning

confidence: 99%

“…Recent work in fine-grained complexity has begun to explain this difficulty: achieving significantly better than linear search time would violate the strong exponential time hypothesis. [4,29,57] However, these queries can be relaxed to approximate similarity search queries. For an approximation factor c, we want to find a database item that is at most a c factor less similar than the most similar item.…”

Section: Introductionmentioning

confidence: 99%

Approximate Similarity Search Under Edit Distance Using Locality-Sensitive Hashing

McCauley

2019

Preprint

View full text Add to dashboard Cite

Edit distance similarity search, also called approximate pattern matching, is a fundamental problem with widespread applications. The goal of the problem is to preprocess n strings of length d, to quickly answer queries q of the form: if there is a database string within edit distance r of q, return a database string within edit distance cr of q. A data structure solving this problem is analyzed using two criteria: the amount of extra space used in preprocessing, and the expected time to answer a query.Previous approaches to this problem have either used trie-based methods, which give exact solutions at the cost of expensive queries, or embeddings, which only work for large (superconstant) values of c.In this work we achieve the first bounds for any approximation factor c, via a simple and easyto-implement hash function. This gives a running time of O(d3 r n 1/c ), with space O(3 r n 1+1/c + dn). We show how to apply these ideas to the closely-related Approximate Nearest Neighbor problem for edit distance, obtaining similar time bounds.

show abstract

Lower bounds for text indexing with mismatches and differences

Cited by 11 publications

References 27 publications

A Lower Bound for Dynamic Fractional Cascading

A Lower Bound for Dynamic Fractional Cascading

Faster Algorithms for Longest Common Substring

Approximate Similarity Search Under Edit Distance Using Locality-Sensitive Hashing

Contact Info

Product

Resources

About