Orario e ricevimento. Automi e Linguaggi Formali. Altre informazioni utili. Sito del corso. Sommario del corso. Linguaggi di programmazione

Transcript

1 Orario e ricevimento Automi e Linguaggi Formali Docente: Francesca Rossi -mail: frossi@math.unipd.it Orario: Lunedi, Martedi, Mercoledi, Giovedi 3:3-5:3 LUM25 Crediti: 8 crediti formativi, circa 64 ore di lezione Ricevimento: Martedi :-3:, studio 428, IV piano, orre Archimede (Via rieste 63) Docente: Francesca Rossi Automi e Linguaggi Formali Docente: Francesca Rossi Automi e Linguaggi Formali Sito del corso Altre informazioni utili URL: frossi/automi22.html Contiene: programma date appelli lucidi voti... Libro principale: Automi, linguaggi e calcolabilita, J.. Hopcroft, R. Motwani, and J. D. Ullman, terza edizione, Pearson/Addison-Wesley, 29. Altro libro: Compilatori: principi, tecniche e strumenti, A.H. Aho, M. S. Lam, R. Sethi, J. D. Ullman, seconda edizione, Pearson/Addison-Wesley, 29. Compitini (forse): Due compitini, uno a meta del corso e uno alla fine. Possono sostituire lo scritto. same: Scritto e, se richiesto dal docente, colloquio orale. Cinque appelli: due a fine corso (Dicembre-Gennaio), uno alla fine del II trimestre (Aprile), uno a Luglio, uno a Settembre. I lucidi per i capitoli -7 del libro principale sono basati sui lucidi in inglese di Gösta Grahne e David Ford ( slides/). Docente: Francesca Rossi Automi e Linguaggi Formali Docente: Francesca Rossi Automi e Linguaggi Formali Sommario del corso Linguaggi di programmazione Struttura dei un compilatore e fasi principali (cap. CPS) Analisi lessicale (cap. 3 CPS) Automi a stati finiti (cap.,2 ALC) spressioni regolari (cap.3 ALC) Pumping lemma e proprieta dei linguaggi regolari (cap.4 ALC) Minimizzazione degli automi a stati finiti (cap.4 ALC) Analisi sintattica top-down e bottom-up (cap.4 CPS) (cap.5 ALC) Linguaggi regolari e grammatiche (cap.5 ALC) Automi a pila (cap.6 ALC) Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di uring, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni e teorema di Rice (cap.9 ALC) Classi P e NP (cap. ALC) Linguaggi di programmazione = notazione per descrivere calcoli e computazioni Per eseguire un programma, deve essere tradotto in una forma che puo essere capita da un calcolatore compilatore Principi e tecniche utili non solo per costruire compilatori, ma in molte altre aree dell informatica: linguaggi di programmazione, architettura, teoria dei linguaggi, algoritmi, ingegneria del software, ecc. Docente: Francesca Rossi Automi e Linguaggi Formali Docente: Francesca Rossi Automi e Linguaggi Formali

2 Compilatori Struttura di un compilatore Compilatore: programma che legge un programma scritto in un linguaggio di programmazione (linguaggio sorgente) e lo traduce in un programma equivalente scritto in un altro linguaggio (linguaggio oggetto) Un compilatore mostra anche gli errori che trova durante la traduzione Se il linguaggio oggetto e eseguibile da una macchina, un utente puo eseguirlo per passare da input ad output Interprete: esegue direttamente le operazioni specificate nel programma sorgente (traducendo un istruzione alla volta ed eseguendo il pezzo di programma oggetto generato) Di solito piu veloce l esecuzione di programmi compilati Assembler: compilatore da linguaggio assembly a codice macchina Due parti: analisi e sintesi Analisi (front end): prende un programma e lo divide in parti su cui impone una struttura grammaticale; crea una rappresentazione intermedia del programma sorgente; segnala possibili errori; mette informazioni sul programma in una tavola dei simboli, da passare alla sintesi Sintesi (back end): costruisce il programma oggetto dalla rappresentazione intermedia e la tavola dei simboli Sequenza di fasi: ogni fase trasforma una rappresentazione del programma sorgente in un altra Fasi principali: analisi lessicale, analisi sintattica, analisi semantica, generazione del codice intermedio, ottimizzazionee del codice, generazione del codice Docente: Francesca Rossi Automi e Linguaggi Formali Docente: Francesca Rossi Automi e Linguaggi Formali Analisi lessicale (scanning) Analisi sintattica (parsing) Legge la stringa di caratteri del programma sorgente e raggruppa i caratteri in sequenze chiamate lexemi Per ogni lexema, un token <nome-token,valore-attributo> nome-token: simbolo associato al token valore-attributo: punta alla tavola dei simboli sempio: comando posizione = iniziale + velocita 6 lexema posizione token <id,>: riga della tavola dei simboli contiene posizione lexema = e token <=> (nessun valore attributo) lexema iniziale e token <id,2>, riga 2 contiene iniziale lexema + e token <+> lexema velocita e token <id,3>, riga 3 contiene velocita lexema e token <> lexema 6 e token <6> Rappresentazione finale: <id,> <=> <id,2> <+> <id,3> <> <6> Useremo: linguaggi regolari, automi a stati finiti, espressioni regolari Docente: Francesca Rossi Automi e Linguaggi Formali Il parser usa la prima componente dei token per creare una rappresentazione ad albero della lista di tokens (struttura grammaticale) Albero: insieme di nodi e archi diretti (da padre a figlio), tale che un nodo (radice) non ha padri, e tutti gli altri hanno esattamente un padre. Foglie: nodi senza figli. Albero sintattico: nodo interno = operazione, figli = argomenti dell operazione Mostra l ordine in cui eseguire le operazioni Useremo: grammatiche libere da contesto, automi a pila, linguaggi liberi da contesto Docente: Francesca Rossi Automi e Linguaggi Formali sempio Dalla lista di tokens <id,> <=> <id,2> <+> <id,3> <> <6> all albero sintattico = / \ <id,> + / \ <id,2> / \ <id,3> 6 Prima dobbiamo moltiplicare il lexema del token <id,3>, cioe velocita con 6 poi dobbiamo sommare il risultato con il valore di iniziale poi dobbiamo mettere il risultato nella locazione dell identificatore posizione Analisi semantica Usa l albero sintattico e la tavola dei simboli per controllare la consistenza semantica del programma Colleziona informazioni sui tipi e le mette nella tavola dei simboli (per la fase di generazione del codice) Controllo dei tipi (type checking): il tipo di ogni operazione deve andare d accordo con i tipi dei suoi operandi sempio: un indice di un array deve essere un intero (errore se ad esempio floating-point) Coercion: conversione di tipo a volte un operazione puo essere applicata sia a due interi che a due floating-point se un operando e intero e l altro e floating point, l intero viene convertito in floating-point Docente: Francesca Rossi Automi e Linguaggi Formali Docente: Francesca Rossi Automi e Linguaggi Formali

