Sparse Regular Expression Matching

TL;DR

This paper introduces a new parameter called density to measure nondeterminism in regular expression matching, leading to an improved algorithm with complexity depending on this parameter, and establishes matching lower bounds under SETH.

Contribution

The paper proposes a novel density parameter for regular expression matching, resulting in an algorithm with complexity tied to this parameter, and provides matching conditional lower bounds.

Findings

New algorithm with $O(\Delta \log \log \frac{nm}{\Delta} + n + m)$ time complexity.

Density parameter $\Delta$ can be significantly smaller than $nm$, improving efficiency.

Conditional lower bounds show the algorithm's near-optimality under SETH.

Abstract

A regular expression specifies a set of strings formed by single characters combined with concatenation, union, and Kleene star operators. Given a regular expression $R$ and a string $Q$, the regular expression matching problem is to decide if $Q$ matches any of the strings specified by $R$. Regular expressions are a fundamental concept in formal languages and regular expression matching is a basic primitive for searching and processing data. A standard textbook solution [Thompson, CACM 1968] constructs and simulates a nondeterministic finite automaton, leading to an $O(nm)$ time algorithm, where $n$ is the length of $Q$ and $m$ is the length of $R$. Despite considerable research efforts only polylogarithmic improvements of this bound are known. Recently, conditional lower bounds provided evidence for this lack of progress when Backurs and Indyk [FOCS 2016] proved that, assuming the strong exponential time hypothesis (SETH), regular expression matching cannot be solved in $O((nm)^{1-\epsilon})$, for any constant $\epsilon > 0$. Hence, the complexity of regular expression matching is essentially settled in terms of $n$ and $m$. In this paper, we take a new approach and introduce a \emph{density} parameter, $\Delta$, that captures the amount of nondeterminism in the NFA simulation on $Q$. The density is at most $nm+1$ but can be significantly smaller. Our main result is a new algorithm that solves regular expression matching in $$O\left(\Delta \log \log \frac{nm}{\Delta} +n + m\right)$$ time. This essentially replaces $nm$ with $\Delta$ in the complexity of regular expression matching. We complement our upper bound by a matching conditional lower bound that proves that we cannot solve regular expression matching in time $O(\Delta^{1-\epsilon})$ for any constant $\epsilon > 0$ assuming SETH.

Equations

$$O\left(\Delta \log \log \frac{nm}{\Delta }+n+m\right)$$

$${\Delta }_{R,Q}^A=\sum _{i=0}^n|S_i|,$$

$$O\left(\Delta \log \log \frac{nm}{\Delta }+n+m\right).$$

$$O\left(|S|\log \log \frac{m}{|S|}+|\delta (S,\alpha )|\right).$$

$$\mathsf{first}(R)$$

$$\mathsf{last}(R)$$

$$\mathsf{follow}(R,p)$$

$$V$$

$$E$$

$$F$$

$${\delta }_{[l,r]}^{\odot }(v,\alpha )$$

$${\delta }_{[l,r]}^{\ast }(v,\alpha )$$

$$N^{\odot }(P,\alpha )$$

$$N^{\ast }(P,\alpha )$$

$$\text{ and parent∗(v)∈lastextent(p)∩firstextent(q)}\}$$

$$\delta (P,\alpha )=\bigcup _{v\in N^{\odot }(P,\alpha )}{\delta }^{\odot }(v,\alpha )\cup \bigcup _{v\in N^{\ast }(P,\alpha )}{\delta }^{\ast }(v,\alpha ).$$

$$S_{\alpha }=\{w\in s\mid w\text{ is a }\odot \text{-live node},\mathsf{left}(w)\in s,\alpha \in \mathsf{label}(w)\text{ and }{\delta }^{\odot }(w,\alpha )\ne \varnothing \}.$$

$$D^{\odot }=\bigcup _{(l,r,u)\in L^{\odot }}{\delta }_{[l,r]}^{\odot }(u,\alpha )\text{ and }{D}^{\ast }=\bigcup _{(l,r,u)\in L^{\ast }}{\delta }_{[l,r]}^{\ast }(u,\alpha ).$$

$$O\left(\sum _{(l,r,u)\in L^{\odot }}(1+|{\delta }_{[l,r]}^{\odot }(u,\alpha )|)+\sum _{(l,r,u)\in L^{\ast }}(1+|{\delta }_{[l,r]}^{\ast }(u,\alpha )|)\right)$$

$$\bigcup _{v\in M^{\odot }}{\delta }^{\odot }(v,\alpha )=\bigcup _{(l,r,u)\in L^{\odot }}{\delta }_{[l,r]}^{\odot }(u,\alpha )\text{ and }\bigcup _{v\in M^{\ast }}{\delta }^{\ast }(v,\alpha )=\bigcup _{(l,r,u)\in L^{\ast }}{\delta }_{[l,r]}^{\ast }(u,\alpha ).$$

$$O\left(\sum _{i=0}^n|S_i|\log \log \frac{m}{|S_i|}\right)=O\left((n+1)\frac{\Delta }{n+1}\log \log \frac{m}{\Delta /(n+1)}\right)=O\left(\Delta \log \log \frac{nm}{\Delta }\right).$$

$$R^{\prime }=\left(\underset{j=1}{\overset{|Q^{\prime }|}{⨀}}(x^{\ast }{y}^{\ast })\right)\cdot P\cdot \left(\underset{j=1}{\overset{|Q^{\prime }|}{⨀}}(x^{\ast }{y}^{\ast })\right).$$

$$Q=x^{\ell }\cdot Q^{\prime }\text{and}R=x^{\ell }\cdot R^{\prime }$$

Full text

In this paper, we take a new approach and introduce a density parameter, $\Delta$, that captures the amount of nondeterminism in the NFA simulation on $Q$. The density is at most $nm+1$ but can be significantly smaller. Our main result is a new algorithm that solves regular expression matching in

[TABLE]

time.

This essentially replaces $nm$ with $\Delta$ in the complexity of regular expression matching. We complement our upper bound by a matching conditional lower bound that proves that we cannot solve regular expression matching in time $O(\Delta^{1-\epsilon})$ for any constant $\epsilon>0$ assuming SETH.

The key technical contribution in the result is a new linear space representation of the classic position automaton that supports fast state-set transition computation in near-linear time in the size of the input and output state sets. To achieve this, we develop several new insights and techniques of independent interest, including new structural properties of the parse trees of regular expressions, a decomposition of state-set transitions based on parse trees, and a fast batched predecessor data structure.

1 Introduction

A regular expression $R$ specifies a set of strings formed by characters from an alphabet $\Sigma$ combined with concatenation ($\odot$), union ($\mid$), and Kleene star (∗) operators. For instance, $(a|(b\odot a))^{\ast}$ describes the set of strings of $a$s and $b$s such that every $b$ is followed by an $a$. Given a regular expression $R$ and string $Q$, the regular expression matching is to decide if $Q$ matches any of the strings specified by $R$. Regular expressions are a fundamental concept in formal language theory introduced by Kleene in the 1950’ties [48] and regular expression matching is a basic tool in computer science for searching and processing text. Standard tools such as grep and sed provide direct support for regular expression matching in files, and the scripting language perl [72] is a full programming language designed to support regular expression matching easily. Regular expression matching appears in many large-scale data processing applications such as internet traffic analysis [44, 78, 49], data mining [31], data bases [52, 60], computational biology [63], and human-computer interaction [47].

A classic textbook algorithm for regular expression matching, due to Thompson [70] from 1968, constructs and simulates a nondeterministic finite automaton (NFA) $A$ in $O(nm)$ time, where $n$ is the length of $Q$ and $m$ is the number of character symbols in $R$. The simulation processes $Q$ from left to right and computes a sequence of sets of states $S_{0},\ldots,S_{n}$ such that $S_{i}$ is the set of states in $A$ to which there is a path from the initial state that matches $Q[1..i]$. In 1985 Galil [29] asked if a faster algorithm could be obtained. A sequence of results [62, 11, 10, 12] improved the $O(nm)$ bound using tabulation or word-level parallelism leading to solutions using either $O(nm\frac{\log\log n}{\log^{1.5}n}+n+m)$ [12] or $O(nm\frac{\log w}{w}+n+m\log m)$ time [10] time, where $w$ is the word length. Finally, Bille and Thorup [13] gave an algorithm using $O(nk\frac{\log w}{w}+n+m\log k)$ time, where $k\leq m$ is the number of strings appearing in the regular expression (see also [26, 8]).

The above solutions are based on the classic NFA simulation algorithm from Thompson’s original algorithm [70] and thus achieve the same $O(nm)$ time with some polylogarithmic factors shaved. Recently, conditional lower bounds have provided evidence for the lack of more significant progress. First, Backurs and Indyk [7] showed in 2016 that we cannot solve regular expression matching in time $O((nm)^{1-\epsilon})$, for $\epsilon>0$, assuming the strong exponential time hypothesis (SETH) [43]. Then, in 2018 Abboud and Bringmann [1] showed that we cannot solve the problem in time $O(nm/\log^{7+\epsilon}n)$, for $\epsilon>0$, assuming the Formula SAT hypothesis [1]. These results, together with Bringmann, Larsen, and Grønlund [15] and Schepper [67], also studied subclasses of regular expression matching depending on the structure of the operators in the expression, leading to a classification of the complexity of each such subclass. In summary, the complexity of regular expression matching is essentially settled in terms of $n$ and $m$.

In this paper, we take a new approach and introduce a density parameter, $\Delta$, that captures the amount of nondeterminism in the NFA simulation on $Q$. The density is at most $nm+1$ but can be significantly smaller. Our main result is a new algorithm that solves regular expression matching in

[TABLE]

time. This essentially replaces $nm$ with $\Delta$ in the complexity of regular expression matching. We complement our upper bound by a conditional lower bound that proves that we cannot solve regular expression matching in time $O(\Delta^{1-\epsilon})$ for any constant $\epsilon>0$ assuming SETH.

1.1 Sparse Regular Expression Matching

Recall that the NFA simulation algorithm constructs a sequence $S_{0},\ldots,S_{n}$ of state sets such that $S_{i}$ is the set of states in the automaton to which there is a path from the initial state that matches $Q[1..i]$. The goal of this paper is to explore the complexity of regular expression matching if these sets are sparse. More precisely, let $(R,Q)$ be an instance of the regular expression matching and let $A$ be a finite automaton that accepts the set of strings defined by $R$, and let $S_{0},\ldots,S_{n}$ be the sequence of sets of states in the simulation of $A$ on $Q$. We define the density of $(R,Q)$ wrt. $A$ to be

[TABLE]

i.e., the density is the total size of the state sets in the simulation of $A$ on $Q$.

We will focus on density wrt. to the classic position automaton (also known as Glushkov’s automaton), denoted $A_{\mathsf{Pos}}$, proposed by Glushkov in 1960 [35, 34] and independently by McNaughton and Yamada [57]. For most NFA constructions [33, 4, 17, 70] (including several textbook constructions [3, 2, 24, 51, 56, 69, 77]), the density wrt. to $A_{\mathsf{Pos}}$ is a lower bound on the density wrt. to the other NFA construction. The key observation is that the set of states in $A_{\mathsf{Pos}}$ naturally corresponds to a subset of the set of states in the other constructions. For instance, we can convert Thompson’s NFA, $A_{\mathsf{T}}$, into the corresponding position automaton, $A_{\mathsf{Pos}}$, by carefully contracting $\epsilon$-transitions [33, 4, 17]. This implies $\Delta^{A_{\mathsf{Pos}}}_{R,Q}\leq\Delta^{A_{\mathsf{T}}}_{R,Q}$ and thus if an algorithm is efficient in terms of $\Delta^{A_{\mathsf{Pos}}}_{R,Q}$ the same algorithm is also efficient in terms of $\Delta^{A_{\mathsf{T}}}_{R,Q}$. Hence, for the rest of the paper, we define the density, denoted $\Delta_{R,Q}$, to be $\Delta^{A_{\mathsf{Pos}}}_{R,Q}$, and when $R$ and $Q$ are clear from the context we simply write $\Delta$.

Intuitively, the density captures the amount of nondeterminism in the simulation of $A_{\mathsf{Pos}}$. At one extreme $\Delta=n+1$ when all of the $n+1$ state sets are singletons (assuming $R$ matches $Q$) and at the other extreme $\Delta=nm+1$ when all of the state sets, except the special $S_{0}$, consists of all states. The density can be significantly smaller than $nm$ in important practical scenarios. For instance, in internet traffic analysis a stream is matched against a large set of rules specified as a regular expression. Typically, most of these packets will only match a small subset of the rules implying a small density of the problem instance.

