Automi finiti deterministici (DFA) (1)

Presentazione sul tema: "Automi finiti deterministici (DFA) (1)"— Transcript della presentazione:

1 Automi finiti deterministici (DFA) (1)
Un DFA è una quintupla (Q, S, d, q0 , F) dove: Q è un insieme finito di stati è un alfabeto finito di input q0  Q è lo stato iniziale F  Q è l’insieme degli stati finali è la funzione di transizione Q  S  Q. d^ è l’estensione di d a stringhe, tale che d^ (q, e) = q d^ (q, wa) = d (d^ (q, w), a) Poiché d^ (q, a) = d (d^ (q, e), a) = d (q, a) non c’è disaccordo tra d e d^ dove sono entrambe definite e scriveremo d per d^.

2 Automi finiti deterministici (DFA) (2)
Una stringa x è accettata da un DFA M = (Q, S, d, q0 , F) se d(q0 , x) = p per un p  F. Definiamo linguaggio accettato da M l’insieme di stringhe L(M) = {x | d(q0 , x)  F}. Il linguaggio accettato da un DFA è detto linguaggio regolare.

3 Diagrammi di transizione
A un DFA è associato un grafo (chiamato diagramma di transizione) tale che i nodi corrispondono agli stati del DFA e se c’è una transizione dallo stato p allo stato q sull’input a allora nel grafo c’è un arco dal vertice corrispondente a p al vertice corrispondente a q. Esempio . 1 1 1 1 Lo stato iniziale è anche finale. Se il controllo è in uno degli stati superiori si è letto un numero pari di 0, se è in uno degli stati a sinistra si è letto un numero pari di 1.

4 Automi finiti non deterministici (NFA) (1)
Un NFA è una quintupla M = (Q, S, d, q0 , F) dove: Q, S, q0 , F sono come nel DFA e d : Q  S  2Q. d^ è l’estensione di d a stringhe, tale che d^(q, e) = {q} d^(q, wa) = {p | per qualche r  d^(q, w) p  d (r, a)}. Poiché d^(q, a) = d(q, a) scriveremo d per d^. Si può estendere d ad argomenti in 2Q  S* d (P, w) =  q  P d(q, w) per P  Q. Una sequenza di input a1 a2 … an è accettata da un NFA se esiste una sequenza di transizioni corrispondente alle sequenza di input che porta dallo stato iniziale a uno stato finale. Per M = (Q, S, d, q0 , F), L(M) = {w | d^(q0, w) contiene uno stato in F}.

5 Automi finiti non deterministici (NFA) (2)
Esempio. L’automa accetta tutte le stringhe di 0 e 1 con due 0 oppure due 1 consecutivi. 1 . 1 1 . 1 1

6 Equivalenza di NFA e DFA (1)
Teorema. Sia L l’insieme accettato da un NFA. Esiste un DFA che accetta L. Prova. Sia M = (Q, S, d, q0 , F) un NFA che accetta L. Sia Sia M’ = (Q’, S, d’, q0’, F’) un DFA tale che: Q’= 2Q un elemento di Q’ è denotato [q1 , q2 , …, qi ] F’ è l’insieme di tutti gli stati in Q’ contenenti uno stato finale di M q0’= [q0 ] d’([q1 , q2 , …, qi ], a) = [p1 , p2 , …, pj ] se e solo se ({q1 , q2 , …, qi}, a) = {p1 , p2 , …, pj }. Mostriamo per induzione sulla lunghezza della stringa di input x che d’(q0’, x) = [q1 , q2 , …, qj ] se e solo se d(q0, x) = {q1 , q2 , …, qj }.

