Automi a pila (1)

1. Un automa a pila (PDA) è M = (Q, S, G, d, q0, Z0, F) dove: Q insieme finito di stati S alfabeto finito di input 3. G alfabeto di pila d: Q  (S  {e}) G  2 QG* q0 stato iniziale Z0 simbolo di inizio pila 7. F  = Q insieme degli stati finali (eventualmente vuoto). La descrizione istantanea di un PDA è (q,w,g) dove 1. q è lo stato 2. w è la stringa ancora da leggere 3. g è il contenuto della pila. Dato un PDA M = (Q, S, G, d, q0, Z0, F), (q, aw, Za) |-M (p, w, ba) se d(q, a, Z) contiene (p, b). L(M) accettato a stati finali è {w | (q0, w, Z0) |-M* (p, e, g), p  F} N(M) accettato a pila vuota è {w | (q0, w, Z0) |-M* (p, e, e), p  Q}. Automi a pila (1)

2. Esempio. Si abbia il PDA M = ({q1,q2}, {0,1}, {R,B,G}, d, q1, R, Ø) • dove d è: d(q1, 0, R) = {(q1, BR)} d(q1, 1, R) = {(q1, GR)} d(q1, 0, B) = {(q1, BB), (q2, e)} d(q1, 1, B) = {(q1, GB)} • d(q1, 0, G) = {(q1, BG)} d(q1, 1, G) = {(q1, GG), (q2, e)} d(q2, 0, B) = {(q2, e)} d(q1, 1, G) = {(q2, e)} • d(q1, e, R) = {(q2, e)} • d(q2, e, R) = {(q2, e)} Il PDA accetta L = {wwR | w  (0+1)* }. Automi a pila (2)

3. Un PDA M = (Q, S, G, d, q0, Z0, F) è deterministico se vale: 1. Se d(q, e, Z) non vuoto, allora d(q, a, Z) vuoto per ogni a  S (non c’è una scelta tra una e -mossa e una mossa su input a) 2. d(q, a, Z) non contiene più di un elemento (per ogni a c’è una sola mossa). PDA deterministici e PDA non deterministici non sono equivalenti: non c’è un PDA che accetta L = {wwR | w  (0+1)* }. Teorema. I linguaggi accettati per stati finali sono esattamente quelli accettati per pila vuota. Prova. Se L è L(M2) per un PDA M2 allora è N(M1) per un PDA M1. M1 cancella la pila quando M2 entra in uno stato finale. Un nuovo marcatore di pila sotto quello originario impedisce che l’automa accetti senza che sia entrato in uno stato finale di M2. Se L è N(M1) per un PDA M1 allora è L(M2) per un PDA M2 . Quando M1 svuota la pila rimane nella pila il nuovo marcatore e l’automa entra in uno stato finale. Automi a pila (3)

4. Teorema. Se L è un CFL allora esiste un PDA M tale che L = N(M). Prova. Sia G = (V,T, P, S) in GNF. Prendiamo M = ({q}, T, V, d, q, S, ) dove d(q, a, A) contiene (q, g) quando A  ag è in P. Si dimostra S ÞG* xa se e solo se (q,x,S) |-M* (q, e, a). Prendendo a = e si ha S ÞG* x se e solo se (q,x,S) |-M* (q, e, e) ossia x  L se e solo se x  N(M). Teorema. Se L è N(M) per PDA M, allora L è un CFL. Prova. Sia M = (Q, S, G, d, q0, Z0 , ). Prendiamo G = (V, S, P, S) dove gli elementi di V sono della forma [q,A,p] con p, q  Q e A G. P è l’insieme delle produzioni S  [q0, Z0 , q] per ogni q  Q [q, A, qm+1]  a [q1, B1, q2] … [qm, Bm, qm+1] se d(q,a,A) contiene (q1, B1 … Bm). Si dimostra [q, A, p] ÞG* x se e solo se (q, x, A) |-M* (p, e, e). Automi a pila (4)

5. Lemma. Sia L un CFL. Allora c’è una costante n (che dipende solo da L) tale che se z è in L e |z| >= n allora si può scrivere z= uvwxy con |vx|>= 1 |vwx|<= n per ogni i>= 0 uviwxiy è in L. Pumping lemma per linguaggi non contestuali (1)

