Regular Languages meet Prefix Sorting

TL;DR

This paper introduces Wheeler languages, a subclass of regular languages characterized by prefix-sortable automata, and develops algorithms for their indexing, sorting, and minimization, extending string prefix sorting techniques to languages.

Contribution

It characterizes Wheeler languages as regular languages with co-lexicographic ordering and provides algorithms for automaton conversion, sorting, and minimization specific to this class.

Findings

Wheeler NFAs can be efficiently converted to Wheeler DFAs with at most 2n-1-|Σ| states.

Algorithms for prefix-sorting Wheeler automata are quadratic, online, and linear-time, depending on the case.

The smallest Wheeler DFA for a language can be computed in nearly optimal time.

Abstract

Indexing strings via prefix (or suffix) sorting is, arguably, one of the most successful algorithmic techniques developed in the last decades. Can indexing be extended to languages? The main contribution of this paper is to initiate the study of the sub-class of regular languages accepted by an automaton whose states can be prefix-sorted. Starting from the recent notion of Wheeler graph [Gagie et al., TCS 2017]-which extends naturally the concept of prefix sorting to labeled graphs-we investigate the properties of Wheeler languages, that is, regular languages admitting an accepting Wheeler finite automaton. Interestingly, we characterize this family as the natural extension of regular languages endowed with the co-lexicographic ordering: when sorted, the strings belonging to a Wheeler language are partitioned into a finite number of co-lexicographic intervals, each formed by elements from a single Myhill-Nerode equivalence class. Moreover: (i) We show that every Wheeler NFA (WNFA) with $n$ states admits an equivalent Wheeler DFA (WDFA) with at most $2n-1-|\Sigma|$ states that can be computed in $O(n^3)$ time. This is in sharp contrast with general NFAs. (ii) We describe a quadratic algorithm to prefix-sort a proper superset of the WDFAs, a $O(n\log n)$-time online algorithm to sort acyclic WDFAs, and an optimal linear-time offline algorithm to sort general WDFAs. By contribution (i), our algorithms can also be used to index any WNFA at the moderate price of doubling the automaton's size. (iii) We provide a minimization theorem that characterizes the smallest WDFA recognizing the same language of any input WDFA. The corresponding constructive algorithm runs in optimal linear time in the acyclic case, and in $O(n\log n)$ time in the general case. (iv) We show how to compute the smallest WDFA equivalent to any acyclic DFA in nearly-optimal time.

Figures

Equations

$$I{<}^{i}J$$

$$\alpha \in I_u\text{ if and only if }u\in I_{\alpha }.$$

$$\alpha {\equiv }_{\mathcal{L}}\beta \text{ if and only if }$$

$$\alpha {\equiv }_{\mathcal{L}}^c\beta \text{ if and only if }$$

$$1+\sum _{i=1}^k(2m_i-1)=1+2(\sum _{i=1}{m}_i)-k=1+2(n-1)-k=2n-1-k=2n-1-|\Sigma |.$$

$$\alpha {\sim }_{\mathcal{A}}\beta \iff I_{\alpha }=I_{\beta }.$$

$$\alpha \in I\iff s_{\sim }⇝I\text{ in }{\mathcal{A}}_{\sim }\text{ reading }\alpha .$$

$$w_1<{\mathbf{u}}_{{\mathbf{i}}_1}\le \cdots \le {\mathbf{u}}_{{\mathbf{i}}_1}^{\prime }<w_2\le \cdots \le w_2^{\prime }<{\mathbf{u}}_{{\mathbf{i}}_2}\le \cdots \le {\mathbf{u}}_{{\mathbf{i}}_2}^{\prime }<\cdots <{\mathbf{u}}_{{\mathbf{i}}_{\mathbf{q}}}\le \cdots \le {\mathbf{u}}_{{\mathbf{i}}_{\mathbf{q}}}^{\prime }<w_{q+1},$$

$$c{B}_1<d{B}_1<c{B}_2<d{B}_2<\dots <c{B}_{2^{m+1}-1}<d{B}_{2^{m+1}-1}$$

Full text

1. (i)

We show that every Wheeler NFA (WNFA) with $n$ states admits an equivalent Wheeler DFA (WDFA) with at most $2n-1-|\Sigma|$ states ($\Sigma$ being the alphabet) that can be computed in $O(n^{3})$ time. This is in sharp contrast with general NFAs (where the blow-up could be exponential). 2. (ii)

We describe a quadratic algorithm to prefix-sort a proper superset of the WDFAs, a $O(n\log n)$-time online algorithm to sort acyclic WDFAs, and an optimal linear-time offline algorithm to sort general WDFAs. By contribution (i), our algorithms can also be used to index any WNFA at the moderate price of doubling the automaton’s size. 3. (iii)

We provide a minimization theorem that characterizes the smallest WDFA recognizing the same language of any input WDFA. The corresponding constructive algorithm runs in optimal linear time in the acyclic case, and in $O(n\log n)$ time in the general case. 4. (iv)

We show how to compute the smallest WDFA equivalent to any acyclic DFA in nearly-optimal time.

Our contributions imply new results of independent interest. Contributions (i-iii) extend the universe of known regular languages for which membership can be tested efficiently [Backurs and Indyk, FOCS 2016] and provide a new class of NFAs for which the minimization problem can be approximated within constant factor in polynomial time. In general, the NFA minimization problem does not admit a polynomial-time $o(n)$-approximation unless P=PSPACE. Contribution (iv) is a big step towards a complete solution to the well-studied problem of indexing graphs for linear-time pattern matching queries: our algorithm provides a provably minimum-size solution for the deterministic-acyclic case.

1 Introduction

Prefix-sorting is the process of ordering the positions of a string in the co-lexicographic order of their corresponding prefixes111Usually, the lexicographic order is used to sort string suffixes. In this paper, we use the symmetric co-lexicographic order of the string’s prefixes, and extend the concept to labeled graphs.. Once this step has been performed, several problems on strings become much easier to solve: for example, substrings can be located efficiently in the string without the need to read all of its characters. Given the versatility of this tool, it is natural trying to generalize it to more complex objects such as edge-labeled trees and graphs. For example, a procedure for lexicographically-sorting the states of a finite-state automaton could be useful to speed up subsequent membership queries in its accepting language or its substring/suffix closure; as shown by Backurs and Indyk [2], membership and pattern matching problems on regular languages are hard in the general case. The newborn theory of Wheeler graphs [11] provides such a generalization. Intuitively, a labeled graph is Wheeler if and only if its nodes can be co-lexicographically sorted in a total order, i.e. pairwise-distinct nodes are ordered according to (i) their incoming labels or (when the labels are equal), according to (ii) their predecessors. As a consequence, Wheeler graphs admit indexes for linear-time exact pattern matching queries (also known as path queries). Wheeler graphs generalize several lexicographically-sorted structures studied throughout the past decades: indexes on strings [23, 32, 10], sets of strings [25], trees [9], de Bruijn graphs [5], variable-order de Bruijn graphs [30], wavelet trees [15], wavelet matrices [4]. These efforts are part of a more general wave of interest (dating as far back as 27 years ago [24]) towards techniques aimed at solving pattern matching on labeled graphs [6, 30, 11, 9, 19, 31, 28, 1, 7, 24]. As discussed above, existing graph-indexing solutions can only deal with simple labeled graphs. The problem of indexing general (or even just acyclic) graphs with a solution of provably-minimum size remains unsolved. Unfortunately, not all graphs are Wheeler and, as Gibney and Thankachan [13] have recently shown, the problem of recognizing (and sorting) them turns out to be NP-complete even when the graph is acyclic (this includes, in particular, acyclic NFAs). Even worse, not all regular languages admit an accepting Wheeler finite automaton: the set of Wheeler languages is a proper superset of the finite languages and a proper subset of the regular languages [11]. Even when an index is not used, exact pattern matching on graphs is hard: Equi et al. [6, 7] have recently shown that any solution to the problem requires at least quadratic time (under the Orthogonal Vectors hypothesis), even on acyclic DFAs. In particular, this implies that converting an acyclic DFA into an equivalent Wheeler DFA cannot be done in less than quadratic time in the worst case.

The remaining open questions, therefore, are: what are the properties of Wheeler languages? which class of automata admits polynomial-time prefix-sorting procedures? Can we efficiently build the smallest (that is, with the minimum number of states) prefix-sortable finite-state automaton that accepts a given regular language? These questions are also of practical relevance: as shown in [30], acyclic DFAs recognizing pan-genomes (i.e. known variations in the reference genome of a population) can be turned into equivalent WDFAs of the same expected asymptotic size. While the authors do not find the minimum such automaton, their theoretical analysis (as well as experimental evaluation) suggests that the graph-indexing problem is tractable in some real-case scenarios.

1.1 Our Contributions

In this paper we provide the following contributions:

We show that Wheeler languages are the natural version of regular languages endowed with the co-lexicographic ordering: when sorted, the strings belonging to a Wheeler language are partitioned into a finite number of intervals, each formed by elements from a single Myhill-Nerode equivalence class. In regular languages, those intervals are replaced with general sets. 2. 2.

We show that every Wheeler NFA (WNFA) with $n$ states admits an equivalent Wheeler DFA (WDFA) with at most $2n-1-|\Sigma|$ states ($\Sigma$ being the alphabet) that can be computed in $O(n^{3})$ time. This is in sharp contrast with general NFAs (where the blow-up could be exponential). 3. 3.

Let $d$-NFA denote the class of NFAs with at most $d$ equally-labeled edges leaving any state. We show that the problem of recognizing and sorting Wheeler $d$-NFAs is in P for $d\leq 2$. A recent result from Gibney and Thankachan [13] shows that the problem is NP-complete for $d\geq 5$. Our result almost completes the picture, the remaining open cases being $d=3$ and $d=4$. 4. 4.

We provide an online incremental algorithm that, when fed with an acyclic Wheeler DFA’s nodes in any topological order, can dynamically compute the co-lexicographic rank of each new incoming node among those already processed with just logarithmic delay. 5. 5.

We improve the running time of (4) to linear in the offline setting for arbitrary WDFAs. 6. 6.

Given a Wheeler DFA $\mathcal{A}$ of size $n$, we show how to compute, in $O(n\log n)$ time, the smallest Wheeler DFA recognizing the same language as $\mathcal{A}$. If $\mathcal{A}$ is acyclic, running time drops to $O(n)$. 7. 7.

Given any acyclic DFA $\mathcal{A}$ of size $n$, we show how to compute, in $O(n+m\log m)$ time, the smallest Wheeler DFA $\mathcal{A}^{\prime}$, of size $m$, recognizing the same language as $\mathcal{A}$.

The paper is structured in a top-down fashion to make it accessible also to non-experts. We provide the main theorems and proof sketches within the first ten pages. We start in Section 2 with results 1 and 2: a Myhill-Nerode theorem for Wheeler languages and a linear conversion from WNFAs to WDFAs. Result 1 shows that Wheeler languages are precisely those admitting a “finite interplay” between the co-lexicographic ordering and the Myhill-Nerode equivalence relation (i.e. the relation characterizing general DFAs). Result 2 implies that the WNFA minimization problem admits a polynomial-time $2$-approximation. We remark that the NFA minimization problem is notoriously hard (even to approximate within $o(n)$-factor) in the general case [14, 16, 22]. In Section 3 we describe results 3-5: polynomial-time algorithms for recognizing and sorting Wheeler $2$-NFAs. These results generalize to labeled graphs existing prefix-sorting algorithms on strings [26] and labeled trees [9] that have been previously described in the literature. Combined with contribution 2, our algorithms can be used to index any Wheeler NFA at the price of a moderate linear blow-up in the number of states. This result expands the universe of known regular languages for which membership and pattern matching problems can be solved efficiently [2]. Contributions 6 and 7 (Section 4) combine our sorting algorithms 3-5 with DFA minimization techniques to solve the following problem: to compute, given a finite language represented either explicitly by a set of strings or implicitly by an acyclic DFA, the smallest accepting WDFA. Note that this can be interpreted as a technique to index arbitrary deterministic acyclic graphs using the smallest prefix-sortable equivalent automaton. While we do not provide a lower bound stating that the space of our index is minimum, we note that all known fast indexes on strings, sets of strings, trees, and variable-order de Bruijn graphs are Wheeler graphs [11]. In this sense, any index on acyclic graphs improving our solution would probably require techniques radically different than those developed in the last decades to solve the indexing problem (virtually any known full-text index uses prefix sorting, including those based on LZ77 [21], run-length BWT [12], and grammars [3]).

1.2 Definitions

We start by giving a definition of finite-state automata that captures, to some extent, the amount of nondeterminism of the automaton. A $d$-NFA is a nondeterministic finite state automaton that has at most $d$ transitions with the same label leaving each state. Note that $1$-NFAs correspond to DFAs, while $\infty$-NFAs correspond to NFAs.

Definition 1

A $d$-NFA is a quintuple $\mathcal{A}=(V,E,F,s,\Sigma)$, where $V$ is a set of states (or vertices), $\Sigma$ is the alphabet (or set of labels), $E\subseteq V\times V\times\Sigma$ is a set of directed labeled edges, $F\subseteq V$ is a set of accepting states, and $s\in V$ is a start state (or source). We moreover require that $s\in V$ is the only node with in-degree zero and that for each $u\in V$ and $a\in\Sigma$, $|\{(u,v,a)\in E\}|\leq d$.

We denote $\sigma=|\Sigma|$. The notation $\mathcal{L}(\mathcal{A})$ indicates the language accepted by $\mathcal{A}$, i.e. the set of all strings labeling paths from $s$ to an accepting state. We assume that each state either is $s$ or is reachable from $s$. Otherwise, any state that cannot be reached from $s$ can be removed without changing $\mathcal{L}(\mathcal{A})$. Note that we allow states with incomplete transition function, i.e. such that the set of labels of their outgoing edges does not coincide with $\Sigma$. If state $s$ misses outgoing label $a$, then any computation following label $a$ from $s$ is considered as non-accepting. In a standard NFA definition, this would be equivalent to having an outgoing edge labeled $a$ to a universal non-accepting node (a sink). We call a $d$-NFA acyclic when the graph $(V,E)$ does not have cycles. We say that a $d$-NFA is input-consistent if, for every $v\in V$, all incoming edges of $v$ have the same label. If the $d$-NFA is input-consistent, we indicate with $\lambda(v)$, $v\in V$, the label of the incoming edges of $v$. For the source, we take $\lambda(s)=\#\notin\Sigma$. We will assume that characters in $\Sigma$ are totally ordered by $\prec$ and that $\#$ is minimum. We extend $\prec$ to $\Sigma^{*}$ co-lexicographically, still denoting it by $\prec$. On DFAs, we denote by $succ_{a}(u)$, with $u\in V$ and $\ a\in\Sigma$, the unique successor of $v$ by label $a$, when it exists. We define the size of an automaton to be the number of its edges. The notion of Wheeler graph generalizes in a natural way the concept of co-lexicographic sorting to labeled graphs:

Definition 2 (Wheeler Graph)