A related concept is deterministic regular expressions (also known as $1$-unambiguous regular expressions). These are defined as regular expressions for which $A_{\mathsf{Pos}}$ is deterministic, that is, all state-set transitions on any singleton state set result in a singleton state set. Deterministic regular expressions are widely used in schema languages [19, 14, 30, 61] and have been extensively studied in complexity and automata theory [19, 18, 36, 65, 55, 23, 54]. Groz and Maneth [36] showed how to solve the deterministic regular expression matching problem in $O(n\log\log m+m)$ time. Note that if the regular expression is deterministic we always have that $\Delta\leq n+1$.

1.2 Sparse State-Set Transitions

Given a set of $S$ of states and a character $\alpha$ a state-set transition, denoted $\delta(S,\alpha)$, is the set of states reachable from $S$ via paths of transitions in the NFA that match $\alpha$ (for $\epsilon$-free NFAs the paths are always single transitions). We can implement the NFA simulation using $n$ state-set transitions by setting $S_{0}$ to be the initial state, and computing $S_{i}=\delta(S_{i-1},Q[i])$ for $i=1,\ldots,n$. In our scenario, we are interested in a compact representation of $A_{\mathsf{Pos}}$ that supports fast sparse state-set transitions, i.e., a state-set computation that is efficient in terms of the sizes of the input set $|S|$ and the output set $|\delta(S,\alpha)|$. Since $\Delta$ is the total size of state sets in the simulation this implies an efficient algorithm for sparse regular expression matching.

Surprisingly, few results are known for this problem. If we store $A_{\mathsf{Pos}}$ explicitly we can compute $\delta(S,\alpha)$ by computing the union of the endpoints of transitions out of states in $S$ labeled $\alpha$. This leads to a data structure that uses $O(m^{2})$ space and supports state-set transitions in $O(|S||\delta(S,\alpha)|)$ time. Note that since endpoints of the transition may overlap (see Figure 1(a)) we may need to explore $\Omega(|S||\delta(S,\alpha)|)$ transitions in general. A similar worst-case trade-off also holds for the many variants of the position automaton, see e.g. [20, 42, 5, 59]. While $\epsilon$-free NFAs with fewer transitions are known [40, 37, 32, 68] these do not appear to translate to simulations for $A_{\mathsf{Pos}}$ nor do they improve the above time bound.

Alternatively, we can store Thompson’s automaton, $A_{\mathsf{T}}$, and use the mapping of states mentioned above to convert state-set transitions on $A_{\mathsf{T}}$ to state-set transitions on $A_{\mathsf{Pos}}$. Since $A_{\mathsf{T}}$ is not an $\epsilon$-free automaton we can compute a state-set transition using a breadth-first search to explore all paths from $S$ that match $\alpha$. This uses $O(m)$ space and $O(m)$ time. However, it is easy to see that with this approach we may need to traverse large subgraphs of $\Omega(m)$ transitions labeled $\epsilon$ even if the sets $|S|$ or $\delta(S,\alpha)$ are sparse. Indeed, the efficient solutions in terms of $n$ and $m$ are based on improving state-set transitions in $A_{\mathsf{T}}$ for the dense case by polylogarithmic factors.

1.3 Results

Our main result is an efficient algorithm for sparse regular expression matching.

Theorem 1**.**

Given a regular expression $R$ with $m$ positions and a string $Q$ of length $n$, we can solve the regular expression matching problem in space $O(m)$ and time

[TABLE]

Since the density $\Delta$ is at most $nm+1$, this essentially replaces $nm$ with $\Delta$ in the complexity of regular expression matching. As an immediate Corollary of Theorem 1 we obtain a solution to deterministic regular expression matching using $O(n\log\log m+m)$ time and $O(m)$ space, thus matching the best known bound of Groz and Maneth [36]. We complement Theorem 1 with an essentially matching conditional lower bound.

Theorem 2**.**

For any $\Delta=n^{1+\gamma}$, for any constant $0<\gamma\leq 1$, there exists no $O(\Delta^{1-\epsilon})$ time algorithm for regular expression matching for any constant $\epsilon>0$ assuming SETH.

Theorem 1 is based on a compact representation of the position automaton that supports efficient sparse state-set transitions.

Theorem 3**.**

Given a regular expression $R$ with $m$ positions, we can represent the position automaton in $O(m)$ space and preprocessing time, such that given any set of states $S$ in sorted order and a character $\alpha$, we can compute the state-set transition $\delta(S,\alpha)$ in time

[TABLE]

The output of the state-set transition is also reported in sorted order.

The sorted order of $S$ and $\delta(S,\alpha)$ in Theorem 3 refers to the ordering of the corresponding positions in $R$ from left to right (without this condition the $\log\log(m/|S|)$ factor becomes $\log\log|S|)$). Theorem 3 significantly improves the previous $O(|S||\delta(S,\alpha)|)$ and $O(m)$ time bounds. Since any solution must use at least $\Omega(|S|+|\delta(S,\alpha)|)$ to read the input and write the output the bound is almost optimal.

1.4 Techniques

We develop several new insights and techniques of independent interest, including new structural properties of the parse trees of regular expressions, a novel decomposition of state-set transitions based on parse trees, and a fast batched predecessor data structure.

We show how to decompose any state-set transition $\delta(S,\alpha)$ into a set of internal transitions on a set of $O(|S|+|\delta(S,\alpha)|)$ transition nodes of the parse tree of $R$. We have two types of internal transitions: one for $\odot$ and one for $\ast$. Intuitively, if $R(v)=R(u)\odot R(w)$ then the internal $\odot$-transition of $v$ wrt. $\alpha$ are all the states/positions in $R(w)$ reachable from a state/position in $R(u)$ using a transition labeled $\alpha$. The internal $\ast$-transitions are more complicated to describe, but both types of internal transitions are independent of the state set $S$. We show how to represent $R$ in linear space to efficiently compute internal transitions for any node $v$ and character $\alpha$.

We identify the set of transition nodes for $\delta(S,\alpha)$ by first computing a compact representation of a transition tree, which encodes all paths in $R$ containing transition nodes in $O(|S|)$ space. Then, we find the set of transition nodes using this tree. The key challenge is that even though the representation of the transition tree is small the tree itself can be significantly larger and contain many nodes that are irrelevant for the character $\alpha$ and/or irrelevant for the state set $S$. Using the structural properties of the parse tree we show how to overcome the challenges and efficiently find the set of transition nodes for any $S$ and $\alpha$. Computing the internal transitions of all transition nodes could take too long, as the output of these overlap and we could end up using $\Omega(|S||\delta(S,\alpha)|)$ time. However, we prove that these output sets form a laminar family and show how to divide the computations of the internal transitions into computations on a bounded number of non-overlapping intervals.

In combination, the above techniques lead to an $O(m)$ space representation of $R$ that supports state-set transitions in $O(|S|\log\log m+|\delta(S,\alpha)|)$ time. The bottleneck here is computing a $O(|S|)$ predecessor queries in $O(\log\log m)$ time. We present a simple two-level data structure that solves this batched predecessor problem in $O(|S|\log\log\frac{m}{|S|})$ time while maintaining linear space leading to our final structure. Using this solution for sparse-set transitions to implement the NFA simulation implies our main result for sparse regular expression matching of Theorem 1.

The lower bound follows from a reduction from the orthogonal vectors problem (OVP). We prove that given $\Delta=n^{1+\gamma}$, for any constant $0<\gamma\leq 1$, we can construct an instance of regular expression matching such that the existence an $O(\Delta^{1-\epsilon})$ algorithm for regular expression matching violates SETH. The reduction is based on the reduction by Backurs and Indyk [7] and is a fairly straightforward generalization of their lower bound.

1.5 Related Work

Another NFA construction, by Chang and Paige [21], considered compact representations of $A_{\mathsf{Pos}}$ that support efficiently implementing NFA to DFA conversion by subset construction. They presented a linear space representation that supports efficiently computing the set of states $S^{\prime}$ reachable via any character from a state-set $S$ in time $O(|S|+|S^{\prime}|)$. Since $S^{\prime}$ can be much larger than $\delta(S,\alpha)$ this does not imply an efficient sparse state-set transition.

Some measures of nondeterminism of NFAs have been studied in automata theory, e.g., width, ambiguity, string tree width, string path width, and cycle height [46, 50, 53, 39, 45]. These focus on the complexity of computing measures of the nondeterminism of a given NFA. In contrast, we study the complexity of regular expression matching in terms of the nondeterminism of a simulation on a given NFA and input string.

As mentioned, Bille and Thorup [13] considered the number of strings $k\leq m$ in the regular expression as a parameter for regular expression matching. They gave an algorithm using $O(nk\frac{\log w}{w}+n+m\log k)=O(nk+m\log k)$ time. It is straightforward to construct instances of regular expression matching (for a matching regular expression) such that either $nk=\Theta(nm)$ and $\Delta=\Theta(n)$ or $nk=\Theta(n)$ and $\Delta=\Theta(nm)$ hence this result is incomparable to ours. Cotumaccio, D’Agostino, Policriti, and Prezza [22] studied the indexing version of regular expressions, where the goal is to preprocess a regular expression in order to allow for fast matching given a query string. They considered the co-lexicographic width of an automaton. Applying their construction in the matching setting gives an algorithm that runs in $O(m^{2}+np^{2}\log(p\cdot\sigma))$, where $p$ is the width of the co-lexicographic order and $m^{2}$ comes from the preprocessing of the automaton.

Several papers have studied the related problem of string matching in labeled graphs. For example, Rizzo, Tomescu, and Policriti [66] studied the problem of matching a pattern on a labeled graph parameterized wrt the size of the labeled direct product graph, and Nellore, Nguyen, and Thompson [64] studied string matching in graphs parameterized by the size of the powerset automaton.

Finally, we note that sparsity is a well-studied phenomenon in a wide range of areas in computer science. In particular, sparsity has been extensively studied for other classic pattern matching problems, see, e.g., [41, 28, 27, 73, 74, 6].

1.6 Outline

We review regular expressions and automata in Section 2 and the parse tree view of regular expressions in Section 3. We introduce internal transitions, state-set decompositions, and transition trees in Section 4 and present our main algorithm for sparse state-set transitions in Section 5. In Section 6, we present the improved batched predecessor data structure. We use this to obtain the final result for sparse state-set transitions of Theorem 3 which we then use to obtain Theorem 1. Finally, we show the lower bound of Theorem 2 in Section 7.

2 Regular Expressions and Automata

We briefly review the classical concepts used in the paper. For more details, see, e.g., Aho et al. [2].

Regular Expressions

We consider the set of non-empty regular expressions over an alphabet $\Sigma$, defined recursively as follows. If $\alpha\in\Sigma\cup\{\epsilon\}$ then $\alpha$ is a regular expression, and if $S$ and $T$ are regular expressions then so is the concatenation, $(S)\odot(T)$, the union, $(S)|(T)$, and the star, $(S)^{*}$. We often omit the concatenation $\odot$ when writing regular expressions. The language $L(R)$ generated by a regular expression $R$ is defined as follows. If $\alpha\in\Sigma\cup\{\epsilon\}$, then $L(\alpha)$ is the set containing the single string $\alpha$. If $S$ and $T$ are regular expressions, then $L(S\odot T)=L(S)\odot L(T)$, that is, any string formed by the concatenation of a string in $L(S)$ with a string in $L(T)$, $L(S)|L(T)=L(S)\cup L(T)$, and $L(S^{*})=\bigcup_{i\geq 0}L(S)^{i}$, where $L(S)^{0}=\{\epsilon\}$ and $L(S)^{i}=L(S)^{i-1}\odot L(S)$, for $i>0$.

Finite Automata

A finite automaton is a tuple $A=(V,E,\Sigma,\Theta,\Phi)$, where $V$ is a set of nodes called states, $E\subseteq(V\times V\times\Sigma\cup\{\epsilon\})$ is a set of directed edges between states called transitions each labeled by a character from $\Sigma\cup\{\epsilon\}$, $\Theta\subseteq V$ is a set of start states, and $\Phi\subseteq V$ is a set accepting states. In short, $A$ is an edge-labeled directed graph with designated subsets of start and accepting nodes. $A$ is a deterministic finite automaton (DFA) if $A$ does not contain any $\epsilon$-transitions, all outgoing transitions of any state have different labels, and there is exactly one start state. Otherwise, $A$ is a nondeterministic finite automaton (NFA).

