Esempio stringhe palindrome 1 Automa per il riconoscimento del linguaggio L = {w c w R } A = < {s,f}, {a,b,c}, {a,b},!, s, { f } > con! che contiene le transizioni: 1. (( s, a, " ), (s, a)! [ push a] 2. (( s b, " ), (s, b) [ push b] 3. (( s, c, " ), (f, ")!! 4. (( f a, a ), (f, ")! [ pop a ] 5. (( f, b, b ), (f, ")! [ pob b ] Si osservi come nell alfabeto di stack non è compreso il simbolo c che denota la demarcazione tra le due parti della stringa esecuzione per abbcbba Stato Stringa di input stack transizione s abbcbba " s bbcbba a 1 s bcbba ba 2 s cbba bba 2 f bba bba 3 f ba ba 5 f a a 5 f " " 4
Esempio stringhe palindrome 2 Automa per il riconoscimento del linguaggio L = {w w R } A = < {{s,f}, {a,b}, {a,b},!, s, { f } > con! che contiene le transizioni: 1. (( s, a, " ), (s, a)! [ push a] 2. (( s b, " ), (s, b) [ push b] 3. (( s, ", " ), (f, ")!! 4. (( f a, a ), (f, ")! [ pop a ] 5. (( f, b, b ), (f, ")! [ pob b ] Nell applicazione della regola 3 la macchina puo scegliere non deterministicamente di andare nello stato f senza consumare input o fare un push del prossimo simbolo nello stack. Si osservi come questa sia l unica regola variata rispetto all automa precedente. Esecuzione per abbbba Stato Stringa di input stack transizione s abbbba " " s bbbba a 1 s bbba ba 2 s bba bba 2 f bba bba 3 f ba ba 5 f a a 5 f " " 4
Esercizio 2 Esercizi Esercizio 1 Definire un automa per il linguaggio L = {a n b n }! 1. (( q, a, "), (q, a)) 2. (( q, b, a), (p, ")) 3. (( p, b, a), (p, ")) 4. (( p, ", "), (f, " )) Definire un automa a pila che riconosca il linguaggio!! L = {w # {a,b}* : w ha lo stesso numero di a e di b } 1. (( s, ", " ), (q, c))! si colloca un carattere c nello stack [c non fa parte di!, ma di $] 2. (( q, a, c ), (q, ac)) se ti trova un a la prima volta si inizializza uno stack di a 3. (( q, a, a ), (q, aa)) ogni altro a viene collocato nello stack di a 4. (( q, a, b ), (q, "))! se si legge un a e nello stack si trova b si elimina b dallo stack! 5. (( q, b, c ), (q, bc)) 6. (( q, b, b ), (q, bb)) 7. (( q, b, a ), (q, ")) } analogamente per il carattere b 8. (( q, ", c ), (f, "))!
Modalità di accettazione Dato l automa pushdown < K, ", $,!, s, Z > si dice che un linguaggio L è accettato per pila vuota se: L e (M) = { w # "* : ( s, w, ") %* (q, ", ") per qualche q # K } [In altre parole la stringa è accettata se e solo se al termine della scansione la pila è vuota " indipendentemente dallo stato raggiunto] Dato l automa pushdown < K, ", $,!, s, Z > si dice che un linguaggio L è accettato per raggiungimento di stato finale se: L f (M) = { w # "* : ( s, w, ") %* (f, ", &) per qualche f # Z, & # $* } [In altre parole la stringa è accettata se e solo se al termine della scansione della stringa l automa raggiunge uno stato finale]
Modalità di accettazione Teorema. Dato un automa a pila non deterministico A che accetta un linguaggio per stato finale esiste un automa A non deterministico che accetta lo stesso linguaggio per pila vuota. Teorema. Dato un automa a pila non deterministico A che accetta un linguaggio per pila vuota esiste un automa A non deterministico che accetta lo stesso linguaggio per stato finale. Questa equivalenza non si mantiene qualora si faccia riferimento ad automi a pila deterministici. Anticipando quanto verrà illustrato nel seguito gli automi a pila deterministici hanno un potere computazionale inferiore rispetto agli automi a pila non deterministici. Si può mostrare come esistano linguaggi accettati da automi a pila deterministici per stato finale che non sono accettati da automi a pila per pila vuota.
Automi Pushdown e grammatiche context-free Teorema: La classe dei linguaggi accettati dagli automi pushdown è esattamente la! classe dei linguaggi context-free. Data la grammatica context-free G = < V N, V T, P, S > siamo in grado di costruire un automa pushdown M equivalente, nel senso che L(G) = L(M) dato da: l insieme K degli stati = {p, q} l alfabeto di ingresso " è V T l alfabeto di stack $ è V = VN ( VT la funzione di transizione! contiene le transizioni definite come: 1. ((p, ", "), (q, S) 2. ((q, ", A), (q, x) per ogni regola grammaticale A' x in P 3. (q, s, s), (q, ") per ciascun simbolo s # V T lo stato iniziale = {p} lo stato finale = {q} [l automa M possiede due stati p, q e rimane permanentemente nello stato q dopo la prima mossa]
Esempio Dalla grammatica G 15 = < S, {a, b, c}, P, S> con produzioni P date da: S ' a S a b S b c [che riconosce il linguaggio L = {w c w R }] è possibile costruire l automa M = < {p, q}, {a, b, c}, {S,a, b, c},!, { p},{q} > con! che contiene le transizioni 1. ((p, ", "), (q, S) 2. ((q, ", S), (q, a S a) 3. ((q, ", S), (q, b S b) 4. ((q, ", S), (q, c) 5. ((q, a, a), (q, ") 6. ((q, b, b), (q, ") 7. ((q, c, c), (q, ") regole grammaticali simboli terminali
Esempio cont. Esecuzione per abbcbba Stato Stringa di input stack regola applicata p abbcbba " q abbcbba S 1. ((p, ", "), (q, S) q abbcbba a S a 2.((q, ", S), (q, a S a) q bbcbba S a 5. ((q, a, a), (q, ") q bbcbba b S b a 3.((q, ", S), (q, b S b) q bcbba S b a 6.((q, b, b), (q, ") q bcbba b S b b a 3.((q, ", S), (q, b S b) q cbba S b b a 6.((q, b, b), (q, ") q cbba c b b a 4.((q, ", S), (q, c) q bba b b a 7.((q, c, c), (q, ") q ba b a 6.((q, b, b), (q, ") q a a 6.((q, b, b), (q, ") q " " 5. ((q, a, a), (q, ")
Proprietà di chiusura dei linguaggi context-free Teorema: La classe dei linguaggi context-free è chiusa rispetto all Unione, Concatenazione,! Chiusura di Kleene. Date le grammatiche context-free G = < V N, V T, P, S > e G = < V N, V T, P, S > che riconoscono i linguaggi L(G ) e L(G ) si costruisce la grammatica G = < V N, V T, P, S> nel seguente modo. 1. Unione L(G) = L(G ) ( L(G )! G =< VN = V N ( V N ({S} ; V T = V T ( V T ; P = P ( P ({S' S, S' S }, S > 2. Concatenazione L(G) = L(G ) L(G ) G = < V N = V N ( V N ({S} ; V T = V T ( V T ; P = P ( P ({S' S S }, S > 3. Chiusura di Kleene L(G )* G = < V N = V N ({S} ; V T = V T ; P = P ( {S' ", S' SS }, S >