A triple $G=(V,E,\Sigma)$, where $V$ is a set of vertices and $E\subseteq V\times V\times\Sigma$ is a set of labeled edges, is called a Wheeler graph if there is a total ordering $<$ on $V$ such that vertices with in-degree [math] precede those with positive in-degree and for any two edges $(u_{1},v_{1},a_{1}),(u_{2},v_{2},a_{2})$ we have (i) $a_{1}\prec a_{2}\rightarrow v_{1}<v_{2}$, and (ii) $\left(a_{1}=a_{2}\right)\wedge\left(u_{1}<u_{2}\right)\rightarrow v_{1}\leq v_{2}$.

Note that the above definition generalizes naturally the concept of prefix-sorting from strings to graphs: two nodes (resp. string prefixes) can be ordered either looking at their incoming labels (resp. last characters) or, if the labels are equal, by looking at their predecessors (resp. previous prefixes). Considering that, differently from strings and trees, a graph’s node can have multiple predecessors, it should be clear that there could exist graphs whose nodes cannot be sorted due to conflicting predecessors: not all labeled graphs enjoy the Wheeler properties. We call a total order of nodes satisfying Definition 2 a Wheeler order of the nodes and we write WDFA,WNFA as a shortcut for Wheeler DFA, Wheeler NFA. By property (i), input-consistence is a necessary condition for a graph to be Wheeler. An important property of Wheeler graphs is path coherence:

Definition 3 (Path coherence [11])

An edge-labeled directed graph $G$ is path coherent if there is a total order of the nodes such that for any consecutive range $[i,j]$ of nodes and string $\alpha$, the nodes reachable from those in $[i,j]$ in $|\alpha|$ steps by following edges whose labels form $\alpha$ when concatenated, themselves form a consecutive range.

A Wheeler graph is path coherent with respect to any Wheeler order of the nodes [11].

2 Wheeler Languages

In this section we collect our basic results on regular languages accepted by automata whose transition relation is a Wheeler graph: Wheeler languages.

Definition 4

Let $\Sigma$ be a finite set. A language $\mathcal{L}$ is Wheeler if $\mathcal{L}=\mathcal{L}(\mathcal{A})$ for a Wheeler NFA $\mathcal{A}$.

Let us begin with some basic notation. Given a language $\mathcal{L}\subseteq\Sigma^{*}$ we denote by $\text{\em Pref}(\mathcal{L}),\text{\em Suff}(\mathcal{L}),$ and $\text{\em Fact}(\mathcal{L})$ the set of prefixes, suffixes, and factors of strings in $\mathcal{L}$, respectively. More formally: $\text{\em Pref}(\mathcal{L})=\{\alpha:\exists\beta\in\Sigma^{*}~{}\alpha\beta\in\mathcal{L}\}$, $\text{\em Suff}(\mathcal{L})=\{\beta:\exists\alpha\in\Sigma^{*}~{}\alpha\beta\in\mathcal{L}\}$, $\text{\em Fact}(\mathcal{L})=\{\alpha:\exists\beta,\gamma\in\Sigma^{*}~{}\gamma\alpha\beta\in\mathcal{L}\}$. Given two states $u,v$ of an NFA $\mathcal{A}$, we denote by $u\rightsquigarrow v$ a path from $u$ to $v$ in $\mathcal{A}$.

Definition 5

If $\mathcal{A}=(V,E,F,s,\Sigma)$ is an NFA, $u\in V$, and $\alpha\in\text{\em Pref}(\mathcal{L}(\mathcal{A}))$, we define:

$V_{\alpha}=\{v~{}|~{}\alpha\text{ labels }s\rightsquigarrow v\}$, 2. 2.

$\text{\em Pref}(\mathcal{L}(\mathcal{A}))_{u}:=\{\alpha\in\text{\em Pref}(\mathcal{L}(\mathcal{A})):\alpha\text{ labels }s\rightsquigarrow u\}$ .

Clearly, from the above definition it follows that (i) $V_{\alpha}\subseteq V$, (ii) $\text{\em Pref}(\mathcal{L}(\mathcal{A}))_{u}\subseteq\text{\em Pref}(\mathcal{L}(\mathcal{A}))$, and (iii) $u\in V_{\alpha}\text{ if and only if }\alpha\in\text{\em Pref}(\mathcal{L}(\mathcal{A}))_{u}$.

The prefix/suffix property introduced below is going to be crucial to determine the Wheeler ordering among states—when such an ordering exists.

Definition 6

Consider a linear order $(L,<)$.

An interval in $(L,<)$ is a $I\subseteq L$ such that $(\forall x,x^{\prime}\in I)(\forall y\in L)(x<y<x^{\prime}\rightarrow y\in I)$. 2. 2.

Given $I,J$ intervals in $(L,<)$ and $I\subseteq J$, then:

$I$ is a prefix of $J$ if $(\forall x\in I)(\forall y\in J\setminus I)(x<y)$;

• -

$I$ is a suffix of $J$ if $(\forall y\in J\setminus I)(\forall x\in I)(y<x)$. 3. 3.

A family $\mathcal{C}$ of non-empty intervals in $(L,<)$ is said to have the prefix/suffix property if, for all $I,J\in\mathcal{C}$ such that $I\subseteq J$, $I$ is either a prefix or a suffix of $J$.

The following lemma will allow us to bound (linearly) the blow-up of the number of states taking place when moving from a WNFA to a WDFA.

Lemma 1

Let $(L,<)$ be a finite linear order of cardinality $|L|=n$, let $\mathcal{C}$ be a prefix/suffix family of non-empty intervals in $(L,<)$. Then:

$|\mathcal{C}|\leq 2n-1$. 2. 2.

The upper bound is tight: for every $n$, there exists a prefix/suffix family of size $2n-1$.

Definition 7

Let $\mathcal{C}$ be a family of non-empty intervals of a linear order $(L,<)$ having the prefix/suffix property. Let $<^{i}$ (or simply $<$) the binary relation over $\mathcal{C}$ defined by

[TABLE]

The following lemma is easily proved.

Lemma 2

Let $\mathcal{C}$ be a family of non-empty intervals of a linear order $(L,<)$ having the prefix/suffix property, then $(\mathcal{C},<^{i})$ is a linear order.

Note that whenever the linear order $(L,<)$ is finite, any non-empty interval $I$ has minimum $m_{I}$ and maximum $M_{I}$. In this special case, the above order $<^{i}$ can be equivalently described on a family having the prefix/suffix property, by: $I<^{i}J\text{ if and only if }(m_{I}<m_{J})\lor[(m_{I}=m_{J})\wedge(M_{I}<M_{J})].$

We now have the basics to start our study of Wheeler languages. In this section, we use $V,E,F,s,\Sigma,<$ to denote the set of states, edges, final states, initial state, alphabet, and Wheeler order of a generic WNFA. The key property of path-coherence will be re-proved below—in Lemma 4—, together with what we may call a sort of its “dual”, that is, the the set of strings read while reaching a given state is an interval. More precisely, if $\mathcal{A}$ is a WNFA, $u\in V$, and $\alpha\in\Sigma^{*}$, we have that $V_{\alpha}$ is an interval in $(V,<)$ ($I_{\alpha}$, from now on), $\text{\em Pref}(\mathcal{L}(\mathcal{A}))_{u}$ is an interval in $(\text{\em Pref}(\mathcal{L}(\mathcal{A})),\prec)$ ($I_{u}$, from now on), and

[TABLE]

Preliminary to our result are the following lemmas, exploiting the interval-structure of both Wheeler languages and automata.

Lemma 3

If $\mathcal{A}$ is a WNFA, $u,v\in V$ are states, and $\alpha,\beta\in\text{Pref}(\mathcal{L}(\mathcal{A}))$, then:

if $\alpha\in I_{u},\beta\in I_{v}$, and $\{\alpha,\beta\}\not\subseteq I_{v}\cap I_{u}$, then $\alpha\prec\beta\text{ if and only if }u<v$; 2. 2.

if $u\in I_{\alpha},v\in I_{\beta}$, and $\{u,v\}\not\subseteq I_{\beta}\cap I_{\alpha}$, then $\alpha\prec\beta\text{ if and only if }u<v$.

Let $I_{V}=\{I_{u}:~{}u\in V\}$ and $I_{\text{\em Pref}(\mathcal{L}(\mathcal{A}))}=\{I_{\alpha}:~{}\alpha\in\text{\em Pref}(\mathcal{L}(\mathcal{A}))\}$.

Lemma 4

If $\mathcal{A}$ is a WNFA and $\mathcal{L}=\mathcal{L}(\mathcal{A})$, then:

for all $u\in V$, the set $I_{u}$ is an interval in $(\text{Pref}(\mathcal{L}(\mathcal{A})),\prec)$; 2. 2.

$I_{V}$* is a prefix/suffix family of intervals in $(\text{Pref}(\mathcal{L}(\mathcal{A})),\prec)$;* 3. 3.

for all $\alpha\in\text{Pref}(\mathcal{L}(\mathcal{A}))$, the set $I_{\alpha}$ is an interval in $(V,<)$; 4. 4.

$I_{\text{Pref}(\mathcal{L}(\mathcal{A}))}$* is a prefix/suffix family of intervals in $(V,<)$.*

From Lemma 2 it follows that both $(I_{v},\prec^{i})$ and $(I_{\text{\em Pref}(\mathcal{L}(\mathcal{A}))},<^{i})$ are linear orders. The link between such orders is made explicit below.

Lemma 5

Consider $I_{u},I_{v}\in I_{V}$ and $I_{\alpha},I_{\beta}\in I_{\text{Pref}(\mathcal{L}(\mathcal{A}))}$.

$I_{u}\prec^{i}I_{v}$* implies that $u<v$ and $u<v$ implies that $I_{u}\preceq^{i}I_{v}$* 2. 2.

$I_{\alpha}<^{i}I_{\beta}$* implies that $\alpha\prec\beta$ and $\alpha\prec\beta$ implies that $I_{\alpha}\leq^{i}I_{\beta}$*

If $\mathcal{A}$ is a WNFA we can prove that the following interval construction—which is the analogous of the power-set construction for NFAs—allows determinization.

Definition 8

If $\mathcal{A}$ is a WNFA we define its (Wheeler) determinization as the automaton ${\mathcal{A}^{d}}=(V^{d},E^{d},F^{d}s^{d},<^{d},\Sigma)$, where:

$V^{d}=I_{\text{ Pref}(\mathcal{L}(\mathcal{A}))}$;

• -

$s^{d}=I_{\epsilon}=\{s\}$

• -

$F^{d}=\{I_{\alpha}~{}|~{}\alpha\in\mathcal{L}(\mathcal{A})\}$;

• -

$E^{d}$ is the set of triples $(I_{\alpha},I_{\alpha e},e)$, for all $e\in\Sigma$ and $\alpha e\in\text{Pref}(\mathcal{L}(\mathcal{A}))$;

• -

$<^{d}=<^{i}$.

The bound proved in Lemma 1 can be sligthly improved in the special case of prefix/suffix families corresponding to WNFA intervals.

Lemma 6 (Determinization of a Wheeler NFA)

If $\mathcal{A}$ is a WNFA with $n$ states over an alphabet $\Sigma$, then $\mathcal{A}^{d}$ is a WDFA with at most $2n-1-|\Sigma|$ states, and $\mathcal{L}(\mathcal{A}^{d})=\mathcal{L}(\mathcal{A})$.

Lemma 7 (Computing the determinization)

If $\mathcal{A}$ is a WNFA with $n$ states, then $\mathcal{A}^{d}$ can be computed in $O(n^{3})$ time.

Lemma 6 above— saying that we can restrict the automata recognizing Wheeler Languages to deterministic ones without an exponential blow up—marks a difference between the standard and the Wheeler case for regular languages and can be seen as the first step in the study of Wheeler Languages. Further differences can be observed. For example, the reader can check that the language $\mathcal{L}(\mathcal{A})=\mathcal{L}=b^{+}a$ is accepted by incomplete WDFAs only.

The subsequent step to take in a theory of Wheeler Languages is a Myhill-Nerode like theorem for this class. To this end, we define:

Definition 9

Given a language $\mathcal{L}\subseteq\Sigma^{*}$, an equivalence relation $\sim$ over $\text{\em Pref}(\mathcal{L})$ is:

right invariant, when for all $\alpha,\beta\in\text{\em Pref}(\mathcal{L})$ and $\gamma\in\Sigma^{*}$: if $\alpha\sim\beta$ and $\alpha\gamma\in\text{\em Pref}(\mathcal{L})$, then $\beta\gamma\in\text{\em Pref}(\mathcal{L})$ and $\alpha\gamma\sim\beta\gamma$;

• -

convex if $\sim$-classes are intervals of $(\text{\em Pref}(\mathcal{L}),\prec)$;

• -

input consistent if all words belonging to the same $\sim$-class end with the same letter.

Consider a language $\mathcal{L}\subseteq\Sigma^{*}$. The Myhill-Nerode equivalence $\equiv_{\mathcal{L}}$ among words in $Pref(L)$ is defined as

[TABLE]

Definition 10

The input consistent, convex refinement of $\equiv_{\mathcal{L}}$ is defined as follows.

For all $\alpha,\beta\in\text{Pref}(\mathcal{L})$:

[TABLE]

where $end(\alpha)$ is the final character of $\alpha$ when $\alpha\neq\epsilon$, and $\epsilon$ otherwise.

Using the above results in this section we can prove:

Theorem 2.1 (Myhill-Nerode for Wheeler Languages)

Given a language $\mathcal{L}\subseteq\Sigma^{*}$, the following are equivalent:

$\mathcal{L}$* is a Wheeler language (i.e. $\mathcal{L}$ is recognized by a WNFA).* 2. 2.

$\equiv_{\mathcal{L}}^{c}$* has finite index.* 3. 3.

$\mathcal{L}$* is a union of classes of a convex, input consistent, right invariant equivalence over $\text{Pref}(\mathcal{L})$ of finite index.* 4. 4.

$\mathcal{L}$* is recognized by a WDFA.*

This theorem and other results on Wheeler Languages are going to be part of a companion paper of this one.

3 Sorting Wheeler Finite Automata

In this section we provide efficient algorithms to sort a relevant sub-class of the Wheeler automata. Combined with the results of the previous section, our algorithms can be used to index any WNFA. We start with a reduction from the problem of recognizing Wheeler $2$-NFAs to 2-SAT. The reduction introduces only a polynomial number of boolean variables and can be computed in polynomial time; since 2-SAT is in P, this implies that Wheeler $2$-NFA recognition is in P.

Theorem 3.1

Let $\mathcal{A}=(V,E,F,s,\Sigma)$ be a $2$-NFA. In $O(|E|^{2})$ time we can:

Decide whether $\mathcal{A}$ is a Wheeler graph, and 2. 2.

If $\mathcal{A}$ is a Wheeler graph, return a node ordering satisfying the Wheeler graph definition.

Proof (Sketch)

It is easy to express the Wheeler properties (i)-(ii) and antisymmetry/connex of the Wheeler order with 2-SAT clauses. Transitivity, however, requires 3-SAT clauses on general graphs. The core of the full proof in Appendix 0.D is to show that, on $2$-NFAs, transitivity automatically “propagates” from the source to all nodes and does not require additional clauses.∎

