Conteggio delle parole accettate da una grammatica regolare

Data una lingua normale (NFA, DFA, grammatica o regex), come si può contare il numero di parole accettate in una determinata lingua? Entrambi "con esattamente n lettere" e "con al massimo n lettere" sono interessanti.

Margareta Ackerman ha due articoli sull'argomento correlato dell'enumerazione delle parole accettate da un NFA, ma non sono stato in grado di modificarle per contare in modo efficiente.

Sembra che la natura ristretta delle lingue normali dovrebbe rendere il conteggio relativamente semplice: mi aspetto quasi una formula più che un algoritmo Sfortunatamente le mie ricerche finora non hanno prodotto nulla, quindi devo usare termini sbagliati.

Per un DFA, in cui lo stato iniziale è lo stato , il numero di parole di lunghezza k che finiscono nello stato i è A k [ 0 , i ] , dove A è la matrice di trasferimento del DFA (una matrice in cui il il numero nella riga i e nella colonna j è il numero di simboli di input diversi che causano una transizione dallo stato i allo stato j ). Quindi puoi contare accettando parole di lunghezza esattamente k facilmente, anche quando $0$$k$$i$$A^k[0,i]$$A$$i$$j$$i$$j$$k$$k$ è moderatamente grande, semplicemente calcolando una potenza di matrice e aggiungendo le voci corrispondenti agli stati di accettazione.

La stessa cosa funziona per accettare parole di lunghezza al massimo , con una matrice leggermente diversa. Aggiungi una riga e una colonna aggiuntive della matrice, con una nella cella che sia sia nella riga che nella colonna, una nella nuova riga e la colonna dello stato iniziale e uno zero in tutte le altre celle. L'effetto di questa modifica alla matrice è di aggiungere un altro percorso allo stato iniziale ad ogni potenza.$k$

Questo non funziona per gli NFA. Ho il sospetto che la cosa migliore da fare sia semplicemente convertire in un DFA e quindi applicare l'algoritmo di alimentazione della matrice.

Let sia una (non deterministico) Automazione finiti con iniziare stato q 1 , Q F ⊆ Q e δ ⊆ Q × Σ × Q .$A = (Q = \{q_1, \dots, q_n\}, \Sigma, \delta, Q_F)$$q_1$$Q_F \subseteq Q$$\delta \subseteq Q\times\Sigma\times Q$

Sia la funzione generatrice per tutte le parole che possono essere accettati partire q i , che è il n ° coefficiente della sua espansione serie [ z n ] Q i = | { w ∣ | w | = n ∧ w  accettato da  q i } | .$Q_i(z)$$q_i$$n$$[z^n]Q_i = |\{w \mid |w| = n \wedge w \text{ accepted from } q_i\}|$

Chiaramente:

$Q_i(z) = \left[ q_i \in Q_F \right] + \sum\limits_{(q_i, a, q_j) \in \delta} x \cdot Q_j(z)$

$Q_1$$[z^n]Q_1$

Questo risale a una tecnica introdotta per le grammatiche da Chomsky e Schützenberger (1963); si trasferisce facilmente su automi finiti.

$\varepsilon$$x$$a \in \Sigma$$w \in \Sigma^k$$x$$x^k$

Penso che questo sia un problema di conteggio difficile, vedi questo documento: Contare la dimensione delle sequenze regolari di una determinata lunghezza è # P-completo: S. Kannan, Z. Sweedyk e SR Mahaney. Conteggio e generazione casuale di stringhe in lingue regolari. Nel simposio ACM-SIAM sugli algoritmi discreti (SODA), pagine 551–557, 1995.

$\#\mathsf{NC}^1$