Given a string $Q$ and a path $p$ in $A$ we say that $p$ and $Q$ match if the concatenation of the labels on the transitions in $p$ is $Q$. Given a state $s$ in $A$ and a character $\alpha$ we define the state-set transition $\delta_{A}(s,\alpha)$ to be the set of states reachable from $s$ through paths matching $\alpha$ (note that the paths may include transitions labeled $\epsilon$). For a set of states $S$ we define $\delta_{A}(S,\alpha)=\bigcup_{s\in S}\delta_{A}(s,\alpha)$. We say that $A$ accepts a string $Q$ if there is a path from a state in $\Theta$ to a state in $\Phi$ that matches $Q$. Otherwise, $A$ rejects $Q$. We can use a sequence of state-set transitions to test acceptance of a string $Q$ of length $n$ by computing a sequence of state-sets $S_{0},\ldots,S_{n}$, given by $S_{0}=\delta_{A}(\Theta,\epsilon)$ and $S_{i}=\delta_{A}(S_{i-1},Q[i])$, $i=1,\ldots,n$. We have that $\Phi\cap S_{n}\neq\emptyset$ iff $A$ accepts $Q$.

The Position Automaton

Given a regular expression $R$, we can construct an NFA accepting precisely the strings in $L(R)$ by several classic methods [57, 34, 70]. In particular, Glushkov gave an important construction called the position automaton or Glushkov automaton. The position automaton is an $\epsilon$-free NFA consisting of only $m+1$ states and $O(m^{2})$ transitions (See Figure 1). Each state except the start state corresponds to a position. Intuitively, each state-set in a state-set simulation is the set of positions in $R$ that correspond to a match of a prefix of $Q$.

We review the details of the position automaton in the following. Let $R$ be a regular expression with $m$ character symbols from an alphabet $\Sigma$. The position of a character in $R$ is the index of the character in the left-to-right order among the characters in $R$. The set of positions in $R$, denoted $\mathsf{Pos}(R)$, is the set $\{1,\ldots,m\}$. The label of a position $p$, denoted $\mathsf{label}(p)$, is the character at position $p$. The subset of positions labeled $\alpha$ is denoted $\mathsf{Pos}_{\alpha}(R)$. When $R$ is clear from the context we abbreviate $\mathsf{Pos}(R)$ to phb $\mathsf{Pos}$.

The marked regular expression of $R$, denoted $\overline{R}$, is obtained from $R$ by subscripting each character in $R$ with its position. Similarly, the marked alphabet, denoted $\overline{\Sigma}$, is obtained from $\Sigma$ by adding subscripts. The marked regular expression $\overline{R}$ defines the language $L(\overline{R})$ over the marked alphabet $\overline{\Sigma}$. Note that $\mathsf{Pos}(\overline{R})=\mathsf{Pos}(R)$. Given a position $p$ we define $\overline{\mathsf{label}}(p)$ to be the label of $p$ in $\overline{R}$. The $\mathsf{first}$ and $\mathsf{last}$ set of $R$ represent the positions that match the first and last character, respectively, in some string in $L(\overline{R})$. Given a position $p$, the $\mathsf{follow}$ set of $R$ and $p$ is the set of positions that can follow a position $p$ in $L(\overline{R})$. More precisely,

[TABLE]

We then define the position automaton for $R$ as the NFA $A=(V,E,\{0\},F)$, where

[TABLE]

3 Regular Expressions as Trees

Throughout the rest of the paper, let $R$ be a regular expression with $m$ positions and let $\delta$ denote the state-set transition function of the position automaton for $R$. For simplicity in the presentation, we will focus on implementing $\delta$ on the positions of $R$ and ignore the extra start state of the position automaton. The extra start state is straightforward to represent with additional linear space and is only needed in the initial step of state-set simulations.

We identify regular expressions by their parse trees (see Figure 2). Note that the leaves in left-to-right order are the positions. We call the three types of internal nodes $\odot$-nodes, $\ast$-nodes, and $\mid$-nodes. For a $|$-node or $\odot$-node $v$ the left and right child are denoted $\mathsf{left}(v)$ and $\mathsf{right}(v)$, respectively, and for a $\ast$-node the single child is denoted $\mathsf{left}(v)$. The depth of a node $v$ in $R$ is the number of edges on the path from the root of $R$ to $v$. We denote the subtree (equivalently subexpression) rooted at a node $v$ by $R(v)$. If $u\in R(v)$ then $v$ is an ancestor of $u$, denoted $v\preceq u$, and if $u\in R(v)$ and $u\neq v$ then $v$ is a proper ancestor of $u$, denoted $v\prec u$. If $v$ is a (proper) ancestor of $u$ then $u$ is a (proper) descendant of $v$. A node $w$ is a common ancestor of $u$ and $v$ if it is an ancestor of both $u$ and $v$. The lowest common ancestor of $u$ and $v$, $\mathsf{lca}(u,v)$, is the common ancestor of $u$ and $v$ of greatest depth. The lowest star ancestor of a node $v$, denoted $\mathsf{parent}^{\ast}(v)$, is the lowest ancestor of $v$ that is a $\ast$-node.

We extend the definition of labels to internal nodes. For each internal node $v$, the label of $v$, denoted $\mathsf{label}(v)$, is a set of characters such that $\alpha\in\mathsf{label}(v)$ iff $v=\mathsf{lca}(p,q)$ for some positions $p$ and $q$ both labeled $\alpha$. In Figure 2, $\mathsf{label}(v_{2})=\{a\}$ since $v_{2}=\mathsf{lca}(p_{1},p_{2})$ and $\mathsf{label}(p_{1})=\mathsf{label}(p_{2})=\{a\}$. Since the total number of internal nodes containing label $\alpha$ is $|\mathsf{Pos}_{\alpha}|-1$ the total size of all labels is $O(m)$. For a node $v$ we extend our notation to define $\mathsf{Pos}(v)$, $\mathsf{first}(v)$, $\mathsf{last}(v)$, and $\mathsf{follow}(v,p)$ to denote the sets on the subexpression $R(v)$ (see Figure 2).

In our setting, we will often view the $\mathsf{first}$ and $\mathsf{last}$ sets from the perspective of a single position $p$ and consider the nodes for which $p$ appears in the corresponding $\mathsf{first}$ and $\mathsf{last}$ sets, respectively. Specifically, we define the first extent and last extent of a position $p$, respectively, to be the set of nodes in $R$ given by $\mathsf{firstextent}(p)=\{v\mid p\in\mathsf{first}(v)\}$ and $\mathsf{lastextent}(p)=\{v\mid p\in\mathsf{last}(v)\}$. Furthermore, for a set of positions $P$, we write $\mathsf{firstextent}(P)=\bigcup_{p\in P}\mathsf{firstextent}(p)$ and $\mathsf{lastextent}(P)=\bigcup_{p\in P}\mathsf{lastextent}(p)$. For instance, in Figure 2 we have $\mathsf{firstextent}(\{p_{3},p_{6}\})=\{p_{3},v_{7},v_{6},v_{4},p_{6},v_{3}\}$. We define the first extent and last extent of an internal node $v$, to be the sets $\mathsf{firstextent}(v)=\{u\mid u\preceq v\textrm{ and }u\in\mathsf{firstextent}(\mathsf{Pos}(v))\}$ and $\mathsf{lastextent}(v)=\{u\mid u\preceq v\textrm{ and }u\in\mathsf{lastextent}(\mathsf{Pos}(v))\}$, respectively.

The first sets and the last sets, respectively, form a laminar family. That is, for any two nodes in the parse tree, their first sets, respectively, last sets, are either disjoint or one is contained in the other. That implies that the set of nodes in $\mathsf{firstextent}(p)$, respectively, $\mathsf{lastextent}(p)$, forms a path from position $p$ to an ancestor of $p$.

Lemma 4**.**

Let $p$ be a position in a regular expression $R$ and let $v$ and $u$ be nodes in $R$ such that $u\preceq v\preceq p$. If $u\in\mathsf{firstextent}(p)$, then $v\in\mathsf{firstextent}(p)$ and if $u\in\mathsf{lastextent}(p)$, then $v\in\mathsf{lastextent}(p)$.

Proof.

We have that $R(v)$ is a subexpression of $R(u)$ and $p$ is a position in $R(v)$. Then, if $p\in\mathsf{first}(u)$ then $p\in\mathsf{first}(v)$. Similarly, if $p\in\mathsf{last}(u)$ then $p\in\mathsf{last}(v)$. ∎

4 Internal Transitions, State-Set Decompositions, and Transition Trees

We now introduce the main structural properties of state-set transitions that we need for our fast sparse state-set transition algorithm in Section 5. We first characterize state-set transitions in the position automaton in terms of $\mathsf{firstextent}$ and $\mathsf{lastextent}$ using the following important property.

Lemma 5**.**

Let $p\in\mathsf{Pos}$ and $q\in\mathsf{Pos}_{\alpha}$ and $v=\mathsf{lca}(p,q)$. Then, $q\in\delta(p,\alpha)$ iff either

1. (i)

$v$* is a $\odot$-node, $\mathsf{left}(v)\in\mathsf{lastextent}(p)$, and $\mathsf{right}(v)\in\mathsf{firstextent}(q)$, or* 2. (ii)

$\mathsf{parent}^{\ast}(v)\in\mathsf{lastextent}(p)\cap\mathsf{firstextent}(q)$.

Lemma 5 has appeared in various forms in earlier work [36, 21, 65]. For our purposes, we state it in terms of lowest common ancestors and first extents and last extents. Lemma 5 states that a position $q$ can only appear in $\delta(p,\alpha)$ through a $\odot$-node or a $\ast$-node. We write $q\in\delta^{\odot}(p,\alpha)$ if (i) is satisfied and $q\in\delta^{\ast}(p,\alpha)$ if (ii) is satisfied.

4.1 Internal Transitions

Given an internal node $v$, an internal transition on $v$ and a character $\alpha$ will correspond to the conditions on $q$ and $v$ in Lemma 5 while ignoring the condition on $p$. In general, we will also specify a range of positions we are interested in. Formally, given an internal node $v$, a character $\alpha$, and positions $l$ and $r$, define the internal $\odot$-transition and internal $\ast$-transition, denoted $\delta^{\odot}(v,\alpha)$ and $\delta^{\ast}(v,\alpha)$, respectively, as follows.

[TABLE]

When the range includes all positions we drop the subscript, that is, $\delta^{\odot}(v,\alpha)=\delta^{\odot}_{[1,m]}(v,\alpha)$ and $\delta^{\ast}(v,\alpha)=\delta^{\ast}_{[1,m]}(v,\alpha)$. For instance, in Figure 2 we have $\delta^{\odot}(v_{2},a)=\{p_{2},p_{3}\}$, $\delta^{\odot}_{[3,5]}(v_{2},a)=\{p_{3}\}$, $\delta^{\odot}(v_{1},c)=\{p_{7}\}$ and $\delta^{\ast}(v_{7},a)=\{p_{3}\}$.

4.2 Transition Nodes

Given a state-set transition $\delta(P,\alpha)$, the transitions nodes are a set of nodes $N$ such that if we compute the union of internal transitions on $N$ we obtain $\delta(P,\alpha)$. Formally, we define the $\odot$-transition nodes and $\ast$-transition nodes of $\delta(P,\alpha)$, denoted $N^{\odot}(P,\alpha)$ and $N^{\ast}(P,\alpha)$, respectively, as

[TABLE]

In combination, the set of transition nodes is the union of the $\odot$-transition nodes and the $\ast$-transition nodes.

Lemma 6**.**

For any set of positions $P$ and a character $\alpha$,

[TABLE]

Proof.

Let $\mathrm{RH}$ denote the right handside of (1).

We first show that $\delta(P,\alpha)\subseteq\mathrm{RH}$. Let $p\in P$ and $q\in\mathsf{Pos}$ be positions with $v=\mathsf{lca}(p,q)$ such that $q\in\delta(p,\alpha)$. Then, $q\in\mathsf{Pos}_{\alpha}$ and hence $p$, $q$, and $v$ satisfies either case (i) or (ii) in Lemma 5. If (i) is satisfied, $v$ is a $\odot$-node and $\mathsf{left}(v)\in\mathsf{lastextent}(p)\subseteq\mathsf{lastextent}(P)$ and $\mathsf{right}(v)\in\mathsf{firstextent}(q)\subseteq\mathsf{lastextent}(\mathsf{Pos}_{\alpha})$. By definition, $v\in N^{\odot}(P,\alpha)$, and thus $q\in\delta^{\odot}(v,\alpha)\subseteq\cup_{v\in N^{\odot}(P,\alpha)}\delta^{\odot}(v,\alpha)$. Similarly, if (ii) is satisfied, then $\mathsf{parent}^{\ast}(v)\in\mathsf{lastextent}(p)\cap\mathsf{firstextent}(q)$, and it follows $v\in N^{\ast}(P,\alpha)$. This implies that $q\in\delta^{\ast}(v,\alpha)\subseteq\cup_{v\in N^{\ast}(P,\alpha)}\delta^{\ast}(v,\alpha)$.