Gibney and Thankachan [13] have recently shown that the problem of recognizing Wheeler $d$-NFAs is NP-complete for $d\geq 5$. Theorem 3.1 almost completes the picture, the remaining open cases being $d=3$ and $d=4$. We note that Theorem 3.1 combined with our determinization result of Section 2 does not break the problem’s NP-completeness: in principle, our determinization algorithm could turn a non-Wheeler NFA into a WDFA.

We now describe more efficient algorithms for the deterministic case. The first, Theorem 3.2, is an online algorithm that solves the problem considered in Theorem 3.1 in $O(|E|\log|V|)$ time when the graph is an acyclic DFA. The algorithm is online in the following sense. We assume that the nodes, together with their incoming labeled edges, are provided to the algorithm in any valid topological ordering. At any step, we maintain a prefix-sorted list of the current nodes, which is updated when a new node is added. When a new node $v$ arrives together with its incoming labeled edges $(u_{1},v,a),\dots,(u_{k},v,a)$, then $u_{1},\dots,u_{k}$ have already been seen in the past node sequence and can be used to decide the co-lexicographic rank of $v$. If $v$ falsifies the Wheeler properties, we detect this event, report it, and stop the computation. Our algorithm is an extension of an existing one that builds online the Burrows-Wheeler transform of a string [26]. In Section 4 we will modify this algorithm so that, instead of failing on non-Wheeler graphs, it computes the smallest Wheeler DFA equivalent to the input acyclic DFA.

First, note that Lemma 3 implies that Wheeler DFAs admit a unique admissible ordering (this follows from the fact that, on WDFAs, $\{\alpha,\beta\}\not\subseteq I_{v}\cap I_{u}$ always holds):

Corollary 1

Let $\mathcal{A}$ be a Wheeler DFA, $<$ be the node ordering satisfying the Wheeler properties, and $\prec$ be the co-lexicographic order among strings. For any two nodes $u\neq v$, the following holds: $\alpha_{u}\prec\alpha_{v}$ for all string pairs $\alpha_{u},\alpha_{v}$ labeling paths $s\rightsquigarrow u$ and $s\rightsquigarrow v$ if and only if $u<v$.

Corollary 1 has two important consequences: on DFAs, (i) we can use any paths connecting $s$ with two nodes $u\neq v$ to decide their co-lexicographic order, and (ii) if it exists, the total ordering of the nodes is unique. The corollary is crucial in proving the following (as well as others) result:

Theorem 3.2

Let $\mathcal{A}=(V,E,F,s,\Sigma)$ be an acyclic DFA. There exists an algorithm that either prefix-sorts the nodes of $\mathcal{A}$ or returns $\mathtt{FAIL}$ if such an ordering does not exist online with $O(\log|V|)$ delay per input edge.

All details of our algorithm (description, pseudocode and data structures) and the proof of its correctness are reported in in Appendices 0.D.1 and 0.D.2.

To conclude the section, we show that in the offline setting we can improve upon the previous result. We first need the following lemma (see Appendix 0.D.3 for the full proof):

Lemma 8

Given an input-consistent edge-labeled graph $G=(V,E,\Sigma)$ and a permutation of $V$ sorted by a total order $<$ on $V$, we can check whether $<$ satisfies the Wheeler properties in optimal $O(|V|+|E|)$ time.

Theorem 3.3

Let $\mathcal{A}=(V,E,F,s,\Sigma)$ be a DFA. In $O(|V|+|E|)$ time we can:

Decide whether $\mathcal{A}$ is a Wheeler graph, and 2. 2.

If $\mathcal{A}$ is a Wheeler graph, return a node ordering satisfying the Wheeler graph definition.

Proof (Sketch)

By Corollary 1, if $\mathcal{A}$ is a Wheeler graph then we can use the strings labeling any paths $s\rightsquigarrow u$ and $s\rightsquigarrow v$ to decide the order of any two nodes $u$ and $v$. We build a spanning tree of $\mathcal{A}$ rooted in $s$ and prefix-sort it using [9, Thm 2]. Finally, we verify correctness using Lemma 8.∎

We note that the above strategy cannot be used to sort Wheeler NFAs, since the spanning tree could connect $s$ with several distinct nodes using the same labeled path: this would prevent us to find the order of those nodes using the spanning tree as support.

4 Wheeler DFA Minimization

We are now ready to use the algorithms of the previous sections to prove our main algorithmic results: (i) a minimization algorithm for WDFAs (Theorem 4.1) and (ii) a near-optimal algorithm generating the minimum acyclic WDFA equivalent to any input acyclic DFA (Theorem 4.3).

Let $\equiv$ be an equivalence relation over the states $V$ of an automaton $\mathcal{A}=(V,E,F,s,\Sigma)$. The quotient automaton is defined as $\mathcal{A}/_{\equiv}=(V/_{\equiv},E/_{\equiv},F/_{\equiv},[s]_{\equiv},\Sigma)$, where $E/_{\equiv}=\{([u]_{\equiv},[v]_{\equiv},c)\ :\ (u,v,c)\in E\}$. The symbol $\approx$ denotes the Myhill-Nerode equivalence among states [27]: $u\approx v$, with $u,v\in V$, if and only if, for any string $\alpha$, we reach a final state by following the path labeled $\alpha$ from $u$ if and only if the same holds for $v$. Note that this is the “state” version of the relation $\equiv_{\mathcal{L}}$ given in Section 2 (which instead is defined among strings). The goal of any DFA-minimization algorithm is to find $\approx$, which is the, provably existing and unique, coarsest (i.e. largest classes) equivalence relation stable with respect to the initial partition in final/non-final states. To abbreviate, we will simply say “coarsest equivalence relation” instead of “coarsest equivalence relation stable with respect to an initial partition”.

In our case, assuming that $\mathcal{A}$ is Wheeler, we want to find the (unique as proved below) coarsest equivalence relation $\equiv_{w}$ finer than $\approx$, such that $\mathcal{A}/_{\equiv_{w}}$ is Wheeler. Our Algorithm 1 achieves precisely this goal: we start with $\approx$ and then refine it preserving stability with respect to characters, while also ensuring that the resulting equivalence classes can be ordered consistently with the Wheeler constraints. Again, it can be proved that $\equiv_{w}$ is the “state” version of the relation $\equiv_{\mathcal{L}}^{c}$ given in Section 2. For the purposes of the following results, we do not need to prove the connection between the two relations and we keep a distinct notation to avoid confusion. We show (formal proof in Appendix 0.E):

Theorem 4.1

Let $\mathcal{A}$ be a WDFA. The automaton $\mathcal{A}/_{\equiv_{w}}$ returned by Algorithm 1 is the minimum WDFA recognizing $\mathcal{L}(\mathcal{A})$.

Note that uniqueness of the minimum WDFA follows from Corollary 1 (uniqueness of the Wheeler order) and Algorithm 1. Note also that, in the automaton output by Algorithm 1, adjacent states in co-lexicographic order are distinct by the relation $\approx$ unless their incoming labels are different (in which case they might be equivalent). It follows that if a sorted Wheeler DFA does not have this property, then it is not minimum (otherwise Algorithm 1 would collapse some of its states). Conversely, If a Wheeler DFA has this property, then Algorithm 1 does not collapse any state, i.e. the automaton is already of minimum size. We therefore obtain the following characterization:

Theorem 4.2 (Minimum WDFA)

Let $\mathcal{A}$ be a Wheeler DFA, let $v_{1}<v_{2}<\dots<v_{t}$ be its co-lexicographically ordered states, and let $\approx$ be the Myhill-Nerode equivalence among them. $\mathcal{A}$ is the minimum Wheeler DFA recognizing $\mathcal{L}(\mathcal{A})$ if and only if the following holds: for every $1\leq i<t$, if $v_{i}\approx v_{i+1}$ then $\lambda(v_{i})\neq\lambda(v_{i+1})$.

Theorem 4.1 implies the following corollaries.

Corollary 2

Given a WDFA $\mathcal{A}$ of size $n$, in $O(n\log n)$ time we can build the minimum WDFA recognizing $\mathcal{L}(\mathcal{A})$.

Proof

We run Algorithm 1 computing $\approx$ with Hopcroft’s algorithm [17] ($O(n\log n)$ time), and prefix-sorting $\mathcal{A}$ with Theorem 3.3 ($O(n)$ time). Note that we can check $u\approx v$ in constant time by representing the equivalence relation as a vector $EQ[v]=[v]_{\approx}$, where we choose $V=\{1,\dots,|V|\}$ and where $[v]_{\approx}$ is any representative of the equivalence class of $v$ (e.g., the smallest one, which we can identify in linear time by radix-sorting equivalent states). Then, $u\approx v$ if and only if $EQ[u]=EQ[v]$. Using this structure, the runs of Algorithm 1 can easily be identified in linear time. ∎

Corollary 3

Given an acyclic WDFA $\mathcal{A}$ of size $n$, in $O(n)$ time we can build the minimum acyclic WDFA recognizing $\mathcal{L}(\mathcal{A})$.

Proof

We run Algorithm 1 computing $\approx$ with Revuz’s algorithm [29] ($O(n)$ time), prefix-sorting $\mathcal{A}$ with Theorem 3.3 ($O(n)$ time), and testing $u\approx v$ in constant time as done in Corollary 2. ∎

Note that Corollary 3 implies that we can, in optimal linear time, build the minimum WDFA $\mathcal{A}/_{\equiv_{w}}$ recognizing any input finite language $\mathcal{L}$ represented as a set of strings: we build the tree DFA accepting $\mathcal{L}$ and apply Corollary 3. The corollary can be applied since trees are always Wheeler [9, 11]. In the next subsection we treat the (more interesting) case where $\mathcal{L}$ is represented by a DFA. Note that this result could already be achieved by unraveling the DFA into a tree and minimizing it using Corollary 3. However, the intermediate tree could be exponentially larger than the output.

4.1 Acyclic DFAs to Smallest Equivalent WDFAs

We show how to build the smallest acyclic Wheeler DFA equivalent to any acyclic DFA in output-sensitive time. Let $\mathcal{A}=(V,E,F,s,\Sigma)$ be an acyclic DFA. We first minimize $\mathcal{A}$ using Revuz’s algorithm [29] and obtain the equivalent minimum acyclic DFA $\mathcal{A}_{1}=\mathcal{A}/_{\approx}=(V_{1},E_{1},F_{1},s_{1},\Sigma)$. Let us denote $|V_{1}|=t$. The idea is to run a modified version of the online Algorithm 3 on $\mathcal{A}_{1}$. The difference is that now we will solve (not just detect) violations to the Wheeler properties without changing the accepting language. The next step is to topologically-sort $\mathcal{A}_{1}$’s states (e.g. using Kahn’s algorithm [20]). At this point, we modify $\mathcal{A}_{1}$ in $t$ steps by processing its states in topological order. This defines a sequence of automata $\mathcal{A}_{1},\mathcal{A}_{1},\dots,\mathcal{A}_{t}$. At each step, the states of $\mathcal{A}_{i}$ are partitioned in two sets:

• •

those not yet processed: $N_{i}=\{v_{i+1},v_{i+2},\dots,v_{t}\}$, and

• •

the remaining states $V_{i}-N_{i}$, sorted by a total ordering $<$ in a sequence $\mathtt{LEX}_{i}$.

At the beginning, $N_{1}=\{v_{2},\dots,v_{t}\}$ and $\mathtt{LEX}_{1}=s$. Note that $N_{t}=\emptyset$ (i.e. at the end we will have processed all states). At each step $i$, we maintain the following invariants:

$\mathcal{L}(\mathcal{A}_{i})=\mathcal{L}(\mathcal{A}_{1})$. 2. 2.

States in $\mathtt{LEX}_{i}$ are sorted by a total order $<$ that does not violate the Wheeler properties among states in $\mathtt{LEX}_{i}$ itself: in Definition 2, we require $u_{1},u_{2},v_{1},v_{2}\in\mathtt{LEX}_{i}$. 3. 3.

for each $j=1,\dots,|\mathtt{LEX}_{i}|-1$, if $\mathtt{LEX}_{i}[j]\approx\mathtt{LEX}_{i}[j+1]$ then $\lambda(\mathtt{LEX}_{i}[j])\neq\lambda(\mathtt{LEX}_{i}[j+1])$.

Invariant 1 implies $\mathcal{L}(\mathcal{A}_{t})=\mathcal{L}(\mathcal{A})$. Since $N_{t}=\emptyset$ and $\mathtt{LEX}_{t}$ contains all $\mathcal{A}_{t}$’s states, invariant 2 implies that $\mathcal{A}_{t}$ is Wheeler (note that intermediate automata $\mathcal{A}_{i}$, with $1<i<t$ might be non-Wheeler). Finally, invariant 3 and Theorem 4.2 imply that $\mathcal{A}_{t}$ is the minimum WDFA accepting $\mathcal{L}(\mathcal{A}_{t})$. As a result, $\mathcal{A}_{t}=\mathcal{A}/_{\equiv_{w}}$. We describe all the details of our algorithm in Appendix 0.E.1 for space constraints; here we give an overview of the procedure. The idea is to process states in topological order as done in Theorem 3.2. This time, however, we also solve inconsistencies of type 1 and 2 among nodes in $\mathtt{LEX}_{i}\cup\{v_{i+1}\}$ by splitting nodes in $\approx$-equivalent copies. Here, splitting means creating two or more copies of a state $v$ in such a way that (i) each copy duplicates all $v$’s outgoing edges, (ii) $v$’s incoming edges are distributed (not duplicated) among the copies, and (iii) each copy is a final state if and only if $v$ is a final state. Our splitting process creates $\approx$-equivalent nodes, therefore the accepted language never changes (invariant 1 stays true). Moreover, since the states of $\mathcal{A}$ have already been collapsed by the equivalence $\approx$, after inserting nodes (or their copies) in $\mathtt{LEX}_{i}$ we never create runs of length greater than one of $\approx$-equivalent states with equal incoming labels (invariant 3 stays true). As a result, we incrementally build the minimum WDFA $\mathcal{A}/_{\equiv_{w}}$ recognizing $\mathcal{L}(\mathcal{A})$. Since our algorithm never deletes edges, the running time is bounded by the output’s size (which could nevertheless be much larger — or smaller — than $\mathcal{A}$). In Appendix 0.E.1 we show:

Theorem 4.3

Given an acyclic DFA $\mathcal{A}$ of size $n$, we can build and prefix-sort the minimum acyclic WDFA, of size $m$, recognizing $\mathcal{L}(\mathcal{A})$ in $O(n+m\log m)$ time.

Theorem 4.3 solves the problem of indexing deterministic DAGs for linear-time pattern matching queries in nearly-optimal time with a solution of minimum size. Note that the hardness result of Equi et al. [7] implies that, under the Orthogonal Vectors hypothesis, in the worst case the minimum WDFA has size $\Omega(n^{2-\epsilon})$ for any constant $\epsilon>0$. We can do better: in Appendix 0.F we show that, in the worst case, the minimum WDFA can be of size $\Omega(2^{n/4})$.

Appendix 0.A Indexing Wheeler Automata