3 sempio Se posizione, iniziale, e velocita sono dichiarati come numero floating-point, e se il lexema 6 e un integer, l operazione e applicata ad un numero integer (6) e ad un floating-point (velocita ) conversione di 6 in un floating-point. Dall albero sintattico di sinistra a quello sulla destra: = = / \ / \ <id,> + <id,> + / \ / \ <id,2> <id,2> / \ / \ <id,3> 6 <id,3> inttofloat 6 Generazione del codice intermedio Rappresentazione intermedia simile al codice macchina Spesso codice a tre indirizzi: sequenza di istruzioni simili all assembly con tre operandi per istruzione Nell esempio, si ottiene: t = inttofloat(6) t2 = id3 t t3 = id2 + t2 id = t3 Al piu un operatore sulla destra: le istruzioni danno l ordine in cui effettuare le operazioni sempio: la moltiplicazione precede la somma Un nome temporaneo generato per contenere il valore calcolato da ogni istruzione Docente: Francesca Rossi Automi e Linguaggi Formali Docente: Francesca Rossi Automi e Linguaggi Formali Ottimizzazione del codice Generazione del codice Miglioramento del codice intermedio per ottenere un migliore codice oggetto Migliore: piu veloce, piu corto, meno energia necessaria, ecc. sempio: da t = inttofloat(6) t2 = id3 t t3 = id2 + t2 id = t3 a t = id3 6. id = id2 + t Conversione da integer a floating-point fatta a a tempo di compilazione (e non a tempo di esecuzione), e quindi eliminata dal codice t3 era usato solo per trasmettere un valore ad id Da rappresentazione intermedia a codice oggetto Registri o locazioni di memoria per ogni variabile del codice Da ogni istruzione in codice intermedio a sequenza di istruzioni in codice macchina sempio: da t = id3 6. id = id2 + t a LDF R2, id3 MULF R2, R2, #6. LDF R, id2 ADDF R, R, R2 SF id, R Il primo operando specifica una destinazione, F: floating-point id3 in R2, poi moltiplicazione con 6. e risultato in R2, poi id2 in R, poi somma di R e R2 in R, poi R in id Docente: Francesca Rossi Automi e Linguaggi Formali Docente: Francesca Rossi Automi e Linguaggi Formali Strumenti per la costruzione di un compilatore Ruolo dell analisi lessicale Generatori di parser: generano automaticamente un parser dalla descrizione della grammatica di un linguaggio Generatori di scanner: generano automaticamente un analizzatore lessicale dalla descrizione tramite espressioni regolari dei token di un linguaggio Generatori di generatori di codice: da regole per tradurre ogni operazione in una sequenza di istruzioni in linguaggio macchina Legge i caratteri del programma, li raggruppa in lexemi, produce in output una sequenza di token per ogni lexema Quando trova un lexema che rappresenta un indentificatore, mette il lexema nella tavola dei simboli limina spazi bianchi e commenti Scanning (compattazione della stringa di caratteri con eliminazione di commenti e spazi bianchi) seguito da analisi lessicale (tokens da lexemi) Diagramma o altro modo di descrivere i lexemi di ogni token Useremo automi a stati finiti e espressioni regolari (equivalenti) Docente: Francesca Rossi Automi e Linguaggi Formali Docente: Francesca Rossi Automi e Linguaggi Formali

4 oken, pattern, lexemi oken: coppia <nome token, valore attributo> nome token: simbolo astratto che rappresenta un unita lessicale (una parola chiave, un identificatore, ecc.) Pattern: descrizione della forma che i lexemi di un token possono avere sempio: se il token e una parola chiave, il pattern e la sequenza di caratteri che formano la parola chiave. Per identificatori, il pattern descrive tante stringhe di caratteri, che sono tutte identificatori. Lexema: sequenza di caratteri del programma sorgente che rispetta il pattern di un token sempi: token if, pattern: caratteri i e f, lexema: if token id, pattern: una lettera seguita da lettere e cifre, esempi di lexemi: posizione, iniziale token number, pattern: un numero, esempi di lexemi: 3.459,, 6.2 Casi tipici di token Un token per ogni parola chiave Vari token per gli operatori Un token per tutti gli identificatori Vari token per le costanti (numeri, letterali, ecc.) oken per altri simboli (parentesi, virgola, ecc.) Nome token per dire che token e, valore attributo per indicare quale lexema come istanza del token. Docente: Francesca Rossi Automi e Linguaggi Formali Docente: Francesca Rossi Automi e Linguaggi Formali sempio Comando Fortran = M C 2 oken generati: <id, puntatore ad nella tavola dei simboli> <assign-op> <id, puntatore ad M nella tavola dei simboli> <mult-op> <id, puntatore a C nella tavola dei simboli> <exp-op> <number, valore intero 2> Input buffering sempio: per sapere di essere alla fine di un identificatore, dobbiamo almeno leggere un carattere che non e ne una lettera ne una cifra sempio (C): < potrebbe essere un operatore oppure l inizio di <= sempio (Fortran 9, spazi sono ignorati): nel comando DO 5 I =.25 il primo lexema e DO5I (e un comando di assegnamento), mentre in DO 5 I =,25 il primo lexema e la parola chiave DO (comando for) Spesso e necessario leggere oltre la fine di un lexema per capire che lexema e Due puntatori per scorrere l input: uno all inizio del lexema corrente, uno per leggere oltre, finche non si trova un lexema che corrisponde ad un token Docente: Francesca Rossi Automi e Linguaggi Formali Docente: Francesca Rossi Automi e Linguaggi Formali Specifica dei token Linguaggi regolari spressioni regolari per descrivere i token Automi a stati finiti per descrivere analizzatori lessicali Da espressione regolare ad automa Docente: Francesca Rossi Automi e Linguaggi Formali

5 Automi a stati finiti sempi Gli automi a stati finiti sono usati come modello per Software per la progettazione di circuiti digitali. Analizzatori lessicali di un compilatore. Ricerca di parole chiave in un file o sul web. Software per verificare sistemi a stati finiti, come protocolli di comunicazione. sempio: automa a stati finiti per un interruttore on/off Push off on Push sempio: automa a stati finiti che riconosce la stringa then t h e n t th the then Rappresentazioni strutturali Concetti di base Ci sono vari modi di specificare una macchina Grammatiche: Una regola come + specifica un espressione aritmetica Coda Persona.Coda dice che una coda e costituita da una persona seguita da una coda. spressioni regolari: Denotano la struttura dei dati, per esempio: [A-Z][a-z][][A-Z][A-Z] e compatibile con (matches) Ithaca NY non e compatibile con Palo Alto CA Domanda: Quale espressione e compatibile con Palo Alto CA? Alfabeto: Insieme fnito e non vuoto di simboli sempio: Σ = {, } alfabeto binario sempio: Σ = {a, b,c,...,z} insieme di tutte le lettere minuscole sempio: Insieme di tutti i caratteri ASCII Stringa: Sequenza fnita di simboli da un alfabeto Σ, e.g. Stringa vuota: La stringa con zero occorrenze di simboli da Σ La stringa vuota e denotata con ǫ Lunghezza di una stringa: Numero di posizioni per i simboli nella stringa. w denota la lunghezza della stringa w = 4, ǫ = Potenze di un alfabeto: Σ k = insieme delle stringhe di lunghezza k con simboli da Σ sempio: Σ = {, } Σ = {,} Σ 2 = {,,, } Σ = {ǫ} Domanda: Quante stringhe ci sono in Σ 3? L insieme di tutte le stringhe su Σ e denotato da Σ Σ = Σ Σ Σ 2 Anche: Σ + = Σ Σ 2 Σ 3 Σ = Σ + {ǫ} Concatenazione: Se x e y sono stringhe, allora xy e la stringa ottenuta rimpiazzando una copia di y immediatamente dopo una copia di x x = a a 2...a i, y = b b 2...b j xy = a a 2...a i b b 2...b j sempio: x =,y =,xy = Nota: Per ogni stringa x xǫ = ǫx = x