To show $\mathrm{RH}\subseteq\delta(P,\alpha)$ first suppose $q\in\cup_{v\in N^{\odot}(P,\alpha)}\delta^{\odot}(v,\alpha)$. Then, $q\in\mathsf{Pos}_{\alpha}$ and there is a $\odot$-node $v$ such that $\mathsf{right}(v)\in\mathsf{firstextent}(q)$ and $\mathsf{left}(v)\in\mathsf{lastextent}(P)$, which implies that $v=\mathsf{lca}(p,q)$ for some $p\in P$. By Lemma 5(i) $q\in\delta(P,\alpha)$. If $q\in\cup_{v\in N^{\ast}(P,\alpha)}\delta^{\ast}(v,\alpha)$ then there exists a $v\in N^{\ast}(P,\alpha)$ such that $q\in\mathsf{Pos}(v)$ and $\mathsf{parent}^{\ast}(v)\in\mathsf{firstextent}(q)$. It follows from the definition of $N^{\ast}(P,\alpha)$ and By Lemma 5(ii) that there exists a $p\in P$ and a $q^{\prime}\in Pos_{\alpha}$ such that $v=\mathsf{lca}(p,q^{\prime})$ and $\mathsf{parent}^{\ast}\in\mathsf{lastextent}(p)\cap\mathsf{firstextent}(q^{\prime})$. Since both $p$ and $q$ are descendants of $v$ we have that $u=\mathsf{lca}(p,q)$ is a (not necessarily proper) descendant of $v$. It follows from Lemma 4 that $u\in\mathsf{lastextent}(p)$ and $\mathsf{parent}^{\ast}(u)\in\mathsf{firstextent}(q)$. Thus by Lemma 5(ii) we have $q\in\delta(P,\alpha)$. ∎

We show that the total size of the two sets $N^{\odot}(P,\alpha)$ and $N^{\ast}(P,\alpha)$ is $O(|P|+|\delta(P,\alpha)|$).

Lemma 7**.**

We have $|N^{\odot}(P,\alpha)|\leq|P|+|\delta^{\odot}(P,\alpha)|-1$ and $|N^{\ast}(P,\alpha)|\leq|P|+|\delta^{\ast}(P,\alpha)|-1$.

Proof.

By definition every node in $N^{\odot}(P,\alpha)$ is the lowest common ancestor of some position $p\in P$ and some position $q\in\delta^{\odot}(P,\alpha)$. The number of distinct pairwise lowest common ancestors of a subset of $\ell$ leaves in a tree cannot exceed $\ell-1$. Therefore, the number of lowest common ancestors between positions in $P$ and positions in $\delta^{\odot}(P,\alpha)$ can never be larger than $|P|+|\delta^{\odot}(P,\alpha)|-1$. The same argument holds for the number of nodes in $|N^{\ast}(P,\alpha)|$. ∎

The internal transitions on the set of transition nodes are not disjoint and hence we cannot afford to compute internal transitions on each of the transition nodes explicitly. Fortunately, by Lemma 4, the internal $\odot$-transitions (resp. $\ast$-transitions) of the nodes from $N^{\odot}(P,\alpha)$ (resp. $N^{\ast}(P,\alpha)$) form a laminar family. We use this to divide the computations of the internal transitions into computations on a bounded number of non-overlapping intervals. We implement this idea by compactly encoding all relevant transition nodes in the transition tree defined in the following.

4.3 Transition Trees

Let $P$ be a set of positions. Given a state-set transition $\delta(P,\alpha)$, we define the transition tree $T$ as the subtree of $R$ induced by all nodes in $P$ and their ancestors (see Figure 4(a)). A segment in $T$ is a path from a leaf or a branching node to (but not including) the nearest branching node above it (or to the root if no such branching node exists). The root node is its own segment (see Figure 4(b)). The bottom node of a segment $s$ is denoted $\mathsf{bot}(s)$. Note that $\mathsf{bot}(s)$ is always a branching node, a leaf, or the root. Any branching node in $T$ is the lowest common ancestor of two nodes in $P$ and vice versa. Hence, we can compactly store $T$ in $O(|P|)$ space by storing $P$ and the branching nodes with pointers into $R$.

The following observation follows immediately from the fact that all nodes in $\mathsf{lastextent}(P)$ and their ancestors are contained in $T$.

Observation 8**.**

Let $T$ be the transition tree for $P$ in $R$. If $v$ is a transition node for $\delta(P,\alpha)$ then $v$ is a node on a segment in $T$.

Thus it is enough to consider the nodes in the transition tree when computing the set of transition nodes.

Observation 9**.**

Any $\odot$-node $u$ that is an internal node on a segment and where $\mathsf{left}(u)\in\mathsf{lastextent}(P)$ must have its left child on the same segment.

To see why, observe that since $\mathsf{left}(u)\in\mathsf{lastextent}(P)$, then $\mathsf{left}(u)$ is an ancestor of a node in $P$, and thus by definition of $T$, $\mathsf{left}(u)$ belongs to $T$. Since $u$ is an internal node on a segment $s$, only one of its children belongs to $T$. Therefore, $\mathsf{left}(u)$ must also belong to segment $s$.

We will show in Section 5.2 that the transition tree $T$ and the key information we need in our algorithm can be computed in $O(|P|)$ time.

5 Sparse State-Set Transitions

We now present our $O(m)$ space data structure that supports computing a state-set transition $\delta(P,\alpha)$ in $O(|P|\log\log m+|\delta(|P|,\alpha)|)$ time. We describe the data structure and analyze the space and preprocessing time in Section 5.1. The high-level idea of our sparse state-set algorithm is to identify the transition nodes for $\delta^{\odot}(P,\alpha)$ and $\delta^{\ast}(P,\alpha)$ using the transition tree. The state-set transitions for each set of nodes induce a partition of $\mathsf{Pos}_{\alpha}$ into nested intervals. We partition these intervals into non-overlapping intervals and then compute the internal transitions for each new interval. We then compute the union of these, which by the decomposition in Lemma 6, is precisely the set $\delta(P,\alpha)$. We describe how to construct the transition tree in Section 5.2. In Section 5.3 we describe how to find the set transition nodes and how to construct the intervals. In Section 5.4 we we show how to compute the internal transitions efficiently. Finally, in Section 5.5 we put everything together to get an algorithm for computing a state-set transition $\delta(P,\alpha)$ in $O(|P|\log\log m+|\delta(P,\alpha)|)$ time.

5.1 Data Structure

We store the regular expression with labels on leaves and internal nodes together with the following components.

• •

For each node $v$ in $R$, we store the range of positions that are descendants of $v$, the depth of $v$, the highest node in $\mathsf{lastextent}(v)$, and the highest node in $\mathsf{firstextent}(v)$. We also store a pointer $\mathsf{parent}^{\odot}(v)$ to the lowest ancestor $u$ of $v$ such that $u$ is an $\odot$-node and $v\in T(\mathsf{left}(u))$, and a pointer $\mathsf{parent}^{\ast}(v)$ to its lowest star ancestor.

• •

At each branching node $v$ we store the position of the rightmost leaf in $\mathsf{left}(v)$ and the position of the leftmost leaf in $\mathsf{right}(v)$.

• •

Data structures for $R$ that supports lowest common ancestor queries and first label queries. Given a node $v$ and a character $\alpha$, a first label query, denoted $\mathsf{firstlabel}(v,\alpha)$, returns the lowest ancestor of $v$ whose label contains $\alpha$.

Furthermore, we store the following information for each $\alpha\in\Sigma$.

• •

Arrays $A_{\alpha}$ and $D_{\alpha}$, where $A_{\alpha}[i]$ is the $i$th position labeled $\alpha$ in the left-to-right ordering of $\mathsf{Pos}_{\alpha}$, and $D_{\alpha}[i]$ is the depth of the highest node in $\mathsf{firstextent}(A_{\alpha}[i])$.

• •

A data structure supporting predecessor and successor queries on the positions in $\mathsf{Pos}_{\alpha}$. That is, given any position $p$ in $R$ the predecessor (successor) query returns the position in $A_{\alpha}$ of the nearest position labeled $\alpha$ to the left (right) of $p$ including $p$ itself. For a branching node $v\in R$, we define the successor of $v$ in $\mathsf{Pos}_{\alpha}$ as the successor in $\mathsf{Pos}_{\alpha}$ of the leftmost leaf in $\mathsf{right}(v)$. Note that this corresponds to the first position labeled $\alpha$ after $v$ in the order obtained by an inorder traversal of the nodes in $R$. Similarly, we define the predecessor of $v$ in $\mathsf{Pos}_{\alpha}$ as the predecessor in $\mathsf{Pos}_{\alpha}$ of the rightmost leaf in $\mathsf{left}(v)$.

• •

A data structure on $D_{\alpha}$ that supports range minimum queries. Given any pair of indices $l$ and $r$, the range minimum query on $D_{\alpha}$ returns a minimum value in the subarray $D_{\alpha}[l,r]$.

• •

For each node $v$ containing label $\alpha$:

• –

A pointer $\mathsf{next}^{\odot}(v,\alpha)$ to the lowest proper ancestor $u$ of $v$ such that $v\in T(\mathsf{left}(u))$, $\alpha\in\mathsf{label}(u)$, and $\delta^{\odot}(u,\alpha)$ is non-empty. If no such $u$ exists we store a null pointer to indicate this.

• –

A pointer $\mathsf{next}^{\ast}(v,\alpha)$ to the lowest proper ancestor $u$ of $v$ labeled $\alpha$ such that there exists a $q\in\delta^{\ast}(u,\alpha)$ where $q\in T(\mathsf{right}(u))$ if $v\in T(\mathsf{left}(u))$ and $q\in T(\mathsf{left}(u))$ if $v\in T(\mathsf{right}(u))$. If no such $u$ exists we store a null pointer to indicate this.

• –

The range of positions in $A_{\alpha}$ that are descendants of $v$, of $\mathsf{left}(v)$, and of $\mathsf{right}(v)$, respectively.

The idea of the $\mathsf{next}^{\odot}$-pointers is that they form a chain of prospective nodes for $N^{\odot}$ with label $\alpha$. Any node $u$ from $N^{\odot}(P,\alpha)$ with label $\alpha$ on a segment $s$ has its left child on the path and $\delta^{\odot}(u,\alpha)\neq\emptyset$, so it is included in this chain. We show that at most one node can be from $N^{\odot}(P,\alpha)$ on each segment that does not have label $\alpha$. Furthermore, given a segment $s$, the nodes from the chain on $s$ that belong to $N^{\odot}(P,\alpha)$ form a subchain starting from the lowest node of the chain that is on $s$ to (not including) the first node in the chain that is either not in $\mathsf{lastextent}(P)$ or not on $s$. Similarly, the $\mathsf{next}^{\ast}$-pointers form a chain of prospective nodes for $N^{\ast}$ with label $\alpha$.

Space

The regular expression and the labels use $O(m)$ space. The arrays $A_{\alpha}$ and $D_{\alpha}$, $\alpha\in\Sigma$, use $O(m)$ space in total. We use linear space and linear preprocessing time data structures to support lowest common ancestors in constant time [38, 9], first label queries in $O(\log\log m)$ time [25], predecessor queries in $O(\log\log m)$ time [75, 58], and range minimum queries in constant time [38, 9]. For each alphabet character, the total size of these data structures is linear in the number of leaves labeled with that character. Thus in total the space for these data structures is linear in $m$. The cited data structures for predecessor queries both use randomization, but since we only need a static structure it is straightforward and well-known how to obtain the same bound deterministically by combining deterministic dictionaries [37] with a simple two-level approach (see, e.g., Thorup [71]). We store at most two $\mathsf{next}$ pointers for each label in $R$ and a single pointer for each position using $O(m)$ space. The remaining information uses $O(m)$ space.

Preprocessing

We compute the range of positions that are descendants of $v$, the depth of $v$, the $\mathsf{parent}^{\odot}(v)$ and $\mathsf{parent}^{\ast}(v)$ pointers, and the positions of $\mathsf{left}(v)$ and $\mathsf{right}(v)$ using tree traversal in linear time. To compute the highest node for each node in $R$, we first compute for each node $u\in R$ if $\epsilon\in R(u)$ using a linear time bottom-up tree traversal. In top-down traversal we then compute the highest node $H_{L}(v)$ in $\mathsf{lastextent}(v)$ for each node $v\in R$ using the following rules: If $v$ is the left child of an $\odot$-node and $\epsilon\not\in R(\mathsf{right}(v))$ then $H_{L}(v)=v$. Otherwise, $H_{L}(v)=H_{L}(\mathsf{parent}(v))$. We compute the highest node in $\mathsf{firstextent}(v)$ similarly. We construct the arrays $A_{\alpha}$ and $D_{\alpha}$, for all $\alpha\in\Sigma$ in a single tree traversal.