7 Equivalenza di NFA e DFA (2)
Base. Immediato per |x| = 0 perché q0’= [q0 ] e x deve essere e. Passo. Assumiamo la tesi vera per |x|<= m e consideriamo la stringa xa con a  S. Per ipotesi di induzione d’(q0’, x) = [p1 , p2 , …, pj ] se e solo se d(q0, x) = {p1 , p2 , …, pj }. Per definizione di d’ si ha d’([p1 , p2 , …, pj ], a) = [r1 , r2 , …, rk ] se e solo se d({p1 , p2 , …, pj}, a) = {r1 , r2 , …, rk}. Quindi infine d’(q0’, xa) = [r1 , r2 , …, rk ] se e solo se d(q0, xa) = {r1 , r2 , …, rk }. Inoltre d’(q0’, x)  F’ esattamente quando d (q0, x) contiene uno stato in F. Perciò L(M) = L(M’).

8 Equivalenza di NFA e DFA (3)
Esempio. M = ({q0 , q1}, {0 , 1}, d, { q1}) con d(q0, 0) = {q0 , q1}, d(q0, 1) = {q1}, d(q1, 0) =  , d(q1,1) = {q0, q1} M’ = (Q, {0 , 1}, d’, [q0 ], F) con Q = {[q0 ], [q1 ], [q0, q1 ], } d’([q0], 0) = [q0, q1], d’(q0,1) = [q1], d’(q1,0) =  , d’(q1,1) = [q0, q1] d’([q0, q1], 0) = [q0, q1], d’([q0, q1],1) = [q0, q1], d’(, 0) = d’(, 1) =  F = {[q1], [q0, q1]} . 1 1 q0 1 1 [q1] [q0] . [q0, q1] 1