6 Linguaggi Altri esempi Definizione: Se Σ e un alfabeto, e L Σ, allora L e un linguaggio sempi di linguaggi: L insieme delle parole italiane legali L insieme dei programmi C legali L insieme delle stringhe che consistono di n zeri seguiti da n uni {ǫ,,,,...} L insieme delle stringhe con un numero uguale di zeri e di uni {ǫ,,,,,,...} L P = insieme dei numeri binari il cui valore e primo {,,,,,...} Il linguaggio vuoto Il linguaggio {ǫ} consiste della stringa vuota Nota: {ǫ} Nota: L alfabeto Σ e sempre finito Problemi Dimostrazioni deduttive La stringa w e un elemento di un linguaggio L? sempio: Dato un numero binario, e primo = e un elemento di L P? L P? Che risorse computazionali sono necessarie per rispondere a questa domanda? Di solito non pensiamo ai problemi come delle decisioni si/no, ma come qualcosa che trasforma un input in un output. sempio: Fare il parsing di un programma C = controllare se il programma e corretto, e se lo e, produrre un albero di parsing. Sequenza di enunciati la cui verita porta da un enunciato iniziale (l ipotesi) ad un enunciato finale (la conclusione) Forma del teorema: Se H, allora C H= ipotesi, C= conclusione sempio: se x 4, allora 2 x x 2 x parametro quantificato universalmente (vale per tutti gli x) Quantificatori Modus ponens: regola logica che fa passare da un enuciato al successivo Se H e vera, e sappiamo che se H allora C, allora possiamo concludere che anche C e vera eoremi della forma C se e solo se C2 : due direzioni di prova Dimostrazione per assurdo: H e non C implica il falso Per ogni x ( x): vale per tutti i valori della variabile siste x ( x): vale per almeno un valore della variabile sempio: un insieme s e infinito se e solo se, per ogni intero n, esiste almeno un sottoinsieme di S con n elementi Dobbiamo considerare un n arbitrario e poi trovare un insieme con quel numero n di elementi precede nunciato simile ma di significato diverso, e scorretto: siste un sottoinsieme dell insieme S tale che, per ogni n, ha n elementi

7 Dimostrazioni per induzione sempio Utili quando ci sono cose definite ricorsivamente sempio: e un intero, e se n e un intero allora n+ e un intero Induzione sugli interi: dobbiamo dimostrare un enunciato S(n) su un intero n Base: dimostriamo S(i) per un intero particolare ( o di solito) Passo induttivo: per n i, dimostriamo che se vale S(n) allora vale anche S(n + ) Possiamo concludere che S(n) e vero per ogni n i Se x 4, allora 2 x x 2 Base: x = 4 2 x = 2 4 = 6 e x 2 = 4 2 = 6 Induzione: Supponiamo che 2 x x 2 per x 4 Dobbiamo dimostrare che 2 x+ (x + ) 2 Abbiamo: 2 x+ = 2 x 2 2 x 2 (dalla base induttiva) Dimostriamo adesso che 2x 2 (x + ) 2 Semplificando: x 2 + /x Se x 4, /x /4 2 + /x 2.25 Induzione strutturale sempio Molte strutture possono essere definite ricorsivamente sempio (espressioni): caso base: qualunque numero o lettera e un espressione caso induttivo: se e F sono espressioni, allora lo sono anche + F, F, e () sempi: 3+(4x2), (2x(5+7))x4 Per dimostrare teoremi su un espressione: si dimostra l enunciato sul caso base, e poi si dimostra l enunciato sulla struttura X a partire dalla validita dell enunciato sulle strutture di cui X e composta secondo la definizione ricorsiva eorema: ogni espressione ha un numero uguale di parentesi aperte e chiuse Caso base: zero parentesi vero Induzione: re modi per costruire un espressione induttivamente: + F, F, e () Per + F e F: se vale per e F, supponiamo che abbia n parentesi aperte e chiuse e F ne abbia m + F ne ha n + m Per (): se vale per, supponiamo che abbia n parentesi aperte e chiuse () ne ha n + Automi a stati finiti deterministici Un DFA e una quintupla A = (Q,Σ, δ, q,f) Q e un insieme finito di stati Σ e un alfabeto finito (= simboli in input) δ e una funzione di transizione (q, a) p q Q e lo stato iniziale F Q e un insieme di stati finali sempio sempio: Un automa A che accetta L = {xy : x,y {,} } L automa A = ({q,q,q 2 }, {, }, δ, q, {q }) come una tabella di transizione: q q 2 q q q q q 2 q 2 q L automa come un diagramma di transizione: q q 2 q,

8 Accettazione Un automa a stati finiti (FA) accetta una stringa w = a a 2 a n se esiste un cammino nel diagramma di transizione che Inizia nello stato iniziale 2 Finisce in uno stato finale (di accettazione) 3 Ha una sequanza di etichette a a 2 a n sempio: L automa a stati finiti, q q q 2 Linguaggio accettato La funzione di transizione δ puo essere estesa a ˆδ che opera su stati e stringhe (invece che su stati e simboli) Base: ˆδ(q, ǫ) = q Induzione: ˆδ(q, xa) = δ(ˆδ(q, x), a) Formalmente, il linguaggio accettato da A e L(A) = {w : ˆδ(q, w) F } I linguaggi accettati da automi a stati finiti sono detti linguaggi regolari accetta ad esempio la stringa sempio sempio sempio: DFA che accetta tutte e sole le stringhe con un numero pari di zeri e un numero pari di uni Rappresentazione tabulare dell automa q q q q 2 3 q q 2 q q q 3 q q 2 q q 3 q 3 q q 2 sercizi DFA per i seguenti linguaggi sull alfabeto {,}: Insieme di tutte le strighe che finiscono con Insieme di tutte le stringhe con tre zeri consecutivi Insieme delle stringhe con come sottostringa Insieme delle stringhe che cominciano o finiscono (o entrambe le cose) con Automi a stati finiti non deterministici (NFA) Un NFA puo essere in vari stati nello stesso momento, oppure, visto in un altro modo, puo scommettere su quale sara il prossimo stato sempio: un automa che accetta tutte e solo le stringhe che finiscono in., q q q 2 cco cosa succede quando l automa elabora l input q q q q q q q q q (stuck) q 2 (stuck) q 2

9 Definizione formale di NFA sempio Formalmente, un NFA e una quintupla A = (Q,Σ, δ, q,f) Q e un insieme finito di stati Σ e un alfabeto finito δ e una funzione di transizione da Q Σ all insieme dei sottoinsiemi di Q q Q e lo stato iniziale F Q e un insieme di stati finali L NFA di due pagine fa e ({q, q,q 2 }, {,}, δ, q, {q 2 }) dove δ e la funzione di transizione q {q, q } {q } q {q 2 } q 2 sempio Funzione di transizione estesa ˆδ. Base: ˆδ(q, ǫ) = {q} Induzione: ˆδ(q, xa) = δ(p, a) p ˆδ(q,x) Proviamo formalmente che l NFA, q q q 2 sempio: Calcoliamo ˆδ(q,) sulla lavagna Formalmente, il linguaggio accettato da A e L(A) = {w : ˆδ(q, w) F } accetta il linguaggio {x : x Σ }. Faremo una induzione mutua sui tre enunciati seguenti w Σ q ˆδ(q,w) q ˆδ(q,w) w = x 2 q 2 ˆδ(q,w) w = x quivalenza di DFA e NFA Base: Se w = allora w = ǫ. Allora l enunciato () segue dalla defnizione Per () e (2) entrambi i lati sono falsi per ǫ Induzione: Assumiamo che w = xa, dove a {, }, x = n e gli enunciati () (2) valgono per x. Si mostra che gli enunciati valgono per xa. Gli NFA sono di solito piu facili da programmare. Sorprendentemente, per ogni NFA N c e un DFA D, tale che L(D) = L(N), e viceversa. Questo comporta una construzione a sottoinsiemi, un esempio importante di come un automa B puo essere costruito da un altro automa A. Dato un NFA N = (Q N,Σ, δ N,q,F N ) costruiremo un DFA D = (Q D,Σ, δ D, {q },F D ) tali che. L(D) = L(N)