We show that any Wheeler NFA can be efficiently indexed in order to support fast membership queries in its accepting language or in its substring/suffix closure. Let $\mathcal{A}$ be any Wheeler NFA. We first remove all states that do not lead to a final state. This preserves the accepted language, the total ordering, and the Wheeler properties. We then use our algorithms to convert the automaton to a WDFA, prefix-sort it in polynomial time, and build a (generalized) FM-index on the graph as described in [11]. We mark in a bitvector $B[1..|V|]$ supporting constant-time rank queries [18] all accepting states of the Wheeler NFA in our array $\mathtt{LEX}$ containing the states in co-lexicographic order. To check membership of a word $w$, we search the word $\#w$ and get a range $\mathtt{LEX}[L,R]$ of all states reachable from the root by a path labeled $w$. At this point, $w$ is accepted if and only if $B[L,R]$ contains at least one bit set (constant time using rank on $B$). Note that this procedure works in $O(w\log\sigma)$ time also if the original automaton is nondeterministic (this, in general, is not possible for general NFAs). If we search for $w$ instead of $\#w$, then we get the range of states reachable by a path labeled $uw$, for any $u\in\Sigma^{*}$. This range is non-empty if and only if $w$ belongs to the substring closure of $\mathcal{L}(\mathcal{A})$. Finally, if we search a word $w$ and get a range $\mathtt{LEX}[L,R]$, then $w$ is in the suffix closure of $\mathcal{L}(\mathcal{A})$ if and only if $B[L,R]$ contains at least one bit set.

Appendix 0.B Conclusions and Future Extensions

In this paper, we have initiated the study of Wheeler languages, that is, regular languages that can be indexed via prefix-sorting techniques. On our way, we provided new results of independent interest: (i) we provided a new class of NFAs for which the minimization problem can be approximated up to multiplicative factor 2 in polynomial time and that admit fast membership and pattern matching algorithms, and (ii) we solved the problem of indexing finite languages with prefix-sortable DFAs of minimum size. Our work leaves several intriguing lines of research (some of which will be explored in future extensions of this paper). First of all, is the problem of recognizing Wheeler languages (encoded, e.g. as regular expressions) decidable? We believe that the answer to this question is positive: the Wheelerness of a regular language seems to translate into particular constraints (that can be verified in bounded time) on the topology of its minimum accepting DFA. Once a regular language has been classified as Wheeler, can we build the minimum accepting Wheeler DFA? Also in this case, we believe that the task can be solved by iterating conflict-resolution (Section 4.1) from the minimum DFA until the process converges to the minimum Wheeler DFA.

Appendix 0.C Proofs of Section 2

Proof

(of Lemma 1)

Let us order the elements of $L$ by the relation $<$, and let us denote by $L[i]$ the $i$-th element in the ordering. The notation $L[i,j]$, with $j\geq i$, denotes the interval $\{L[k]:i\leq k\leq j\}$. In particular, $L[1,n]=L$.

We say that an interval $I\in\mathcal{C}$ is maximal if $I$ is not the prefix nor the suffix of any other interval in $\mathcal{C}$. We say that an interval $I\in\mathcal{C}$ is prefix (resp. suffix) if $I$ is the proper prefix (resp. suffix) of a maximal interval of $\mathcal{C}$. Note that, by this definition, intervals of $\mathcal{C}$ are either maximal or prefix/suffix. Note also that there could be elements of $\mathcal{C}$ being both prefix and suffix intervals.

(1) We first prove that (1.i) $\mathcal{C}$ contains at most $n$ prefix intervals, then (1.ii) slightly improve this bound to $n-1$, and finally (1.iii) show that the sum between the number of maximal and suffix intervals is at most $n$. To prove (1.i), we show that every $L[j]$, $1\leq j\leq n$, can be the largest element of at most one prefix interval. In turn, this is shown by considering the prefixes of any two pairwise distinct maximal intervals of $\mathcal{C}$. Consider two distinct maximal intervals $I=L[i,j]$ and $J=L[i^{\prime},j^{\prime}]$. If $I$ and $J$ do not overlap (i.e. $j<i^{\prime}$ or $j^{\prime}<i$), then the property is trivially true: if $I^{\prime}$ and $J^{\prime}$ are prefixes of $I$ and $J$, respectively, then $\max(I^{\prime})\neq\max(J^{\prime})$. Consider now the case where $I$ and $J$ overlap. Without loss of generality, we can assume $i<i^{\prime}\leq j<j^{\prime}$ (the strict inequalities follow from the fact that, by maximality, it cannot be $i=i^{\prime}$ or $j=j^{\prime}$). Assume, for contradiction, that $\mathcal{C}$ contains two intervals $L[i,j^{\prime\prime}]$ and $L[i^{\prime},j^{\prime\prime}]$ such that $i^{\prime}\leq j^{\prime\prime}<j$, i.e. $L[i,j^{\prime\prime}]$ and $L[i^{\prime},j^{\prime\prime}]$ are (proper) prefixes of $I$ and $J$, respectively, that share their largest element $j^{\prime\prime}$. Then, we have $i<i^{\prime}\leq j^{\prime\prime}<j$: interval $L[i^{\prime},j^{\prime\prime}]$ is strictly contained inside $L[i,j]\in\mathcal{C}$ (i.e. $L[i^{\prime},j^{\prime\prime}]\subset L[i,j]$) and it is not a prefix nor a suffix of it. This is forbidden by the definition of prefix/suffix family. From this contradiction we deduce that any two distinct prefix intervals $I^{\prime},J^{\prime}\in\mathcal{C}$ satisfy $\max(I^{\prime})\neq\max(J^{\prime})$, which implies that $\mathcal{C}$ contains at most $n$ prefix intervals.

To improve the above bound to $n-1$ and prove (1.ii), consider the rightmost maximal interval $I=L[i,j]$, i.e. the one having largest $j$. We show that $j$ cannot be the maximum element of any prefix interval. Assume, for contradiction, that such a prefix interval $K=L[i^{\prime},j]$ exists. Then, the corresponding maximal interval $J=L[i^{\prime},j^{\prime}]$ of which $K$ is a proper prefix satisfies $j^{\prime}>j$. This contradicts the fact that $I$ is the rightmost maximal interval.

The next step is to prove (1.iii), i.e. that the sum between the number of maximal and suffix intervals is at most $n$. We proceed by induction on the number $M$ of maximal intervals. If $M=1$, then the unique maximal interval $I=L[i,j]$ contains at most $j-i$ suffix intervals. In total, $\mathcal{C}$ contains at most $1+(j-i)\leq n$ maximal and suffix intervals. For $M>1$, consider the maximal interval $I=L[i,j]$ with minimum $j$ (call it the “leftmost”). Now, consider the immediate maximal “successor” $J=L[i^{\prime},j^{\prime}]$ of $I$, i.e. the maximal interval with the smallest endpoint $j^{\prime}\geq j$. Clearly, such $j^{\prime}$ satisfies $j^{\prime}>j$, otherwise $J$ would be a suffix of $I$ (contradicting maximality of $J$). Note that it must also be the case that $i^{\prime}>i$: if $i=i^{\prime}$, then $I$ would be a prefix of $J$ (contradicting maximality of $I$); on the other hand, if $i^{\prime}<i$ then $I$ would be strictly contained in $J$, contradicting the definition of prefix/suffix family. We are left with two cases:

(a) $i\leq j<i^{\prime}\leq j^{\prime}$. In this case, $I$ and $J$ are disjoint. As seen above, $I$ contributes to at most one maximal interval ($I$ itself) and $j-i$ suffix intervals. In total, $I$ contributes to at most $j-i+1$ maximal and suffix intervals. We are left to count the number of maximal and suffix intervals in the remaining portion of the linear order $L[i^{\prime},...,n]$. Note that there are no other intervals to be considered: if $L[i^{\prime\prime},j^{\prime\prime}]$ is a maximal interval in $\mathcal{C}$, different from $I,J$, then $j^{\prime\prime}>j^{\prime}$ and hence $i^{\prime\prime}>i^{\prime}$ or $L[i^{\prime\prime},j^{\prime\prime}]$ would contain $J$. The portion $L[i^{\prime},...,n]$ contains $M-1$ maximal intervals, so we can apply the inductive hypothesis and obtain that this segment contains at most $n-i^{\prime}+1$ maximal and suffix intervals. In total, we have that $L[1,...,n]$ contains at most $(j-i+1)+(n-i^{\prime}+1)$ maximal and suffix intervals. Since $i^{\prime}>j$ and $i\geq 1$, this quantity is at most $n$.

(b) $i<i^{\prime}\leq j<j^{\prime}$. Denote by $k=i^{\prime}-i$ the number of $L$’s elements belonging to $I\setminus J$. Then, $\mathcal{C}$ can contain at most $k$ proper suffixes of $I$: $L[i+1,j]$, $L[i+2,j]$, …, $L[i^{\prime},j]$. All other suffixes of $I$ are strictly contained inside $J$, and cannot belong to $\mathcal{C}$ due to the prefix/suffix property. Actually, one of those suffixes, $L[i^{\prime},j]$, is a prefix of $J$ so it has already been counted above in points (1.i) and (1.ii). We are left with $k-1$ suffixes to take into account, plus the maximal interval $I$ itself: in total, $k=i^{\prime}-i$ maximal and suffix intervals. As noted above, all remaining maximal and suffix intervals of $\mathcal{C}$ to take into account are those contained in $L[i^{\prime},n]$. Since $L[i^{\prime},n]$ contains $M-1$ maximal intervals, we can apply the inductive hypothesis and deduce that it contains at most $n-i^{\prime}+1$ maximal and suffix intervals. In total, $L[1,n]$ contains therefore at most $(i^{\prime}-i)+(n-i^{\prime}+1)\leq n$ maximal and suffix intervals. This concludes the proof of the upper bound $|\mathcal{C}|\leq 2n-1$.

(2) Consider the prefix/suffix family containing just one maximal interval and all its proper prefixes and suffixes: $\mathcal{C}=\{L[1,n],L[1,1],\dots,L[1,n-1],L[2,n],\dots,L[n,n]\}$. This family satisfies $|\mathcal{C}|=2n-1$. ∎

Proof

(of Lemma 2) We just prove transitivity when $I<^{i}J$ and $J<^{i}K$ are witnessed by $x_{0}\in I$ satisfying $(\forall y\in J)(x_{0}<y)$, and $z_{0}\in K$ satisfying $(\forall y\in J)(y<z_{0})$, respectively (the other cases are similar). We claim that $z_{0}>x$, for all $x\in I$. Suppose, for contradiction, that there exists $x_{1}\in I$ with $z_{0}\leq x_{1}$; then, from $x_{0}<y<z_{0}\leq x_{1}$ for all $y\in J$ and the fact that $I$ is an interval, it follows that $z_{0}\in I$, $J\subseteq I$, so that, by prefix/suffix property of $\mathcal{C}$, $J$ is either a prefix or a suffix of $I$. Since $x_{0}<y$ for all $y\in J$, we see that $J$ must be a suffix of $I$ and this, knowing that $z_{0}\in I$, implies $z_{0}\in J$. A contradiction.

In the following proofs, we always refer to a WNFA $\mathcal{A}=(V,E,F,s,\Sigma,<)$.

Proof

(of Lemma 3)

1. (1)

Suppose $\alpha\in I_{u},\beta\in I_{v}$ and $\{\alpha,\beta\}\not\subseteq I_{v}\cap I_{u}$. From this we have that $\alpha\in I_{u}\setminus I_{v}$ or $\beta\in I_{v}\setminus I_{u}$, hence $u\neq v$ and $\alpha\neq\beta$ follows.

If $u=s$ or $v=s$, either $\alpha$ or $\beta$ is the empty string $\epsilon$ and the result follows easily. Hence, we suppose $u\neq s\neq v$ and (hence) $\alpha\neq\epsilon\neq\beta$.

To see the left-to-right implication, assume $\alpha\prec\beta$: we prove that $u<v$ by induction on the maximum betwewn $|\alpha|$ and $|\beta|$. If $|\alpha|=|\beta|=1$, then the property follows from the Wheeler-(i). If $\max(|\alpha|,|\beta|)>1$ and $\alpha$ and $\beta$ end with different letters, then again the property follows from Wheeler-(i). Hence, we are just left with the case in which $\alpha=\alpha^{\prime}e$ and $\beta=\beta^{\prime}e$, with $e\in\Sigma$. If $\alpha\prec\beta$, then $\alpha^{\prime}\prec\beta^{\prime}$. Consider states $u^{\prime},v^{\prime}$ such that $\alpha^{\prime}\in I_{u^{\prime}},\beta^{\prime}\in I_{v^{\prime}}$, and $(u^{\prime},u,e),(v^{\prime},v,e)\in E$. Then $\alpha^{\prime}\in I_{u^{\prime}}\setminus I_{v^{\prime}}$ or $\beta^{\prime}\in I_{v^{\prime}}\setminus I_{u^{\prime}}$ because otherwise we would have $\alpha^{\prime}\in I_{v^{\prime}}$ and $\beta^{\prime}\in I_{u^{\prime}}$ which imply respectively $\alpha\in I_{v}$ and $\beta\in I_{u}$. By induction we have $u^{\prime}<v^{\prime}$ and therefore, by Wheeler-(ii), $u\leq v$. From $u\neq v$ it follows $u<v$.

Conversely, for the right-to-left implication, suppose $u<v$. Since $\alpha\neq\beta$, if it were $\beta\prec\alpha$ then, by the above, we would have $v<u$: a contradiction. Hence, $\alpha\prec\beta$ holds. 2. (2)

Recall that, by definition, $\alpha\in I_{u}\text{ if and only if }u\in I_{\alpha}$ and $\beta\in I_{v}\text{ if and only if }v\in I_{\beta}$. Hence, the hypothesis that $u\in I_{\alpha},v\in I_{\beta}$ and $\{u,v\}\not\subseteq I_{\beta}\cap I_{\alpha}$, is equivalent to say that $\alpha\in I_{u},\beta\in I_{v}$ and $\{\alpha,\beta\}\not\subseteq I_{v}\cap I_{u}$. Therefore, (2) follows from (1).

Proof

(of Lemma 4)

Suppose $\alpha\prec\beta\prec\gamma$ with $\alpha,\gamma\in I_{u}$ and $\beta\in\text{\em Pref}(\mathcal{L}(\mathcal{A}))$; we want to prove that $\beta\in I_{u}$. From $\beta\in\text{\em Pref}(\mathcal{L}(\mathcal{A}))$ it follows that there exists a state $v$ such that $\beta\in I_{v}$. Suppose, for contradiction, that $\beta\not\in I_{u}$. Then $\beta\in I_{v}\setminus I_{u}$ and from $\alpha\prec\beta$ and Lemma 3, it follows $u<v$. Similarly, applying again Lemma 3, from $\beta\prec\gamma$ we have $v<u$, which is a contradiction. 2. 2.

Suppose, for contradiction, that $I_{u},I_{v}\in I_{V}$ are such that $I_{u}\subsetneq I_{v}$ and $I_{u}$ is neither a prefix nor a suffix of $I_{v}$. In these hypotheses there must exist $\alpha,\alpha^{\prime}\in I_{v}\setminus I_{u}$ and $\beta\in I_{u}$ such that $\alpha\prec\beta\prec\alpha^{\prime}$. Lemma 3 implies $v<u<v$, which is a contradiction.

