Algoritmo di Brzozowski per la minimizzazione di DFA

L'algoritmo di minimizzazione DFA di Brzozowski crea un DFA minimo per DFA $G$ :

1. invertendo tutti gli spigoli in $G$ , rendendo lo stato iniziale uno stato accetta, e gli stati accetta iniziale, per ottenere un NFA $N'$ per la lingua inversa,
2. usando la costruzione di powerset per ottenere $G'$ per la lingua inversa,
3. invertendo i bordi (e iniziando lo scambio iniziale) in $G'$ per ottenere un NFA $N$ per la lingua originale e
4. $G_{\min}$

Naturalmente, poiché alcuni DFA hanno un DFA inverso di grandi dimensioni esponenziale, questo algoritmo viene eseguito nel tempo esponenziale nel peggiore dei casi in termini di dimensioni dell'input, quindi consente di tenere traccia delle dimensioni del DFA inverso.

Se è la dimensione del DFA di input, è la dimensione del DFA minimo e la dimensione del DFA inverso minimo, qual è il tempo di esecuzione dell'algoritmo di Brzozowski in termini di , e ?$N$$n$$m$$N$$n$$m$

In particolare, in quale relazione tra e l'algoritmo di Brzozowski supera quello degli algoritmi di Hopcroft o Moore?$n$$m$

Ho sentito che su esempi tipici nella pratica / applicazione , l'algoritmo di Brzozowski supera gli altri. Informalmente, come sono questi esempi tipici?

Ecco una risposta parziale riguardo alla tua terza domanda. In effetti, forse l'algoritmo di Brzozowski in realtà non supera di gran lunga tutti gli altri algoritmi nella minimizzazione di DFA.

In [1], gli autori studiano le prestazioni pratiche degli algoritmi di minimizzazione DFA / NFA. Gli algoritmi sono Hopcroft, Brzozowski e due varianti di Watson. Concludono che non esiste un chiaro vincitore, ma l'algoritmo di Hopcroft ha prestazioni migliori per i DFA con alfabeti di piccole dimensioni. Per gli NFA, Brzozowski è chiaramente il più veloce.

Il documento stesso è piuttosto breve e chiaramente scritto. Ci sono anche ulteriori discussioni e riferimenti che potrebbero essere utili.

[1] Almeida M., Moreira N. e Reis R. On the Performance of Automata Minimization Algorithms, Quarta conferenza sulla calcolabilità in Europa, giugno 2008.

La maggior parte del seguito proviene dalla teoria dell'analisi di Sippu e Soisalon-Soininen.

Sia un insieme di stati del DFA. Sia T l'alfabeto di input. Let | M | = O ( | T | ⋅ | Q | ) è la dimensione della macchina. L'esercizio 3.40 fornisce un algoritmo O ( | T | ⋅ | Q | 2 ) per minimizzare lo stato. Come descritto da Wikipedia , l'algoritmo di Hopcroft ha un tempo di esecuzione del registro O ( | T | ⋅ | Q |$Q$$T$$|M|=O(|T| \cdot |Q|)$$O(|T|\cdot|Q|^2)$ e l'algoritmo di Moore ha un tempo di esecuzione di O ( | T | 2 ⋅ | Q | ) .$O(|T| \cdot |Q| \cdot \log|T|)$$O(|T|^2 \cdot |Q|)$

Il teorema 3.30 afferma che la costruzione del sottoinsieme può essere eseguita in producendo un automa di dimensione O ( 2 | T | + log | Q | ) (in realtà, se il l'automa risultante ha | T ′ | stati, il tempo di esecuzione è ( | T ′ | + | T | ⋅ |$O(2^{|T|+\log|T|+\log|Q|})$$O(2^{|T|+\log|Q|})$$|T'|$). Le due inversioni e la seconda determinazione sono quindi irrilevanti nel tempo di esecuzione, quindi il tempo di esecuzione asintotico dell'algoritmo di Brzozowski è lo stesso di quello della costruzione del sottoinsieme.$(|T'| + |T|\cdot|M|) \cdot |Q|$

$(a|b)^*a^k$$k+1$$O(2^k)$

$|T'|=O(|T|)$, then its running time is also $O(|T|^2 \cdot |Q|^2)$, which is often the case on real-life inputs. Furthermore, if proper care is taken when computing the closure of a state, then this can be done much faster in most cases (that is, cases where the closure is small), saving a factor $|T|$ in practice (for essentially the same reason that transitive closures can be computed quite quickly on real-world examples). Furthermore, if the input and intermediate automatons are sparse, which means that states have few transitions, then a factor $|Q|$ is saved, which gives a $O(|T| \cdot |Q|)$ running time on 'good' inputs.

Unfortunately, I'm not familiar enough with Hopcroft's or Moore's algorithms to give an analysis of their running times in typical cases. Wikipedia talks about a $O(|T| \log \log |T|)$ running time in some cases, which would make the three algorithms comparable.

De Felice and Nicaud show that Brzozowski's algorithms is asymptotically hyper-polynomial. David has shown that, for several distributions on final states, Hopcroft's algorithm is slower that Moore's algorithm.

References

S. De Felice and C. Nicaud, "Brzozowski Algorithm is Generically Super-Polynomial for Deterministic Automata". In Proceedings of 17th International Conference on Developments in Language Theory (DLT 2013), Lecture Notes in Computer Science, pp. 170–190, 2013. (PDF)

J. David, "Average complexity of Moore’s and Hopcroft’s algorithms". Theoretical Computer Science, 417:50–65, 2012. (Science Direct)