1 Introduction↩︎

Wheeler graphs [4] are a class of directed, labelled graphs that has received attention in both the compression community and bioinformatics. In compression, Wheeler graphs allow storing a (potentially infinite) set of strings, and support indexing for matching patterns \(P\) in \(O(|P|\log \sigma)\) time, in contrast to the conditional lower bound of \(\omega(m^\delta|P|^\beta)\) time (for \(\delta<1\) or \(\beta< 1\)) required in general labelled graphs [5]. They have also been studied as an important subclass of finite automata [1], [2]. In the bioinformatics community, Wheeler graphs have been used for indexing genomic databases. The compressed index of the variation graph toolkit VG [6] is based on the Wheeler properties of the de Bruijn graph of the data, as well as other indices such as VARI [7] and Themisto [8].

Most of the algorithmic work on Wheeler graphs has been described on deterministic Wheeler graphs, that is, graphs where no two edges with the same label leave the same vertex. Important examples are computing matching statistics [9], computing the LCP array [10], counting distinct \(k\)-mers [11], and minimizing the size [12]. Further work that extends results from Wheeler graphs to arbitrary finite automata also maintains the deterministic restriction [13], [14], or provides efficient algorithms only for deterministic automata [15]. It is therefore an important question whether these results can be extended to non-deterministic graphs, and under what conditions.

In what follows, we use the notation \(n_\mathcal{W}\) and \(m_\mathcal{W}\) for the number of vertices and edges of an automaton \(\mathcal{W}\), respectively, and define \(|\mathcal{W}|=n_\mathcal{W}+m_\mathcal{W}\). Alanko et al. describe, in their seminal papers [1], [2], a deterministic Wheeler automaton (WDFA) with the same language of any non-deterministic Wheeler automaton (WNFA), dubbed the Wheeler determinization of the WNFA. It has at most \(2n_\mathcal{A}-1-\sigma\) nodes and \(O(n_\mathcal{A}\sigma)\) edges, where \(\sigma\) is the size of the alphabet. They give an \(O(n_\mathcal{A}^3)\) time algorithm to construct the Wheeler determinization, which is not output-sensitive given the stated size. Still, this result is remarkable, given that in general graphs the blow-up in size when going from NFAs to DFAs is exponential in the worst case.

Our contribution.

We describe an algorithm for building the WDFA described by Alanko et al. that runs in output-sensitive time. More precisely:

Given that \(m_\mathcal{W}=O(n_\mathcal{W}\sigma)\) holds for any Wheeler graph [16], we have a linear time algorithm for sorted inputs. If all vertices of \(\mathcal{A}\) are reachable from the source (a standard assumption, see [1]), then the number of edges of \(\mathcal{D}\) dominates the running time, and we obtain an improvement of \(n_\mathcal{A}^2/\sigma\) over the state of the art. Additionally, we show that the upper bound is tight for any \(n\) and \(\sigma\), by showing a family of WNFAs where our determinization \(\mathcal{D}\) is the minimum WDFA with the same language as \(\mathcal{A}\), and its size is \(\Theta(n\sigma)\).

Our approach follows the classical powerset construction algorithm to build a DFA with the same language as an input NFA. To achieve our results, we introduce two new data structures: firstly, an edge discovery data structure that outputs the distinct edge labels outgoing from an interval of nodes; and secondly, a bitvector-based dynamic set data structure for intervals of nodes.

2 Preliminaries↩︎

We work with directed, labelled graphs \(G=(V, E)\), where the edges have single character labels. The labels come from a finite alphabet \(\Sigma\) of size \(\sigma\) with a total order \(\preceq\). The edges are a set \(E\subseteq V\times V\times \Sigma\), and we denote them by a triple \((u,v,a)\) where \(u\) is the tail and \(v\) is the head. We assume standard notions of nondeterministic and deterministic finite state automata; see, e.g. [17]. We denote a finite automaton by \(\mathcal{A}=(V,E,\Sigma,s,F)\) and its language by \(\mathcal{L}(\mathcal{A})\). We use the notation \(|V|=n_\mathcal{A},|E|=m_\mathcal{A}\) and \(|\mathcal{A}|=n_\mathcal{A}+m_\mathcal{A}\) throughout the paper, and we drop the subscript when it is understood from the context. The set \(\textrm{Pref}(\mathcal{L}(\mathcal{A}))\) is the set of all prefixes of strings in \(\mathcal{L}(\mathcal{A})\).

