Come dimostrare che una lingua è regolare?

Esistono molti metodi per dimostrare che una lingua non è regolare , ma cosa devo fare per dimostrare che una lingua è regolare?

Ad esempio, se mi viene dato che è regolare, come posso dimostrare che anche la seguente L ′ è regolare?$L$$L'$

$\qquad \displaystyle L' := \{w \in L: uv = w \text{ for } u \in \Sigma^* \setminus L \text{ and } v \in \Sigma^+ \}$

Posso disegnare un automa finito non deterministico per dimostrarlo?

Sì, se riesci a trovare uno dei seguenti:

• automa finito deterministico (DFA),
• automa finito non deterministico (NFA),
• espressione regolare (regexp di linguaggi formali) o
• grammatica regolare

per qualche lingua , allora L è regolare. Esistono modelli più equivalenti , ma i precedenti sono i più comuni.$L$$L$

Esistono anche proprietà utili al di fuori del mondo "computazionale". è anche regolare se$L$

• è finito,

• puoi costruirlo eseguendo determinate operazioni su lingue regolari e quelle operazioni sono chiuse per lingue regolari , come ad esempio

  • intersezione,
  • complemento,
  • omomorfismo,
  • inversione,
  • quoziente sinistro o destro,
  • trasduzione regolare

  e altro ancora , o

• usando il teorema di Myhill – Nerode se il numero di classi di equivalenza per è finito.$L$

Nell'esempio dato, abbiamo alcune lingue (regolari) come base e vogliamo dire qualcosa su una lingua L ′ derivata da essa. Seguendo il primo approccio - costruiamo un modello adatto per L ′ - possiamo assumere qualunque modello equivalente per L che desideriamo tanto; rimarrà astratto, ovviamente, poiché L è sconosciuto. Nel secondo approccio, possiamo usare L direttamente e applicare le proprietà di chiusura per arrivare a una descrizione per L ′ .$L$$L'$$L'$$L$$L$$L$$L'$

Metodi elementari

1. Automi finiti (possibilmente non deterministici, con transizioni vuote).
2. Espressioni regolari.
3. Equazioni lineari di destra (o sinistra, ma non entrambe), come dove K e L sono regolari.$X = KX + L$$K$$L$
4. Grammatica regolare (tipo 3).
5. Operazioni che preservano le lingue regolari (operazioni booleane, prodotto, stella, shuffle, morfismi, inversioni di morfismi, inversione, ecc.)
6. Riconosciuto da un monoide finito.

Metodi logici (spesso utilizzati nella verifica formale)

1. Logica monadica del secondo ordine (teorema di Büchi).
2. Logica temporale lineare (teorema di Kamp).
3. Teorema dell'albero di Rabin (logica monadica del secondo ordine con due successori). Molto potente.

Metodi avanzati

1. Lemmi di pompaggio sofisticati. Vedi ad esempio
   [1] J. Jaffe, un lemma di pompaggio necessario e sufficiente per le lingue regolari, Sigact News - SIGACT 10 (1978) 48-49.
   [2] A. Ehrenfeucht, R. Parikh e G. Rozenberg, Lemmi di pompaggio per set regolari, SIAM J. Comput. 10 (1981), 536-541.
   [3] S. Varricchio, Una condizione di pompaggio per set regolari, SIAM J. Comput. 26 (1997) 764-771.

2. Bene quasi ordini. Vedi
   [4] W. Bucher, A. Ehrenfeucht, D. Haussler, Sui regolatori totali generati dalle relazioni di derivazione, Theor. Comput. Sci. 40 (1985) 131-148.
   [5] M. Kunz, Soluzioni regolari di disuguaglianze linguistiche e quasi ordini .

3. $\mathbb{N}$

4. Metodi algebrici basati su trasduzioni (vedi anche Operazioni che preservano le lingue regolari ).

La risposta di Ran G. fornisce un elenco abbastanza ampio dei modelli equivalenti che possono essere utilizzati per specificare lingue regolari (e l'elenco continua, automi a due vie, logica MSO, ma che è coperto dal link sotto "modelli più equivalenti '). E come sottolinea Raffaello, abbiamo bisogno di una discussione per convincere il pubblico che la rappresentazione scelta è davvero corretta.

$\dots$$L$$L'$$L$$L'$

$L'= (\Sigma^* \setminus L) \cdot \Sigma^*$

$L$$L'$

$s$$k$$s$<some property>$k$$k$

$$L_1 \mathop{S} L_2 = \{ x_1y_1 \ldots x_n y_n \in \Sigma^* : x_1 \ldots x_n \in L_1, y_1 \ldots y_n \in L_2 \}$$ $A_i = \langle \Sigma, Q_i, F_i, \delta_i, q_{0i} \rangle$$L_i$$i=1,2$$\langle \Sigma, Q, F, \delta, q_0 \rangle$