Points $(3),(4)$ follow similarly from Lemma 3.

Proof

(of Lemma 6)

The verification that $\mathcal{L}(\mathcal{A}^{d})=\mathcal{L}(\mathcal{A})$ follows the same lines of the proof in the classical regular case. We prove that $<^{d}$ is a Wheeler order on the states of the automaton $\mathcal{A}^{d}$. By Lemma 4, the set $V^{d}=I_{\text{\em Pref}(\mathcal{L}(\mathcal{A}))}$ of states of $\mathcal{A}^{d}$ is a prefix/suffix family of intervals, so that, by Lemma 2, $<^{d}$ is a linear order on $V^{d}$. Next, we check the Wheeler properties. The only vertex with in-degree [math] is $I_{\epsilon}$, and it clearly precedes those with positive in-degree. For any two edges $(I_{\alpha},I_{\alpha a_{1}},a_{1})$, $(I_{\beta},I_{\beta a_{2}},a_{2})$ we have:

• (i)

if $a_{1}\prec a_{2}$ then $\alpha a_{1}\prec\beta a_{2}$, and from Lemma 5 it follows $I_{\alpha a_{1}}\leq^{d}I_{\beta a_{2}}$. Moreover, by the input consistency of $\mathcal{A}$, states in $I_{\alpha a_{1}}$ are $a_{1}$-states, while states in $I_{\beta a_{2}}$ are $a_{2}$-states; hence $I_{\alpha a_{1}}\neq I_{\beta a_{2}}$, so that $I_{\alpha a_{1}}<^{d}I_{\beta a_{2}}$ follows.

• (ii)

If $a=a_{1}=a_{2}$ and $I_{\alpha}<I_{\beta}$, from Lemma 5 it follows $\alpha\prec\beta$, so that $\alpha a\prec\beta a$ and, using again Lemma 5, we obtain $I=I_{\alpha a}\leq^{i}I=I_{\beta a}$.

Finally, we prove that $|V^{d}|\leq 2n-1-|\Sigma|$. By the Wheeler properties, we know that the only interval in $I_{\text{\em Pref}(\mathcal{L}(\mathcal{A}))}$ containing the initial state $s$ of the automaton $\mathcal{A}$ is $\{s\}$ and that the remaining intervals can be partitioned into $|\Sigma|$-classes, by looking at the letter labelling incoming edges. If $\Sigma=\{a_{1},\ldots,a_{k}\}$, and, for every $i=1,\ldots,k$, we denote by $m_{i}$ the number of states of the automaton $\mathcal{A}$ whose incoming edges are labeled $a_{i}$, we have $\sum_{i=1}^{k}m_{i}=n-1$. Using Lemma 1 we see that the intervals in $V^{d}$ composed by $a_{i}$ states are at most $2m_{i}-1$, so that the total number of intervals in $V^{d}$ is at most

[TABLE]

Proof (of Lemma 7)

We apply the standard powerset construction algorithm starting from the original WNFA $\mathcal{A}$. By Lemma 6, the powerset algorithm does not generate more than $2n-1-|\Sigma|$ distinct sets of states. Remember that such algorithm starts from the set $\{s\}$ containing the NFA’s source and simulates a visit of the final DFA, whose states are represented as sets of states of the original NFA. At each step, the successor with label $a\in\Sigma$ of a set $K$ is computed by calculating all the $a$-successors of states in $K$, and taking their union. In the worst case, $|K|=O(n)$ and each state in $K$ has $O(n)$ $a$-successors. After having obtained the $a$-successor $K^{\prime}$ of $K$, we need to check if $K^{\prime}$ had already been visited. Since $K^{\prime}$’s cardinality is at most $n$, this operation takes $O(n)$ time using a standard dictionary (e.g. a hash table). Overall, we spend $O(n^{2})$ time to simulate an edge traversal of the final DFA. By Lemma 6, we visit at most $O(n)$ distinct sets of states. Overall, the powerset algorithm’s complexity is $O(n^{3})$. ∎

Proof

(of Theorem 2.1)

• (1) $\Rightarrow$ (2) If $\mathcal{A}$ is a Wheeler NFA such that $\mathcal{L}=\mathcal{L}(\mathcal{A})$, consider the following equivalence relation $\sim_{\mathcal{A}}$ over $\text{\em Pref}(\mathcal{L})$:

[TABLE]

Using the fact that the $I_{\alpha}$ are intervals (see Lemma 4), and other properties of Wheeler automata, one can easily prove that the equivalence $\sim_{\mathcal{A}}$ is a refinement of $\equiv_{\mathcal{L}}^{c}$, so that each $\equiv_{\mathcal{L}}^{c}$-class is a union of $\sim_{\mathcal{A}}$-classes. Moreover, the equivalence $\sim_{\mathcal{A}}$ has finite index, bounded by the number of intervals $I_{\alpha}$, hence $\equiv_{\mathcal{L}}^{c}$ has finite index as well.

• (2) $\Rightarrow$ (3) We prove that the relation $\equiv_{\mathcal{L}}^{c}$ is a convex, input consistent, right invariant equivalence, and that $\mathcal{L}$ is a union of $\equiv_{\mathcal{L}}^{c}$-classes; this last property is true simply because $\mathcal{L}$ is a union of $\equiv_{\mathcal{L}}$-classes and $\equiv_{\mathcal{L}}^{c}$ is a refinement of $\equiv_{\mathcal{L}}$. The fact that $\equiv_{\mathcal{L}}^{c}$ is convex and input consistent follows directly from its definition. We prove that $\equiv_{\mathcal{L}}^{c}$ is right invariant. Suppose $\alpha,\alpha^{\prime},\gamma\in\text{\em Pref}(\mathcal{L})$ and $\alpha\equiv_{\mathcal{L}}^{c}\alpha^{\prime}$. Note that if $\alpha\gamma\in\text{\em Pref}(\mathcal{L})$ then there exists $\nu\in\Sigma^{*}$ such that $\alpha\gamma\nu\in\mathcal{L}$, so that $\alpha^{\prime}\gamma\in\text{\em Pref}(\mathcal{L})$ follows from $\alpha\equiv_{\mathcal{L}}\alpha^{\prime}$. Hence, we are left to prove that $\alpha\gamma\equiv_{\mathcal{L}}^{c}\alpha^{\prime}\gamma$. We easily prove the following:

$\alpha\gamma\equiv_{\mathcal{L}}\alpha^{\prime}\gamma$ (it follows from $\alpha\equiv_{\mathcal{L}}\alpha^{\prime}$).

• -

If $\alpha\gamma\prec\beta^{\prime}\prec\alpha^{\prime}\gamma$, for $\beta^{\prime}\in\text{\em Pref}(\mathcal{L})$, then $\beta^{\prime}\equiv_{\mathcal{L}}\alpha\gamma$: from $\alpha\gamma\prec\beta^{\prime}\prec\alpha^{\prime}\gamma$ it follows that $\beta^{\prime}=\beta\gamma$, for some $\beta\in\text{\em Pref}(\mathcal{L})$, and $\alpha\prec\beta\prec\alpha^{\prime}$. Since $\alpha,\alpha^{\prime}$ belong to the same $\equiv_{\mathcal{L}}^{c}$ class, then $\beta\equiv_{\mathcal{L}}\alpha$, and $\beta\gamma\equiv_{\mathcal{L}}\alpha\gamma$ follows from the right invariance of $\equiv_{\mathcal{L}}$.

Since $\alpha\gamma,\beta\gamma$ end with the same letter, the previous points imply that $\alpha\gamma\equiv_{\mathcal{L}}^{c}\alpha^{\prime}\gamma$ and $\equiv_{\mathcal{L}}^{c}$ is right invariant.

• (3) $\Rightarrow$ (4) Suppose $\mathcal{L}$ is a union of classes of a convex, input consistent, right invariant equivalence relation $\sim$ of finite index. We build a WDFA ${\mathcal{A}}_{\sim}=(V_{\sim},E_{\sim},F_{\sim},s_{\sim},\Sigma,<_{\sim})$ such that $\mathcal{L}=\mathcal{L}(\mathcal{A})$ as follows:

$V_{\sim}=\{[\alpha]_{\sim}~{}|~{}\alpha\in\text{\em Pref}(\mathcal{L})\}$;

• -

$s_{\sim}=[\epsilon]_{\sim}$ (note that, by input consistency, $[\epsilon]_{\sim}=\{\epsilon\}$);

• -

$(I,J,e)\in E_{\sim}$ if and only if $Ie\cap\text{\em Pref}(\mathcal{L})\neq\emptyset$ and $Ie\subseteq J$, where $Ie=\{\alpha e~{}|~{}\alpha\in I\}$ (note that $J$, if existing, is unique by right invariancy);

• -

$F_{\sim}=\{I~{}|~{}I\subseteq\mathcal{L}\}$;

• -

$<_{\sim}=\prec^{i}$ (being pairwise disjoint and convex, the classes in $V_{\sim}$ form a prefix/suffix family of intervals of $(\text{\em Pref}(\mathcal{L}),\prec)$).

Note that all words in $\text{\em Pref}(\mathcal{L})$ label a computation in ${\mathcal{A}}_{\sim}$. We claim that, for all $\sim$-class $I$ and $\alpha\in\text{\em Pref}(\mathcal{L})$:

[TABLE]

We prove the implication from right to left by induction on the length of $\alpha\in\text{\em Pref}(\mathcal{L})$.

If $\alpha=\epsilon$ then the claim follows from the definition of $s_{\sim}$.

If $\alpha=\alpha^{\prime}e\in\text{\em Pref}(\mathcal{L})$ with $e\in\Sigma$, then $\alpha^{\prime}\in\text{\em Pref}(\mathcal{L})$. Then, if $K\in V_{\sim}$ is such that $s_{\sim}\rightsquigarrow K$ reading $\alpha^{\prime}$ in $\mathcal{A}_{\sim}$, by induction we know that $\alpha^{\prime}\in K$. Since $\alpha=\alpha^{\prime}e\in Ke$, we have $Ke\cap\text{\em Pref}(\mathcal{L})\neq\emptyset$; by right invariance of $\sim$ there exists a unique $J$ such that $Ke\subseteq J$. From $\alpha=\alpha^{\prime}e\in Ke\subseteq J$ it follows $\alpha\in J$, and also $J=I$, because ${\mathcal{A}}_{\sim}$ is a deterministic automaton and $s_{\sim}\rightsquigarrow I$, $s_{\sim}\rightsquigarrow J$, both by reading $\alpha$.

In order to prove the implication from left to right of the claim, suppose $\alpha\in I$, and $J\in V_{\sim}$ is such that $s_{\sim}\rightsquigarrow J\text{ in }\mathcal{A}_{\sim}$ reading $\alpha$. Then, by the first part of the proof of the claim we obtain $\alpha\in J$; since $J$ and $I$ are equivalence classes and $\alpha\in I\cap J$, it follows that $I=J$ and $s_{\sim}\rightsquigarrow I\text{ in }\mathcal{A}_{\sim}$ reading $\alpha$.

From the above claim and the definition of $F_{\sim}$, it easily follows that $\mathcal{L}$ is the language recognised by ${\mathcal{A}}_{\sim}$.

We conclude by checking that ${\mathcal{A}}_{\sim}$ is Wheeler, proving the two Wheeler properties (i) and (ii) with respect to the linear order $(V_{\sim},<_{\sim})$.

To see Wheeler-(i) assume $e\prec e^{\prime}$ with $e,e^{\prime}\in\Sigma$. Consider $I,J\in V_{\sim}$ such that $(I,H,e)\in E_{\sim}$ and $(J,K,e^{\prime})\in E_{\sim}$. We want to prove that $H<_{\sim}K$ (i.e. $H\prec^{i}K$). By definition of $E_{\sim}$, in our hypotheses there are $\alpha\in I$, $\alpha^{\prime}\in J$ with $\alpha e\in H$ and $\alpha^{\prime}e^{\prime}\in K$. From $e\prec e^{\prime}$ it follows $\alpha e\prec\alpha^{\prime}e^{\prime}$ and hence $H\preceq^{i}K$. To conclude observe that $H\prec^{i}K$ since all words in $H$ end with $e$, while all words in $K$ end with $e^{\prime}$.

To see Wheeler-(ii) assume $I<_{\sim}J$ (i.e. $I\prec^{i}J$), $e\in\Sigma$, $(I,H,e)\in E_{\sim}$, and $(J,K,e)\in E_{\sim}$. In these hypotheses there are $\alpha\in I$, $\alpha^{\prime}\in J$, with $\alpha e\in H$ and $\alpha^{\prime}e\in K$. From $I\prec^{i}J$ and the fact that different classes are disjoint it follows $\alpha\prec\alpha^{\prime}$; therefore, $\alpha e\prec\alpha^{\prime}e$ and hence $H\preceq^{i}K$.

This ends the proof of the implication $(3)\Rightarrow(4)$.

• (4) $\Rightarrow$ (1) Trivial.

Appendix 0.D Proofs of Section 3

Proof

(of Theorem 3.1)

We can assume, without loss of generality, that $\mathcal{A}$ is input-consistent, since checking this property takes linear time. If $\mathcal{A}$ is not input-consistent, then it is not Wheeler. We show a reduction of problem 1 to 2-SAT, which can be solved in linear time using Aspvall, Plass, and Tarjan’s (APT) algorithm based on strongly connected components computation. The reduction introduces $O(|V|^{2})$ variables and $O(|E|^{2})$ clauses, hence the final running time will be $O(|E|^{2})$. Moreover, since a satisfying assignment to our boolean variables will be sufficient to define a total order of the nodes, APT will essentially solve also problem 2.

For every pair $u\neq v$ of nodes we introduce a variable $x_{u<v}$ which, if true, indicates that $u$ must precede $v$ in the ordering. We now describe a 2-SAT CNF formula whose clauses are divided in two types: clauses of the former type ensure that the Wheeler graph property is satisfied, while clauses of the second type ensure that the order of nodes induced by the variables is total.

The following formulas ensure that the Wheeler properties are satisfied:

• (a)

For each $u,v$, if $\lambda(u)\prec\lambda(v)$ then we add the unary clause $x_{u<v}$.

• (b)

For each $u\neq v$, if $\lambda(u)=\lambda(v)=a$, then for every pair $u^{\prime}\neq v^{\prime}$ such that $(u^{\prime},u,a)\in E$ and $(v^{\prime},v,a)\in E$ we add the clause $x_{u^{\prime}<v^{\prime}}\rightarrow x_{u<v}$.

There are at most $|V|^{2}\leq|E|^{2}$ clauses of type (a) and at most $|E|^{2}$ clauses of type (b).

The following formulas guarantee that the order is total. Note that we omit transitivity which, on a general graph, would require a 3-literals clause $(x_{u<v}\wedge x_{v<w})\rightarrow x_{u<w}$ for each triple $u,v,w$. We will show that, if the graph is an input-consistent $2$-NFA, then transitivity is satisfied “for free”.

• (1)

Antisymmetry. For every pair $u\neq v$, add the clause $x_{u<v}\rightarrow\neg x_{v<u}$.

• (2)

Completeness. For every pair $u\neq v$, add the clause $x_{u<v}\ \vee\ x_{v<u}$.