To compute the remaining information we do the following for each $\alpha\in\Sigma$. Construct a tree $R_{\alpha}$ containing all nodes with label $\alpha$. To do this, we use $\mathsf{lca}$ queries on each consecutive pair of leaves in $A_{\alpha}$ from left to right. By keeping track of the depths of the nodes and checking if the newest node is an ancestor of the previous node it is straightforward to implement this in linear time. To compute the $\mathsf{next}$-pointers we do a top-down traversal of $R_{\alpha}$. In each node $u$ we check if $\delta^{\odot}(u,\alpha)$ and $\delta^{\ast}(u,\alpha)$ are empty using range minimum queries on $D_{\alpha}$. To check if $\delta^{\odot}(u,\alpha)$ we do the range minimum query on the range of positions in $\mathsf{Pos}_{\alpha}$ in $\mathsf{right}(v)$. If the depth returned is less than or equal to $0pt(\mathsf{right}(v))$ then $\delta^{\odot}(u,\alpha)$ is non-empty. For $\delta^{\ast}(u,\alpha)$ we do the query separately on the intervals corresponding to the left and the right child and we compare with the depth of $\mathsf{parent}^{\ast}(v)$. With this information, we can compute the $\mathsf{next}$-pointers during the traversal of $R_{\alpha}$ in constant time per node. The total size of all the $R_{\alpha}$ trees $O(m)$, since each tree has size $2|\mathsf{Pos}_{\alpha}|-1$. Thus the total time used for each $\alpha$ is $O(|\mathsf{Pos}_{\alpha}|)$. Hence, it follows that the total preprocessing time is $O(m)$.

5.2 Constructing the Transition Tree

We say that a node $v$ is a $\odot$-live node if $\mathsf{left}(v)\in\mathsf{lastextent}(P)$ and $v$ is a $\odot$-node. Note that any node in $N^{\odot}(P,\alpha)$ is a $\odot$-live node and a node in the transition tree $T$. It follows from Observation 9 that any $\odot$-live node that is an internal node on a segment has its left child on the segment. A segment $s$ in $T$ is called a $\ast$-segment if $\mathsf{bot}(s)$ is not the root and $\mathsf{parent}^{\ast}(\mathsf{bot}(s))\in\mathsf{lastextent}(P)$.

We compute the compact representation of the transition tree as follows. Let $P$ be the set of leaves and repeatedly take the $\mathsf{lca}$ of adjacent nodes to form the internal nodes and the segments of $T$. Using a tree traversal on the compact transition tree we also compute for all branching nodes $v$ in $T$ the depth of the highest node in $\mathsf{lastextent}(P\cap\mathsf{Pos}(v))$, all $\odot$-live branching nodes in $T$, and all $\ast$-segments of $T$. Hence, we have the following result.

Lemma 10**.**

*In $O(|P|)$ time we can compute the transition tree $T$ of $P$, for all branching nodes $v$ in $T$ the depth of the highest node in $\mathsf{lastextent}(P\cap\mathsf{Pos}(v))$, all $\odot$-live branching nodes in $T$, and all $\ast$-segments of $T$. *

Observation 11**.**

We can check in constant time if a node $v\in T$ is in $\mathsf{lastextent}(P)$ given the segment it is on.

If $v$ is a leaf or a branching node, we already computed the information. Otherwise, $v$ is an internal node on a segment $s$. Then we compare the depth of $v$ with the depth $d$ of the highest node in $\mathsf{lastextent}(P\cap\mathsf{Pos}(\mathsf{bot}(s)))$. Now $v$ is in $\mathsf{lastextent}(P)$ if and only if the depth of $v$ is at least $d$.

5.3 Computing Transitions Nodes and Intervals

We construct two sets of nodes $M^{\odot}$ and $M^{\ast}$ that consists of all nodes in $N^{\odot}(P,\alpha)$ and $N^{\ast}(P,\alpha)$, respectively, together with a constant number of other nodes per segment. We compute these sets for each segment using a depth-first traversal of the transition tree. We also construct sets $L^{\odot}$ and $L^{\ast}$, that partition $\mathsf{Pos}_{\alpha}$ into intervals in order to avoid recomputing overlapping internal transitions. We associate each interval with the lowest node from $M^{\odot}$ (respectively $M^{\ast}$) that can contain the positions in its internal transition (see Figure 5).

5.3.1 Computing Transitions Nodes

We first explain how to compute the transition nodes using the $\mathsf{next}$-pointers and the transition tree.

Computing $M^{\odot}$

We find for each segment $s$ all $\odot$-transition nodes for $\delta(P,\alpha)$ as follows.

*Find first relevant $\odot$-node on $s$: * Set $x=\mathsf{parent}^{\odot}(\mathsf{bot}(s))$. If $x$ is not on $s$ or $x$ is not an $\odot$-live node stop. 2. 2.

*Find first $\odot$-transition node on $s$: * Compute the successor $q$ of $x$ in $\mathsf{Pos}_{\alpha}$, i.e., $q$ is the successor in $\mathsf{Pos}_{\alpha}$ of the leftmost leaf in $R(\mathsf{right}(x))$. If no such $q$ exists stop, otherwise set $v=\mathsf{lca}(x,q)$. If $v$ is not on $s$ stop. If $v$ is a $\odot$-live node not labeled $\alpha$ we add $v$ to $M^{\odot}$. Now compute $x=\mathsf{firstlabel}(v,\alpha)$. If $x$ is not a $\odot$-live node set $x=\mathsf{next}^{\odot}(x,\alpha)$. 3. 3.

*Repeatedly find next transition node by following $\mathsf{next}^{\odot}$-pointers: * We find all $\odot$-transition nodes by repeatedly following $\mathsf{next}^{\odot}$-pointers from $x$ and adding the visited nodes to $M^{\odot}$ as follows. As long as $\mathsf{left}(x)\in\mathsf{lastextent}(P)$ and $x$ is on $s$ we add $x$ to $M^{\odot}$ and set $x=\mathsf{next}^{\odot}(x,\alpha)$.

Computing $M^{\ast}$

We find for each segment $s=(v,w)$ all $\ast$-transition nodes for $\delta(P,\alpha)$.

If $s$ is not a $\ast$-segment we stop. 2. 2.

Find first $\ast$-transition node on $s$: Compute the predecessor $q^{-}$ and successor $q^{+}$ of $\mathsf{bot}(s)$ in $\mathsf{Pos}_{\alpha}$ and let $v$ be the lowest of $\mathsf{lca}(\mathsf{bot}(s),q^{-})$ and $\mathsf{lca}(\mathsf{bot}(s),q^{+})$. If $v$ is not on $s$ stop. If $\alpha\not\in\mathsf{label}(v)$ and $\mathsf{parent}^{\ast}(v)\in\mathsf{lastextent}(P)$ we add $v$ to $M^{\ast}$. 3. 3.

*Repeatedly find next transition node by following $\mathsf{next}^{\ast}$-pointers: * We first compute $x=\mathsf{firstlabel}(v,\alpha)$. We find all $\ast$-transition nodes by repeatedly following $\mathsf{next}^{\ast}$-pointers from $x$ and adding the visited nodes to $M^{\ast}$ as follows. As long as $\mathsf{parent}^{\ast}(x)\in\mathsf{lastextent}(P)$ and $x$ is on $s$ we add $x$ to $M^{\ast}$ and set $x=\mathsf{next}^{\ast}(v,\alpha)$.

Complexity

We first analyze the time used to find $M^{\odot}$. We use $O(|M^{\odot}|)$ time to follow pointers. Additionally, we use $O(|T|\log\log m)=O(|P|\log\log m)$ time to compute the first label queries, as we do one first label query on each of the $|T|$ segments. The time to check if a node is $\odot$-live is constant. For all the bottom nodes of the segments the information is stored in the tree and for all the other nodes $v$ we can check in constant time if $\mathsf{left}(v)\in\mathsf{lastextent}(P)$ as described in the end of Section 5.2 as $\mathsf{left}(v)$ will always be on the current segment. Thus the total time used is $O(|M^{\odot}|+|P|\log\log m)$. Similarly, we use time $O(|M^{\ast}|+|P|\log\log m)$ to compute $M^{\ast}$. Next we analyze the size of $M^{\odot}$ and $M^{\ast}$.

Lemma 12**.**

$|M^{\odot}|=O(|\delta^{\odot}(P,\alpha)|+|P|)$.

Proof.

We will prove that at most one node from $M^{\odot}$ from each segment is not in $N^{\odot}(P,\alpha)$. Recall that $N^{\odot}(P,\alpha)$ consists of all the $\odot$-nodes $v$ that have $\mathsf{left}(v)\in\mathsf{lastextent}(P)$ and $\mathsf{right}(v)\in\mathsf{firstextent}(\mathsf{Pos}_{\alpha})$.

Any node $u\in s$ added to $M^{\odot}$ in step 3 except the first one has $\delta(u,\alpha)\neq\emptyset$, since they were found using $\mathsf{next}^{\odot}$-pointers. Thus, $\mathsf{right}(u)\in\mathsf{firstextent}(\mathsf{Pos}_{\alpha})$. A node is only added if it is $\odot$-live, i.e., $\mathsf{left}(u)\in\mathsf{lastextent}(P)$. Thus $u\in N^{\odot}(P,\alpha)$. Therefore, only the first node found on each segment—the node from step 2—might not be in $N^{\odot}(P,\alpha)$. Since there are $O(|P|)$ segments in $T$ we have $|M^{\odot}|=O(|N^{\odot}(P,\alpha)|+|P|)$. By Lemma 7 we have $|N^{\odot}(P,\alpha)|\leq|\delta^{\odot}(P,\alpha)|+|P|$ and thus $|M^{\odot}|=O(|\delta^{\odot}(P,\alpha)|+|P|)$. ∎

The argument for the size of $M^{\ast}$ is similar, but here we show that the number of nodes in $M^{\ast}$ that are not in $N^{\ast}(P,\alpha)$ is at most $2|P|$.

Lemma 13**.**

$|M^{\ast}|=O(|\delta^{\ast}(P,\alpha)|+|P|)$.

Proof.

We will prove that at most two nodes from $M^{\ast}$ from each segment is not in $N^{\ast}(P,\alpha)$. Recall that $N^{\ast}(P,\alpha)$ consists of all the nodes $v$ such that there exists a $q\in\mathsf{Pos}_{\alpha}$ and a $p\in P$ such that $v=\mathsf{lca}(p,q)$ and $\mathsf{parent}^{\ast}(v)\in\mathsf{lastextent}(p)\cap\mathsf{firstextent}(q)$.

Any node $u$ added to $M^{\ast}$ by following $\mathsf{next}^{\ast}$-pointers has $\delta^{\ast}(u,\alpha)\neq\emptyset$ and $\mathsf{parent}^{\ast}(u)\in\mathsf{lastextent}(P)$. Furthermore, if $\mathsf{left}(u)$ is on the segment $s$, then there exists a position $q\in\mathsf{right}(u)\cap\delta^{\ast}(u,\alpha)$ and a position $p\in P\cap\mathsf{left}(u)$. This implies that $u$ is in $N^{\ast}(P,\alpha)$. The argument for the case where $\mathsf{right}(u)$ is on the segment $s$ is symmetric.

At most two other nodes are added to $M^{\ast}$ for each segment (the first two nodes are added to $M^{\ast}$ on each segment). It follows that the total number of nodes in $M^{\ast}$ is at most $|\delta^{\ast}(P,\alpha)|+2|P|$. By Lemma 7 we have $|N^{\ast}(P,\alpha)|\leq|\delta^{\ast}(P,\alpha)|+|P|$ and thus $|M^{\ast}|=O(|\delta^{\ast}(P,\alpha)|+|P|)$. ∎

Combining Lemmas 12 and 13 and the above discussion, the total time to compute $M^{\odot}$ and $M^{\ast}$ is $O(|\delta^{\odot}(P,\alpha)|+|P|\log\log m)$ and $O(|\delta^{\ast}(P,\alpha)|+|P|\log\log m)$, respectively.

Correctness

We argue that the sets $M^{\odot}$ and $M^{\ast}$ include all transition nodes for $\delta(P,\alpha)$. We need the following lemma, which follows from the path structure of the last extent sets.