Wheeler graphs [4].

A Wheeler graph \(\mathcal{A}=(V,E)\) is a directed, labelled graph with a total order \(\leq\) on the vertices, called the Wheeler order, that satisfies the following properties. For any two edges \((u, v,a),(u',v',a')\in E\):

W1:

\(a\prec a'\implies v\leq v'\)

W2:

\((a=a')\wedge (u<u')\implies (v\leq v')\)

Additionally, sources come before vertices with positive in-degree in the Wheeler order. Wheeler graphs have the property of path coherence [4]: given an interval of vertices \([i,j]\subseteq V\) and any string \(\alpha\), the subset of vertices that we reach when following walks that spell \(\alpha\) starting from \([i,j]\) is also an interval of \(V\). Wheeler graphs also have the property that \(m_\mathcal{A}=O(n_\mathcal{A}\sigma)\) (see [16]).

A Wheeler NFA (WNFA) is an NFA whose state graph is a Wheeler graph. A Wheeler DFA (WDFA) is a WNFA with a deterministic state graph. Given a WNFA \(\mathcal{A}\), the Wheeler determinization of \(\mathcal{A}\) is a WDFA \(\mathcal{D}= (V^\mathcal{D},E^\mathcal{D},\Sigma,s^\mathcal{D},F^\mathcal{D})\) with \(\mathcal{L}(\mathcal{D})=\mathcal{L}(\mathcal{A})\), defined as follows [1], [2]. Let \(I_\alpha\subseteq V\) be the interval of vertices that we reach when following walks that spell a string \(\alpha\), starting from \(s\). Then, \(V^\mathcal{D}=\{I_\alpha \mid \alpha\in \textrm{Pref}(\mathcal{L}(\mathcal{A}))\}\), \(E^\mathcal{D}=\{(I_\alpha, I_{\alpha e},e)\in V^\mathcal{D}\times V^\mathcal{D}\times \Sigma\}\), \(s^\mathcal{D}=I_{\epsilon}=[s,s]\), and \(F^\mathcal{D}=\{I_\alpha:\alpha\in \mathcal{L}(\mathcal{A})\}\). Note that this WDFA may not be the WDFA with the minimum size for the language \(\mathcal{L}(\mathcal{A})\). However, we have a bound on the number of vertices: \(n_\mathcal{D}\leq 2n_\mathcal{A}-1-\sigma\) (see [1], [2]). A Wheeler graph with \(n\) vertices can be represented by a succinct data structure (called index) for navigation and pattern matching queries. We describe the two components that we use. Let \(\ell_i=\deg_{out}(v_i)\) be the out degree of the \(i\)-th vertex in Wheeler order, and let \(L_i\) be the sequence of its outgoing labels, ordered by \(\preceq\). We define the bitvector \(O=0^{\ell_1}10^{\ell_2}1\cdots0^{l_n}1\), and a character vector \(L=L_1L_2\cdots L_n\).

Data structures.

We use standard Range Minimum Query (RMQ) data structures of \(O(n)\) space, constructible in \(O(n)\) time and with \(O(1)\)-time queries [18], [19]. We also use succinct rank and select data structures for bit-vectors, that use \(n+o(1)\) space, are constructible in \(O(n)\) time and have \(O(1)\) query time [20], [21].

Rank space.

We can assume that the labels of any WNFA \(\mathcal{A}\) are in rank space (meaning \(\Sigma\subseteq [1,m]\)) if \(\mathcal{A}\) is sorted, even if the alphabet size is unbounded. To show this, represent the edges of \(\mathcal{A}\) by pairs \((v, u)\rightarrow a\), where \(v\) is the head and \(u\) is the tail of the edge, and the label \(a\) is only satellite data. Now, radix sort the pairs, and do a linear scan to re-label the satellite data in \([1,m]\) following the new found order. By property W1, this corresponds to the natural order of the labels. Because the Wheeler order gives indices in \([1,n]\) to the vertices, the radix sort step takes linear time.

3 Data structures↩︎

In this section we describe two data structures specialized for a Wheeler NFA \(\mathcal{A}\). The first is a dynamic set data structure for the intervals of \(\mathcal{A}\)’s vertices, with worst-case deterministic constant time for search and insertion. The second is an edge discovery data structure that answers the following query: given an interval of vertices \([v_i,v_j]\subseteq V\), let \(\Lambda_{ij}\) be the set of labels on the outgoing edges from \([v_i,v_j]\). For each \(a\in \Lambda_{ij}\), it returns the maximal intervals of vertices that we reach by traversing the edges labelled \(a\) starting from \([v_i,v_j]\). This last data structure is based on the colored range query data structure of Muthukrishnan [22], that we describe in Appendix 6:

3.1 Dynamic set data structure for intervals of vertices↩︎

Given a WNFA \(\mathcal{A}\), in [1], [2] it was proven that the vertices of the determinization \(\mathcal{D}\) are elements of a prefix/suffix family of intervals \(\mathcal{C}\) over \([1,n]\). The elements are intervals \(I=[m_I,M_I]\subseteq [1,n]\), where \(m_I\) is the smallest endpoint, and \(M_I\) is the largest. If we consider the sum of the endpoints for any two intervals \(I<J\) in this special family \(\mathcal{C}\), it holds that \(m_I+M_I<m_J+M_J\). This implies that there are at most \(2n-1\) elements in \(\mathcal{C}\), and that we have a total order for them given by \(rank(I)=m_I+M_I\).

Since we allow ourselves to use \(O(n)\) space, and we want to represent a dynamic set of size at most \(O(n)\), we can use a bit vector \(B[1,2n-1]\) as our set data structure. To add \(I\) to \(B\), set \(B[m_I+M_I]\) to \(1\). An interval \(J\) of the family is in \(B\) if and only if \(B[m_J+M_J]\) is set to \(1\). We can also support deletions if needed, by setting \(B[m_I+M_I]\) to \(0\). Since \(I\neq J\) implies \(m_I+M_I\neq m_J+M_J\), the queries are correct. Summarizing:

3.2 Edge discovery data structure↩︎

We augment the data structure of Muthukrishnan to create a data structure for edge discovery queries. We need one last building block: observe that we can obtain easily a colored range query that reports the indices of the last occurrences of the set of characters inside a range. To achieve this, in the construction of the data structure, instead of a predecessor array we use a successor array \(S[1,n]\), where \(S[i]\) is the index of the next occurrence of \(A[i]\) in \(A\), or \(n+1\) otherwise. Then, instead of range minimum queries, we use range maximum queries to obtain the maximum indices of the distinct characters in a range. The query for a range \([i,j]\) is similar: as long as the retrieved index has a successor larger than \(j\), we recurse both left and right.

To support edge discovery queries, at preprocessing time, build the two versions of colored range queries on \(L\). Then, build an array \(E[1,\sigma]\) to hold pairs of vertices (initially empty), and create an empty queue of vertices \(Q\). We also build the standard rank and select data structures [20], [21] on the bitvector \(O\).

To solve an edge discovery query for an interval \([v_i,v_j]\), we first obtain the indices in \(L\) of the first outgoing edge from \(v_i\) and the last outgoing edge from \(v_j\), denoted \([i_e,j_e]\), by \(i_e=rank_0(select_1(i-1,O)+1,O),j_e=rank_0(select_1(j,O),O)\). Then, we do a colored range query for \([i_e,j_e]\) on \(L\), to find the indices of the first occurrences in \(L[i_e,j_e]\) of the set of unique elements in \(L[i_e,j_e]\). For each reported index \(w\), we add \(L[w]\) to the queue \(Q\). We also compute \(rank_1(select_0(w, O), O)+1\) to find the index of the vertex at the tail of the edge labelled by \(L[w]\), and we set it as the first element of the pair at \(E[a]\). Then, we repeat the query on \(L[i_e,j_e]\) but using the other colored range data structure that finds the last occurrences inside the range. For each reported index \(w'\), we find in the same way the vertex at the tail of the edge labelled by \(L[w']\), and we add it to the second element of the pair at \(E[a]\). Finally, we pop one by one the characters in \(Q\), and for each one \(a\), we report \((a, E[a])\).

It follows from Theorem [thm:muthukrishnan] and the rank space assumption that we can build this data structure in \(O(|\mathcal{A}|)\) time, and that an edge discovery query will run in \(O(1+occ)\) time, where \(occ\) is the number of pairs \((a,[v_i',v_j'])\) that we output. Note that, since we only inspect the indices of \(E\) that we output after we have set them to the correct values, we can support a future edge discovery query without any further processing or cleanup.

4 Determinization algorithm↩︎

In this section we describe the \(O(|\mathcal{A}|+|\mathcal{D}|)\) algorithm to compute the Wheeler determinization \(\mathcal{D}\) given the sorted WNFA \(\mathcal{A}\). We leave the details to construct the set of final states in appendix 7.

The input to our algorithm will be the bitvector \(O\) and the character vector \(L\) as described before. These can be built in linear time once we know the Wheeler order of \(\mathcal{A}\). The data structures we need are as follows. We first make a queue \(K\) to hold newly found vertex intervals, and we add \([v_1,v_1]\) at the start. We also build the dynamic set data structure \(H\) (see section 3.1) for intervals of vertices, and insert \([v_1,v_1]\) in it. Finally, we build the edge discovery data structure \(\mathcal{E}\) that we described in section 3.2. The output will be computed as the adjacency list representation of the output WDFA graph. Neither the vertices of \(\mathcal{D}\) nor their adjacency lists are guaranteed to be sorted at the end, but once the graph is deterministic, it can be sorted in linear time if needed [1].

The algorithm runs until the queue \(K\) is empty. The main loop pops an interval \([v_i,v_j]\) from \(K\), and discovers the set of outgoing intervals of vertices \([v_i',v_j']\) with each label \(a\in \Sigma\), using a query to \(\mathcal{E}\). For each outgoing interval \([v_i',v_j']\), we first check in the set \(H\) if \([v_i',v_j']\) exists already. If so, we just add the edge \(([v_i,v_j],[v_i',v_j'],a)\) to the adjacency list of \([v_i,v_j]\). Otherwise, we add that edge, add \([v_i',v_j']\) to \(H\), and enqueue \([v_i',v_j']\) in \(K\). When all the outgoing edges from \([v_i,v_j]\) are processed, we return to the start of the loop.

4.0.1 Analysis.↩︎

The correctness follows from the same argument as the powerset construction algorithm, see for example [1]. We need to argue the time complexity. Building \(H\) takes \(O(n_\mathcal{A})\) time by Lemma 1, and building \(\mathcal{E}\) takes \(O(|\mathcal{A}|)\) time by Lemma 2. This amounts to \(O(|\mathcal{A}|)\) time. During the construction algorithm we do \(n_\mathcal{D}\) iterations of the main loop. Each iteration with a vertex \([v_i,v_j]\) makes a query to \(\mathcal{E}\) that takes \(O(1+\deg_{out}([v_i,v_j]))\) time, and for each reported output, we do at most one lookup and one insertion into \(H\), plus at most one insertion into \(K\). All the operations on \(H\) and \(K\) are constant time. Thus, the time to run all iterations adds up to \(O(n_\mathcal{D}+m_\mathcal{D})=O(|\mathcal{D}|)\) time. In total, we arrive at \(O(|\mathcal{A}|+|\mathcal{D}|)\) time. This proves Theorem 1.

Since \(n_\mathcal{D}\leq 2n_\mathcal{A}-1-\sigma\), \(m_\mathcal{D}=O(n_\mathcal{D}\sigma)\) and \(m_\mathcal{A}=O(n_\mathcal{A}\sigma)\), we have \(|\mathcal{D}|=O(n_\mathcal{A}\sigma)\) and \(O(|\mathcal{A}|+|\mathcal{D}|)=O(n_\mathcal{A}\sigma)\). For constant alphabets, this implies that our running time is \(O(n_\mathcal{A})\).

5 Tight family↩︎

In this section we show a family of WNFAs parameterized by \(\sigma\), such that for any WNFA \(\mathcal{A}\) in the family, the output WDFA \(\mathcal{D}\) of our algorithm is minimum, and has \(n_\mathcal{D}\leq 2n_\mathcal{A}- 1 - \sigma\) vertices and \(m_\mathcal{D}=\Theta(n_\mathcal{A}\sigma)\) edges. Since Wheeler graphs always satisfy \(m=O(n\sigma)\), this output is as large as possible. Figure 1 shows an example WNFA with \(\sigma=O(n_\mathcal{A})\), and Figure [fig:wdfa] shows the output \(\mathcal{D}\). We can construct instances for an arbitrary \(\sigma\) by including only \(\sigma-2\) different nodes in the bottom row, each with a unique incoming label; and we increase \(n\) by making the top row longer. It is easy to see that \(\mathcal{D}\) will always have \(O(n)\) edges from the top row to each of the \(\sigma-2\) nodes in the bottom row. We consider all nodes final.

Minimality of \(\mathcal{D}\) (see [1], [12] for the precise conditions) can be seen in two steps: firstly, the top row vertices are inequivalent because they have a distinct outgoing string ending at \(v_{10}\). Secondly, the bottom row vertices are inequivalent due to their distinct incoming labels.

6 Colored Range Queries↩︎

We review the colored range data structure of Muthukrishnan [22]. Given an array \(A[1,n]\) of elements from a universe of size \(u=O(n)\), we preprocess the array to solve the following query: given a range of indices \([i,j]\subseteq [1,n]\), return the set of unique elements in \(A[i,j]\). In practice, our data structure will report the indices of such elements in \(A\), that we can retrieve later.

To preprocess the array, we build a predecessor array \(P[1,n]\) that holds, in the \(i\)-th element, the index of the previous occurrence of \(A[i]\) in \(A\), or \(-1\) if it is the first occurrence. Then, we build a Range Minimum Query (RMQ) data structure [18], [19] over \(P\). The predecessor array can be built by scanning \(A\) and keeping track of the last occurrence of each character of the alphabet with an array of size \(u\), in time \(O(n+u)=O(n)\). The RMQ data structure can also be built in linear time [18], [19].

To solve the colored range query over \([i,j]\), we query the index \(w\) of the minimum element in \([i,j]\) in \(P\) with the RMQ data structure. If \(w<i\), then the previous occurrence of \(A[w]\) in \(A\) is outside the range \([i,j]\), therefore we report \(w\). To continue, we recurse on \([i,w-1]\) and \([w+1,j]\), and we keep on reporting the index of elements as long as their previous occurrence appears before \(i\). This reports all the indices of the \(occ\) unique elements in \(A[i,j]\) in \(O(1+occ)\) time.

We make a crucial observation: the indices that are found by the colored range query are the indices of the first occurrence of elements in \(A[i,j]\), because any further occurrence of an element in \(A[i,j]\) has a predecessor index in \([i,j]\), and thus it will not be reported.

7 Final states↩︎

We can construct the set of final states at the end of our determinization algorithm easily. Let \(B_F[1,n_\mathcal{A}]\) be a bitvector that is \(1\) if the \(i\)-th node of \(\mathcal{A}\) is final, and \(0\) otherwise. Build a constant-time rank data structure for \(B_F\). Once we have computed the set of vertices of the determinization, \(V^\mathcal{D}\), we determine if \([v_i,v_j]\in V^\mathcal{D}\) is final by computing \(rank_1(v_j,B_F)-rank_1(v_{i-1},B_F)\) (we consider \(rank_1(v_0,B_F)=0\)). If the result is greater than 0, it means that there exists at least one final state in \([v_i,v_j]\), and thus we set \([v_i,v_j]\) as a final state; otherwise we set it as non-final. This can be done in \(O(n_\mathcal{D})=O(n_\mathcal{A})\) time, at no asymptotic cost.

References↩︎