There are at most $O(|V|^{2})=O(|E|^{2})$ clauses of types (1) and (2).

We now show that on input-consistent $2$-NFAs transitivity propagates from the source to all nodes. Consider a variable assignment that satisfies clauses (a),(b),(1), and (2) (if $\mathcal{A}$ is a Wheeler $2$-NFA, then such an assignment exists by definition). Assume, moreover, that $x_{u<v}$ and $x_{v<w}$ are set true by the assignment, for three pairwise distinct nodes $u,v,w$. We want to show that also $x_{u<w}$ must be true.

Consider a directed shortest-path tree $\mathcal{T}$ with root $s$ of $\mathcal{A}$. Since we assume that each state is reachable from $s$, $\mathcal{T}$ must exist and must contain all nodes of $\mathcal{A}$. Let $d_{v}$ be the length of a shortest directed path connecting $s$ to $v$. By definition of $\mathcal{T}$, the path connecting $s$ to $v$ in $\mathcal{T}$ has length $d_{v}$, with $d_{s}=0$. We proceed by induction on $k=\max\{d_{u},d_{v},d_{w}\}$. The case $k=0$ is trivial, since there are no triples of pairwise distinct nodes in $\{u\ :\ d_{u}\leq 0\}$ (this set contains just $s$). Take now a general $k>0$. We consider two main cases:

(i) $|\{\lambda(u),\lambda(v),\lambda(w)\}|>1$. Then, since $x_{u<v}$ and $x_{v<w}$, for some $a<b<c\in\Sigma$ either: (i.1) $\lambda(u)=a,\ \lambda(v)=b,\ \lambda(w)=c$, or (i.2) $\lambda(u)=a,\ \lambda(v)=a,\ \lambda(w)=b$, or (i.3) $\lambda(u)=a,\ \lambda(v)=b,\ \lambda(w)=b$. Any other choice would force one of the variables $x_{v<u},x_{w<v}$ to be true (by an (a)-clause), forcing a contradiction by a (1)-clause. In all cases (i.1)-(i.3) we have that $\lambda(u)<\lambda(w)$, therefore $x_{u<w}$ must be true by (a).