Lemma 14**.**

Let $u$ be an $\odot$-live node and let $s$ be the segment in $T$ containing $u$. All $\odot$-nodes below $u$ on $s$ with $\mathsf{left}(u)$ on $s$ are also $\odot$-live.

Proof.

If $\mathsf{left}(u)$ is not on $s$ then $u$ is a branching node in $T$ by construction of $T$. Thus $u=\mathsf{bot}(s)$ and it is trivially true since $u$ has no descendants on $s$. We will prove the case $\mathsf{left}(u)$ on $s$ by contradiction. Since $u$ is $\odot$-live there exists a node $p\in\mathsf{left}(u)\cap P$ such that $u\in\mathsf{lastextent}(p)$. Furthermore, $\mathsf{bot}(s)$ is an ancestor of some node $p^{\prime}$ in $P$. Let $w=\mathsf{lca}(\mathsf{bot}(s),p)$. If $p^{\prime}=p$ then $w=\mathsf{bot}(s)$. If $p^{\prime}\neq p$ then $w$ is a branching node in $T$. Since there are no branching nodes internally on a segment it follows that $w=\mathsf{bot}(s)$. By Lemma 4 all nodes on $s$ are in $\mathsf{lastextent}(p)$. ∎

We are now ready to prove that $N^{\odot}(P,\alpha)$ is contained in $M^{\odot}$. Let $u$ be a node in $N^{\odot}(P,\alpha)$. There are two main cases in the proof depending on whether $u$ labeled $\alpha$ or not. If not, then we show that $u=\mathsf{lca}(x,q)$ in step 2. If $u$ is labeled $\alpha$, then we show, that either $u$ is the first $\odot$-node on the segment, in which case it is added as the first node in step 3, or it is a node on the path induced by the $\mathsf{next}^{\odot}$-pointers. As we proved in Lemma 14 above, all the nodes on this path below $u$ are also $\odot$-live and we show by induction that all the $\odot$-live nodes from $s$ on this path are added to $M^{\odot}$ in step 3.

Lemma 15**.**

$N^{\odot}(P,\alpha)\subseteq M^{\odot}$.

Proof.

Let $u\in N^{\odot}(P,\alpha)$. By definition $u$ is $\odot$-live, $\mathsf{right}(v)\in\mathsf{firstextent}(\mathsf{Pos}_{\alpha})$, and $\delta(u,\alpha)\neq\emptyset$. Let $s$ be the segment in $T$ containing $u$. We want to show that $u$ is added to $M^{\odot}$. Define $x=\mathsf{parent}^{\odot}(\mathsf{bot}(s))$ and $q$ as the successor of $x$ in $\mathsf{Pos}_{\alpha}$ as in step 1 and 2 of the algorithm. There are two cases depending on whether $u$ has label $\alpha$ or not.

Case 1: $\alpha\not\in\mathsf{label}(u)$.   We first show that $u=\mathsf{lca}(x,q)$. Since $u$ is an $\odot$-node we have that $u$ is an ancestor of $x$. If $u$ is a proper ancestor of $x$ then $x\in R(\mathsf{left}(u))$. Since $\mathsf{right}(u)\in\mathsf{firstextent}(\mathsf{Pos}_{\alpha})$ there is a position $q^{\prime}\in\mathsf{Pos}_{\alpha}$ such that $q^{\prime}\in\mathsf{Pos}(\mathsf{right}(u))$. This implies that $q\leq q^{\prime}$. If $q\in\mathsf{Pos}(\mathsf{right}(u))$ then $u=\mathsf{lca}(x,q)$ and we are done (see Figure 6(a)). Assume $q\not\in\mathsf{Pos}(\mathsf{right}(u))$ and let $w=\mathsf{lca}(x,q)\neq u$. Since $q<q^{\prime}$ we have $u\prec w$. But then $q\in\mathsf{Pos}(w)\subset\mathsf{Pos}(\mathsf{left}(u))$. Thus $u=\mathsf{lca}(q,q^{\prime})$ and $u$ has label $\alpha$ which is a contradiction (see Figure 6(b)). It follows that $u=\mathsf{lca}(x,q)$. Thus, since $u$ is $\odot$-live and not labeled $\alpha$, $u$ is added to $M^{\odot}$ in step 2.

Case 2: $\alpha\in\mathsf{label}(u)$.   There are two subcases. In the first case $u=\mathsf{parent}^{\odot}(\mathsf{bot}(s))$. Then $u=x$ in step 1. Since $\mathsf{right}(u)\in\mathsf{firstextent}(\mathsf{Pos}_{\alpha})$ we have $u=v=\mathsf{lca}(x,q)$ in step 2. Since $u$ is labeled $\alpha$ we have $u=\mathsf{firstlabel}(v,\alpha)=\mathsf{firstlabel}(u,\alpha)$. Since $\mathsf{left}(u)\in\mathsf{lastextent}(P)$ we add $u$ to $M^{\odot}$ in the first iteration in step 3.

In the other case $u\neq\mathsf{parent}^{\odot}(\mathsf{bot}(s))$. Let

[TABLE]

Clearly, $u\in S_{\alpha}$, and thus $u\in M^{\odot}$ follows from the following claim.

Claim 16**.**

Let $w$ be a node in $S_{\alpha}$. Then $w$ is added to $M^{\odot}$ in step 3.

Proof: We prove the claim using induction on the height of $w$. For the base case let $w$ be the lowest node in $S_{\alpha}$. Since $w$ is $\odot$-live it follows from Lemma 14 that $\mathsf{parent}^{\odot}(\mathsf{bot}(s))$ is also $\odot$-live and thus we continue from step 1 to step 2. Since $\mathsf{right}(w)\in\mathsf{firstextent}(\mathsf{Pos}_{\alpha})$ we have $w\preceq v$, where $v=\mathsf{lca}(x,q)$ as computed in step 2. Now either $w=\mathsf{firstlabel}(v,\alpha)$ and then $w$ is added to $M^{\odot}$ in the first iteration in step 3. Otherwise, $w\prec\mathsf{firstlabel}(v,\alpha)$. Since $w$ is the lowest node in $S_{\alpha}$ then $x=\mathsf{firstlabel}(v,\alpha)$ has its $\mathsf{next}^{\odot}$-pointer pointing to $w$. Now either $x$ is an $\odot$-live node, in which case $x$ is set to $w$ in the end of the first iteration of step 3. Otherwise, $x$ is set to $w$ in the end of step 2. In either case, $w$ is added to $M^{\odot}$ in step 3.

Induction step: Let $w\in S_{\alpha}$ be a node that is not the lowest node in $S_{\alpha}$. Let $w^{\prime}\in S_{\alpha}$ be the highest node in $S_{\alpha}$ that is a proper descendant of $w$. Then $w^{\prime}$ points to $w$. Let $v=\mathsf{next}^{\odot}(w^{\prime},\alpha)$. By definition of the $\mathsf{next}^{\odot}$-pointers $v\in S_{\alpha}$ and $v\prec w^{\prime}$. Now, since $w^{\prime}\in R(\mathsf{left}(w))$, $\alpha\in\mathsf{label}(w)$ and $\delta^{\odot}(w,\alpha)\neq\emptyset$, we have $v=\mathsf{next}^{\odot}(w^{\prime},\alpha)\succeq w$. If $v\neq w$ then $w^{\prime}\succ v\succ w$ contradicting that $w^{\prime}$ is the highest descendant of $w$ in $S_{\alpha}$. Thus $v=w$. By the induction hypothesis, $w^{\prime}$ was added to $M^{\odot}$ in step 3, whereafter we follow the $\mathsf{next}^{\odot}$-pointer to $w$ and add $w$ in the next iteration. $\blacksquare$ ∎

We will now prove that $N^{\ast}(P,\alpha)\subseteq M^{\ast}$. Here is an outline of the proof. Recall that for any node $u$ in $N^{\ast}(P,\alpha)$, there exists a position $q$ in $\mathsf{Pos}_{\alpha}$ and a position $p$ in $P$, such that $u$ is the $\mathsf{lca}$ of $q$ and $p$ and $\mathsf{parent}^{\ast}(u)$ is in both $\mathsf{firstextent}(q)$ and $\mathsf{lastextent}(p)$. We first prove that the segment $s$ containing $u$ is a $\ast$-segment. Then it follows easily that if $u=\mathsf{bot}(s)$ then $u$ is added to $M^{\ast}$ in step 2 or 3. If $u$ is not the bottom node on $s$, then due to the properties of the transition tree the child of $u$ not on $s$ contains $q$ in its subtree. We then show that if $u$ is not labeled $\alpha$ then it is added to $M^{\ast}$ in step 2. Otherwise, it is either added as the first node in step 3, or it is a node on the path induced by the $\mathsf{next}^{\ast}$-pointers on $s$. By similar arguments as those in the previous proof all nodes below $u$ on this path has their $\mathsf{parent}^{\ast}$-node in $\mathsf{lastextent}(p)$, the first node on the path is $x$ found by a firstlabel query in step 3, and thus $u$ is added to $M^{\ast}$ in step 3. See Figure 6.

Lemma 17**.**

$N^{\ast}(P,\alpha)\subseteq M^{\ast}$.

Proof.

Let $u$ be a node in $N^{\ast}(P,\alpha)$. Then there exists a position $p\in P$ and a position $q\in\mathsf{Pos}_{\alpha}$ such that $u=\mathsf{lca}(p,q)$ and $\mathsf{parent}^{\ast}(u)\in\mathsf{lastextent}(p)\cap\mathsf{firstextent}(q)$. Let $s$ be the segment $u$ is on. We first prove that $s$ is a $\ast$-segment: If $u=\mathsf{bot}(s)$ then $\mathsf{parent}^{\ast}(\mathsf{bot}(s))=\mathsf{parent}^{\ast}(u)\in\mathsf{lastextent}(P)$ and thus $s$ is a $\ast$-segment. Otherwise, $u\prec\mathsf{bot}(s)$. By construction of $T$ we have $p\in\mathsf{Pos}(\mathsf{bot}(s))$ and thus by Lemma 4 $\mathsf{bot}(s)\in\mathsf{lastextent}(p)$, since $\mathsf{parent}^{\ast}(u)$ is an ancestor of $\mathsf{bot}(s)$.

We now prove that $u\in M^{\ast}$. Let $v$ be the lowest of $\mathsf{lca}(\mathsf{bot}(s),q-)$ and $\mathsf{lca}(\mathsf{bot}(s),q+)$ as computed in step 2. If $u=\mathsf{bot}(s)$ then $q\in\mathsf{Pos}(\mathsf{bot}(s))$ and thus $v=\mathsf{bot}(s)=u$. If $\alpha\not\in\mathsf{label}(u)$ then $u$ is added to $M^{\ast}$ in step 2. Otherwise, it is added in step 3.

If $u\neq\mathsf{bot}(s)$, let $u_{s}$ be the child of $u$ that is on $s$ and let $u_{o}$ be the child not on $s$. By construction of $T$ we have $p\in\mathsf{Pos}(u_{s})$ and $p\in\mathsf{Pos}(\mathsf{bot}(s))$, since all bottom nodes of segments in $T$ have a position from $P$ in their subtree and any node that is the $\mathsf{lca}$ of two nodes in $P$ is a branching node in $T$. Thus $q\in\mathsf{Pos}(u_{o})$. There are two cases depending on whether $u$ is labeled $\alpha$ or not.

Case 1: $\alpha\not\in\mathsf{label}(u)$.    Since $q\in\mathsf{Pos}(u_{o})$ we have $\mathsf{Pos}(u_{s})\cap\mathsf{Pos}_{\alpha}=\emptyset$. Thus, either $q+$ or $q-$ is in $\mathsf{Pos}(u_{o})$ and then $v=u$. Therefore, $u$ is added to $M^{\ast}$ in step 2.

Case 2: $\alpha\in\mathsf{label}(u)$.    Then $u$ is the $\mathsf{lca}$ of two positions in $\mathsf{Pos}_{\alpha}$, which implies that there exists a position labeled $\alpha$ in $\mathsf{Pos}(u_{s})$. It follows that either $q-$ or $q+$ is in $\mathsf{Pos}(u_{s})$ and thus $u\preceq v$. If $u=v$ then $u$ is added to $M^{\ast}$ in the first iteration in step 3. Otherwise, $u\prec v$. Let $x=\mathsf{firstlabel}(v,\alpha)$. If $u=x$ then $u$ is added to $M^{\ast}$ in the first iteration in step 3.