9 NFA con e transizioni (1)
Si considera una funzione di transizione d : Q  (S  {e}) 2Q. Esempio. L’automa accetta le stringhe di un numero finito di 0 seguito da un numero finito di 1 seguito da un numero finito di 2. e-closure(p) è l’insieme di tutti i vertici q tali che c’è un cammino da p a q etichettato e e-closure(P) =  p  P e-closure(p) d^(q, e) = e-closure(q) d^(q, wa) = e-closure({p | $r  d^(q, w) p  d (r, a)}. Osservazione. d^(q, a) non è necessariamente uguale a d(q,a). . e e 1 2

10 NFA con e transizioni (2)
Teorema. Se L è accettato da un NFA con e-transizioni allora L è accettato da un NFA senza e-transizioni. Prova. Dato M = (Q, S, d, q0 , F) NFA con e-transizioni costruiamo M’ = (Q, S, d’, q0 , F’) senza e-transizioni d’(q,a) = d^(q,a) e F’ = F{q0} se e-closure(q0 ) contiene uno stato in F e F’= F altrimenti. Proviamo d’(q0,x) = d^(q0,x) per induzione su |x|. Poiché d’(q0,e)= {q0} mentre d^(q0, e) = e-closure(q0 ) può non essere vero per x = e. Base: |x|=1 d’(q0,a) = d^(q0,a) per definizione Passo: |x|>1 d’(q0,wa) = d’(d’(q0,w),a) . Per ipotesi di induzione d’(q0,w) = d^(q0,w) = P. Dobbiamo mostrare d’(P,a) = d^(q0,wa). Si ha d’(P,a) =  q  P d^(q,a) per la base dell’induzione = d^(q0,wa) per definizione di d^.

11 NFA con e transizioni (3)
Dobbiamo ora mostrare che d’(q0,x) contiene uno stato di F’ se e solo se d^(q0,x) contiene uno stato di F. Se x = e d’(q0,e) = {q0 } e è posto in F’ ogni volta che d^(q,e) = e-closure(q0 ) contiene uno stato in F. Se non x = e se d^(q0,x) contiene uno stato in F allora d’(q0,x) contiene lo stesso stato in F’. Viceversa, se d’(q0,x) contiene uno stato in F’ diverso da q0 , allora d^(q0,x) contiene uno stato in F. Infatti se d’(q0,x) contiene q0 e q0 non è in F, allora per definizione di d^ lo stato in e-closure(q0 ) e in F deve essere in d^(q0,x).

12 NFA con e transizioni (4)
Esempio. Dato l’automa La funzione è la seguente: d^(q0,0)={q0,q1,q2}, d^(q0,1)={q1, q2}, d^(q0,2)={q2} d^(q1,0)= , d^(q1,1)={q1, q2}, d^(q1,2)={q2} d^(q2,0)= , d^(q2,1)= , d^(q2,2)={q2} L’automa senza e transizioni è il seguente: . e e 1 2 . . 1 2 0,1 1,2 0,1,2

13 Proprietà di chiusura degli insiemi regolari (1)
Teorema. Gli insiemi regolari sono chiusi per unione, concatenazione, chiusura di Kleene.

14 Proprietà di chiusura degli insiemi regolari (2)
Teorema. Gli insiemi regolari sono chiusi per complementazione, ossia se L è regolare anche S*-L è regolare. Prova. Sia L accettato dall’automa M = (Q, S, d, q0, F). Prendiamo M’ = (Q, S, d, q0, Q-F). Allora M’ accetta una parola w se e solo se d(q0,w) è in Q-F, cioè se w  S*-L. Teorema. Gli insiemi regolari sono chiusi per intersezione. Prova. Siano M1 = (Q1, S, d1, q1, F1) e M2 = (Q2, S, d2, q2, F2). L’automa M = (Q1  Q2, S, d, [q1, q2], F1  F2) con d([p1,p2],a) = [d1(p1, a),d2(p2, a)] accetta L(M) = L(M1)  L(M2). La tesi segue anche dalla chiusura per unione e per complementazione. Infatti L1 L2 = (L1C  L2C )C .

15 Proprietà di chiusura degli insiemi regolari (3)
Una sostituzione f : S  2D* è un’applicazione di un alfabeto S su un sottoinsieme di D* per un alfabeto D. L’applicazione è estesa a stringhe f(e) = e f(xa) = f(x) f(a) e a linguaggi f(L)= xL f(x) Esempio. Sia f(0) = a, f(1) = b*. Allora f(01) = ab*. Se L = 0*(0+1)1* allora f(L) = a*(a+b*)(b*)* = a*b*.

16 Proprietà di chiusura degli insiemi regolari (4)
Teorema. La classe degli insiemi regolari è chiusa per sostituzione. Prova . Sia R  S* un insieme regolare e per ogni a  S sia f : S  2D* la sostituzione tale che f(a) = Ra. Osserviamo che la sostituzione di unione, prodotto, chiusura è unione, prodotto, chiusura della sostituzione. La prova si fa per induzione sul numero di operatori nell’espressione regolare. Un omomorfismo h è una sostituzione tale che h(a) contiene una sola stringa per ciascun a. L’immagine omomorfica di un linguaggio L è h-1(L)= {x | h(x)  L}. Per una stringa w h-1(w)= {x | h(x) = w}.

17 Proprietà di chiusura degli insiemi regolari (5)
Esempio. Prendiamo h tale che h(0) = aa, h(1)= aba. Allora h(0101) = aaabaaaaba. Se L1 = (01)* allora h(L1) = (aaaba)*. Se L2 = (ab+ba)*a allora h-1(L2) = {1} (è la sola stringa tale che h(x) = y con y  L2). Osservazione. h(h-1(L2)) = {aba}  L2 Con l’omomorfismo h(0) = a, h(1) = aa h -1(h (L1)) = (01+10)*  L1. In generale h(h-1(L))  L h -1(h (L))  L1

18 Proprietà di chiusura degli insiemi regolari (6)
Teorema. La classe degli insiemi regolari è chiusa per omomorfismo e omomorfismo inverso. Prova. La chiusura per omomorfismo segue dalla chiusura per sostituzione di cui è un caso particolare. Per la chiusura inversa prendiamo M = (Q, S, d, q0, F) che accetta L. Sia h un omomorfismo da D in S*. Prendiamo M = (Q’, S, d’, q0, F) con d’(q,a) = d(q, h(a)) per q  Q, a  D. Per induzione su |x| si ha d’(q0,x) = d(q0,h(x)). Quindi M’ accetta x se e solo se M accetta h(x), cioè L(M’) = h-1(L (M)).

19 Applicazione della chiusura per omomorfismo e per omomorfismo inverso
Sappiamo che {0n1n | n ≥ 1} non è regolare. Mostriamo che anche {anban | n ≥ 1} non è regolare facendo vedere che si può trasformare in {0n1n | n ≥ 1} con operazioni che preservano la regolarità. Prendiamo due omomorfismi h1, h2 tali che h1(a) = a h1(b) = ba h1(c) = a h2 (a) = 0 h2 (b) = h2 (c) =1 Si ha h1-1({anban | n ≥ 1})  a*b*c*= {anbcn-1 | n ≥ 1} h2 (h1-1({anban | n ≥ 1})  a*b*c*) = {0n1n | n ≥ 1} Se {anban | n ≥ 1} fosse regolare, poiché omomorfismi, omomorfismi inversi e intersezione preservano la regolarità ne seguirebbe che {0n1n | n ≥ 1} è regolare, che è una contraddizione.

20 Proprietà di chiusura degli insiemi regolari (7)
Il quoziente di due linguaggi L1 e L2, denotato L1/L2, è {x | $ y  L2 tale che xy  L1 }. Esempi. Prendiamo L1 = 0*10*, L2 = 10*1. Poiché ogni y in L2 ha due 1 e ogni stringa in L1 ha un solo 1, non c’è x tale che xy  L1, y  L2. Prendiamo L1 = 0*10*, L2 = 0*1. Allora L1/L2 = 0* poiché per oni x in 0* possiamo prendere y uguale a 1.

21 Proprietà di chiusura degli insiemi regolari (8)
Teorema. La classe degli insiemi regolari è chiusa per quoziente con insiemi arbitrari. Prova. Sia M = (Q, S, d, q0, F) un automa che accetta un insieme regolare R. Sia L un linguaggio arbitrario. Il quoziente R/L è accettato da un automa M’ = (Q, S, d, q0, F’) che si comporta come M tranne che gli stati finali di M’ sono tutti gli stati di M tali che esiste un y in L per cui d(q,y) è in F. La costruzione non è effettiva.

22 Proprietà decidibili degli insiemi regolari (1)
Teorema. L’insieme delle parole accettate da un automa finito M con n stati è: 1. non vuoto se e solo se M accetta una stringa di lunghezza minore di n 2. infinito se e solo se l’automa accetta qualche stringa di lunghezza l con n £ l < 2n. Prova. 1.”se”: ovvio. “solo se”: supponiamo che M accetti un insieme non vuoto e che w sia una delle stringhe più corte accettate da M. Per il pumping lemma deve essere |w| < n. Infatti se w fosse la parola più corta con |w| ≥ n, allora sarebbe w = uxy e uy sarebbe la stringa più corta accettata, contro l’ipotesi.

23 Proprietà decidibili degli insiemi regolari (2)
2. Se w  L(M) e n £ |w| < 2n allora L(M) è infinito per il pumping lemma. Infatti w = w1w2w3 e, per ogni i, anche w1w2iw3  L(M). Viceversa, se L(M) è infinito esiste in L(M) w tale che |w| ≥ n. Dobbiamo dimostrare che |w| < 2n. Se nessuna stringa è di lunghezza compresa tra n e 2n-1, allora sia w di lunghezza almeno 2n ma di lunghezza uguale a quella delle parole più corte di lunghezza almeno 2n. Allora per il pumping lemma possiamo scrivere w = w1w2w3 con 1 £ |w2| £ n e w1w3  L(M). Allora o w non era una parola tra le più corte di quelle di lunghezza 2n o più oppure |w1w3| è tra n e 2n-1. In ogni caso una contraddizione. Per decidere se L(M) è vuoto basta controllare l’accettazione di ogni stringa fino alla lunghezza n. Per decidere se il linguaggio è infinito basta controllare l’appartenenza a L(M) di un parola di lunghezza tra n e 2n-1. Basta anche controllare che il diagramma abbia un ciclo.

24 Proprietà decidibili degli insiemi regolari (3)
Teorema. C’è un algoritmo per determinare se due automi finiti sono equivalenti. Prova. Siano M1, M2 due automi che accettano L1, L2 rispettivamente. Per le proprietà di chiusura per unione, intersezione e complementazione (L1  L2C )  (L1C  L2 ) è accettato da un automa finito M3 , ma M3 accetta una stringa se e solo se L1 L2 .Quindi l’equivalenza è ridotta alla vuotezza, che è decidibile.

25 Teorema di Myhill e Nerode (1)
Dato un linguaggio L definiamo una relazione RL tale che x RL y se e solo se per ciascuno z o entrambi o nessuno di xz e yz è in L. Osservazione. La relazione è sempre di indice finito, per il pumping lemma, se il linguaggio è regolare. La relazione può essere espressa in termini di automi. Dato un DFA M = (Q, S, d, q0, F), per x, y  S* x RM y se e solo se d(q0,x) = d(q0,y). Proprietà. RM è una relazione di equivalenza. RM divide S* in classi di equivalenza (una per ciascuno stato raggiungibile da q0). RM è invariante destra rispetto alla concatenazione: se x RM y allora per ogni z  S* xz RM yz, poiché d(q0, xz) = d(d(q0,x), z) = d(d(q0,y), z) = d(q0, yz).

26 Teorema di Myhill e Nerode (2)
Teorema. Le asserzioni seguenti sono equivalenti: 1. L’insieme L è accettato da un automa finito. 2. L’insieme è l’unione di alcune classi di equivalenza di una relazione di equivalenza invariante destra di indice finito. 3. La relazione di equivalenza RL sia definita da x RL y se e solo se per ogni z  S* è xz  L esattamente quando yz  L. Allora RL è di indice finito. Prova. 1  2. Sia L accettato da un DFA M = (Q, S, d, q0, F). Sia RM la relazione di equivalenza x RM y se e solo se d(q0,x) = d(q0,y). RM è invariante destra perché per ogni z se d(q0,x) = d(q0,y) allora se d(q0,xz) = d(q0,yz). L’indice è finito perché al più uguale al numero degli stati in Q. L è l’unione di quelle classi di equivalenza che includono stringhe x tali che d(q0,x) è in F.

27 Teorema di Myhill e Nerode (3)
2  3. Una relazione di equivalenza E che soddisfa (2) è un raffinamento di RL, ossia ogni classe di E è contenuta in una classe di RL. Quindi l’indice di RL non è più grande di quello di E e perciò è finito. Assumiamo xEy. Poiché E è invariante destra, allora per ogni z  S* xzEyz e quindi yz è in L se e solo se xz è in L. Quindi per definizione di RL vale anche xRLy e quindi la classe di equivalenza di x in E è contenuta nella classe di equivalenza di x in RL. 3  1. Mostriamo che RL è invariante destra. Supponiamo xRLy e prendiamo w  S* . Allora dobbiamo provare xwRLyw. Poiché xRLy allora per v qualsiasi xv  L se e solo se yv  L. Se prendiamo v = wz è provato che è invariante destra. Sia Q’ l’insieme delle classi di equivalenza di RL e [x] l’elemento di Q’ che contiene x. Definiamo d’([x], a)=[xa]. Prendiamo q0’ = [e], F’={[x]| x in L}. L’automa M’ = (Q’, S’, d’, q0’, F’) accetta L poiché d’(q0’,x)=[x] e cosí x  L(M’) se e solo se x  F’.

28 Teorema di Myhill e Nerode (4)
Prendiamo l’automa Assumiamo F = {c,d,e}. Tutti gli stati sono raggiungibili dallo stato iniziale. Le classi di equivalenza sono: ca = (00)*, cb = (00)*0, cc = (00)*1, cd = (00)*01, ce = 0*100*, cf = 0*10*1(0+1)*. L è l’unione delle classi cc, cd, ce. a b 1 1 . . d c 1 1 . e f 1 0,1

29 Teorema di Myhill e Nerode (5)
La relazione RL per L ha x RLy se e solo se x e y non hanno 1 x e y hanno ciascuno un 1 x e y hanno ciascuno più di un 1 (per esempio se x = 00 e y = 000 allora xz in L se e solo se z in 1+100*, ma questo vale anche per yz). Denotiamo le tre classi c1 = 0*, c2 = 0*10*, c3 = 0*10*1(0+1)*. Si ha c1 = ca  cb, c2 = cc  cd  ce , c3 = cf. Da RL costruiamo un DFA. Prendiamo rappresentanti per c1, c2, c3, ad esempio e, 1, 11. Prendiamo F ={[1]}. Per d’ abbiamo d’([1],0) = [1] perché se w è in [1], ad esempio 0i10j, allora w0 è in 0i10j+1 che è in c1. [e] [1] [11] . 1 1 0,1

30 Teorema di Myhill e Nerode (6)
Teorema. Il minimo automa che accetta L è unico a meno di isomorfismo (ridenominazione degli stati) ed è dato da M’ come costruito nella prova del teorema precedente. Prova. Nella prova del teorema precedente si vede che un qualunque DFA M = (Q, S, d, q0, F) che accetta L definisce una relazione di equivalenza che è un raffinamento di RL. Così il numero di stati di M è più grande o uguale al numero di stati dell’automa M’ che risulta dalla costruzione. Se vale l’uguaglianza ciascuno stato di M può essere identificato con uno degli stati di M’. Ossia, sia q uno stato di M. Ci deve essere x in S* tale che d(q0,x) = q, altrimenti q potrebbe essere rimosso e si potrebbe trovare un automa più piccolo. Identifichiamo q con lo stato d(q0’,x) di M’. L’identificazione è consistente. Infatti se d(q0,x) = d(q0,y) = q allora (per la prova del teorema precedente) x e y sono nella stessa classe di equivalenza di RL. Ne segue d’(q0’,x) = d’(q0’,y) = q e questo prova l’unicità.

31 Algoritmo per la costruzione dell’automa minimale (1)
Idea. Dato M = (Q, S, d, q0, F) sia  la relazione di equivalenza sugli stati di M tale che p  q se e solo se, per ogni stringa di input x, d(p,x) è uno stato accettore se e solo se d(q,x) è uno stato accettore. Per il teorema c’è un isomorfismo tra le classi di equivalenza di  che contengono gli stati raggiungibili da q0 per qualche stringa di input e gli stati dell’automa minimale M’, cosí gli stati di M’ possono essere identificati con queste classi. Se p  q diciamo che p è equivalente a q. Diciamo che p è distinguibile da q se esiste un x tale che d(p,x) è in F e d(q,x) no, e viceversa. L’idea è di marcare inizialmente come distinti uno stato finale e uno stato non finale e di procedere quindi marcando come distinti due stati da cui per uno stesso simbolo di input si hanno transizioni a due stati distinti.

32 Algoritmo per la costruzione dell’automa minimale (2)
Esempio. Consideriamo l’automa di esempio. Costruiamo una tabella con un’entrata per ogni coppia di stati. Mettiamo una marca nella tabella ogni volta che scopriamo che due stati non possono essere equivalenti. Inizialmente marchiamo ogni entrata corrispondente a uno stato finale e a uno non finale. Poi marchiamo coppie di stati da uno dei quali andiamo a uno stato finale mentre dall’altro andiamo a uno stato non finale. b c   d   e   f      a b c d e

33 Algoritmo per la costruzione dell’automa minimale (3)
Poiché d(f,1), d(a,2)) = (f,c) e (f,c) marcata, marchiamo (f,a) e analogamente marchiamo (f,b). Così alla fine abbiamo a  b, c  d  e. Algoritmo begin 1) for p in F and q in Q-F do mark (p,q); 2) for each pair of distinct states (p,q) in F  F or Q-F  Q-F do 3) if for some input symbol a, (d(p,a), d(q,a)) is marked then begin 4) mark (p,q); 5) recursively mark all unmarked pairs on the list for (p,q) and on lists of other pairs that are marked at this step end else /* no pair (d(p,a), d(q,a)) is marked */ 6) for all input symbols a do 7) put (p,q) on the list for (d(p,a), d(q,a)) unless d(p,a) = d(q,a) end