10 I dettagli della costruzione a sottoinsiemi: Q D = {S : S Q N }. Nota: Q D = 2 Q N, anche se la maggior parte degli stati in Q D sono garbage, cioe non raggiungibili dallo stato iniziale. F D = {S Q N : S F N } Per ogni S Q N e a Σ, δ D (S, a) = p S δ N (p,a) Costruiamo δ D dall NFA gia visto: {q } {q, q } {q } {q } {q 2 } {q 2 } {q, q } {q, q } {q, q 2 } {q, q 2 } {q, q } {q } {q, q 2 } {q 2 } {q,q, q 2 } {q, q } {q, q 2 } Nota: Gli stati di D corrispondono a sottoinsiemi di stati di N, ma potevamo denotare gli stati di D in un altro modo, per esempio A F. A A A B B C A D D A A F F B G A D H F Possiamo spesso evitare la crescita esponenziale degli stati costruendo la tabella di transizione per D solo per stati accessibili S come segue: Base: S = {q } e accessibile in D Induzione: Se lo stato S e accessibile, lo sono anche gli stati in a Σ δ D(S, a). sempio: Il sottoinsieme DFA con stati accessibili solamente. { q { q, q {q, } } q } 2 Induzione: ˆδ D ({q }, xa) def = δ D (ˆδ D ({q },x),a) eorema 2.: Sia D il DFA ottenuto da un NFA N con la costruzione a sottoinsiemi. Allora L(D) = L(N). Prova: Prima mostriamo per induzione su w che ˆδ D ({q }, w) = ˆδ N (q,w) Base: w = ǫ. L enunciato segue dalla definizione. i.h. = δ D (ˆδ N (q,x),a) cst = p ˆδ N (q,x) δ N (p,a) def = ˆδ N (q,xa) Ora segue che L(D) = L(N).

11 Crescita esponenziale degli stati eorema 2.2: Un linguaggio L e accettato da un DFA se e solo se L e accettato da un NFA. Prova: La parte se e il eorema 2.. Per la parte solo se notiamo che un qualsiasi DFA puo essere convertito in un NFA equivalente modificando la δ D in δ N secondo la regola seguente: Se δ D (q, a) = p, allora δ N (q, a) = {p}. Per induzione su w si puo mostrare che se ˆδ D (q,w) = p, allora ˆδ N (q, w) = {p}. L enunciato del teorema segue. siste un NFA N con n + stati che non ha nessun DFA equivalente con meno di 2 n stati,,,,, q q q 2 q n L(N) = {xc 2 c 3 c n : x {,},c i {,}} Supponiamo che esista un DFA equivalente con meno di 2 n stati. D deve ricordare gli ultimi n simboli che ha letto. Ci sono 2 n sequenze di bit a a 2 a n q,a a 2 a n,b b 2 b n : q ˆδ N (q, a a 2 a n ),q ˆδ N (q,b b 2 b n ),a a 2 a n b b 2 b n FA con transizioni epsilon Caso : a 2 a n b 2 b n Allora q deve essere sia uno stato di accettazione che uno stato di non accettazione. Caso 2: a a i a i+ a n b b i b i+ b n Ora ˆδ N (q,a a i a i+ a n i ) = ˆδ N (q,b b i b i+ b n i ) e ˆδ N (q, a a i a i+ a n i ) F D ˆδ N (q,b b i b i+ b n i ) / F D Un ǫ-nfa che accetta numeri decimali consiste di: Un segno + o -, opzionale 2 Una stringa di cifre decimali 3 un punto decimale 4 un altra stringa di cifre decimali Una delle stringhe (2) e (4) sono opzionali,,...,9,,...,9 q,+,- q q q 2 3.,,...,9 q 5,,...,9 q 4. sempio ǫ-nfa che accetta l insieme di parole chiave {ebay,web} Definizione ed esempio Un ǫ-nfa e una quintupla (Q,Σ, δ, q,f) dove δ e una funzione da Q Σ {ǫ} all insieme dei sottoinsiemi di Q. sempio: L ǫ-nfa della pagina precedente Σ w e b = ({q, q,...,q 5 }, {.,+,,,,...,9} δ, q, {q 5 }) dove la tabella delle transizioni per δ e e b a y ǫ +,-.,...,9 q {q } {q } q {q 2 } {q,q 4 } q 2 {q 3 } q 3 {q 5 } {q 3 } q 4 {q 3 } q 5

12 psilon-chiusura sempio di epsilon-chiusura Chiudiamo uno stato aggiungendo tutti gli stati raggiungibili da lui tramite una sequenza ǫǫ ǫ Definizione induttiva di CLOS(q) Base: q CLOS(q) Induzione: p CLOS(q) and r δ(p, ǫ) r CLOS(q) Per esempio, b a CLOS() = {,2,3,4,6} Da ǫ-nfa a DFA Definizione induttiva di ˆδ per automi ǫ-nfa Base: Induzione: ˆδ(q, xa) = ˆδ(q, ǫ) = CLOS(q) p δ(ˆδ(q,x),a) Calcoliamo ˆδ(q,5.6) per l NFA dei numeri decimali CLOS(p) Dato un ǫ-nfa costruiremo un DFA tale che = (Q, Σ, δ, q,f ) D = (Q D,Σ, δ D,q D, F D ) L(D) = L() Dettagli della costruzione: Q D = {S : S Q e S = CLOS(S)} q D = CLOS(q ) F D = {S : S Q D e S F } δ D (S,a) = {CLOS(p) : p δ(t,a) per alcuni t S} sempio ǫ-nfa,,...,9,,...,9 q,+,- q q q q ,,...,9,,...,9. q 4 DFA D corrispondente ad,,...,9,,...,9 +,- { q, q } { q } { q, q } { q 4 2, q 3, q 5,,...,9. }.,,...,9. { q2 } { q 3, q 5 },,...,9,,...,9