If $u\neq x$ then $u\prec x$. Since $q\in\mathsf{Pos}(u_{o})$ and $\mathsf{parent}^{\ast}(u)\in\mathsf{firstextent}(q)$ we have $q\in\delta^{\ast}(u,\alpha)$. Therefore, the highest proper descendant of $u$ labeled $\alpha$ has its $\mathsf{next}^{\ast}$-pointer pointing to $u$. It follows that there is a chain of $\mathsf{next}^{\ast}$-pointers from $x$ to $u$. It remains to show that for all the nodes in this chain $x=x_{0},\ldots,x_{k}=u$ we have $\mathsf{parent}^{\ast}(x_{i})\in\mathsf{lastextent}(P)$. If this is true we will reach $u$ in step 3. Since $p\in\mathsf{Pos}(\mathsf{bot}(s))$ then all nodes on $s$ are ancestors of $p$. Since $u\preceq x_{i}$ we have $\mathsf{parent}^{\ast}(u)\preceq\mathsf{parent}^{\ast}(x_{i})$. By Lemma 4 we have $\mathsf{parent}^{\ast}(x_{i})\in\mathsf{lastextent}(p)$. ∎

5.3.2 Computing the Intervals

We now compute the lists $L^{\odot}$ and $L^{\ast}$ of intervals for the nodes in $M^{\odot}$ and $M^{\ast}$, respectively. We do this by processing the nodes $M^{\odot}$ and $M^{\ast}$ in inorder using a depth-first left-to-right inorder traversal of $T$.

First, we compute for each node $v$ in $M^{\odot}$ the range $[l_{v},r_{v}]$ of positions labeled $\alpha$ that are descendants of $\mathsf{right}(v)$. If $v$ is labeled $\alpha$ the range $[l_{v},r_{v}]$ is stored at $v$ and otherwise we use the predecessor data structure to compute it using the range stored at $\mathsf{right}(v)$. Similarly, we compute for each node in $M^{\ast}$ the range $[l_{v},r_{v}]$ of positions labeled $\alpha$ that are descendants of $v$.

Computing $L^{\odot}$

We compute the list of intervals $L^{\odot}$ by a depth-first left-to-right inorder traversal of $T$. We maintain a stack $S$ keeping track of the deepest node not finished and a counter $\ell$ equal to the left starting point of the currently open interval. If there is no open interval $\ell=-1$. Initially, $S=\emptyset$ and $\ell=-1$.

For each node $v\in M^{\odot}$ in inorder do the following:

• •

When we meet $v$ in the traversal after traversing the left subtree of $v$: If $\ell\neq-1$ append $(\ell,l_{v}-1,\mathsf{top}(S))$ to $L^{\odot}$. Set $\ell=l_{v}$ and push $v$ onto the stack $S$.

• •

When we finish the traversal of the subtree containing $v$: Note that in this case $\mathsf{top}(S)=v$. If $\ell\leq r_{v}$ append $(\ell,r_{v},v)$ to $L^{\odot}$. Pop $v$ from $S$. If the stack is now empty set $\ell=-1$, otherwise set $\ell=r_{v}+1$.

Note that $\mathsf{right}(v)$ might not be in $T$, in which case the two steps for $v$ follow immediately after each other.

Computing $L^{\ast}$

We maintain a stack $S$ and counter $\ell$ as before.

For each node $v\in M^{\ast}$ in inorder do the following:

• •

First time we meet $v$ in the traversal: If $\ell\neq-1$ append $(\ell,l_{v}-1,\mathsf{top}(S))$ to $L^{\ast}$. Set $\ell=l_{v}$ and push $v$ onto the stack $S$.

• •

Last time we meet $v$ in the traversal: Note that in this case $\mathsf{top}(S)=v$. If $\ell\leq r_{v}$ append $(\ell,r_{v},v)$ to $L^{\ast}$. Pop $v$ from $S$. If the stack is now empty set $\ell=-1$, otherwise set $\ell=r_{v}+1$.

Complexity

To compute the ranges use time $O(|M^{\odot}|+|P|\log\log m)$ as at most one node in $M^{\odot}$ on each segment is not labeled $\alpha$. We will store the nodes in $M^{\odot}$ in increasing order of depth for each segment. This is easy to maintain as we find them in order of decreasing depth. This way we can do the depth-first left-to-right traversal on the nodes of $M^{\odot}$ in $T$ in linear time in the size of $M^{\odot}$. Thus computing $L^{\odot}$ takes time $O(|M^{\odot}|)$.

Similarly, we use time $O(|M^{\ast}|)$ to compute $L^{\ast}$. In summary, we have the following lemma.

Lemma 18**.**

The sets $M^{\odot}$ and $M^{\ast}$, and the lists $L^{\odot}$ and $L^{\ast}$, can be computed in time $O(|\delta(P,\alpha)|+|P|\log\log m)$.

5.4 Internal Transitions

We will compute and return the state-set transition by computing the internal transitions on the nodes in $L^{\odot}$ and $L^{\ast}$. Next, we show how to compute internal transitions efficiently using 3-sided range queries. We assume that the range $[l,r]$ is given as indexes in $A_{\alpha}$.

Computing $\delta^{\odot}_{[l,r]}(v,\alpha)$.