34 Algoritmo per la costruzione dell’automa minimale (4)
Lemma (Complessità). Assumiamo che S abbia k simboli e Q abbia n stati. La complessità dell’algoritmo è O(kn2). Prova. La linea 1 richiede O(n2) passi. Il ciclo delle linee 2-7 è eseguito O(n2) volte, al più una volta per ogni coppia di stati. Il tempo totale speso nelle linee da 2 a 4, 6, 7 è O(kn2). Il tempo speso in totale nella linea 5 è la somma delle lunghezze di tutte le liste, ma ogni coppia è messa nella linea 7 in al più k liste, quindi il tempo speso nella linea 5 è O(kn2), cosí il tempo totale è O(kn2).

35 Algoritmo per la costruzione dell’automa minimale (5)
Lemma (Correttezza della marcatura degli stati). Sia M = un DFA. Allora p è distinguibile da q se e solo se l’entrata corrispondente alla coppia (p,q) è marcata dall’algoritmo. Prova. Assumiamo che p sia distinguibile da q e sia x la stringa più breve che distingue p da q. Proviamo per induzione sulla lunghezza di x che l’entrata (p,q) viene marcata. Se x è e allora esattamente uno di p e q è finale e la coppia viene marcata nella linea 1. Assumiamo l’ipotesi vera per |x| < i, 1 £ i, e |x| = i. Sia x=ay, t=d(p,a), u=d(q,a). Ora, y distingue t da u e |y|=i-1, quindi la coppia (t,u) è marcata. Se questo avviene dopo che (p,q) è già stata considerata o è marcata o è nella lista associata a (t,u) e viene marcata (linea 5). Se (p,q) è considerata dopo (t,u), allora (p,q) è marcata quando è considerata. In tutti i casi viene marcata. Viceversa, assumiamo che (p,q) sia marcata e facciamo vedere che p,q sono distinguibili. Perinduziojne sul numero delle coppie.