13 eorema 2.22: Un linguaggio L e accettato da un ǫ-nfa se e solo se L e accettato da un DFA. Prova: Usiamo D costruito come sopra e mostriamo per induzione che ˆδ (q, w) = ˆδ D (q D, w) Induzione: ˆδ (q, xa) = = p δ (ˆδ (q,x),a) p δ D (ˆδ D (q D,x),a) CLOS(p) CLOS(p) Base: ˆδ (q, ǫ) = CLOS(q ) = q D = ˆδ(q D, ǫ) = CLOS(p) p ˆδ D (q D,xa) = ˆδ D (q D, xa) spressioni regolari spressioni regolari Un FA (NFA o DFA) e un metodo per costruire una macchina che riconosce linguaggi regolari. Una espressione regolare e un modo dichiarativo per descrivere un linguaggio regolare. sempio: + Le espressioni regolari sono usate, ad esempio, in comandi UNIX (grep) strumenti per l analisi lessicale di UNIX (Lex (Lexical analyzer generator) e Flex (Fast Lex)). spressioni regolari spressioni regolari Operazioni sui linguaggi Definizione induttiva di espressioni regolari Unione: L M = {w : w L o w M} Concatenazione: L.M = {w : w = xy,x L,y M} Potenze: L = {ǫ}, L = L, L k+ = L.L k Chiusura di Kleene: L = L i i= Base: ǫ e sono espressioni regolari. L(ǫ) = {ǫ} e L( ) =. Se a Σ, allora a e un espressione regolare. L(a) = {a}. Induzione: Se e un espressione regolare, allora () e un espressione regolare. L(()) = L(). Se e F sono espressioni regolari, allora + F e un espressione regolare. L( + F) = L() L(F). Se e F sono espressioni regolari, allora.f e un espressione regolare. L(.F) = L().L(F). Se e un espressione regolare, allora e un espressione regolare. L( ) = (L()). spressioni regolari spressioni regolari

14 sempio Ordine di precedenza per gli operatori spressione regolare per L = {w {,} : e alternati in w} o, equivalentemente, () + () + () + () (ǫ + )() (ǫ + ) Chiusura 2 Concatenazione (punto) 3 Piu (+) sempio: + e raggruppato in (() ) + spressioni regolari spressioni regolari quivalenza di FA e espr. regolari Abbiamo gia mostrato che DFA, NFA, e ǫ-nfa sono tutti equivalenti. La tecnica di eliminazione di stati tichettiamo gli archi con espressioni regolari di simboli R m -NFA R NFA DFA q p Q R s S P Per mostrare che gli FA sono equivalenti alle espressioni regolari, mostreremo che Per ogni DFA A possiamo trovare (costruire, in questo caso) un espressione regolare R, tale che L(R) = L(A). 2 Per ogni espressione regolare R esiste un ǫ-nfa A, tale che L(A) = L(R). q k Q k R km P m p m R k spressioni regolari spressioni regolari Ora eliminiamo lo stato s. R + Q S P q p R m + Q S P m Per ogni q F saremo rimasti con A q della forma R U S e che corrisponde all espressione regolare q = (R + SU ) SU o con A q della forma q k R k + Q k S P R km + Q k S P m Per lo stato accettante q eliminiamo dall automa originale tutti gli stati eccetto q e q. p m R che corrisponde all espressione regolare q = R L espressione finale e q q F spressioni regolari spressioni regolari

15 sempio sempio A, dove L(A) = {W : w = xb, o w = xbc, x {,}, {b,c} {,}} A B C D,,, A B C D liminiamo lo stato B + La trasformiamo in un automa con espressioni regolari come etichette A B C D A ( + ) + C Poi eliminiamo lo stato C e otteniamo A D + A ( + ) ( + ) D D spressioni regolari con espressione regolare ( + ) ( + )( + ) spressioni regolari sempio Da espressioni regolari a ǫ-nfa Da + A ( + ) + C D eorema 3.7: Per ogni espressione regolare R possiamo costruire un ǫ-nfa A, tale che L(A) = L(R). Prova: Per induzione strutturale: Base: Automa per ǫ,, e a. possiamo eliminare D e ottenere A C + (a) A ( + ) C con espressione regolare ( + ) ( + ) L espressione finale e la somma delle due espressioni regolari precedenti: ( + ) ( + )( + ) + ( + ) ( + ) (b) a (c) spressioni regolari spressioni regolari Induzione: Automa per R + S, RS, e R sempio R rasformiamo ( + ) ( + ) S (a) R (b) S (a) R (c) (b) spressioni regolari spressioni regolari

16 sempio (b) Leggi algebriche per i linguaggi L M = M L. L unione e commutativa. (L M) N = L (M N). L unione e associativa. (LM)N = L(MN). La concatenazione e associativa. Nota: La concatenazione non e commutativa, cioe, esistono L e M tali che LM ML. (c) spressioni regolari spressioni regolari L = L = L. e l identita per l unione. {ǫ}l = L{ǫ} = L. {ǫ} e l identita sinistra e destra per la concatenazione. L = L =. e l annichilatore sinistro e destro per la concatenazione. L(M N) = LM LN. La concatenazione e distributiva a sinistra sull unione. (M N)L = ML NL. La concatenazione e distributiva a destra sull unione. L L = L. L unione e idempotente. = {ǫ}, {ǫ} = {ǫ}. L + = LL = L L, L = L + {ǫ} spressioni regolari spressioni regolari (L ) = L. La chiusura e idempotente. Prova: ( ) i w (L ) w L j i= j= k,m N : w (L m ) k Da pattern ad analizzatore lessicale p N : w L p w i= w L L i spressioni regolari Da pattern ad analizzatore lessicale

17 Da espressioni regolari ad automa Una espressione regolare per ogni pattern Da ogni espressione regolare, un NFA corrispondente Un unico NFA mettendo insieme i vari NFA con un nuovo stato iniziale e transizioni ǫ sempio: i pattern sono descritti dalle seguenti espressioni regolari a abb a bb Notare che: la stringa abb va bene sia per il pattern abb che per il pattern a bb useremo il primo dei pattern possibili nella lista (in questo caso il pattern abb) stringhe come aabbb... hanno molti prefissi che vanno d accordo con il pattern a bb prendiamo la stringa piu lunga che vada bene per a bb Da pattern ad analizzatore lessicale Da automa a lexema e pattern L analizzatore lessicale simula l automa mentre legge la stringa in input In ogni momento, considera l insieme di stati in cui e Le transizioni ǫ vanno considerate: inizia dalla ǫ-chiusura dello stato iniziale, e ad ogni passo calcola la ǫ- chiusura Quando legge un simbolo che lo porta in un insieme vuoto di stati, ha finito a leggere il lexema corrente per qualche pattern Per capire quale pattern, torna indietro nella lista degli stati finche non c e uno stato finale (lexema piu lungo per i dati pattern). In alternativa: da NFA e DFA, e poi muoversi nel DFA leggendo la stringa in input Da pattern ad analizzatore lessicale Leggere oltre il lexema Il pumping lemma Proprieta di chiusura Proprieta di decisione A volte, per riconoscere un lexema per un certo pattern, dobbiamo leggere oltre la fine del lexema Se r e il pattern del lexema e r 2 il pattern di cosa leggere dopo il lexema, costruiamo le due espressioni regolari e i due automi corrispondenti, e li concateniamo con una transizione ǫ Proprieta dei linguaggi regolari Uno stato finale si raggiunge se leggiamo sia r che r 2 Se arriviamo in uno stato finale, torniamo indietro fino alla fine di r per capire qual e il lexema letto Da pattern ad analizzatore lessicale Proprieta dei linguaggi regolari Il pumping lemma Proprieta di chiusura Proprieta di decisione Proprieta dei Linguaggi regolari Il pumping lemma Proprieta di chiusura Proprieta di decisione Il Pumping Lemma, informalmente Pumping Lemma. Ogni linguaggio regolare soddisfa il pumping lemma. Se qualcuno vi presenta un falso linguaggio regolare, l uso del pumping lemma mostrera una contraddizione. Proprieta di chiusura. Come costruire automi da componenti usando delle operazioni, ad esempio dati L e M possiamo costruire un automa per L M. Proprieta di decisione. Analisi computazionale di automi, cioe quanto costa controllare varie proprieta, come l equivalenza di due automi. ecniche di minimizzazione. Possiamo risparmiare costruendo automi piu piccoli. Supponiamo che L = { n n : n } sia regolare. Allora deve essere accettato da un qualche DFA A, con, ad esempio, k stati. Supponiamo che A legga k. Avra le seguenti transizioni: ǫ p p p k p k i < j : p i = p j Chiamiamo q questo stato. Proprieta dei linguaggi regolari Proprieta dei linguaggi regolari