6. Il pumping lemma può essere usato per provare che un linguaggio non è non contestuale. Esempio. Prendiamo L = {aibici |i >= 1}. Supponiamo che sia non contestuale e che n sia la costante del lemma. Prendiamo z = anbncn e scriviamo z = uvwxy. Dove potrebbero essere in anbncn le stringhe v e x da pompare? Poiché |vwx|<= n, vx non può contenere istanze di a e di c poiché la a più a destra è n+1 posizioni più lontano dal c più a sinistra. Se v e x consistono di sole a allora uwy ha n b e n c ma non n a (le altre istanze di a sono in vx) e quindi uwy non è della forma aibici , una contraddizione. Analogamente se v e x consistono di sole b o sole c. Se vx ha a e b allora uwy ha più c che a e b. Similmente se vx contiene b e c. Pumping lemma per linguaggi non contestuali (4)

7. Teorema. I linguaggi non contestuali sono chiusi per unione, concatenazione, chiusura di Kleene. Prova. Sia L1 non contestuale generato da G1 = (V1,T1, P1, S1) e L2 non contestuale generato da G2 = (V2,T2, P2, S2). Assumiamo V1 e V2 disgiunti e S3 ,S4 ,S5 non in V1 V2. Per L1 L2 prendiamo G3 = (V1 V2  { S3}, T1  T2, P3, S3) dove P3 = P1 P2 {S3 S1 , S3 S2}. Per L1 . L2 prendiamo G4 = (V1 V2  { S4}, T1  T2, P4, S4) dove P3 = P1 P2 {S4 S1 S2}. Per L1* prendiamo G5 = (V1 {S5}, T1, P5, S5) dove P3 = P1 {S5 S1 S5 ,S5  e}. Teorema. I linguaggi non contestuali sono chiusi per sostituzione. Teorema. I linguaggi non contestuali sono chiusi per omomorfismo. Proprietà dei linguaggi non contestuali (1)

8. Esempio. Sia L un linguaggio di parole con un numero uguale di a e di b, sia La = {0n1n | n>= 1}, Lb = {wwR | w  (0+2)*}. Prendiamo per G la grammatica con produzioni Sa S b S| b S a S| e Per Ga prendiamo Sa 0 Sa 1 | 01 Per Gb prendiamo Sb 0 Sb 0 | 2 Sb 2 | e Sia f la sostituzione f(a) = La, f(b) = La. Allora f(L) è generato dalla grammatica con produzioni SSa S Sb S| Sb S Sa S| e Sa 0 Sa 1 | 01 Sb 0 Sb 0 | 2 Sb 2 | e Proprietà dei linguaggi non contestuali (2)

9. Teorema. I linguaggi non contestuali sono chiusi per omomorfismo inverso. Prova. Sia L = L(M). Si costruisce un PDA M’ che sull’input a genera la stringa h(a), simula M su h(a) e accetta a se M accetta h(a). Teorema. I linguaggi non contestuali non sono chiusi per intersezione. Prova. Prendiamo L1 = {aibici |i >= 1}, L2 = {aibicj |i >= 1, j >= 1}, L3 = {aibjcj |i >= 1, j >= 1}. Il linguaggio L1 = L2 L3 è l’intersezione di due CFL ma non è un CFL. Teorema. I linguaggi non contestuali non sono chiusi per Intersezione con gli insiemi regolari. Proprietà dei linguaggi non contestuali (3)

10. Teorema. Data una CFG G = (V,T, P, S) e x  T* è decidibile se x  L(G). Prova. Convertiamo G in G’ in forma normale di Greibach. Ogni produzione aggiunge un solo terminale e quindi se x ha una derivazione in G’ ne ha una in esattamente |x| passi. Se nessun non terminale in G’ ha più di k produzioni, allora ci sono al più k|x| Derivazioni da più a sinistra di stringhe di lunghezza |x|. Si possono provare sistematicamente. Questo algoritmo richiede un tempo esponenziale in |x|. Ne esiste uno di Cocke-Younger-Kasami in tempo cubico. Proprietà dei linguaggi non contestuali (4)