Given an $\odot$-node $v$, a character $\alpha$, and a range $[l,r]$ we compute $\delta^{\odot}_{[l,r]}(v,\alpha)$ as follows. We perform a 3-sided range reporting query $(l,r,0pt(\mathsf{right}(v))$ on $D_{\alpha}$. That is, we return all positions in $D_{\alpha}[l,r]$ with a value less than or equal to $0pt(\mathsf{right}(v))$. This can be done by a standard technique of recursively applying range minimum queries as follows. Let $j$ be the position returned by range minimum query on $D_{\alpha}[l,r]$. If $D_{\alpha}[j]\leq 0pt(\mathsf{right}(v))$ return $A_{\alpha}[j]$ and recurse on the ranges $[l,j-1]$ and $[j+1,r]$. We stop if this is not the case or if the range is empty.

For instance, suppose we compute $\delta^{\odot}_{[2,4]}(v_{2},a)$ in our example in Figure 2. The range $[2,4]$ in $A_{\alpha}$ corresponds to the positions $p_{2}$, $p_{3}$, and $p_{5}$. We find the highest first extent in to be $f=v_{4}$ corresponding to both $p_{2}$ and $p_{3}$. Suppose $j=3$ corresponding to $p_{3}$. Then we compare $f$ with $\mathsf{right}(v_{2})=v_{4}$ and since $f$ is an ancestor of $v_{4}$ we report $p_{3}$ and repeat on the subarrays $[2,2]$ and $[4,4]$. On $[2,2]$ we return $p_{2}$, while on $[4,4]$ we do not get a position since $v_{8}$ is a proper descendant of $v_{4}$.

Note, that we can get the output in sorted order if we first recurse on the range $[l,j-1]$, then report $A_{\alpha}[j]$, and then recurse on the range $[j+1,r]$.

The algorithm returns all positions $q$ with label $\alpha$ in $[l,r]$ such that $\mathsf{right}(v)\in\mathsf{firstextent}(q)$ and is thus correct. Each recursive call uses constant time and we repeat at most $2|\delta^{\odot}_{[l,r]}(v,\alpha)|+1$ times. Hence, in total we use $O(1+|\delta^{\odot}_{[l,r]}(v,\alpha)|)$ time.

Computing $\delta^{\ast}_{[l,r]}(v,\alpha)$.

To compute an internal transition for the $\ast$-case we do a 3-sided range reporting query $(l,r,0pt(\mathsf{parent}^{\ast}(v))$. Correctness follows as above and the time and space bounds are the same.

In summary, we have the following result.

Lemma 19**.**

Let $R$ be a regular expression of size $m$. Given $R$ we can build a data structure in $O(m)$ space and preprocessing time, such that given a node $v$ in $R$, a character $\alpha\in\Sigma$, and a range $[l,r]$ we can compute $\delta^{\odot}_{[l,r]}(v,\alpha)$ in sorted order in time $O(1+|\delta^{\odot}_{[l,r]}(v,\alpha)|)$ and $\delta^{\ast}_{[l,r]}(v,\alpha)$ in sorted order in time $O(1+|\delta^{\ast}_{[l,r]}(v,\alpha)|)$.

5.5 Computing State-Set Transitions

Given a set of positions $P$ and a character $\alpha$, we compute the state-set transition $\delta(P,\alpha)$ as follows. For simplicity, we assume that the positions in $P$ are sorted according to their left-to-right order since otherwise we can sort them in additional $O(|P|\log\log m)$ time using integer sorting. The final algorithm for computing fast state-set transitions is as follows.

First, we construct the transition tree and all the information from Lemma 10 as in Subsection 5.2. 2. 2.

We then compute $M^{\odot}$, $M^{\ast}$, $L^{\odot}$, and $L^{\ast}$ as in Subsection 5.3. 3. 3.

Finally, we compute and return the state-set transition by computing

[TABLE]

by processing $L^{\odot}$ and $L^{\ast}$ from left-to-right using the procedure from Subsection 5.4 that computes $\delta^{\odot}_{[l,r]}(u,\alpha)$ and $\delta^{\ast}_{[l,r]}(u,\alpha)$ in sorted order. Since both lists $L^{\odot}$ and $L^{\ast}$ are sorted the lists $D^{\odot}$ and $D^{\ast}$ are also sorted. We merge these two lists to get the final output.

Analysis of the algorithm

Step 1 uses $O(|P|)$ time by Lemma 10, and Step 2 uses $O(|\delta(P,\alpha)|+|P|\log\log m)$ time by Lemma 18. By Lemma 19 the time to compute all internal transitions in step 3 is

[TABLE]

The length of list $L^{\odot}$ is $O(|M^{\odot}|)$ as each interval endpoint is due to meeting a node in $M^{\odot}$ for the first or last time in the traversal. Similarly, $|L^{\ast}|=O(|M^{\ast}|)$. Hence, (2) is $O(|M^{\odot}|+|M^{\ast}|+|\delta(P,\alpha)|)$. The time to merge the two lists is linear in the total size of the lists since the lists are sorted. Thus the time for step 3 is $O(|M^{\odot}|+|M^{\ast}|+|\delta(P,\alpha)|)$. Plugging in the bounds from Lemma 12 and 13 we get a total running time of $O(|\delta(P,\alpha)|+|P|\log\log m)$.

Correctness

We have already proved that $N^{\odot}(P,\alpha)\subseteq M^{\odot}$ and $N^{\ast}(P,\alpha)\subseteq M^{\ast}$. Thus, by Lemma 6 the set of positions computed in step 4 is $\delta(P,\alpha)$. There are at most $|P|$ nodes in $M^{\odot}\setminus N^{\odot}(P,\alpha)$. These nodes are all in $\mathsf{lastextent}(P)$ and thus the set of internal transitions on these will all be in $\delta(P,\alpha)$. Similarly, for the nodes in $M^{\ast}\setminus N^{\ast}(P,\alpha)$.

It remains to show that the partition into lists is correct. We show that a position $q\in\bigcup_{v\in M^{\odot}}\delta^{\odot}(v,\alpha)$ is covered by the lowest node in $M^{\odot}$ such that $q\in\delta^{\odot}(u,\alpha)$, i.e., where covered means that $q\in\delta^{\odot}_{[l,r]}(u,\alpha)$ for some $l,r$ such that $(l,r,u)\in L^{\odot}$. This follows easily from the properties of the inorder traversal. The arguments for $q\in\cup_{v\in M^{\ast}}\delta^{\ast}(v,\alpha)$ are similar. For completeness, the full proof is shown below.

Lemma 20**.**

We have

[TABLE]

Proof.

We split the proof into two cases.

Case 1: $\bigcup_{v\in M^{\odot}}\delta^{\odot}(v,\alpha)=\bigcup_{(l,r,u)\in L^{\odot}}\delta_{[l,r]}^{\odot}(u,\alpha)$.    We are only adding subranges of the range of $\mathsf{right}(v)$ for any node in $v\in M^{\odot}$ to $L^{\odot}$. This immediately implies that $\cup_{(l,r,u)\in L^{\odot}}\delta_{[l,r]}^{\odot}(u,\alpha)\subseteq\cup_{v\in M^{\odot}}\delta^{\odot}(v,\alpha)$.

For the other direction, let $q$ be a position in $\cup_{v\in M^{\odot}}\delta^{\odot}(v,\alpha)$ and let $u$ be the deepest node in $M^{\odot}$ such that $q\in\delta^{\odot}(u,\alpha)$. We will show that $q\in\delta^{\odot}_{[l,r]}(u,\alpha)$ for some $l,r$ such that $(l,r,u)\in L^{\odot}$.

Let $\mathsf{pred}(u)=\arg\max_{x\in M^{\odot}}\{r_{x}<q\}$ and $\mathsf{succ}(u)=\arg\min_{x\in M^{\odot}}\{l_{x}>q\}$. If neither $\mathsf{pred}(u)$ nor $\mathsf{succ}(u)$ are in $T(\mathsf{right}(u))$ then nothing happens with $\ell$ and the stack $S$ after the step where we add $u$ to the top of the stack until we leave $u$ the last time. At this point $\mathsf{top}(S)=v$ and $\ell=l_{u}$ and $(\ell,r_{u},u)=(l_{u},r_{u},u)$ is appended to $L^{\odot}$. If $\mathsf{pred}(u)\in T(\mathsf{right}(u))$ then when we leave $\mathsf{pred}(u)$, node $u$ will be on top of the stack and $\ell=r_{\mathsf{pred}(u)}+1$. If also $\mathsf{succ}(u)\in T(\mathsf{right}(u))$ then $\mathsf{succ}(u)$ is the next node from $M^{\odot}$ we process in our inorder traversal. When we meet $\mathsf{succ}(u)$ before traversing its right subtree we add $(\ell,l_{\mathsf{succ}(u)}-1,\mathsf{top}(S))=(r_{\mathsf{pred}(u)}+1,l_{\mathsf{succ}(u)}-1,u)$ to $L^{\odot}$. Since $r_{\mathsf{pred}(u)}+1\leq q\leq l_{\mathsf{succ}(u)}-1$ we have $q\in\delta^{\odot}_{[r_{\mathsf{pred}(u)}+1,l_{\mathsf{succ}(u)}+1]}(u,\alpha)$. If $\mathsf{succ}(u)\not\in T(\mathsf{right}(u))$ then the next change we perform is when leaving $u$. Here we add $(\ell,r_{u}-1,u)$ to $L^{\odot}$. If only $\mathsf{succ}(u)\in T(\mathsf{right}(u))$ then we have $\mathsf{top}(S)=u$ and $\ell=l_{u}$ when we process $\mathsf{succ}(u)$ the first time (after visiting its left subtree). Then we add $(l_{u},l_{\mathsf{succ}(u)}-1,u)$ to $L^{\odot}$.

Case 2: $\bigcup_{v\in M^{\ast}}\delta^{\ast}(v,\alpha)=\bigcup_{(l,r,u)\in L^{\ast}}\delta_{[l,r]}^{\ast}(u,\alpha)$.    The arguments are similar to case 1. We are only adding subranges of the range of $v$ for any node in $v\in M^{\ast}$ to $L^{\ast}$. This immediately implies that $\cup_{(l,r,u)\in L^{\ast}}\delta_{[l,r]}^{\ast}(u,\alpha)\subseteq\cup_{v\in M^{\ast}}\delta^{\ast}(v,\alpha)$.

For the other direction let $q$ be a position in $\bigcup_{v\in M^{\ast}}\delta^{\ast}(v,\alpha)$ and let $u$ be the deepest node in $M^{\ast}$ such that $q\in\delta^{\ast}(u,\alpha)$. We will show that $q\in\delta^{\ast}_{[l,r]}(u,\alpha)$ for some $l,r$ such that $(l,r,u)\in L^{\ast}$.

If there are no other nodes from $M^{\ast}$ than $u$ in $T(u)$ then nothing happens between the first and last time we meet $u$ in the traversal and $(l_{u},r_{u},u)$ is appended to $L^{\odot}$ when we meet $u$ the last time. Similarly to case 1, let $u_{\mathsf{pred}(u)}=\arg\max_{x\in M^{\ast}}\{r_{x}<q\}$ and $\mathsf{succ}(u)=\arg\min_{x\in M^{\ast}}\{l_{x}>q\}$. If $\mathsf{pred}(u)\in T(u)$ then when we leave $\mathsf{pred}(u)$, node $u$ will be on top of the stack and $\ell=r_{\mathsf{pred}(u)}+1$. If also $\mathsf{succ}(u)\in T(u)$ then $\mathsf{succ}(u)$ is the next node from $M^{\ast}$ we process in our traversal. When we meet $\mathsf{succ}(u)$ the first time we add $(\ell,l_{\mathsf{succ}(u)}-1,\mathsf{top}(S))=(r_{\mathsf{pred}(u)}+1,l_{\mathsf{succ}(u)}-1,u)$ to $L^{\ast}$. Since $r_{\mathsf{pred}(u)}+1\leq q\leq l_{\mathsf{succ}(u)}-1$ we have $q\in\delta^{\ast}_{[r_{\mathsf{pred}(u)}+1,l_{\mathsf{succ}(u)}+1]}(u,\alpha)$. If $\mathsf{succ}(u)\not\in T(u)$ then the next change we perform is when leaving $u$. Here we add $(\ell,r_{u}-1,u)$ to $L^{\ast}$. If only $\mathsf{succ}(u)\in T(u)$ then we have $\mathsf{top}(S)=u$ and $\ell=l_{u}$ when we process $\mathsf{succ}(u)$ the first time (after visiting its left subtree). Then we add $(l_{u},l_{\mathsf{succ}(u)}-1,u)$ to $L^{\ast}$. ∎

In summary, we have the following result.

Lemma 21**.**

Given a regular expression $R$ of size $m$, we can build a data structure in $O(m)$ space and preprocessing time such that given any set of positions $P$ in $R$ and character $\alpha\in\Sigma$, we can compute $\delta(P,\alpha)$ in $O(|P|\log\log m+|\delta(P,\alpha)|)$ time.

6 Speeding Up State-Set Transitions

We now show how to improve the run time of computing a state-set transition $\delta(P,\alpha)$ from $O(|P|\log\log m+|\delta(P,\alpha)|)$ to $O(|P|\log\log\frac{m}{|P|}+|\delta(P,\alpha)|)$ while still using linear space. Finally, we show how to use this to obtain the main results of Theorems 1. We now require that the input positions in $P$ are sorted and the output positions in $\delta(P,\alpha)$ are reported in sorted order.

First, observe that the $\log\log m$ factor is from computing $|P|$ predecessor queries and $|P|$ first label queries in steps 2 and 3 in the main algorithm in Section 5.5. The first label queries in turn are reduced to computing $O(|P|)$ predecessor queries on the Euler tour of $R$ [25]. In both cases, we need to answer a batch of $b=\Theta(|P|)$ predecessor queries on a set of size $t=\Theta(|\mathsf{Pos}_{\alpha}|)$ from a universe of size $u=\Theta(m)$. The batch is provided in sorted order and the output should also be sorted.

We use a simple two-level data structure as follows. We first partition the universe into $t$ intervals of size $u/t$ (except possibly the last which may be smaller). For each interval, we store a predecessor data structure over the subset of the elements in the interval using a reduced universe of size $u/t$. Furthermore, we also store a pointer to the nearest non-empty smaller interval. Using the same predecessor data structure as in Section 5.5 for each interval the total space is $O(t)$. We answer a batch of $b$ predecessor queries according to the following two cases:

If $b\leq t$ we process each predecessor query in the batch by identifying the at most two intervals containing the answer and then querying these predecessor data structures. In total, this uses $O(b\log\log(u/t))=O(b\log\log(u/b))$ time. 2. 2.

If $b>t$ we simply merge the sorted batch of queries with the input set using $O(b+t)=O(b)$ time.

Since the batch is sorted we can also return the output in sorted order in $O(b)$ time. It follows that the running time is bounded by $O(b\log\log(u/b)$. Plugging into to the algorithm of Section 5.5, we obtain a data structure that uses $O(m)$ space and supports computing a state-set transition $\delta(P,\alpha)$ in time $O(|P|\log\log\frac{m}{|P|}+|\delta(P,\alpha)|)$. This completes the proof of Theorem 3.

Next consider Theorem 1. Let $Q$ be a string of length $n$ and let $S_{0},\ldots,S_{n}$ be the state-sets in the simulation of $R$ on $Q$. We implement the state-set transitions using Theorem 3. Note that each state-set transition produces the output in sorted order as required. Since logarithms are concave we have that the total time for the state-set transitions is

[TABLE]

The algorithm uses $O(m)$ space to store the representation of $R$ and at most two state sets during the simulation. This completes the proof of Theorem 1.

7 Conditional Lower Bound

We now prove the conditional lower bound of Theorem 2. Our lower bound follows the reduction of Backurs and Indyk [7] from the orthogonal vectors problem (OVP) to regular expression matching.

The orthogonal vectors problems is defined as follows. Given two sets $A,B\subseteq\{0,1\}^{d}$ such that $|A|=M$, $|B|=N$, determine if there exists $a\in A$ and $b\in B$ such that $a\cdot b=0$. For any $M=\Theta(N^{\alpha})$ for some $\alpha\in(0,1]$ and any constant $\epsilon>0$, any algorithm for OVP with running time $O((MN)^{1-\epsilon})$ violates SETH for $d=\omega(\log N)$ [76, 16].

Backurs and Indyk [7] showed hardness of regular expression matching using a reduction from OVP. Given an instance of OVP they show how to construct a regular expression $R^{\prime}$ and a string $Q^{\prime}$ in $O(Nd)$ time such that $Q^{\prime}$ matches $R^{\prime}$ if and only if there exists $a\in A$ and $b\in B$ such that $a\cdot b=0$. The reduction works in $O(Nd)$ time, the lengths of both $R^{\prime}$ and $Q^{\prime}$ is $\Theta(Nd)$, and the alphabet is $\{x,y\}$. The regular expression $R^{\prime}$ has the form

[TABLE]

Here $P$ is a regular expression of length $O(Md)$ with the property that a substring of $Q^{\prime}$ can be derived from $P$ if and only if there exists $a\in A$ and $b\in B$ such that $a\cdot b=0$. The precise definition of $R^{\prime}$, $Q^{\prime}$, and $P$ can be found in [7].

We claim that $\Delta_{R^{\prime},Q^{\prime}}=\Theta(|Q^{\prime}|^{2})$. To see this first note that $\Delta_{R^{\prime},Q^{\prime}}$ is at most $|R^{\prime}||Q^{\prime}|+1=O(|Q^{\prime}|^{2})$. For the lower bound, consider the sequence $S_{0},S_{1},\ldots,S_{|Q^{\prime}|}$ of state sets in the NFA simulation, and focus on the first $2|Q^{\prime}|$ positions in $R^{\prime}$, i.e., the positions corresponding to the subexpression immediately before $P$. Since $Q$ is a string of $x$s and $y$s, we have $|S_{1}|=|Q^{\prime}|$ and $|S_{i}|\geq|S_{i-1}|-1$ . Thus, $\Delta_{R^{\prime},Q^{\prime}}=\Omega(|Q^{\prime}|^{2})$ and hence the claim follows. See Figure 7(a).

We can now prove the following theorem.

Theorem 22**.**

Given $A=\{a^{1},\ldots,a^{N}\}\subseteq\{0,1\}^{d}$ and $B=\{b^{1},\ldots,b^{M}\}\subseteq\{0,1\}^{d}$ and a constant $\gamma$, where $0<\gamma\leq 1$, we can construct in $O((Nd)^{2/(1+\gamma)})$ time a regular expression $R$ and a string $Q$, such that there exists $a\in A$ and $b\in B$ where $a\cdot b=0$ if and only if $Q\in L(R)$. The size of $R$ and $Q$ is $\Theta((Nd)^{2/(1+\gamma)})$ and $\Delta_{R,Q}=\Theta(|Q|^{1+\gamma})=\Theta(N^{2}d^{2})$.

Proof.

We construct our instance $R$, $Q$ from $R^{\prime}$ and $Q^{\prime}$ as follows.

[TABLE]

where $\ell=(Nd)^{2/(1+\gamma)}$.

Clearly, $Q$ matches $R$ if and only if $Q^{\prime}$ matches $R^{\prime}$. Furthermore, the NFA simulation on the first $\ell$ characters must produce singleton state sets (see Figure 7(b)). Hence, we have that $\Delta_{R,Q}=\ell+\Delta_{R^{\prime},Q^{\prime}}=\Theta((Nd)^{2})$. Since $|Q|=\ell+|Q^{\prime}|=\Theta((Nd)^{2/(1+\gamma)})$ we have that $\Delta=\Theta(|Q|^{1+\gamma)})$. ∎

Theorem 2 follows directly from Theorem 22, since an $O(\Delta^{1-\epsilon})=O((Nd)^{2-2\epsilon})$ time algorithm for regular expression matching would imply a $O((Nd)^{2-2\epsilon}+(Nd)^{2/(1+\gamma)})$ algorithm for OVP.

8 Acknowledgments

We thank the anonymous reviewers whose comments and suggestions significantly improved the presentation of the paper.