Finger Search in Grammar-Compressed Strings

Abstract

Grammar-based compression, where one replaces a long string by a small context-free grammar that generates the string, is a simple and powerful paradigm that captures many popular compression schemes. Given a grammar, the random access problem is to compactly represent the grammar while supporting random access, that is, given a position in the original uncompressed string report the character at that position. In this paper we study the random access problem with the finger search property, that is, the time for a random access query should depend on the distance between a specified index f , called the finger, and the query index i. We consider both a static variant, where we first place a finger and subsequently access indices near the finger efficiently, and a dynamic variant where also moving the finger such that the time depends on the distance moved is supported.Let n be the size the grammar, and let N be the size of the string. For the static variant we give a linear space representation that supports placing the finger in O(log N ) time and subsequently accessing in O(log D) time, where D is the distance between the finger and the accessed index. For the dynamic variant we give a linear space representation that supports placing the finger in O(log N ) time and accessing and moving the finger in O(log D + log log N ) time. Compared to the best linear space solution to random access, we improve a O(log N ) query bound to O(log D) for the static variant and to O(log D + log log N ) for the dynamic variant, while maintaining linear space. As an application of our results we obtain an improved solution to the longest common extension problem in grammar compressed strings. To obtain our results, we introduce several new techniques of independent interest, including a novel van Emde Boas style decomposition of grammars.

Compression by Contracting Straight-Line Programs

“…The survey [4] provides a good overview on dynamic finger search trees. In the setting of finger search on a string s, Bille, Christiansen, Cording, and Gørtz [2] considered three operations: access(i) returns symbol s[i], setfinger(i) sets the finger at position i of s, and movefinger(i) moves the finger to position i in s. Given an SLP of size g for a string of length N , they presented an O(g) size data structure which supports setfinger(i) in O(log N ) time, and access(i) and movefinger(i) in O(log d + log log N ) time where d is the distance from the current finger position [2]. If we assume that the SLP is α-balanced or an AVL-grammar, one can come up with a linear space solution which supports access(i) and movefinger(i) in O(log d) time (Theorem 20).…”

“…Let us remark that Theorem 1 holds in the pointer machine model [23], whereas for Theorem 2 and Theorem 3 we assume the word RAM model with the standard arithmetic and bitwise operations on w-bit words, where w ≥ log N . The assumption on the word length is standard in the area of grammar-based compression, see [3,2].…”

“…To solve finger search efficiently, Bille, Christiansen, Cording, and Gørtz first consider the fringe access problem [2]: Given a variable A and a position 1…”

“…We can maintain the accelerated path in a dynamic predecessor structure with constant update and query time, thanks to the O(log N ) height of the SLP. We follow the approach of [2] and present an improved O(tg) space solution for the fringe access problem: Given a variable A and a position 1 ≤ i ≤ |A|, we can access the i-th symbol of A in time O(log d + log (t) N ) where d = min{i, |A| − i + 1} is the distance from the fringe of A, and t is any parameter.…”

RePair Grammars are the Smallest Grammars for Fibonacci Words

“…Grammar-based compression is a loss-less data compression scheme that represents a string w by an SLP for w. We are aware of more powerful compression schemes such as run-length SLPs [23,35,5], composition systems [18], collage systems [25], NU-systems [34], the Lempel-Ziv 77 family [40,37,11,12], and bidirectional schemes [37]. Nevertheless, since SLPs exhibit simpler structures than those, a number of efficient algorithms that can work directly on SLPs have been proposed, including pattern matching [24,23], convolutions [38], random access [7], detection of repeats and palindromes [21], Lyndon factorizations [22], longest common extension queries [20], longest common substrings [33], finger searches [4], and balancing the grammar [16]. More examples of algorithms directly working on SLPs can be found in references therein and the survey [30].…”