(ii) $\lambda(u)=\lambda(v)=\lambda(w)=a$ for some $a\in\Sigma$ (note that $a\neq\#$ since the NFA has only one source and $u,v,w$ are distinct by assumption). Let $u^{\prime},v^{\prime},w^{\prime}$ be the parents of $u,v,w$, respectively, in $\mathcal{T}$. Note that $u^{\prime},v^{\prime},w^{\prime}$ cannot be the same vertex, since $u,v,w$ are distinct and every node has at most two outgoing edges with the same label. We therefore consider two sub-cases.

(ii.1) $|\{u^{\prime},v^{\prime},w^{\prime}\}|=2$. We first show that $u^{\prime}=w^{\prime}\neq v^{\prime}$ generates a contradiction. Since $x_{u<v}$ and $x_{v<w}$ are true and $u^{\prime}\neq v^{\prime}$ and $v^{\prime}\neq w^{\prime}$ hold, $x_{u^{\prime}<v^{\prime}}$ and $x_{v^{\prime}<w^{\prime}}$ must be true: otherwise, by (b), would imply that $x_{v<u}$ and $x_{w<v}$ are true, which generates a contradiction. Now, $u^{\prime}=w^{\prime}$ means that $x_{v^{\prime}<w^{\prime}}$ and $x_{v^{\prime}<u^{\prime}}$ have the same truth value; since $x_{u^{\prime}<v^{\prime}}$ and $x_{v^{\prime}<u^{\prime}}$ cannot be both true, we have a contradiction. We are therefore left with the case $u^{\prime}=v^{\prime}\neq w^{\prime}$ ($u^{\prime}\neq v^{\prime}=w^{\prime}$ is symmetric). Remember that we assumed $x_{u<v}$ and $x_{v<w}$ are true. Hence, $x_{v^{\prime}<w^{\prime}}$ must be true: otherwise, by (b), the truth of $x_{w^{\prime}<v^{\prime}}$ would imply that $x_{w<v}$ is true, which generates a contradiction. Since $x_{v^{\prime}<w^{\prime}}=x_{u^{\prime}<w^{\prime}}$ is true, by (b) we conclude that also $x_{u<w}$ must be true.

(ii.2) $u^{\prime},v^{\prime},w^{\prime}$ are pairwise distinct. We show that $x_{u^{\prime}<v^{\prime}}$ and $x_{v^{\prime}<w^{\prime}}$ must be true. Suppose, for contradiction, that $x_{u^{\prime}<v^{\prime}}$ is false (the proof is symmetric for $x_{v^{\prime}<w^{\prime}}$). Then, by (2), $x_{v^{\prime}<u^{\prime}}$ is true. But then, by (b) it must be the case that $x_{v<u}$ is true. Since we are assuming that $x_{u<v}$ is true, this introduces a contradiction by (1). Therefore, we conclude that $x_{u^{\prime}<v^{\prime}}$ and $x_{v^{\prime}<w^{\prime}}$ are true for the (pairwise distinct) parents $u^{\prime},v^{\prime},w^{\prime}$ of $u,v,w$ in $\mathcal{T}$. Now, by definition of the shortest-path tree $\mathcal{T}$ it must be the case that $d_{u^{\prime}}=d_{u}-1$, $d_{v^{\prime}}=d_{v}-1$, and $d_{w^{\prime}}=d_{w}-1$ as $u^{\prime},v^{\prime},w^{\prime}$ are the parents of $u,v,w$ in $\mathcal{T}$. As a consequence, $\max\{d_{u^{\prime}},d_{v^{\prime}},d_{w^{\prime}}\}=k-1$. We can therefore apply the inductive hypothesis and conclude that $x_{u^{\prime}<w^{\prime}}$ is true. But then, by (b) we conclude that $x_{u<w}$ must also be true.

From the above proof correctness follows: if $\mathcal{A}$ is an input-consistent $2$-NFA and there exists a truth assignment satisfying the formula, then the assignment induces a total ordering of the nodes satisfying the Wheeler properties. Conversely, the algorithm is clearly complete: if $\mathcal{A}$ is a Wheeler $2$-NFA, then there exists a total ordering of the nodes satisfying the Wheeler properties. This defines a truth assignment of the variables that satisfies our 2-SAT formula. ∎

We note that it is tempting to try to generalize the above solution to general NFAs by simulating arbitrary degree-$d$ nondeterminism using binary trees: a node with $d$ equally-labeled outgoing edges could be expanded to a binary tree with $d$ leaves (bringing down the degree of nondeterminism to $2$). Unfortunately, while this solution works for transitivity (which is successfully propagated from the source), it could make the graph non-Wheeler: the topology of those trees cannot be arbitrary and must satisfy the co-lexicographic ordering of the nodes, i.e. the solution we are trying to compute.

0.D.1 Sorting WDFAs Online

Algorithm 2 initializes all variables used by our procedure and implements Kahn’s topological-sorting algorithm [20]. Every time a new node is appended to the topological ordering, we call Algorithm 3—our actual online algorithm—to update also the co-lexicographic ordering. This step also checks if the new node and its incoming edges falsify the Wheeler properties. We use the following structures (indices start from 1):

• •

$\mathtt{LEX}$ is a dynamic sequence of distinct nodes $v_{1},\dots,v_{k}\in V$ supporting the following operations:

$\mathtt{LEX[i]}$ returns $v_{i}$. 2. 2.

$\mathtt{LEX^{-1}[v]}$, with $v\in\mathtt{LEX}$, returns the index $i$ such that $\mathtt{LEX}[i]=v$. 3. 3.

$\mathtt{LEX.insert(v,i)}$ inserts node $v$ between $\mathtt{LEX[i-1]}$ and $\mathtt{LEX[i]}$. If $i=1$, $v$ is inserted at the beginning of the sequence. This operation increases the sequence’s length by one.

• •

$\mathtt{IN}$ and $\mathtt{OUT}$ are dynamic sequences of strings, i.e. sequences $\alpha_{1},\dots,\alpha_{k}$, where $\alpha_{i}\in\Sigma^{*}$ (note that $\alpha_{i}$ could be the empty string $\epsilon$). To make our pseudocode more readable, we index $\mathtt{IN}$ and $\mathtt{OUT}$ by nodes of $\mathtt{LEX}$ (these three arrays will be synchronized). Let $\mathtt{T}=\alpha_{1},\alpha_{2},\dots,\alpha_{k}$, with $\mathtt{T\in\{IN,OUT\}}$. Both arrays support the following operation:

$\mathtt{T.insert(\alpha,v)}$, where $\alpha\in\Sigma^{*}$ and $v\in\mathtt{LEX}$: insert $\alpha$ between $\alpha_{\mathtt{LEX}^{-1}[v]-1}$ and $\alpha_{\mathtt{LEX}^{-1}[v]}$. If $\mathtt{LEX^{-1}[v]}=1$, then $\alpha$ is inserted at the beginning of $\mathtt{T}$. This operation increases the sequence’s length by one.

Sequence $\mathtt{OUT}$ supports these additional operations:

$\mathtt{OUT}[v]$, with $v\in\mathtt{LEX}$, returns $\alpha_{\mathtt{LEX}^{-1}[v]}$. 2. 6.

$\mathtt{OUT.append(\alpha,v)}$, where $\alpha\in\Sigma^{*}$ and $v\in\mathtt{LEX}$: append the string $\alpha$ at the end of the string $\mathtt{OUT[v]}$, i.e. replace $\mathtt{OUT[v]}\leftarrow\mathtt{OUT[v]}\cdot\alpha$. Note that this operation does not increase $\mathtt{OUT}$’s length. 3. 7.

$\mathtt{OUT.rank(c,u)}$, with $u\in\mathtt{LEX}$ and $c\in\Sigma$: return the number of characters equal to $c$ in all strings $\mathtt{OUT[v]}$, with $v=\mathtt{LEX[1]},\mathtt{LEX[2]},\dots,\mathtt{LEX[LEX^{-1}[u]]}$. 4. 8.

$\mathtt{OUT.reserve(u,v,c)}$, with $u,v\in\mathtt{LEX}$ and $c\in\Sigma$: from the moment this operation is called, the sequence $\alpha_{\mathtt{LEX^{-1}[u]}},\dots,\alpha_{\mathtt{LEX^{-1}[v]}}$ is marked with label $c$. Note that inserting new elements inside $\alpha_{\mathtt{LEX^{-1}[u]}},\dots,\alpha_{\mathtt{LEX^{-1}[v]}}$ will increase the length of the reserved sequence. 5. 9.

$\mathtt{OUT.is\_reserved(v,c)}$, with $v\in\mathtt{LEX}$ and $c\in\Sigma$: return $\mathtt{TRUE}$ iff $\alpha_{\mathtt{LEX}^{-1}(v)}$ falls inside a sequence that has been marked (reserved) with character $c$.

In our algorithm, sequence $\mathtt{IN}$ will always be partitioned in at most $t\leq\sigma+1$ sub-sequences $\mathtt{IN}=\alpha^{c_{1}}_{1},\dots,\alpha^{c_{1}}_{k_{c_{1}}},\alpha^{c_{2}}_{1},\dots,\alpha^{c_{2}}_{k_{c_{2}}},\dots,\alpha^{c_{t}}_{1},\dots,\alpha^{c_{t}}_{k_{c_{t}}}$, where each $\alpha^{c}_{i}$ contains only character $c$ and $c_{1}\prec c_{2}\prec\dots\prec c_{t}$. We define an additional operation on $\mathtt{IN}$:

$\mathtt{IN.start(c)}$, with $c\in\Sigma$, returns the largest integer $j\geq 1$ such that all characters in $\mathtt{IN}[v]$ are strictly smaller than $c$, for all $v=\mathtt{LEX}[1],\dots,\mathtt{LEX}[j-1]$.

Figure 1 shows how our dynamic structures evolve while processing states in topological order. In Appendix 0.D.2 we discuss data structures implementing the above operations in $O(\log k)$ time, $k$ being the sequence’s length. Intuitively, these three dynamic sequences have the following meaning: $\mathtt{LEX}$ will contain the co-lexicographically-ordered sequence of nodes. $\mathtt{IN}[v]$ and $\mathtt{OUT}[v]$, with $v\in\mathtt{LEX}$, will contain the labels of the incoming and outgoing edges of $v$, respectively. To keep the three sequences synchronized, when inserting $v$ in $\mathtt{LEX}$ we will also need to update the other two sequences so that $\mathtt{IN}[v]=c^{t}$, where $t$ is the number of incoming edges, labeled $c$, of $v$, and $\mathtt{OUT}[v]=\epsilon$, since $v$ does not have yet outgoing edges. $\mathtt{OUT}[v]$ will (possibly) be updated later, when new nodes adjacent to $v$ will arrive in the topological order. Our representation is equivalent to that used in [30] to represent the GCSA data structure. Intuitively, $\mathtt{OUT}$ is a generalized version of the well-known Burrows-Wheeler transform (except that we sort prefixes in co-lexicographic order instead of suffixes in lexicographic order). If the graph is a path (i.e. a string) then $\mathtt{OUT}$ is precisely the BWT of the reversed path.

We proceed with a discussion of the pseudocode. In Lines 2-2 of Algorithm 2 we initialize all variables and data structures. Let $u\in V$. The variable $\mathtt{u.in}$ memorizes the number of incoming edges in $u$; we will use this counter to implement Kahn’s topological sorting procedure. $\mathtt{u.label}$ is the label of all incoming edges of $u$, or $\#$ if $u=s$. $\mathtt{IN},\mathtt{LEX}$, and $\mathtt{OUT}$ are initialized as empty dynamic sequences. Lines 2-2 implement Kahn’s topological sorting algorithm [20]. Each time a new node $u$ is appended to the order, we call our online procedure $\mathtt{update(u)}$, implemented in Algorithm 3. Algorithm 3 works as follows. Assume that we have already sorted $v_{1},\dots,v_{k}$, that $\mathtt{LEX}$ contains the nodes’ permutation reflecting their co-lexicographic order, and that $\mathtt{IN[v_{i}]}$ and $\mathtt{OUT[v_{i}]}$ contain the incoming and outgoing labels for each $i=1,\dots,k$ in the sub-graph induced by $v_{1},\dots,v_{k}$. When a new node $u$ arrives in topological order, all its $t$ predecessors are in $\mathtt{LEX}$. Let $b=\mathtt{u.label}$ be the incoming label of $u$. We find the co-lexicographically smallest $v_{min}$ and largest $v_{max}$ predecessors of $u$ (using function $\mathtt{LEX^{-1}}$ on all $u$’s predecessors). In our pseudocode, if $u=s$ then $v_{min}=v_{max}=\mathtt{NULL}$. To keep the Wheeler properties true, note that there cannot be $b$’s in the range $\mathtt{OUT[v_{min}..v_{max}]}$: if there are, since we will append $b$ to $\mathtt{OUT[v_{min}]}$ and $\mathtt{OUT[v_{max}]}$, there will be three nodes $v_{min}<v^{\prime}<v_{max}$ such that $(v_{min},u,b),(v^{\prime},u^{\prime},b),(v_{max},u,b)\in E$ for some $u^{\prime}$. Then, by Wheeler property (ii), this would imply that $u<u^{\prime}<u$, a contradiction. We therefore check this event using function $\mathtt{contains}$ (note: this function can be easily implemented using two calls to $\mathtt{rank}$). If $b$’s are present, then the graph is no longer Wheeler: such an event is shown in Figure 1, left-hand side (where $u=v_{5}$). Otherwise, the number $j$ of $b$’s before $v_{min}$ (which is equal to the number of $b$’s before $v_{max}$) tells us the co-lexicographic rank $i$ of $u$ (similarly to the standard string-BWT, we obtain this number by adding $j$ to the starting position of $b$’s in $\mathtt{IN}$), and we can mark (reserve) range $\mathtt{OUT[v_{min}..v_{max}]}$ with letter $b$ using function $\mathtt{reserve}$. Such an event is shown in Figure 1, left-hand side, when inserting, e.g., node $v_{3}$. At this point, we may have an additional inconsistency falsifying the Wheeler properties in the case that one of the predecessors $v_{i}$ of $u$ falls inside a reserved range for $b$ (reserved by a node other than $u$): this happens, for example, when inserting $v_{6}$ in Figure 1, right-hand side. This check requires calling function $\mathtt{is\_reserved}$. If all tests succeed, we insert $u$ in position $i$ of $\mathtt{LEX}$ and we update $\mathtt{IN}$ and $\mathtt{OUT}$ by inserting $b^{t}$ at the $i$-th position in $\mathtt{IN}$ (i.e. the position corresponding to $u$) and by appending $b$ at the end of each $\mathtt{OUT[v_{i}]}$ for each predecessor $v_{i}$ of $u$.

0.D.2 Data Structure Details

In this section we show how to implement operations 1-10 used by Algorithms 2 and 3 using state-of-the-art data structures. At the core of $\mathtt{LEX}$ and $\mathtt{OUT}$ stands the dynamic sequence representation of Navarro and Nekrich [26]. This structure supports insertions, access, rank, and select in $O(\log n)$ worst-case time, $n$ being the sequence’s length. The space usage is bounded by $nH_{0}+o(n\log\sigma)+O(\sigma\log n)$ bits, where $H_{0}$ is the zero-th order entropy of the sequence. Sequence $\mathtt{IN}$ will instead be represented using a dynamic partial sum data structure, e.g. a balanced binary tree or a Fenwick tree [8], and a dynamic bitvector. All details follow.

Sequence $\mathtt{LEX}$ is stored with Navarro and Nekrich’s dynamic sequence representation [26]. Operations 1-3 are directly supported on the representation. Operation 2 is simply a $select_{v}(1)$ (i.e. the position of the first $v$).

Sequence $\mathtt{OUT}$ is stored using a dynamic sequence $\mathtt{out}$ and a bitvector, both represented with Navarro and Nekrich’s dynamic sequence. The idea is to store all the strings $\mathtt{OUT}[1],\dots,\mathtt{OUT}[|\mathtt{OUT}|]$ concatenated in a single sequence $\mathtt{out}$, and mark the beginning of those strings with a bit set in a dynamic bitvector $\mathtt{B_{out}[1..n]}$, were $n=|\mathtt{out}|$. Clearly, operations 4-7 on $\mathtt{OUT}$ can be simulated with a constant number of operations (insert, access, rank, select) on $\mathtt{out}$ and $\mathtt{B_{out}}$.

Operations 8-9 require an additional dynamic sequence of parentheses $\mathtt{PAR}[1..n]$ on alphabet $\{\mathtt{(}_{c}\ :\ c\in\Sigma\}\cup\{\mathtt{)}_{c}\ :\ c\in\Sigma\}\cup\{\square\}$. Every time a new character is inserted at position $i$ in $\mathtt{out}$, we also insert $\square$ at position $i$ in $\mathtt{PAR}$. When $\mathtt{OUT.reserve(u,v,c)}$ is called (i.e. operation 8), let $i_{v}$ and $i_{u}$ be the positions in $\mathtt{out}$ corresponding to the two occurrences of character $c$ in $\mathtt{OUT[u]}$ and $\mathtt{OUT[u]}$, respectively (remember that the automaton is deterministic, so these positions are unique). These positions can easily be computed in $O(\log n)$ time using select and rank operations on $\mathtt{out}$ and $\mathtt{B_{out}}$. Then, we replace $\mathtt{PAR}[i_{u}]$ and $\mathtt{PAR}[i_{v}]$ with characters $\mathtt{(_{c}}$ and $\mathtt{)_{c}}$, respectively (replacing a character requires a deletion followed by an insertion). Note that reserved intervals for a fixed character do not overlap, so this parentheses representation permits to unambiguously reconstruct the structure of the intervals. At this point, operation 9 is implemented as follows. Let $i_{v}$ be the position in $\mathtt{out}$ corresponding to the first character in $\mathtt{OUT}[v]$. This position can be computed in $O(\log n)$ time with two select operations on $\mathtt{LEX}$ and $\mathtt{B_{out}}$. Then, $\mathtt{OUT.is\_reserved(v,c)}$ returns true if and only if $\mathtt{PAR.rank_{(_{c}}(i_{v})}>\mathtt{PAR.rank_{)_{c}}(i_{v})}$, i.e. if we did not close all opening parentheses $\mathtt{{(_{c}}}$ before position $i_{v}$ (note that does not make any difference if $i_{v}$ is the first or last position in $\mathtt{OUT}[v]$, since when we call this operation $\mathtt{OUT}[v]$ does not contain characters equal to $c$).

To conclude, $\mathtt{IN}$ is represented with a dynamic bitvector $\mathtt{B_{IN}[1..n]}$ and a partial sum $\mathtt{PS[1..\sigma+1]}$ supporting the following operations in $O(\log\sigma)$ time:

• •

partial sum: $\mathtt{PS.ps(i)}=\sum_{j=1}^{i}\mathtt{PS[j]}$.

• •

update: $\mathtt{PS[i]}\leftarrow\mathtt{PS[i]}+\delta$.

Fenwick trees [8] support the above operations within this time bound. Bitvector $\mathtt{B_{IN}[1..n]}$ contains the bit sequence $110^{t_{v_{2}}-1}10^{t_{v3}-1}\dots 10^{t_{v_{k}}-1}$, where $t_{v_{i}}$ is the number of predecessors of $v_{i}$ in the current sequence $\mathtt{LEX}=v_{1},\dots,v_{k}$ of sorted nodes (note that $v_{1}$ is always the source $s$). Assume, for simplicity, that $\Sigma=[1,\sigma+1]$, where $\#$ corresponds to $1$ (this is not restrictive, as we can map the alphabet to this range at the beginning of the computation). At the beginning, the partial sum is initialized as $\mathtt{IN[c]=0}$ for all $c$. Operation 10, $\mathtt{IN.start(c)}$, with $c\neq\#$, is implemented as $\mathtt{PS.ps(c-1)+1}$. If $c=\#$, the operation returns $1$. Operation 4, $\mathtt{IN.insert(c^{p},u)}$, is implemented as $\mathtt{PS[c]}\leftarrow\mathtt{PS[c]}+p$ followed by $\mathtt{B_{IN}.insert(10^{p-1},i_{u})}$ (i.e. $p$ calls to insert on the dynamic bitvector at position $i_{u}$), where $i_{u}$ is the position of the $j$-th bit set in $\mathtt{B_{IN}}$ (a select operation) and $j=\mathtt{LEX^{-1}[u]}$, or $i_{u}=n+1$ if $\mathtt{B_{IN}}$ has $j-1$ bits set (note that, when we call $\mathtt{IN.insert(c^{p},u)}$, node $u$ has already been inserted in $\mathtt{LEX}$).

0.D.3 Proof of Theorem 3.2

In Appendix 0.D.2 we show that all operations on the dynamic sequences can be implemented in logarithmic time. Correctness follows from the fact that we always check that the Wheeler properties are maintained true. To prove completeness, note that at each step we place $u$ between two nodes $v_{1}$ and $v_{2}$ in array $\mathtt{LEX}$ only if the smallest $u$’s predecessor is larger than the largest $v_{1}$’s predecessor, and if the largest $u$’s predecessor is smaller than the smallest $v_{2}$’s predecessor. This is the only possible choice we can make in order to satisfy $w_{v_{1}}\prec w_{u}\prec w_{v_{2}}$ for all strings labeling paths $s\rightsquigarrow v_{1}$, $s\rightsquigarrow u$, and $s\rightsquigarrow v_{2}$ and to obtain, by Corollary 1, the only possible correct ordering of the nodes. It follows that, if the new node $v$ does not falsify the Wheeler properties, then we are computing its co-lexicographic rank correctly.

Proof

(of Lemma 8)

First, we sort edges by label, with ties broken by origin, and further ties broken by destination. This can be achieved in time $O(|E|+|V|)$ by radix sorting the edges represented as triples $(a,u,v)$, where $a$ is the label, and $u$ and $v$ respectively are the ranks of the source and destination nodes in the given order $<$.

Let $L$ denote the sorted list of edges. We claim that the given order $<$ satisfies the Wheeler properties (Definition 2) if and only if for all pairs of consecutive edges $(a_{i},u_{i},v_{i}),(a_{i+1},u_{i+1},v_{i+1})$ in $L$, we have $(a_{i}=a_{i+1})\rightarrow v_{i}\leq v_{i+1}$ and $(a_{i}\neq a_{i+1})\rightarrow v_{i}<v_{i+1}$. Clearly this can be checked in time $O(|E|)$ with one scan over $L$. We now argue the correctness of this algorithm.

Wheeler property (ii) is equivalent to the condition that when all edges labeled by some character $a\in\Sigma$ are sorted by source with ties broken by destination, the sequence of destinations is monotonically increasing, which is expressed by the condition $(a_{i}=a_{i+1})\rightarrow v_{i}\leq v_{i+1}$.

Wheeler property (i) is equivalent to the condition that for all pairs of characters $a,b\in\Sigma$ such that $b$ is a successor of $a$ in the order of $\Sigma$, denoting by $v_{a}$ the largest node with an incoming $a$-edge, and by $v_{b}$ the smallest node with an incoming $b$-edge, we have $v_{a}<v_{b}$. If Wheeler property (ii) holds, then destinations $v_{a}$ and $v_{b}$ are consecutive in $L$ because the list is sorted primarily by label and destinations are monotonically increasing for each label. Hence checking for $(a_{i}\neq a_{i+1})\rightarrow v_{i}<v_{i+1}$ verifies Wheeler property (i) given that Wheeler property (ii) holds. ∎

Proof

(of Theorem 3.3)

In $O(|V|+|E|)$ time we build a directed spanning tree $\mathcal{T}$ of $\mathcal{A}$ with root $s$ (e.g. its directed shortest-path tree with root $s$). Note that this is always possible since we assume that all states are reachable from $s$.

By Corollary 1, if $\mathcal{A}$ is a Wheeler graph then we can use the strings that label any two paths $s\rightsquigarrow u$ and $s\rightsquigarrow v$ to decide the order of any two nodes $u$ and $v$. We can therefore sort $V$ according to the paths spelled by $\mathcal{T}$; by Corollary 1, if $\mathcal{A}$ is Wheeler then we obtain the correct (unique) ordering. To prefix-sort $\mathcal{T}$, we compute its XBW transform 222note: this requires mapping the labels of $\mathcal{T}$ to alphabet $\Sigma^{\prime}\subseteq[1,|V|]$ while preserving their lexicographic ordering. Since we assume that the original alphabet’s size does not exceed $|E|^{O(1)}=|V|^{O(1)}$, this step can be performed in linear time by radix-sorting the labels. in $O(|V|)$ time [9, Thm 2]. The array containing the lexicographically-sorted nodes (i.e. the prefix array of $\mathcal{T}$) can easily be obtained from the XBW transform using, e.g. the partial rank counters defined in the proof of Lemma 8 to navigate the tree (this is analogous to repeatedly applying function LF on the BWT in order to obtain the suffix array). At this point, we check that the resulting node order satisfies the Wheeler properties using Lemma 8. If this is this case, then the above-computed prefix array contains the prefix-sorted nodes of $\mathcal{A}$. ∎

Appendix 0.E Proofs of Section 4

Proof

(of Theorem 4.1)

Let $\mathcal{A}=(V,E,F,s,\Sigma)$. Consider the (possibly infinite) deterministic automaton $\mathcal{T}$ that is a tree and that is equivalent to $\mathcal{A}$ in the following sense: $\mathcal{T}$ is the (unique) tree obtained by “unraveling” $\mathcal{A}$, i.e. the tree containing all words in $\mathcal{L}(\mathcal{A})$ such that each path labeled with such a word leads to an accepting state. Clearly, $\mathcal{T}$ is a (possibly infinite) deterministic automaton recognizing $\mathcal{L}(\mathcal{A})$: a string $\alpha$ leads to a final state in $\mathcal{A}$ if and only if it does in $\mathcal{T}$.

Let $L^{u}=\{u^{1},u^{2},\dots,u^{k_{u}}\}$ be the (possibly infinite) set of nodes of $\mathcal{T}$ reached by following, from its root, all the paths labeled $\alpha$ for each $\alpha$ labeling a path $s\rightsquigarrow u$ connecting $s$ with $u$ in $\mathcal{A}$. Note that each state $u$ of $\mathcal{A}$ can be identified by the set $L^{u}$ of states of $\mathcal{T}$; this allows us to extend $\equiv_{w}$ to the states of $\mathcal{T}$ as follows: $u^{i}\equiv_{w}u^{j}$ for all $u^{i},u^{j}\in L^{u}$, $u\in V$, and $u^{i}\equiv_{w}v^{j}$ for $u^{i}\in L^{u}$, $v^{j}\in L^{v}$ if and only if $u\equiv_{w}v$.

Consider now the process of minimizing $\mathcal{T}$ by collapsing states in equivalence classes in such a way that (i) the quotient automaton is finite, (ii) the accepting language of the quotient DFA is the same as that of $\mathcal{T}$ and (iii) the quotient DFA is Wheeler. By the existence of $\mathcal{A}$, there exists such a partition (not necessarily the coarsest): the one putting $u^{i}$ and $u^{j}$ in the same equivalence class if and only if $u^{i},u^{j}\in L^{u}$, for some $u\in V$ (in this case, $\mathcal{A}$ itself is the resulting quotient automaton). Call $\equiv$ the relation among states of $\mathcal{T}$ yielding the smallest such WDFA $\mathcal{A}/_{\equiv}$. By definition, $\mathcal{A}/_{\equiv}$ is the smallest WDFA recognizing $\mathcal{L}(\mathcal{A})$. Our claim is that $\equiv\ =\ \equiv_{w}$, i.e. that Algorithm 1 returns this automaton.

We observe that:

$u^{i}\approx u^{j}$ for any $u^{i},u^{j}\in L^{u}$ and all $u\in V$. Otherwise, assume for a contradiction that there exists a string $\alpha$ leading to an accepting state from $u^{i}$ but not from $u^{j}$. By construction of $\mathcal{T}$, $u^{i}$ and $u^{j}$ are $\approx$-equivalent to $u$: this leads to a contradiction, since the state reached from $u$ with label $\alpha$ cannot be both accepting and not accepting. 2. 2.

Since $\mathcal{A}$ is a Wheeler DFA, Corollary 1 applied to $\mathcal{A}$ tells us that, for any two nodes $u<v\in V$, all strings labeling paths from the root of $\mathcal{T}$ to nodes in $L^{u}$ are co-lexicographically smaller than those labeling paths from the root of $\mathcal{T}$ to nodes in $L^{v}$. We express this fact using the notation $L^{u}<L^{v}$. 3. 3.

Since $\mathcal{A}$ is Wheeler, then each $u\in V$ has only one distinct incoming label and $\lambda(u^{j})=\lambda(u)$ for all $u^{j}\in L^{u}$.

By the above properties, $u^{i}\equiv u^{j}$ for all $u^{i},u^{j}\in L^{u}$, $u\in V$. To see this, note that, by property 1, those states are all equivalent by relation $\approx$. Moreover, properties 2-3 combined with Corollary 1 imply that, by grouping states in each $L^{u}$, we cannot break any Wheeler property. It follows that $\equiv$ must group those states, being the coarsest partition finer than $\approx$ with these two properties. Let us indicate with $L^{u}\equiv L^{v}$ the fact that $u^{i}\equiv v^{j}$ for all $u^{i}\in L^{u},\ v^{j}\in L^{v}$.

Suppose now, for a contradiction, that there exist $L^{u}<L^{v}<L^{w}$ with $L^{u}\equiv L^{w}\not\equiv L^{v}$. Then, by Corollary 1, $L^{u}<L^{v}$ implies that, in the quotient automaton, states $[L^{w}]_{\equiv}=[L^{u}]_{\equiv}$ and $[L^{v}]_{\equiv}$ are reachable from the source by two paths $\alpha$ and $\beta$, respectively, with $\alpha\prec\beta$. Conversely, $L^{v}<L^{w}$ implies that states $[L^{v}]_{\equiv}$ and $[L^{w}]_{\equiv}$ are reachable from the source by two paths $\alpha^{\prime}$ and $\beta^{\prime}$, respectively, with $\alpha^{\prime}\prec\beta^{\prime}$. Then, by Corollary 1 we cannot define a total order on $\mathcal{A}/_{\equiv}$’s states, i.e. $\mathcal{A}/_{\equiv}$ is not Wheeler.

By all the above observations, we conclude that $\equiv$ must (i) group only equivalent states by $\approx$, (ii) group only states with the same incoming label, (iii) group all states inside each $L^{u}$, and (iv) group only states in adjacent sets $L^{u}$, $L^{v}$ in the co-lexicographic order. By its definition, the relation $\equiv_{w}$ induces the coarsest partition that satisfies (i)-(iv), therefore we conclude that $\equiv\ =\ \equiv_{w}$. ∎

0.E.1 Converting DFAs to minimum WDFAs

We describe an online step of our algorithm. Assume we successfully built $\mathcal{A}_{i}$, with $i<t$, and we are about to process $v_{i+1}$ in order to build $\mathcal{A}_{i+1}$. Let $\{c_{1},\dots,c_{k}\}$ be the labels of incoming $v_{i+1}$’s edges. We first replace (split) $v_{i+1}$ by $k$ equivalent states $v_{i+1}^{c_{1}}\approx\dots\approx v_{i+1}^{c_{k}}$: each $v_{i+1}^{c_{k}}$ (i) is accepting if and only if $v_{i+1}$ is accepting, (ii) keeps only the incoming edges of $v_{i+1}$ labeled $c_{i}$, and (iii) it duplicates all its outgoing edges: we replace each $(v_{i+1},u,c)$ with the edges $(v_{i+1}^{c_{1}},u,c),\dots,(v_{i+1}^{c_{k}},u,c)$. Note that all the newly-created edges must be present in the final automaton $\mathcal{A}_{t}$ since the states $v_{i+1}^{c_{1}},\dots,v_{i+1}^{c_{k}}$ cannot be collapsed back by $\equiv_{w}$ (as they have different incoming labels); it follows that in this step we are not creating more edges than necessary.

We now insert separately $v_{i+1}^{c_{1}},\dots,v_{i+1}^{c_{k}}$ in $\mathtt{LEX}_{i}$ in any order as follows. The procedure is the same for all those vertices, therefore we may simply assume we are about to process a node $v$ with all incoming edges labeled with the same character $a$. Let $u_{1}<\dots<u_{k}$ be the predecessors of $v$ in the graph; note that those nodes must belong to $\mathtt{LEX}_{i}$ (since we are processing states in topological order), therefore their order $<$ is well-defined. We now must detect and solve inconsistencies of type 1 and 2 as defined in the proof of Theorem 3.2 (see also Figure 1).

We start with inconsistencies of type 1: there already are nodes $w_{i}\notin\{u_{1},\dots,u_{k}\}$ with outgoing edges labeled $a$ inside the range $[u_{1},u_{k}]$. This breaks the sequence $u_{1}<\dots<u_{k}$ into $q$ sub-intervals $[u_{i_{j}},u^{\prime}_{i_{j}}]$, $j=1,\dots,q$, that do not contain nodes with outgoing label $a$ different than those in $\{u_{1},\dots,u_{k}\}$. The range has therefore the following form, where we denote with $w_{i}$ and $w^{\prime}_{i}$ all nodes not in $\{u_{1},\dots,u_{k}\}$ with outgoing edges labeled $a$ and we highlight in bold the runs $[u_{i_{j}},u^{\prime}_{i_{j}}]$:

[TABLE]

where $u_{i_{1}}=u_{1}$, $u^{\prime}_{i_{q}}=u_{k}$, and $w_{1}<u_{1},\ w_{q+1}>u_{k}$ are the rightmost and leftmost states with an outgoing edge labeled $a$, respectively (if they exist). The top part of Figure 2 depicts this situation, where $k=4$ and $u_{1},\dots,u_{4}$ are clustered in $q=3$ runs: $w_{1}<\mathbf{u_{1}}<w_{2}<w_{3}<\mathbf{u_{2}<u_{3}}<w_{4}<\mathbf{u_{4}}<w_{5}$. We solve the inconsistencies of type 1 by splitting $v$ in (i.e. replacing it with) $q$ equivalent nodes: $v_{1}\approx\dots\approx v_{q}$. Each $v_{j}$ is final if and only if $v$ is final, duplicates all $v$’s outgoing edges (as seen above), and keeps only incoming edges from $v$’s predecessors inside the corresponding run $[u_{i_{j}},u^{\prime}_{i_{j}}]$. This is depicted in the bottom part of Figure 2: $v$ has been split into the three equivalent nodes $v_{1}\approx v_{2}\approx v_{3}$.

Inconsistencies of type 2 are solved similarly by splitting $a$-successors of $w_{1},\dots,w_{q+1}$ that belong to $\mathtt{LEX}_{i}$ when necessary. Let $\mathtt{LEX}_{i}\cap\{succ_{a}(w_{1}),\dots,succ_{a}(w_{q+1})\}=\{z_{1}<\dots<z_{q^{\prime}}\}$ be the $a$-successors of $w_{1},\dots,w_{q+1}$ in $\mathtt{LEX}_{i}$. Note that it might be the case that $q^{\prime}<q+1$. Note also that some of the nodes $z_{i}$ might belong to $\{u_{1},\dots,u_{k}\}\cup\{w_{1},\dots,w_{q+1}\}$. We have an inconsistency of type 2 (among nodes in $\mathtt{LEX}_{i}$) whenever $succ_{a}(w_{i})=succ_{a}(w_{i+1})=z_{e}$, for some $1\leq e\leq q^{\prime}$, and there exist some $u_{j}$ such that $w_{i}<u_{j}<w_{i+1}$. In this case, we split $z_{e}=succ_{a}(w_{i})=succ_{a}(w_{i+1})$ in two equivalent nodes $z_{e}^{\prime}\approx z_{e}^{\prime\prime}$ ordered as $z_{e}^{\prime}<succ_{a}(u_{j})<z_{e}^{\prime\prime}$. This cannot contradict the Wheeler properties (even if $z_{i}\in\{u_{1},\dots,u_{k}\}\cup\{w_{1},\dots,w_{q+1}\}$), since $succ_{a}(u_{j})$ is one of the copies of $v$ (or $v$ itself if $v$ has not been splitted in the previous step) and has therefore no successors in the current automaton. The process of fixing inconsistencies of type 2 is shown in Figure 2: nodes $w_{3}$ and $w_{4}$ are separated by $u_{2},u_{3}$ as $w_{3}<u_{2}<u_{3}<w_{4}$. In this case, $succ_{a}(w_{3})=succ_{a}(w_{4})=z_{3}$, and we split $z_{3}$ in the two equivalent nodes $z^{\prime}_{3}$ and $z^{\prime\prime}_{3}$. Note also that we only need to check those $w_{i}$ that immediately precede or follow a predecessor of $v$ (i.e. $w_{1},w_{2},w_{2}^{\prime},\dots,w_{q+1}$): those nodes are at most $O(k)$, where $k$ is the number of $v$’s predecessors.

As shown in Figure 2 (bottom), after solving the inconsistencies of type 1 and 2 the nodes in $\mathtt{LEX}_{i+1}$ are again range-consistent: the $a$-successors of any (sorted) range of nodes form themselves a (sorted) range. Moreover, the splitting process defines unambiguously a total ordering of the new nodes among those already in $\mathtt{LEX}_{i}$, which can be therefore updated to $\mathtt{LEX}_{i+1}$ by inserting those nodes at the right place: to insert a node $v^{\prime}$ in $\mathtt{LEX}_{i}$, let $u^{\prime}$ be its $a$-predecessor: $succ_{a}(u^{\prime})=v^{\prime}$. Let moreover $u^{\prime\prime}<u^{\prime}$ be the rightmost node preceding $u^{\prime}$ (in $\mathtt{LEX}_{i}$) having an outgoing edge labeled $a$, and let $v^{\prime\prime}$ be its $a$-successor: $succ_{a}(u^{\prime\prime})=v^{\prime\prime}$. By range-consistency, node $v^{\prime}$ has to be inserted immediately after $v^{\prime\prime}$ in $\mathtt{LEX}_{i}$. If such a node $u^{\prime\prime}$ does not exist (i.e. $u^{\prime}$ is the leftmost node in $\mathtt{LEX}_{i}$ having an outgoing edge labeled $a$), then $v^{\prime}$ has to be inserted in $\mathtt{LEX}_{i}$ so that it becomes the first node with incoming edges labeled $a$ (i.e. in the position immediately following the rightmost node $v^{\prime\prime}$ with incoming label $a^{\prime}$, where $a^{\prime}$ is the lexicographically-largest character such that $a^{\prime}\prec a$, or at the first position in $\mathtt{LEX}_{i}$ if such a character $a^{\prime}$ does not exist). This shows that invariant 2 is maintained: the Wheeler properties are kept true among nodes in $\mathtt{LEX}_{i+1}$. It is also clear that we do not insert $\approx$-equivalent adjacent states with the same incoming label (see Figure 2: by construction, the newly-inserted nodes $v_{1},z^{\prime}_{3},v_{2},z^{\prime\prime}_{3},v_{3}$ are non-equivalent to their neighbors), i.e. invariant 3 is maintained. Finally, the accepted language does not change since the splitting process generates $\approx$-equivalent nodes: also invariant 1 stays true.

Note that the minimization process on the original acyclic DFA $\mathcal{A}$ takes linear time. After that, we only insert edges/nodes in the minimum output WDFA: never delete. It follows that the number of performed operations is equal to the output’s size. The final automaton could be either smaller or exponentially-larger than $\mathcal{A}$. We note that all the discussed operations can be easily implemented in logarithmic time using the data structures discussed in Section 0.D.2: finding the $q$ runs of states $[u_{i_{j}},u^{\prime}_{i_{j}}]$, as well as finding the $O(k)$ states $w_{i}$, requires executing a constant number of rank operations on sequence $\mathtt{OUT}$ and start operations on $\mathtt{IN}$ for each predecessor of $v$. Nodes can be inserted at the right position in sequence $\mathtt{LEX}$ exactly as done in Algorithm 3 (by also updating $\mathtt{IN}$ and $\mathtt{OUT}$). Finally, the graph can be dynamically updated (i.e. splitting nodes) and queried (i.e. navigation) by keeping it as a dynamic adjacency list: since we can spend logarithmic time per edge, we can store the graph as a self-balancing tree associating nodes to their predecessors and successors (also kept as self-balancing trees). This structure supports all updates and queries on the graph in logarithmic time. It follows that the overall procedure terminates in $O(n+m\log m)$ time, $n$ and $m$ being the input and output’s sizes, respectively.

Appendix 0.F Worst case blowup from an acyclic DFA to the minimum equivalent WDFA

In this section we show that the running time of the conflict resolution algorithm in Section 4.1 is exponential in the worst case, i.e. there exists a family of regular languages where the size of the smallest WDFA is exponential in the size of the smallest DFA. We now show that one such family the sequence of languages $L_{1},L_{2},\ldots$, where $L_{m}=\{c\alpha e\;|\;\alpha\in\{a,b\}^{m}\}\cup\{d\alpha f\;|\;\alpha\in\{a,b\}^{m}\}$.

For an example, Figure 3 shows a DFA and the smallest WDFA for the language $L_{3}$. In general, we can build a DFA for $L_{m}$ by generalizing the construction in the figure: the source node has outgoing edges labeled with $c$ and $d$, followed by simple linear size ”universal gadgets” capable of generating all binary strings of length $m$, with one gadget followed by an $e$ and the other by an $f$. The two sink states are the only accepting states.

The smallest WDFA for $L_{m}$ is an unraveling of the described DFA, such that all paths up to (but not including) the sinks end up in distinct nodes, i.e. the universal gadgets are replaced by full binary trees (see Figure 3). It is easy to see that the automaton is Wheeler as the only nodes that have multiple incoming paths are the sinks, and the sinks have unique labels.

To prove that this is the minimal WDFA, we need to check the condition of Theorem 4.2, i.e. that all colexicographically consecutive pairs of nodes with the same incoming label are Myhill-Nerode inequivalent. As labels $c,d,e$ and $f$ occur only once, it is enough to focus on nodes that have label $a$ or $b$. Let $B_{1},B_{2},B_{2^{m+1}-1}$ be the colexicographically sorted sequence of all possible binary strings with lengths $1\leq|B_{i}|\leq m$ from the alphabet $\{a,b\}$. Observe that the nodes with incoming label $a$ and $b$ correspond to path labels of the form $cB_{i}$ and $dB_{i}$ for all $1\leq i\leq 2^{m+1}-1$. The colexicographically sorted order of these path labels is:

[TABLE]

Here we can see that all consecutive pairs have a different first character, and therefore they lead to a different sink in the construction, and hence they are not Myhill-Nerode equivalent. Therefore the automaton is the minimum WDFA.

The DFA has $n=4m+5$ states and the WDFA has $1+2^{m+2}=1+2^{(n-5)/4+2}$ states, so we obtain the following result:

Theorem 0.F.1

The minimal WDFA equivalent to an acyclic DFA with $n$ states has $\Omega(2^{n/4})$ states in the worst case.