36 Algoritmo per la costruzione dell’automa minimale (6)
Teorema. Il DFA costruito dall’algoritmo e rimuovendo stati inaccessibili è il minimo DFA per il linguaggio che riconosce. Prova. Sia M = (Q, S, d, q0, F) il DFA dato e M’ = (Q’, S, d’, [q0], F’) il DFA costruito con Q’= {[q] | q accessibile da q0}, F’= {[q]| q  F}, d’([q],a) = d(q,a). La relazione d’ è definita consistentemente perché se q  p allora d(p,a)  d(q,a), cioè se d(p,a) è distinto da d(p,a) da x, allora ax distingue q da p. Per induzione su |w| si vede d’([q0],w) = [d(q0,w)]. Ne segue L(M) = L(M’). Mostriamo che M’non ha più statidi quante sono le classi di equivalenza di RL dove L = L(M). Se non fosse cosí, ci sarebbero in q due stati accessibili q e p tali che non q  p e tuttavia ci sono x e y tali che d(q0,x)=q e d(q0,y)=p e xRLy. Ma allora q  p, perché se non fosse cosí qualche w in S* dovrebbe distinguere p da q (per il lemma). Ma allora sarebbe falso xwRLyw perché potremmo prendere z=e e osservare che esattamente uno di xwz e ywz è in L. Ma poiché è invariante destra, si ha xwRLyw. Quindi q e p non esistono, M’ non ha più stati dell’indice di RL.