• $Q_1 \times Q_2 \times \{1,2\}$$x_i$$y_i$
• $q_0 = \langle q_{01}, q_{02}, 1 \rangle$
• $F = F_1 \times F_2 \times \{1\}$
• $\delta(\langle q_1, q_2, 1 \rangle, \sigma) = \langle \delta_1(q_1,\sigma), q_2, 2 \rangle$$\delta(\langle q_1, q_2, 2 \rangle, \sigma) = \langle q_1, \delta_2(q_2,\sigma), 1 \rangle$

---

$$L^R = \{ w^R : w \in \Sigma^* \}.$$ $(w_1\ldots w_n)^R = w_n \ldots w_1$$L$$\langle \Sigma, Q, F, \delta, q_0 \rangle$$\langle \Sigma, Q', F', \delta', q'_0 \rangle$

• $Q' = Q \cup \{q'_0\}$
• $q'_0$
• $q_0$
• $\delta'(q'_0,\epsilon) = F$$q \in Q$$\sigma \in \Sigma$$\delta(q', \sigma) = \{ q : \delta(q,\sigma) = q' \}$

$q'_0$

---

$$R(L) = \{ yx \in \Sigma^* : xy \in L \}.$$ $L$$\langle \Sigma, Q, F, \delta, q_0 \rangle$$\langle \Sigma, Q', F', \delta', q'_0 \rangle$$q=\delta(q_0,x)$$\delta(q,y) \in F$$\delta(q_0,x) = q$$y$$x$

• $Q' = \{q'_0\} \cup Q \times Q \times \{1,2\}$$q'_0$$\langle q,q_{curr}, s \rangle$$q$$q_{curr}$$s$$y$$x$
• $F' = \{\langle q,q,2 \rangle : q \in Q\}$$\delta(q_0,x)=q$
• $\delta'(q'_0,\epsilon) = \{\langle q,q,1 \rangle : q \in Q\}$$q$
• $\delta'(\langle q,q_{curr},s \rangle, \sigma) = \langle q,\delta(q_{curr},\sigma),s \rangle$$q,q_{curr} \in Q$$s \in \{1,2\}$
• $\delta'(\langle q,q_f,1 \rangle, \epsilon) = \langle q,q_0,2 \rangle$$q \in Q$$q_f \in F$$y$$x$$y$

---

$$E_k(L) = \{ x \in \Sigma^* : \text{ there exists $y \in L$ whose edit distance from $x$ is at most $k$} \}.$$ $\langle \Sigma, Q, F, \delta, q_0 \rangle$$L$$\langle \Sigma, Q', F', \delta', q'_0 \rangle$$E_k(L)$

• $Q' = Q \times \{0,\ldots,k\}$
• $q'_0 = \langle q_0,0 \rangle$
• $F' = F \times \{0,\ldots,k\}$
• $q,\sigma,i$$\langle \delta(q,\sigma), i \rangle \in \delta'(\langle q,i \rangle, \sigma)$
• $\langle q,i+1 \rangle \in \delta'(\langle q,i \rangle, \sigma)$$q,\sigma,i$$i < k$
• $\langle \delta(q,\sigma), i+1 \rangle \in \delta'(\langle q,i \rangle, \epsilon)$$q,\sigma,i$$i < k$
• $\langle \delta(q,\sigma), i+1 \rangle \in \delta'(\langle q,i \rangle, \tau)$$q,\sigma,\tau,i$$i < k$

Una lingua è normale se puoi scrivere uno scanner che decide su stringhe arbitrarie se appartengono o meno alla lingua usando non più di una quantità fissa di memoria - cioè il riconoscimento può essere fatto nello spazio O (1) .

La trasformazione delle espressioni regolari è un modo per dimostrare la chiusura in determinate operazioni. I due esempi più semplici sono la chiusura sotto inversione e la chiusura sotto omomorfismo .

$r$$L$$L^R$$L$

• $\epsilon^R = \epsilon$$\sigma^R = \sigma$$\emptyset^R = \emptyset$
• $(r_1+r_2)^R = (r_1^R + r_2^R)$$(r^*)^R = (r^R)^*$$(r_1r_2)^R = r_2^R r_1^R$

$(r_1r_2)^R = r_2^R r_1^R$$(0^*1^*)^R = 1^*0^*$$r^R$$L^R$

$h\colon \Sigma \to \Delta^*$$r$$L$$h(L)$$\sigma$$r$$h(\sigma)$

Un altro modo è costruire la lingua usando le operazioni in base alle quali si sa che sono chiuse. Questa è un'estensione per mostrare un'espressione regolare, poiché hai molte più operazioni disponibili (inverti la stringa, complemento, intersezione, taglia un pezzo, mantieni solo una parte, omomorfismi e omomorfismi inversi, ...)