18 Il pumping lemma Proprieta di chiusura Proprieta di decisione Il pumping lemma Proprieta di chiusura Proprieta di decisione eorema 4.: Il Pumping Lemma per Linguaggi Regolari Adesso possiamo ingannare A: Se ˆδ(q, i ) F l automa accettera, sbagliando, j i. Se ˆδ(q, i ) / F l automa rifiutera, sbagliando, i i. Quindi L non puo essere regolare. Sia L un linguaggio regolare. Allora n, w L : w n w = xyz tale che: y ǫ 2 xy n 3 k, xy k z L Proprieta dei linguaggi regolari Proprieta dei linguaggi regolari Prova Il pumping lemma Proprieta di chiusura Proprieta di decisione Ora w = xyz, dove x = a a 2 a i 2 y = a i+ a i+2 a j Il pumping lemma Proprieta di chiusura Proprieta di decisione Supponiamo che L sia regolare. Allora L e riconosciuto da un DFA A con, ad esempio, n stati. Sia w = a a 2...a m L, m > n. Sia p i = ˆδ(q,a a 2 a i ). i < j : p i = p j 3 z = a j+ a j+2...a m y = a i+... a j x = z = a... p a i a... p j+ i a m Quindi anche xy k z L, per ogni k. Proprieta dei linguaggi regolari Proprieta dei linguaggi regolari sempio Il pumping lemma Proprieta di chiusura Proprieta di decisione sempio Il pumping lemma Proprieta di chiusura Proprieta di decisione Sia L eq il linguaggio delle stringhe con ugual numero di zeri e di uni. Supponiamo che L eq sia regolare. Allora w = n n L. Per il pumping lemma, w = xyz, xy n, y ǫ e xy k z L eq w = }{{}}{{}}{{} x y z In particolare, xz L eq, ma xz ha meno zeri di uni. Proprieta dei linguaggi regolari Supponiamo che L pr = { p : p e primo } sia regolare. Sia n dato dal pumping lemma. Scegliamo un numero primo p n + 2. p {}}{ w = }{{}}{{} x }{{} y y =m Ora xy p m z L pr xy p m z = xz +(p m) y = p m+(p m)m = (+m)(p m) che non e primo a meno che uno dei fattori non sia. y ǫ + m > m = y xy n, p n + 2 p m n + 2 n = 2. z Proprieta dei linguaggi regolari

19 Il pumping lemma Proprieta di chiusura Proprieta di decisione Proprieta di chiusura dei linguaggi regolari Il pumping lemma Proprieta di chiusura Proprieta di decisione Chiusura rispetto a unione e complemento Siano L e M due linguaggi regolari. Allora i seguenti linguaggi sono regolari: Unione: L M Intersezione: L M Complemento: N Differenza: L \ M Inversione: L R = {w R : w L} Chiusura: L. Concatenazione: L.M eorema 4.4. Per ogni coppia di linguaggi regolari L e M, L M e regolare. Prova. Sia L = L() e M = L(F). Allora L( + F) = L M per definizione. eorema 4.5. Se L e un linguaggio regolare su Σ, allora che L = Σ \ L e regolare. Prova. Sia L riconosciuto da un DFA A = (Q,Σ,δ,q,F). Sia B = (Q,Σ,δ,q,Q \ F). Allora L(B) = L. Proprieta dei linguaggi regolari Proprieta dei linguaggi regolari sempio Il pumping lemma Proprieta di chiusura Proprieta di decisione Il pumping lemma Proprieta di chiusura Proprieta di decisione Chiusura rispetto all intersezione Sia L riconosciuto dal DFA qui sotto: { q { q, q {q, } } q } 2 Allora L e riconosciuto da: eorema 4.8. Se L e M sono regolari, allora anche L M e regolare. Prova. Per la legge di DeMorgan, L M = L M. Sappiamo gia che i linguaggi regolari sono chiusi sotto il complemento e l unione. { q { q, q {q, } } q } 2 Proprieta dei linguaggi regolari Proprieta dei linguaggi regolari Il pumping lemma Proprieta di chiusura Proprieta di decisione Chiusura rispetto all intersezione: un altra prova Se L e M sono regolari, allora anche L M e regolare. Prova 2. Sia L il linguaggio di Il pumping lemma Proprieta di chiusura Proprieta di decisione Se A L va dallo stato p allo stato s leggendo a, e A M va dallo stato q allo stato t leggendo a, allora A L M andra dallo stato (p,q) allo stato (s,t) leggendo a. Input a A L = (Q L,Σ,δ L,q L,F L ) e M il linguaggio di A M = (Q M,Σ,δ M,q M,F M ) A L Assumiamo senza perdita di generalita che entrambi gli automi siano deterministici. Costruiremo un automa che simula A L e A M in parallelo, e accetta se e solo se sia A L che A M accettano. A M AND Accept Proprieta dei linguaggi regolari Proprieta dei linguaggi regolari

20 Il pumping lemma Proprieta di chiusura Proprieta di decisione sempio Il pumping lemma Proprieta di chiusura Proprieta di decisione Formalmente A L M = (Q L Q M,Σ,δ L M,(q L,q M ),F L F M ), dove δ L M ((p,q),a) = (δ L (p,a),δ M (q,a)) (c) = (a) (b) p r (a) q s,, Si puo mostrare per induzione su w che ) ˆδ L M ((q L,q M ),w) = (ˆδ L (q L,w), ˆδ M (q M,w) pr (b) ps qr (c) qs, Proprieta dei linguaggi regolari Proprieta dei linguaggi regolari Il pumping lemma Proprieta di chiusura Proprieta di decisione Chiusura rispetto alla differenza Il pumping lemma Proprieta di chiusura Proprieta di decisione Chiusura rispetto al reverse eorema 4. Se L e M sono linguaggi regolari, allora anche L \ M e regolare. Prova. Osserviamo che L \ M = L M. Sappiamo gia che i linguaggi regolari sono chiusi sotto il complemento e l intersezione. eorema 4. Se L e un linguaggio regolare, allora anche L R e regolare. Prova : Sia L riconosciuto da un FA A. Modifichiamo A per renderlo un FA per L R : Giriamo tutti gli archi. 2 Rendiamo il vecchio stato iniziale l unico stato finale. 3 Creiamo un nuovo stato iniziale p, con δ(p,ǫ) = F (i vecchi stati finali). Proprieta dei linguaggi regolari Proprieta dei linguaggi regolari Il pumping lemma Proprieta di chiusura Proprieta di decisione Chiusura rispetto al reverse : un altra prova Il pumping lemma Proprieta di chiusura Proprieta di decisione Proprieta di decisione Se L e un linguaggio regolare, allora anche L R e regolare. Prova 2: Sia L descritto da un espressione regolare. Costruiremo un espressione regolare R, tale che L( R ) = (L()) R. Procediamo per induzione strutturale su. Base: Se e ǫ,, o a, allora R =. Induzione: = F + G. Allora R = F R + G R 2 = F.G. Allora R = G R.F R 3 = F. Allora R = (F R ) Convertire tra diverse rappresentazioni dei linguaggi regolari. 2 L =? 3 w L? 4 Due descrizioni definiscono lo stesso linguaggio? Proprieta dei linguaggi regolari Proprieta dei linguaggi regolari

21 Da NFA a DFA Il pumping lemma Proprieta di chiusura Proprieta di decisione Il pumping lemma Proprieta di chiusura Proprieta di decisione Da DFA a NFA Dobbiamo solo mettere le parentesi graffe attorno agli stati. otale: O(n) passi. Supponiamo che un ǫ-nfa abbia n stati. Per calcolare CLOS(p) seguiamo al piu n 2 archi. Lo facciamo per n stati, quindi in totale sono n 3 passi. Il DFA ha 2 n stati, per ogni stato S e ogni a Σ calcoliamo δ D (S,a) in n 3 passi. In totale abbiamo O(n 3 2 n ) passi. Se calcoliamo δ solo per gli stati raggiungibili, dobbiamo calcolare δ D (S,a) solo s volte, dove s e il numero di stati raggiungibili. In totale: O(n 3 s) passi. Proprieta dei linguaggi regolari Da FA a espressione regolare Dobbiamo calcolare n 3 cose di grandezza fino a 4 n. otale: O(n 3 4 n ). L FA puo essere un NFA. Se prima vogliamo convertire l NFA in un DFA, il tempo totale sara doppiamente esponenziale. Da espressioni regolari a FA Possiamo costruire un albero per l espressione in n passi. Possiamo costruire l automa in n passi. liminare le ǫ-transizioni ha bisogno di O(n 3 ) passi. Se si vuole un DFA, potremmo aver bisogno di un numero esponenziale di passi. Proprieta dei linguaggi regolari Il pumping lemma Proprieta di chiusura Proprieta di decisione Controllare se un linguaggio e vuoto Il pumping lemma Proprieta di chiusura Proprieta di decisione Controllare l appartenenza ad un linguaggio L(A) per FA A se e solo se uno stato finale e raggiungibile dallo stato iniziale in in A. otale: O(n 2 ) passi. Oppure, possiamo guardare un espressione regolare e vedere se L() =, considerando tutti i casi: = F + G. Allora L() e vuoto se e solo se sia L(F) che L(G) sono vuoti. = F.G. Allora L() e vuoto se e solo se o L(F) o L(G) sono vuoti. = F. Allora L() non e mai vuoto, perche ǫ L(). = ǫ. Allora L() non e vuoto. = a. Allora L() non e vuoto. =. Allora L() e vuoto. Per controllare se w L(A) per DFA A, simuliamo A su w. Se w = n, questo prende O(n) passi. Se A e un NFA e ha s stati, simulare A su w prende O(ns 2 ) passi. Se A e un ǫ-nfa e ha s stati, simulare A su w prende O(ns 3 ) passi. Se L = L(), per l espressione regolare di lunghezza s, prima convertiamo in un ǫ-nfa con 2s stati. Poi simuliamo w su questo automa, in O(ns 3 ) passi. Proprieta dei linguaggi regolari Proprieta dei linguaggi regolari Stati equivalenti Sia A = (Q,Σ,δ,q,F) un DFA, e {p,q} Q. Definiamo quivalenza e minimizzazione di automi p q w Σ : ˆδ(p,w) F se e solo se ˆδ(q,w) F Se p q diciamo che p e q sono equivalenti Se p q diciamo che p e q sono distinguibili In altre parole: p e q sono distinguibili se e solo se w : ˆδ(p,w) F e ˆδ(q,w) / F, o viceversa quivalenza e minimizzazione di automi quivalenza e minimizzazione di automi

22 sempio Cosa si puo dire su A e? A B C D F G H A B C D F G H ˆδ(C,ǫ) F, ˆδ(G,ǫ) / F C G ˆδ(A,) = C F, ˆδ(G,) = / F A G quivalenza e minimizzazione di automi ˆδ(A,ǫ) = A / F, ˆδ(,ǫ) = / F ˆδ(A,) = F = ˆδ(,) Quindi ˆδ(A,x) = ˆδ(,x) = ˆδ(F,x) ˆδ(A,) = G = ˆδ(,) ˆδ(A,) = C = ˆδ(,) Conclusione: A. quivalenza e minimizzazione di automi Algoritmo induttivo Possiamo calcolare coppie di stati distinguibili con il seguente metodo induttivo (algoritmo di riempimento di una tavola): Base: Se p F e q F, allora p q. Induzione: Se a Σ : δ(p,a) δ(q,a), allora p q. sempio: Applichiamo l algoritmo ad A: B C D F G H x x x x x x x x x x x x x x x x x x x x x x x x x Correttezza dell algoritmo eorema 4.2: Se p e q non sono distinguibili dall algoritmo, allora p q. Prova: Supponiamo per assurdo che esista una coppia sbagliata {p,q}, tale che w : ˆδ(p,w) F, ˆδ(q,w) / F, o viceversa. 2 L algoritmo non distingue tra p e q. Sia w = a a 2 a n la stringa piu corta che identifica la coppia sbagliata {p,q}. Allora w ǫ perche altrimenti l algoritmo distinguerebbe p da q (caso base). Quindi n. A B C D F G quivalenza e minimizzazione di automi quivalenza e minimizzazione di automi estare l equivalenza di linguaggi regolari Consideriamo gli stati r = δ(p,a ) e s = δ(q,a ). Allora {r,s} non puo essere una coppia sbagliata perche {r,s} srebbe identificata da una stringa piu corta di w. Quindi, l algoritmo deve aver scoperto nel caso base che r and s sono distinguibili. Ma allora l algoritmo distinguerebbe p da q nella parte induttiva. Quindi non ci sono coppie sbagliate e il teorema e vero. Siano L e M linguaggi regolari (descritti in qualche forma). Per testare se L = M convertiamo sia L che M in DFA. 2 Immaginiamo il DFA che e l unione dei due DFA (non importa se ha due stati iniziali) 3 Se l algoritmo dice che i due stati iniziali sono distinguibili, allora L M, altrimenti L = M. quivalenza e minimizzazione di automi quivalenza e minimizzazione di automi

23 sempio sempio A B Il risultato dell algoritmo e C D B C D x x x x x x A B C D Quindi i due automi sono equivalenti. Possiamo vedere che entrambi i DFA accettano L(ǫ + ( + ) ). quivalenza e minimizzazione di automi quivalenza e minimizzazione di automi Minimizzazione di DFA ransitivita Possiamo usare l algoritmo per minimizzare un DFA mettendo insieme tutti gli stati equivalenti. Cioe rimpiazzando p by p/. sempio: Il DFA di prima ha le seguenti classi di equivalenza: {{A,}, {B,H}, {C}, {D,F }, {G }}. Il DFA unione di prima ha le seguenti classi di equivalenza: {{A,C,D}, {B,}}. Notare: affinche p/ sia una classe di equivalenza, la relazione deve essere una relazione di equivalenza (riflessiva, simmetrica, e transitiva). eorema 4.23: Se p q e q r, allora p r. Prova: Supponiamo per assurdo che p r. Allora w tale che ˆδ(p,w) F e ˆδ(r,w) F, o viceversa. Lo stato ˆδ(q,w) e o di accettazione o no. Caso : ˆδ(q,w) e di accettazione. Allora q r. Caso 2: ˆδ(q,w) non e di accettazione. Allora p q. Il caso contrario puo essere provato simmetricamente. Quindi deve essere p r. quivalenza e minimizzazione di automi quivalenza e minimizzazione di automi Minimizzazione di automi sempio Per minimizzare un DFA A = (Q,Σ,δ,q,F) costruiamo un DFA B = (Q/,Σ,γ,q /,F/ ), dove γ(p/,a) = δ(p,a)/ Affinche B sia ben definito, dobbiamo mostrare che Se p q allora δ(p,a) δ(q,a) Se δ(p,a) δ(q,a), allora l algoritmo concluderebbe p q, quindi B e ben definito. Notare anche che F/ contiene tutti e soli gli stati accettanti di A. Possiamo minimizzare A B C D F G H quivalenza e minimizzazione di automi quivalenza e minimizzazione di automi

24 sempio Notare: Non possiamo applicare l algoritmo a NFA. Per esempio, per minimizzare Otteniamo: G D,F, A B A, B,H C rimuoviamo lo stato C. Ma A C. C quivalenza e minimizzazione di automi quivalenza e minimizzazione di automi Perche non si puo migliorare il DFA minimizzato Sia B il DFA minimizzato ottenuto applicando l algoritmo al DFA A. Sappiamo gia che L(A) = L(B). Potrebbe esistere un DFA C, con L(C) = L(B) e meno stati di B? Applichiamo l algoritmo a B unito con C. Dato che L(B) = L(C), abbiamo q B qc. Inoltre, δ(q B,a) δ(qc,a), per ogni a. Per ogni stato p in B esiste almeno uno stato q in C, tale che p q. Prova: Non ci sono stati inaccessibili, quindi p = ˆδ(q B, a a 2 a k ), per una qualche stringa a a 2 a k. Allora q = ˆδ(q C, a a 2 a k ), e p q. Dato che C ha meno stati di B, ci devono essere due stati r e s di B tali che r t s, per qualche stato t di C. Ma allora r s che e una contraddizione, dato che B e stato costruito dall algoritmo. quivalenza e minimizzazione di automi quivalenza e minimizzazione di automi Grammatiche e Linguaggi Liberi da Contesto Abbiamo visto che molti linguaggi non sono regolari. Consideriamo allora classi piu grandi di linguaggi. I Linguaggi Liberi da Contesto (CFL) sono stati usati nello studio dei linguaggi naturali dal 95, e nello studio dei compilatori dal 96. Le grammatiche libere da contesto (CFG) sono la base della sintassi BNF (Backus-Naur-Form). Oggi i CFL sono importanti per XML. Studieremo: CFG, i linguaggi che generano, gli alberi sintattici, gli automi a pila, e le proprieta di chiusura dei CFL.

25 sempio informale di CFG Le CFG sono un modo formale per definire linguaggi come L pal. Consideriamo L pal = {w Σ : w = w R } Per esempio: otto L pal, madamimadam L pal. Sia Σ = {,} e supponiamo che L pal sia regolare. Sia n dato dal pumping lemma. Allora n n L pal. Nel leggere n il FA deve passare per un loop. Se omettiamo il loop, contraddizione. Definiamo L pal induttivamente: Base: ǫ,, e sono palindromi. Induzione: Se w e una palindrome, anche w e w lo sono. Nessun altra stringa e una palindrome.. P ǫ 2. P 3. P 4. P P 5. P P e sono terminali P e una variabile (o nonterminale, o categoria sintattica) P e in questa gramatica anche il simbolo iniziale. 5 sono produzioni (o regole) Definizione formale di CFG sempi Una grammatica libera da contesto e una quadrupla dove G = (V,,P,S) V e un insieme finito di variabili. e un insieme finito di terminali. P e un insieme finito di produzioni della forma A α, dove A e una variabile e α (V ) S e una variabile distinta chiamata il simbolo iniziale. G pal = ({P}, {,},A,P), dove A = {P ǫ,p,p,p P,P P}. A volte raggruppiamo le produzioni con la stessa testa: A = {P ǫ P P}. Le espressioni regolari su {,} possono essere definite dalla grammatica G regex = ({}, {,},A,) dove A = {,,., +,, ()} sempio spressioni (semplici) in un tipico linguaggio di programmazione. Gli operatori sono + e, e gli operandi sono identificatori, cioe stringhe in L((a + b)(a + b + + ) ) Usiamo la grammatica G = ({,I },,P,) dove = {+,,(,),a,b,,} e P e il seguente insieme di produzioni:. I () 5. I a 6. I b 7. I Ia 8. I Ib 9. I I. I I Derivazioni Sia G = (V,,P,S) una CFG, A V, {α,β} (V ), e A γ P. Allora scriviamo o, se e ovvia la G, αaβ G αγβ αaβ αγβ e diciamo che da αaβ si deriva αγβ. Definiamo la chiusura riflessiva e transitiva di, cioe : Base: Sia α (V ). Allora α α. Induzione: Se α β, e β γ, allora α γ.

26 sempio Derivazione di a (a + b) da nella grammatica delle espressioni: I a a () a ( + ) a (I + ) a (a + ) a (a + I) a (a + I) a (a + I) a (a + b) Ad ogni passo potremmo avere varie regole tra cui scegliere, ad esempio I a a (), oppure I I () a (). Non tutte le scelte portano a derivazioni di una particolare stringa, per esempio + non ci fa derivare a (a + b). Derivazioni a sinistra e a destra Derivazione a sinistra lm : rimpiazza sempre la variabile piu a sinistra con il corpo di una delle sue regole. Derivazione a destra rm : rimpiazza sempre la variabile piu a destra con il corpo di una delle sue regole. Der. a sinistra: quella del lucido precedente. A destra: rm rm () rm ( + ) rm ( + I) rm ( + I) ( + I) ( + b) (I + b) rm rm rm (a + b) I (a + b) a (a + b) rm rm rm Possiamo concludere che rm a (a + b) Il linguaggio di una grammatica eorema 5.7: L(G pal ) = {w {,} : w = w R } Se G(V,,P,S) e una CFG, allora il linguaggio di G e L(G) = {w : S G w} cioe l insieme delle stringhe su derivabili dal simbolo iniziale. Se G e una CFG, chiameremo L(G) un linguaggio libero da contesto. sempio: L(G pal ) e un linguaggio libero da contesto. Prova: (direzione ) Supponiamo w = w R. Mostriamo per induzione su w che w L(G pal ). Base: w =, or w =. Allora w e ǫ,, or. Dato che P ǫ, P, and P sono produzioni, concludiamo che P G w in tutti i casi base. Induzione: Supponiamo w 2. Dato che w = w R, abbiamo w = x, o w = x, e x = x R. Se w = x sappiamo che per l ipotesi induttiva P x. Allora P P x = w Quindi w L(G pal ). Il caso di w = x e simile. (direzione ) Assumiamo che w L(G pal ) e dobbiamo mostrare che w = w R. Dato che w L(G pal ), abbiamo P w. Faremo un induzione sulla lunghezza di. Base: La derivazione P w ha passo. Allora w deve essere ǫ,, o, tutte palindromi. Induzione: Sia n, e supponiamo che la derivazione ha n + steps. Allora dobbiamo avere o w = x P P w = x P P dove la seconda derivazione ha n passi. Per l ipotesi induttiva, x e una palindrome. Forme sentenziali Sia G = (V,,P,S) una CFG, e α (V ). Se S α diciamo che α e una forma sentenziale. Se S lm α diciamo che α e una forma sentenziale sinistra, Se S rm α diciamo che α e una forma sentenziale destra Nota: L(G) contiene le forme sentenziali che sono in.