docente: francescarossi automielinguaggiformali · pumping lemma per linguaggi liberi da contesto...
TRANSCRIPT
Automi e Linguaggi Formali
Docente: Francesca Rossi
E-mail: [email protected]
Docente: Francesca Rossi Automi e Linguaggi Formali
Orario e ricevimento
Orario:
Lunedi’, Martedi’, Mercoledi’, Giovedi’ 13:30-15:30 LUM250
Crediti: 8 crediti formativi, circa 64 ore di lezioneRicevimento:
Martedi’ 11:00-13:00, studio 428, IV piano, Torre Archimede(Via Trieste 63)
Docente: Francesca Rossi Automi e Linguaggi Formali
Sito del corso
URL: http://www.math.unipd.it/˜frossi/automi2012.html
Contiene:
programma
date appelli
lucidi
voti
...
Docente: Francesca Rossi Automi e Linguaggi Formali
Altre informazioni utili
Libro principale: Automi, linguaggi e calcolabilita’,J. E. Hopcroft, R. Motwani, and J. D. Ullman, terza edizione,Pearson/Addison-Wesley, 2009.
Altro libro: Compilatori: principi, tecniche e strumenti, A.H.Aho, M. S. Lam, R. Sethi, J. D. Ullman, seconda edizione,Pearson/Addison-Wesley, 2009.
Compitini (forse): Due compitini, uno a meta’ del corso euno alla fine. Possono sostituire lo scritto.
Esame: Scritto e, se richiesto dal docente, colloquio orale.Cinque appelli: due a fine corso (Dicembre-Gennaio), uno allafine del II trimestre (Aprile), uno a Luglio, uno a Settembre.
I lucidi per i capitoli 1-7 del libro principale sono basati suilucidi in inglese di Gosta Grahne e David Ford(http://www.cs.concordia.ca/~grahne/hmu slides/).
Docente: Francesca Rossi Automi e Linguaggi Formali
Sommario del corso
Struttura dei un compilatore e fasi principali (cap.1 CPTS)
Analisi lessicale (cap. 3 CPTS)
Automi a stati finiti (cap.1,2 ALC)
Espressioni regolari (cap.3 ALC)
Pumping lemma e proprieta’ dei linguaggi regolari (cap.4ALC)
Minimizzazione degli automi a stati finiti (cap.4 ALC)
Analisi sintattica top-down e bottom-up (cap.4 CPTS)
Grammatiche libere da contesto (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 Turing, problemi ricorsivamente enumerabili(cap.8 ALC)
Riduzioni e teorema di Rice (cap.9 ALC)
Classi P e NP (cap.10 ALC)
Docente: Francesca Rossi Automi e Linguaggi Formali
Linguaggi di programmazione
Linguaggi di programmazione = notazione per descriverecalcoli e computazioni
Per eseguire un programma, deve essere tradotto in una formache puo’ essere capita da un calcolatore ⇒ compilatore
Principi e tecniche utili non solo per costruire compilatori, main molte altre aree dell’informatica: linguaggi diprogrammazione, architettura, teoria dei linguaggi, algoritmi,ingegneria del software, ecc.
Docente: Francesca Rossi Automi e Linguaggi Formali
Compilatori
Compilatore: programma che legge un programma scritto inun linguaggio di programmazione (linguaggio sorgente) e lotraduce in un programma equivalente scritto in un altrolinguaggio (linguaggio oggetto)
Un compilatore mostra anche gli errori che trova durante latraduzione
Se il linguaggio oggetto e’ eseguibile da una macchina, unutente puo’ eseguirlo per passare da input ad output
Interprete: esegue direttamente le operazioni specificate nelprogramma sorgente (traducendo un’istruzione alla volta edeseguendo il pezzo di programma oggetto generato)
Di solito piu’ veloce l’esecuzione di programmi compilati
Assembler: compilatore da linguaggio assembly a codicemacchina
Docente: Francesca Rossi Automi e Linguaggi Formali
Struttura di un compilatore
Due parti: analisi e sintesi
Analisi (front end): prende un programma e lo divide in partisu cui impone una struttura grammaticale; crea unarappresentazione intermedia del programma sorgente; segnalapossibili errori; mette informazioni sul programma in unatavola dei simboli, da passare alla sintesiSintesi (back end): costruisce il programma oggetto dallarappresentazione intermedia e la tavola dei simboli
Sequenza di fasi: ogni fase trasforma una rappresentazione delprogramma sorgente in un’altra
Fasi principali: analisi lessicale, analisi sintattica, analisisemantica, generazione del codice intermedio, ottimizzazioneedel codice, generazione del codice
Docente: Francesca Rossi Automi e Linguaggi Formali
Analisi lessicale (scanning)
Legge la stringa di caratteri del programma sorgente eraggruppa i caratteri in sequenze chiamate lexemiPer ogni lexema, un token <nome-token,valore-attributo>
nome-token: simbolo associato al tokenvalore-attributo: punta alla tavola dei simboli
Esempio: comando posizione = iniziale + velocita’* 60
lexema posizione ⇒ token <id,1>: riga 1 della tavola deisimboli contiene posizionelexema = e token <=> (nessun valore attributo)lexema iniziale e token <id,2>, riga 2 contiene inizialelexema + e token <+>
lexema velocita’ e token <id,3>, riga 3 contiene velocita’lexema * e token <*>lexema 60 e token <60>Rappresentazione finale: <id,1> <=> <id,2> <+> <id,3><*> <6>
Useremo: linguaggi regolari, automi a stati finiti,espressioni regolari
Docente: Francesca Rossi Automi e Linguaggi Formali
Analisi sintattica (parsing)
Il parser usa la prima componente dei token per creare unarappresentazione ad albero della lista di tokens (strutturagrammaticale)
Albero: insieme di nodi e archi diretti (da padre a figlio), taleche un nodo (radice) non ha padri, e tutti gli altri hannoesattamente 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
Esempio
Dalla lista di tokens <id,1> <=> <id,2> <+> <id,3> <*><6> all’albero sintattico
=
/ \
<id,1> +
/ \
<id,2> *
/ \
<id,3> 60
Prima dobbiamo moltiplicare il lexema del token <id,3>, cioe’velocita’ con 60
poi dobbiamo sommare il risultato con il valore di iniziale
poi dobbiamo mettere il risultato nella locazionedell’identificatore posizione
Docente: Francesca Rossi Automi e Linguaggi Formali
Analisi semantica
Usa l’albero sintattico e la tavola dei simboli per controllare laconsistenza semantica del programma
Colleziona informazioni sui tipi e le mette nella tavola deisimboli (per la fase di generazione del codice)
Controllo dei tipi (type checking): il tipo di ogni operazionedeve andare d’accordo con i tipi dei suoi operandi
Esempio: un indice di un array deve essere un intero (errore sead esempio floating-point)
Coercion: conversione di tipo
a volte un’operazione puo’ essere applicata sia a due interi chea due floating-pointse un operando e’ intero e l’altro e’ floating point, l’interoviene convertito in floating-point
Docente: Francesca Rossi Automi e Linguaggi Formali
Esempio
Se posizione, iniziale, e velocita’ sono dichiarati comenumero floating-point, e se il lexema 60 e’ un integer, l’operazione* e’ applicata ad un numero integer (60) e ad un floating-point(velocita’) ⇒ conversione di 60 in un floating-point. Dall’alberosintattico di sinistra a quello sulla destra:
= =
/ \ / \
<id,1> + <id,1> +
/ \ / \
<id,2> * <id,2> *
/ \ / \
<id,3> 60 <id,3> inttofloat
|
60
Docente: Francesca Rossi Automi e Linguaggi Formali
Generazione del codice intermedio
Rappresentazione intermedia simile al codice macchina
Spesso codice a tre indirizzi: sequenza di istruzioni similiall’assembly con tre operandi per istruzione
Nell’esempio, si ottiene:t1 = inttofloat(60)
t2 = id3 * t1
t3 = id2 + t2
id1 = t3
Al piu’ un operatore sulla destra: le istruzioni danno l’ordinein cui effettuare le operazioni
Esempio: la moltiplicazione precede la somma
Un nome temporaneo generato per contenere il valorecalcolato da ogni istruzione
Docente: Francesca Rossi Automi e Linguaggi Formali
Ottimizzazione del codice
Miglioramento del codice intermedio per ottenere un migliorecodice oggetto
Migliore: piu’ veloce, piu’ corto, meno energia necessaria, ecc.
Esempio: dat1 = inttofloat(60)
t2 = id3 * t1
t3 = id2 + t2
id1 = t3
at1 = id3 * 60.0
id1 = id2 + t1
Conversione da integer a floating-point fatta a a tempo dicompilazione (e non a tempo di esecuzione), e quindieliminata dal codice
t3 era usato solo per trasmettere un valore ad id1
Docente: Francesca Rossi Automi e Linguaggi Formali
Generazione del codice
Da rappresentazione intermedia a codice oggetto
Registri o locazioni di memoria per ogni variabile del codice
Da ogni istruzione in codice intermedio a sequenza diistruzioni in codice macchina
Esempio: dat1 = id3 * 60.0
id1 = id2 + t1
aLDF R2, id3
MULF R2, R2, #60.0
LDF R1, id2
ADDF R1, R1, R2
STF id1, R1
Il primo operando specifica una destinazione, F: floating-point
id3 in R2, poi moltiplicazione con 60.0 e risultato in R2, poiid2 in R1, poi somma di R1 e R2 in R1, poi R1 in id1
Docente: Francesca Rossi Automi e Linguaggi Formali
Strumenti per la costruzione di un compilatore
Generatori di parser: generano automaticamente un parserdalla descrizione della grammatica di un linguaggio
Generatori di scanner: generano automaticamente unanalizzatore lessicale dalla descrizione tramite espressioniregolari dei token di un linguaggio
Generatori di generatori di codice: da regole per tradurre ognioperazione in una sequenza di istruzioni in linguaggiomacchina
Docente: Francesca Rossi Automi e Linguaggi Formali
Ruolo dell’analisi lessicale
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
Elimina spazi bianchi e commenti
Scanning (compattazione della stringa di caratteri coneliminazione di commenti e spazi bianchi) seguito da analisilessicale (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
Token, pattern, lexemi
Token: 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 tokenpossono avere
Esempio: se il token e’ una parola chiave, il pattern e’ lasequenza di caratteri che formano la parola chiave. Peridentificatori, il pattern descrive tante stringhe di caratteri, chesono tutte identificatori.
Lexema: sequenza di caratteri del programma sorgente cherispetta il pattern di un token
Esempi:
token if, pattern: caratteri i e f, lexema: iftoken id, pattern: una lettera seguita da lettere e cifre, esempidi lexemi: posizione, inizialetoken number, pattern: un numero, esempi di lexemi:3.14159, 0, 6.2
Docente: Francesca Rossi Automi e Linguaggi Formali
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.)
Token per altri simboli (parentesi, virgola, ecc.)
Nome token per dire che token e’, valore attributo per indicarequale lexema come istanza del token.
Docente: Francesca Rossi Automi e Linguaggi Formali
Esempio
Comando Fortran E = M * C ** 2
Token generati:<id, puntatore ad E 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>
Docente: Francesca Rossi Automi e Linguaggi Formali
Input buffering
Esempio: per sapere di essere alla fine di un identificatore,dobbiamo almeno leggere un carattere che non e’ ne’ unalettera ne’ una cifra
Esempio (C): < potrebbe essere un operatore oppure l’iniziodi <=
Esempio (Fortran 90, spazi sono ignorati): nel comando
DO 5 I = 1.25
il primo lexema e’ DO5I (e’ un comando di assegnamento),mentre in
DO 5 I = 1,25
il primo lexema e’ la parola chiave DO (comando for)
Spesso e’ necessario leggere oltre la fine di un lexema percapire che lexema e’
Due puntatori per scorrere l’input: uno all’inizio del lexemacorrente, uno per leggere oltre, finche’ non si trova un lexemache corrisponde ad un token
Docente: Francesca Rossi Automi e Linguaggi Formali
Specifica dei token
Linguaggi regolari
Espressioni 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
Linguaggi regolari e automi a stati finiti
Linguaggi regolari e automi a stati finiti
Automi a stati finiti
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 dicomunicazione.
Linguaggi regolari e automi a stati finiti
Esempi
Esempio: automa a stati finiti per un interruttore on/off
Push
Push
Start
onoff
Esempio: automa a stati finiti che riconosce la stringa then
t th the
Start t nh e
then
Linguaggi regolari e automi a stati finiti
Rappresentazioni strutturali
Ci sono vari modi di specificare una macchina
Grammatiche:Una regola come E ⇒ E + E specifica un’espressionearitmeticaCoda ⇒ Persona.Coda
dice che una coda e’ costituita da una persona seguita da unacoda.
Espressioni 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 conPalo Alto CA?
Linguaggi regolari e automi a stati finiti
Concetti di base
Alfabeto: Insieme fnito e non vuoto di simboli
Esempio: Σ = {0, 1} alfabeto binarioEsempio: Σ = {a, b, c , . . . , z} insieme di tutte le lettereminuscoleEsempio: Insieme di tutti i caratteri ASCII
Stringa: Sequenza fnita di simboli da un alfabeto Σ, e.g.0011001
Stringa vuota: La stringa con zero occorrenze di simboli daΣ
La stringa vuota e’ denotata con ǫ
Linguaggi regolari e automi a stati finiti
Lunghezza di una stringa: Numero di posizioni per i simbolinella stringa.|w | denota la lunghezza della stringa w
|0110| = 4, |ǫ| = 0Potenze di un alfabeto: Σk = insieme delle stringhe di lunghezzak con simboli da ΣEsempio: Σ = {0, 1}Σ1 = {0, 1}Σ2 = {00, 01, 10, 11}Σ0 = {ǫ}Domanda: Quante stringhe ci sono in Σ3?
Linguaggi regolari e automi a stati finiti
L’insieme di tutte le stringhe su Σ e’ denotato da Σ∗
Σ∗ = Σ0 ∪ Σ1 ∪ Σ2 ∪ · · ·Anche:Σ+ = Σ1 ∪ Σ2 ∪ Σ3 ∪ · · ·Σ∗ = Σ+ ∪ {ǫ}Concatenazione: Se x e y sono stringhe, allora xy e’ la stringaottenuta rimpiazzando una copia di y immediatamente dopo unacopia di x
x = a1a2 . . . ai , y = b1b2 . . . bj
xy = a1a2 . . . aib1b2 . . . bj
Esempio: x = 01101, y = 110, xy = 01101110Nota: Per ogni stringa x
xǫ = ǫx = x
Linguaggi regolari e automi a stati finiti
Linguaggi
Definizione: Se Σ e’ un alfabeto, e L ⊆ Σ∗, allora L e’ unlinguaggioEsempi 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
{ǫ, 01, 0011, 000111, . . .}
Linguaggi regolari e automi a stati finiti
Altri esempi
• L’insieme delle stringhe con un numero uguale di zeri e di uni
{ǫ, 01, 10, 0011, 0101, 1001, . . .}
• LP = insieme dei numeri binari il cui valore e’ primo
{10, 11, 101, 111, 1011, . . .}
• Il linguaggio vuoto ∅• Il linguaggio {ǫ} consiste della stringa vuotaNota: ∅ 6= {ǫ}Nota: L’alfabeto Σ e’ sempre finito
Linguaggi regolari e automi a stati finiti
Problemi
La stringa w e’ un elemento di un linguaggio L?
Esempio: Dato un numero binario, e’ primo = e’ un elementodi LP?
E’ 11101 ∈ LP? Che risorse computazionali sono necessarieper 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.
Esempio: Fare il parsing di un programma C = controllare seil programma e’ corretto, e se lo e’, produrre un albero diparsing.
Linguaggi regolari e automi a stati finiti
Dimostrazioni deduttive
Sequenza di enunciati la cui verita’ porta da un enunciatoiniziale (l’ipotesi) ad un enunciato finale (la conclusione)
Forma del teorema: Se H, allora C
H= ipotesi, C= conclusione
Esempio: se x ≥ 4, allora 2x ≥ x2
x parametro quantificato universalmente (vale per tutti gli x)
Linguaggi regolari e automi a stati finiti
Modus ponens: regola logica che fa passare da un enuciato alsuccessivo
Se H e’ vera, e sappiamo che ”se H allora C”, allora possiamoconcludere che anche C e’ vera
Teoremi della forma ”C1 se e solo se C2”: due direzioni diprova
Dimostrazione per assurdo: H e non C implica il falso
Linguaggi regolari e automi a stati finiti
Quantificatori
Per ogni x (∀x): vale per tutti i valori della variabile
Esiste x (∃x): vale per almeno un valore della variabile
Esempio: un insieme s e’ infinito se e solo se, per ogni interon, esiste almeno un sottoinsieme T di S con n elementi
Dobbiamo considerare un n arbitrario e poi trovare un insiemecon quel numero n di elementi
∀ precede ∃
Enunciato simile ma di significato diverso, e scorretto: Esisteun sottoinsieme T dell’insieme S tale che, per ogni n, T ha n
elementi
Linguaggi regolari e automi a stati finiti
Dimostrazioni per induzione
Utili quando ci sono cose definite ricorsivamente
Esempio: 0 e’ un intero, e se n e’ un intero allora n+1 e’ unintero
Induzione sugli interi: dobbiamo dimostrare un enunciato S(n)su un intero n
Base: dimostriamo S(i) per un intero particolare (0 o 1 disolito)Passo induttivo: per n ≥ i , dimostriamo che se vale S(n) alloravale anche S(n + 1)
Possiamo concludere che S(n) e’ vero per ogni n ≥ i
Linguaggi regolari e automi a stati finiti
Esempio
Se x ≥ 4, allora 2x ≥ x2
Base: x = 4 ⇒ 2x = 24 = 16 e x2 = 42 = 16
Induzione: Supponiamo che 2x ≥ x2 per x ≥ 4
Dobbiamo dimostrare che 2x+1 ≥ (x + 1)2
Abbiamo:
2x+1 = 2x × 2 ≥ 2 × x2 (dalla base induttiva)Dimostriamo adesso che 2x2 ≥ (x + 1)2
Semplificando: x ≥ 2 + 1/x
Se x ≥ 4, 1/x ≤ 1/4 ⇒ 2 + 1/x ≤ 2.25
Linguaggi regolari e automi a stati finiti
Induzione strutturale
Molte strutture possono essere definite ricorsivamente
Esempio (espressioni):
caso base: qualunque numero o lettera e’ un’espressionecaso induttivo: se E e F sono espressioni, allora lo sono ancheE + F , E × F , e (E )Esempi: 3+(4x2), (2x(5+7))x4
Per dimostrare teoremi su un’espressione: si dimostral’enunciato sul caso base, e poi si dimostra l’enunciato sullastruttura X a partire dalla validita’ dell’enunciato sullestrutture di cui X e’ composta secondo la definizione ricorsiva
Linguaggi regolari e automi a stati finiti
Esempio
Teorema: ogni espressione ha un numero uguale di parentesiaperte e chiuse
Caso base: zero parentesi ⇒ vero
Induzione: Tre modi per costruire un’espressioneinduttivamente: E + F , E × F , e (E )
Per E + F e E × F : se vale per E e F , supponiamo che E
abbia n parentesi aperte e chiuse e F ne abbia m ⇒ E + F neha n + m
Per (E ): se vale per E , supponiamo che E abbia n parentesiaperte e chiuse ⇒ (E ) ne ha n + 1
Linguaggi regolari e automi a stati finiti
Automi a stati finiti deterministici
Un DFA e’ una quintupla
A = (Q,Σ, δ, q0,F )
• Q e’ un insieme finito di stati
• Σ e’ un alfabeto finito (= simboli in input)• δ e’ una funzione di transizione (q, a) 7→ p
• q0 ∈ Q e’ lo stato iniziale
• F ⊆ Q e’ un insieme di stati finali
Linguaggi regolari e automi a stati finiti
Esempio
Esempio: Un automa A che accettaL = {x01y : x , y ∈ {0, 1}∗}L’automa A = ({q0, q1, q2}, {0, 1}, δ, q0, {q1}) come una tabella di
transizione:
0 1
→ q0 q2 q0
⋆q1 q1 q1
q2 q2 q1
L’automa come un diagramma di transizione:
1 0
0 1q0
q2
q1 0, 1
Start
Linguaggi regolari e automi a stati finiti
Accettazione
Un automa a stati finiti (FA) accetta una stringa w = a1a2 · · · an
se esiste un cammino nel diagramma di transizione che
1 Inizia nello stato iniziale
2 Finisce in uno stato finale (di accettazione)
3 Ha una sequanza di etichette a1a2 · · · an
Esempio: L’automa a stati finiti
Start 0 1q0
q q
0, 1
1 2
accetta ad esempio la stringa 01101
Linguaggi regolari e automi a stati finiti
Linguaggio accettato
• La funzione di transizione δ puo’ essere estesa a δ che opera sustati 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 : δ(q0, w) ∈ F}
• I linguaggi accettati da automi a stati finiti sono detti linguaggi
regolari
Linguaggi regolari e automi a stati finiti
Esempio
Esempio: DFA che accetta tutte e sole le stringhe con un numeropari di zeri e un numero pari di uni
q q
q q
0 1
2 3
Start
0
0
1
1
0
0
1
1
Linguaggi regolari e automi a stati finiti
Esempio
Rappresentazione tabulare dell’automa
0 1
⋆ → q0 q2 q1
q1 q3 q0
q2 q0 q3
q3 q1 q2
Linguaggi regolari e automi a stati finiti
Esercizi
DFA per i seguenti linguaggi sull’alfabeto {0, 1}:
Insieme di tutte le strighe che finiscono con 00Insieme di tutte le stringhe con tre zeri consecutiviInsieme delle stringhe con 011 come sottostringaInsieme delle stringhe che cominciano o finiscono (o entrambele cose) con 01
Linguaggi regolari e automi a stati finiti
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’ ilprossimo statoEsempio: un automa che accetta tutte e solo le stringhe chefiniscono in 01.
Start 0 1q0
q q
0, 1
1 2
Ecco cosa succede quando l’automa elabora l’input 00101
q0
q2
q0
q0
q0
q0
q0
q1
q1
q1
q2
0 0 1 0 1
(stuck)
(stuck)
Linguaggi regolari e automi a stati finiti
Definizione formale di NFA
Formalmente, un NFA e’ una quintupla
A = (Q,Σ, δ, q0,F )
• Q e’ un insieme finito di stati• Σ e’ un alfabeto finito• δ e’ una funzione di transizione da Q × Σ all’insieme deisottoinsiemi di Q
• q0 ∈ Q e’ lo stato iniziale
• F ⊆ Q e’ un insieme di stati finali
Linguaggi regolari e automi a stati finiti
Esempio
L’ NFA di due pagine fa e’
({q0, q1, q2}, {0, 1}, δ, q0, {q2})
dove δ e’ la funzione di transizione
0 1
→ q0 {q0, q1} {q0}q1 ∅ {q2}
⋆q2 ∅ ∅
Linguaggi regolari e automi a stati finiti
Esempio
Funzione di transizione estesa δ.Base: δ(q, ǫ) = {q}Induzione:
δ(q, xa) =⋃
p∈δ(q,x)
δ(p, a)
Esempio: Calcoliamo δ(q0, 00101) sulla lavagna• Formalmente, il linguaggio accettato da A e’
L(A) = {w : δ(q0, w) ∩ F 6= ∅}
Linguaggi regolari e automi a stati finiti
Proviamo formalmente che l’ NFA
Start 0 1q0
q q
0, 1
1 2
accetta il linguaggio {x01 : x ∈ Σ∗}. Faremo una induzione mutuasui tre enunciati seguenti
0 w ∈ Σ∗ ⇒ q0 ∈ δ(q0,w)
1 q1 ∈ δ(q0,w) ⇔ w = x0
2 q2 ∈ δ(q0,w) ⇔ w = x01
Linguaggi regolari e automi a stati finiti
Base: Se |w | = 0 allora w = ǫ. Allora l’enunciato (0) segue dalladefnizione Per (1) e (2) entrambi i lati sono falsi per ǫInduzione: Assumiamo che w = xa, dove a ∈ {0, 1}, |x | = n e glienunciati (0)–(2) valgono per x . Si mostra che gli enunciativalgono per xa.
Linguaggi regolari e automi a stati finiti
Equivalenza di DFA e NFA
• Gli NFA sono di solito piu’ facili da ”programmare”.• Sorprendentemente, per ogni NFA N c’e’ un DFA D, tale cheL(D) = L(N), e viceversa.• Questo comporta una construzione a sottoinsiemi, un esempioimportante di come un automa B puo’ essere costruito da un altroautoma A.• Dato un NFA
N = (QN ,Σ, δN , q0,FN)
costruiremo un DFA
D = (QD ,Σ, δD , {q0},FD)
tali cheL(D) = L(N)
.
Linguaggi regolari e automi a stati finiti
I dettagli della costruzione a sottoinsiemi:• QD = {S : S ⊆ QN}.Nota: |QD | = 2|QN |, anche se la maggior parte degli stati in QD
sono ”garbage”, cioe’ non raggiungibili dallo stato iniziale.• FD = {S ⊆ QN : S ∩ FN 6= ∅}• Per ogni S ⊆ QN e a ∈ Σ,
δD(S , a) =⋃
p∈S
δN(p, a)
Linguaggi regolari e automi a stati finiti
Costruiamo δD dall’ NFA gia’ visto:
0 1
∅ ∅ ∅→ {q0} {q0, q1} {q0}
{q1} ∅ {q2}⋆{q2} ∅ ∅
{q0, q1} {q0, q1} {q0, q2}⋆{q0, q2} {q0, q1} {q0}⋆{q1, q2} ∅ {q2}
⋆{q0, q1, q2} {q0, q1} {q0, q2}
Linguaggi regolari e automi a stati finiti
Nota: Gli stati di D corrispondono a sottoinsiemi di stati di N, mapotevamo denotare gli stati di D in un altro modo, per esempioA − F .
0 1
A A A
→ B E B
C A D
⋆D A A
E E F
⋆F E B
⋆G A D
⋆H E F
Linguaggi regolari e automi a stati finiti
Possiamo spesso evitare la crescita esponenziale degli staticostruendo la tabella di transizione per D solo per stati accessibiliS come segue:Base: S = {q0} e’ accessibile in D
Induzione: Se lo stato S e’ accessibile, lo sono anche gli stati in⋃a∈Σ δD(S , a).
Esempio: Il ”sottoinsieme” DFA con stati accessibili solamente.
Start
{ {q q {q0 0 0
, ,q q1 2}}
0 1
1 0
0
1
}
Linguaggi regolari e automi a stati finiti
Teorema 2.11: Sia D il DFA ottenuto da un NFA N con lacostruzione a sottoinsiemi. Allora L(D) = L(N).Prova: Prima mostriamo per induzione su |w | che
δD({q0}, w) = δN(q0,w)
Base: w = ǫ. L’enunciato segue dalla definizione.
Linguaggi regolari e automi a stati finiti
Induzione:
δD({q0}, xa)def= δD(δD({q0}, x), a)
i.h.= δD(δN(q0, x), a)
cst=
⋃
p∈δN(q0,x)
δN(p, a)
def= δN(q0, xa)
Ora segue che L(D) = L(N).
Linguaggi regolari e automi a stati finiti
Teorema 2.12: Un linguaggio L e’ accettato da un DFA se e solose L e’ accettato da un NFA.Prova: La parte ”se” e’ il Teorema 2.11.Per la parte ”solo se” notiamo che un qualsiasi DFA puo’ essereconvertito in un NFA equivalente modificando la δD in δN secondola regola seguente:• Se δD(q, a) = p, allora δN(q, a) = {p}.Per induzione su |w | si puo’ mostrare che se δD(q0,w) = p, alloraδN(q0, w) = {p}.L’enunciato del teorema segue.
Linguaggi regolari e automi a stati finiti
Crescita esponenziale degli stati
Esiste un NFA N con n + 1 stati che non ha nessun DFAequivalente con meno di 2n stati
Start
0, 1
0, 1 0, 1 0, 1q q qq
0 1 2 n
1 0, 1
L(N) = {x1c2c3 · · · cn : x ∈ {0, 1}∗, ci ∈ {0, 1}}
Supponiamo che esista un DFA equivalente con meno di 2n stati.D deve ricordare gli ultimi n simboli che ha letto.Ci sono 2n sequenze di bit a1a2 · · · an
∃ q, a1a2 · · · an, b1b2 · · · bn : q ∈ δN(q0, a1a2 · · · an), q ∈δN(q0, b1b2 · · · bn), a1a2 · · · an 6= b1b2 · · · bn
Linguaggi regolari e automi a stati finiti
Caso 1:
1a2 · · · an
0b2 · · · bn
Allora q deve essere sia uno stato di accettazione che uno stato dinon accettazione.Caso 2:
a1 · · · ai−11ai+1 · · · an
b1 · · · bi−10bi+1 · · · bn
Ora δN(q0, a1 · · · ai−11ai+1 · · · an0i−1) =
δN(q0, b1 · · · bi−10bi+1 · · · bn0i−1)
e δN(q0, a1 · · · ai−11ai+1 · · · an0i−1) ∈ FD
δN(q0, b1 · · · bi−10bi+1 · · · bn0i−1) /∈ FD
Linguaggi regolari e automi a stati finiti
FA con transizioni epsilon
Un ǫ-NFA che accetta numeri decimali consiste di:
1 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
q q q q q
q
0 1 2 3 5
4
Start
0,1,...,9 0,1,...,9
ε ε
0,1,...,9
0,1,...,9
,+,-
.
.
Linguaggi regolari e automi a stati finiti
Esempio
ǫ-NFA che accetta l’insieme di parole chiave {ebay, web}
1
2 3 4
5 6 7 8Start
Σw
e
e
yb a
b
Linguaggi regolari e automi a stati finiti
Definizione ed esempio
Un ǫ-NFA e’ una quintupla (Q,Σ, δ, q0,F ) dove δ e’ una funzioneda Q × Σ ∪ {ǫ} all’insieme dei sottoinsiemi di Q.Esempio: L’ ǫ-NFA della pagina precedente
E = ({q0, q1, . . . , q5}, {.,+,−, 0, 1, . . . , 9} δ, q0, {q5})
dove la tabella delle transizioni per δ e’
ǫ +,- . 0, . . . , 9
→ q0 {q1} {q1} ∅ ∅q1 ∅ ∅ {q2} {q1, q4}q2 ∅ ∅ ∅ {q3}q3 {q5} ∅ ∅ {q3}q4 ∅ ∅ {q3} ∅
⋆q5 ∅ ∅ ∅ ∅
Linguaggi regolari e automi a stati finiti
Epsilon-chiusura
Chiudiamo uno stato aggiungendo tutti gli stati raggiungibili da luitramite una sequenza ǫǫ · · · ǫDefinizione induttiva di ECLOSE(q)Base:
q ∈ ECLOSE(q)Induzione:
p ∈ ECLOSE(q) and r ∈ δ(p, ǫ) ⇒ r ∈ ECLOSE(q)
Linguaggi regolari e automi a stati finiti
Esempio di epsilon-chiusura
1
2 3 6
4 5 7
ε
ε ε
ε
εa
b
Per esempio,
ECLOSE(1) = {1, 2, 3, 4, 6}
Linguaggi regolari e automi a stati finiti
• Definizione induttiva di δ per automi ǫ-NFABase:
δ(q, ǫ) = ECLOSE(q)
Induzione:
δ(q, xa) =⋃
p∈δ(δ(q,x),a)
ECLOSE(p)
Calcoliamoδ(q0, 5.6) per l’NFA dei numeri decimali
Linguaggi regolari e automi a stati finiti
Da ǫ-NFA a DFA
Dato un ǫ-NFAE = (QE , Σ, δE , q0,FE )
costruiremo un DFA
D = (QD ,Σ, δD , qD , FD)
tale cheL(D) = L(E )
Dettagli della costruzione:• QD = {S : S ⊆ QE e S = ECLOSE(S)}• qD = ECLOSE(q0)• FD = {S : S ∈ QD e S ∩ FE 6= ∅}• δD(S , a) =
⋃{ECLOSE(p) : p ∈ δ(t, a) per alcuni t ∈ S}
Linguaggi regolari e automi a stati finiti
Esempio
ǫ-NFA E
q q q q q
q
0 1 2 3 5
4
Start
0,1,...,9 0,1,...,9
ε ε
0,1,...,9
0,1,...,9
,+,-
.
.
Linguaggi regolari e automi a stati finiti
DFA D corrispondente ad E
Start
{ { { {
{ {
q q q q
q q
0 1 1, }q
1} , q
4} 2, q
3, q
5}
2}3, q
5}
0,1,...,9 0,1,...,9
0,1,...,9
0,1,...,9
0,1,...,9
0,1,...,9
+,-
.
.
.
Linguaggi regolari e automi a stati finiti
Teorema 2.22: Un linguaggio L e’ accettato da un ǫ-NFA E se esolo se L e’ accettato da un DFA.Prova: Usiamo D costruito come sopra e mostriamo per induzioneche δE (q0, w) = δD(qD , w)
Base: δE (q0, ǫ) = ECLOSE(q0) = qD = δ(qD , ǫ)
Linguaggi regolari e automi a stati finiti
Induzione:
δE (q0, xa) =⋃
p∈δE (δE (q0,x),a)
ECLOSE(p)
=⋃
p∈δD(δD(qD ,x),a)
ECLOSE(p)
=⋃
p∈δD(qD ,xa)
ECLOSE(p)
= δD(qD , xa)
Linguaggi regolari e automi a stati finiti
Espressioni regolari
Espressioni regolari
Espressioni regolari
Un FA (NFA o DFA) e’ un metodo per costruire una macchinache riconosce linguaggi regolari.
Una espressione regolare e’ un modo dichiarativo perdescrivere un linguaggio regolare.
Esempio: 01∗ + 10∗
Le espressioni regolari sono usate, ad esempio, in
comandi UNIX (grep)strumenti per l’analisi lessicale di UNIX (Lex (Lexical analyzergenerator) e Flex (Fast Lex)).
Espressioni regolari
Operazioni sui linguaggi
Unione:
L ∪ M = {w : w ∈ L o w ∈ M}
Concatenazione:
L.M = {w : w = xy , x ∈ L, y ∈ M}
Potenze:
L0 = {ǫ}, L1 = L, Lk+1 = L.Lk
Chiusura di Kleene:
L∗ =
∞⋃
i=0
Li
Espressioni regolari
Definizione induttiva di espressioni regolari
Base:
ǫ e ∅ sono espressioni regolari.L(ǫ) = {ǫ} e L(∅) = ∅.Se a ∈ Σ, allora a e’ un’espressione regolare.L(a) = {a}.
Induzione:
Se E e’ un’espressione regolare, allora (E ) e’ un’espressioneregolare. L((E )) = L(E ).Se E e F sono espressioni regolari, allora E + F e’un’espressione regolare. L(E + F ) = L(E ) ∪ L(F ).Se E e F sono espressioni regolari, allora E .F e’ un’espressioneregolare. L(E .F ) = L(E ).L(F ).Se E e’ un’espressione regolare, allora E ⋆ e’ un’espressioneregolare. L(E ⋆) = (L(E ))∗.
Espressioni regolari
Esempio
Espressione regolare perL = {w ∈ {0, 1}∗ : 0 e 1 alternati in w}
(01)∗ + (10)∗ + 0(10)∗ + 1(01)∗
o, equivalentemente,
(ǫ + 1)(01)∗(ǫ + 0)
Espressioni regolari
Ordine di precedenza per gli operatori
1 Chiusura
2 Concatenazione (punto)
3 Piu’ (+)
Esempio: 01∗ + 1 e’ raggruppato in (0(1)∗) + 1
Espressioni regolari
Equivalenza di FA e espr. regolari
Abbiamo gia’ mostrato che DFA, NFA, e ǫ-NFA sono tuttiequivalenti.
ε-NFA NFA
DFARE
Per mostrare che gli FA sono equivalenti alle espressioni regolari,mostreremo che
1 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 cheL(A) = L(R).
Espressioni regolari
La tecnica di eliminazione di stati
Etichettiamo gli archi con espressioni regolari di simboli
q
q
p
p
1 1
k m
s
Q
Q
P1
Pm
k
1
11R
R1m
Rkm
Rk1
S
Espressioni regolari
Ora eliminiamo lo stato s.
11R Q
1P1
R1m
Rk1
Rkm
Q1
Pm
Qk
Qk
P1
Pm
q
q
p
p
1 1
k m
+ S*
+
+
+
S*
S*
S*
Per lo stato accettante q eliminiamo dall’automa originale tutti glistati eccetto q0 e q.
Espressioni regolari
Per ogni q ∈ F saremo rimasti con Aq della forma
Start
R
S
T
U
e che corrisponde all’espressione regolare Eq = (R + SU∗T )∗SU∗
o con Aq della forma
R
Start
che corrisponde all’espressione regolare Eq = R∗
• L’espressione finale e’⊕
q∈F
Eq
Espressioni regolari
Esempio
A, dove L(A) = {W : w = x1b, o w = x1bc, x ∈{0, 1}∗, {b, c} ⊆ {0, 1}}
Start
0,1
1 0,1 0,1
A B C D
La trasformiamo in un automa con espressioni regolari comeetichette
0 1+
0 1+ 0 1+Start
A B C D
1
Espressioni regolari
Esempio
0 1+
0 1+ 0 1+Start
A B C D
1
Eliminiamo lo stato B
0 1+
DC
0 1+( ) 0 1+Start
A
1
Poi eliminiamo lo stato C e otteniamo AD
0 1+
D
0 1+( ) 0 1+( )Start
A
1
con espressione regolare (0 + 1)∗1(0 + 1)(0 + 1)Espressioni regolari
Esempio
Da
0 1+
DC
0 1+( ) 0 1+Start
A
1
possiamo eliminare D e ottenere AC
0 1+
C
0 1+( )Start
A
1
con espressione regolare (0 + 1)∗1(0 + 1)• L’espressione finale e’ la somma delle due espressioni regolariprecedenti:
(0 + 1)∗1(0 + 1)(0 + 1) + (0 + 1)∗1(0 + 1)
Espressioni regolari
Da espressioni regolari a ǫ-NFA
Teorema 3.7: Per ogni espressione regolare R possiamo costruireun ǫ-NFA A, tale che L(A) = L(R).Prova: Per induzione strutturale:Base: Automa per ǫ, ∅, e a.
ε
a
(a)
(b)
(c)
Espressioni regolari
Induzione: Automa per R + S , RS , e R∗
(a)
(b)
(c)
R
S
R S
R
ε ε
εε
ε
ε
ε
ε ε
Espressioni regolari
Esempio
Trasformiamo (0 + 1)∗1(0 + 1)
ε
ε
ε
ε
0
1
(a)
(b)
0
1
ε ε
ε
ε
ε ε
εε
Espressioni regolari
Esempio
ε
ε
ε
ε
0
1
ε
ε1
Start
(b)
(c)
ε
0
1
ε ε
ε
ε
ε ε
ε
Espressioni regolari
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 eM tali che LM 6= ML.
Espressioni 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.
Espressioni regolari
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+ ∪ {ǫ}
Espressioni regolari
• (L∗)∗ = L∗. La chiusura e’ idempotente.Prova:
w ∈ (L∗)∗ ⇐⇒ w ∈∞⋃
i=0
( ∞⋃
j=0
Lj
)i
⇐⇒ ∃k,m ∈ N : w ∈ (Lm)k
⇐⇒ ∃p ∈ N : w ∈ Lp
⇐⇒ w ∈∞⋃
i=0
Li
⇐⇒ w ∈ L∗
Espressioni regolari
Da pattern ad analizzatore lessicale
Da pattern ad analizzatore lessicale
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 nuovostato iniziale e transizioni ǫ
Esempio: 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 patterna∗bb
∗⇒ useremo il primo dei pattern possibili nella lista (in
questo caso il pattern abb)
stringhe come aabbb... hanno molti prefissi che vannod’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 lastringa in input
In ogni momento, considera l’insieme di stati in cui e’
Le transizioni ǫ vanno considerate: inizia dalla ǫ-chiusura dellostato iniziale, e ad ogni passo calcola la ǫ- chiusura
Quando legge un simbolo che lo porta in un insieme vuoto distati, ha finito a leggere il lexema corrente per qualche pattern
Per capire quale pattern, torna indietro nella lista degli statifinche’ non c’e’ uno stato finale (lexema piu’ lungo per i datipattern).
In alternativa: da NFA e DFA, e poi muoversi nel DFAleggendo la stringa in input
Da pattern ad analizzatore lessicale
Leggere oltre il lexema
A volte, per riconoscere un lexema per un certo pattern,dobbiamo leggere oltre la fine del lexema
Se r1 e’ il pattern del lexema e r2 il pattern di cosa leggeredopo il lexema, costruiamo le due espressioni regolari e i dueautomi corrispondenti, e li concateniamo con una transizione ǫ
Uno stato finale si raggiunge se leggiamo sia r1 che r2
Se arriviamo in uno stato finale, torniamo indietro fino allafine di r1 per capire qual e’ il lexema letto
Da pattern ad analizzatore lessicale
Il pumping lemmaProprieta’ di chiusuraProprieta’ di decisione
Proprieta’ dei linguaggi regolari
Proprieta’ dei linguaggi regolari
Il pumping lemmaProprieta’ di chiusuraProprieta’ di decisione
Proprieta’ dei Linguaggi regolari
Pumping Lemma.
Ogni linguaggio regolare soddisfa il pumping lemma. Sequalcuno vi presenta un falso linguaggio regolare, l’uso delpumping lemma mostrera’ una contraddizione.
Proprieta’ di chiusura.
Come costruire automi da componenti usando delleoperazioni, ad esempio dati L e M possiamo costruire unautoma per L ∩ M.
Proprieta’ di decisione.
Analisi computazionale di automi, cioe’ quanto costacontrollare varie proprieta’, come l’equivalenza di due automi.
Tecniche di minimizzazione.
Possiamo risparmiare costruendo automi piu’ piccoli.
Proprieta’ dei linguaggi regolari
Il pumping lemmaProprieta’ di chiusuraProprieta’ di decisione
Il Pumping Lemma, informalmente
Supponiamo che L01 = {0n1n : n ≥ 1} sia regolare.
Allora deve essere accettato da un qualche DFA A, con, adesempio, k stati.
Supponiamo che A legga 0k . Avra’ le seguenti transizioni:
ǫ p0
0 p1
00 p2
. . . . . .0k pk
⇒ ∃i < j : pi = pj
Chiamiamo q questo stato.
Proprieta’ dei linguaggi regolari
Il pumping lemmaProprieta’ di chiusuraProprieta’ di decisione
Adesso possiamo ingannare A:
Se δ(q, 1i ) ∈ F l’automa accettera’, sbagliando, 0j1i .Se δ(q, 1i ) /∈ F l’automa rifiutera’, sbagliando, 0i1i .
Quindi L01 non puo’ essere regolare.
Proprieta’ dei linguaggi regolari
Il pumping lemmaProprieta’ di chiusuraProprieta’ di decisione
Teorema 4.1: Il Pumping Lemma per Linguaggi Regolari
Sia L un linguaggio regolare.Allora ∃n,∀w ∈ L : |w | ≥ n ⇒ w = xyz tale che:
1 y 6= ǫ
2 |xy | ≤ n
3 ∀k ≥ 0, xykz ∈ L
Proprieta’ dei linguaggi regolari
Il pumping lemmaProprieta’ di chiusuraProprieta’ di decisione
Prova
Supponiamo che L sia regolare.
Allora L e’ riconosciuto da un DFA A con, ad esempio, n stati.
Sia w = a1a2 . . . am ∈ L, m > n.
Sia pi = δ(q0, a1a2 · · · ai ).
⇒ ∃i < j : pi = pj
Proprieta’ dei linguaggi regolari
Il pumping lemmaProprieta’ di chiusuraProprieta’ di decisione
Ora w = xyz , dove
1 x = a1a2 · · · ai
2 y = ai+1ai+2 · · · aj
3 z = aj+1aj+2 . . . am
Startpi
p0
a1
. . . ai
ai+1
. . . aj
aj+1
. . . am
x = z =
y =
Quindi anche xykz ∈ L, per ogni k ≥ 0.
Proprieta’ dei linguaggi regolari
Il pumping lemmaProprieta’ di chiusuraProprieta’ di decisione
Esempio
Sia Leq il linguaggio delle stringhe con ugual numero di zeri edi uni.
Supponiamo che Leq sia regolare. Allora w = 0n1n ∈ L.
Per il pumping lemma, w = xyz , |xy | ≤ n, y 6= ǫ e xykz ∈ Leq
w = 000 · · ·︸ ︷︷ ︸
x
· · · 0︸︷︷︸
y
0111 · · · 11︸ ︷︷ ︸
z
In particolare, xz ∈ Leq, ma xz ha meno zeri di uni.
Proprieta’ dei linguaggi regolari
Il pumping lemmaProprieta’ di chiusuraProprieta’ di decisione
Esempio
Supponiamo che Lpr = {1p : p e’ primo } sia regolare.Sia n dato dal pumping lemma.Scegliamo un numero primo p ≥ n + 2.
w =
p︷ ︸︸ ︷
111 · · ·︸ ︷︷ ︸
x
· · · 1︸︷︷︸
y|y |=m
1111 · · · 11︸ ︷︷ ︸
z
Ora xyp−mz ∈ Lpr
|xyp−mz | = |xz |+(p−m)|y | = p−m+(p−m)m = (1+m)(p−m)che non e’ primo a meno che uno dei fattori non sia 1.• y 6= ǫ ⇒ 1 + m > 1• m = |y | ≤ |xy | ≤ n, p ≥ n + 2⇒ p − m ≥ n + 2 − n = 2.
Proprieta’ dei linguaggi regolari
Il pumping lemmaProprieta’ di chiusuraProprieta’ di decisione
Proprieta’ di chiusura dei linguaggi regolari
Siano L e M due linguaggi regolari. Allora i seguenti linguaggisono regolari:
Unione: L ∪ M
Intersezione: L ∩ M
Complemento: N
Differenza: L \ M
Inversione: LR = {wR : w ∈ L}
Chiusura: L∗.
Concatenazione: L.M
Proprieta’ dei linguaggi regolari
Il pumping lemmaProprieta’ di chiusuraProprieta’ di decisione
Chiusura rispetto a unione e complemento
Teorema 4.4. Per ogni coppia di linguaggi regolari L e M, L ∪ M
e’ regolare.Prova. Sia L = L(E ) e M = L(F ). Allora L(E + F ) = L ∪ M perdefinizione.
Teorema 4.5. Se L e’ un linguaggio regolare su Σ, allora cheL = Σ∗ \ L e’ regolare.Prova. Sia L riconosciuto da un DFA
A = (Q,Σ, δ, q0,F ).
Sia B = (Q,Σ, δ, q0,Q \ F ). Allora L(B) = L.
Proprieta’ dei linguaggi regolari
Il pumping lemmaProprieta’ di chiusuraProprieta’ di decisione
Esempio
Sia L riconosciuto dal DFA qui sotto:
Start
{ {q q {q0 0 0
, ,q q1 2}}
0 1
1 0
0
1
}
Allora L e’ riconosciuto da:1 0
Start
{ {q q {q0 0 0
, ,q q1 2}}
0 1}
1
0
Proprieta’ dei linguaggi regolari
Il pumping lemmaProprieta’ di chiusuraProprieta’ di decisione
Chiusura rispetto all’intersezione
Teorema 4.8. Se L e M sono regolari, allora anche L ∩ M e’regolare.
Prova 1. Per la legge di DeMorgan, L ∩ M = L ∪ M. Sappiamogia’ che i linguaggi regolari sono chiusi sotto il complemento el’unione.
Proprieta’ dei linguaggi regolari
Il pumping lemmaProprieta’ di chiusuraProprieta’ 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
AL = (QL,Σ, δL, qL,FL)
e M il linguaggio di
AM = (QM ,Σ, δM , qM ,FM)
Assumiamo senza perdita di generalita’ che entrambi gli automisiano deterministici.Costruiremo un automa che simula AL e AM in parallelo, e accettase e solo se sia AL che AM accettano.
Proprieta’ dei linguaggi regolari
Il pumping lemmaProprieta’ di chiusuraProprieta’ di decisione
Se AL va dallo stato p allo stato s leggendo a, e AM va dallo statoq allo stato t leggendo a, allora AL∩M andra’ dallo stato (p, q) allostato (s, t) leggendo a.
Start
Input
AcceptAND
a
L
M
A
A
Proprieta’ dei linguaggi regolari
Il pumping lemmaProprieta’ di chiusuraProprieta’ di decisione
Formalmente
AL∩M = (QL × QM ,Σ, δL∩M , (qL, qM),FL × FM),
doveδL∩M((p, q), a) = (δL(p, a), δM(q, a))
Si puo’ mostrare per induzione su |w | che
δL∩M((qL, qM),w) =(
δL(qL,w), δM (qM ,w))
Proprieta’ dei linguaggi regolari
Il pumping lemmaProprieta’ di chiusuraProprieta’ di decisione
Esempio
(c) = (a) × (b)
Start
Start
1
0 0,1
0,11
0
(a)
(b)
Start
0,1
p q
r s
pr ps
qr qs
0
1
1
0
0
1
(c)
Proprieta’ dei linguaggi regolari
Il pumping lemmaProprieta’ di chiusuraProprieta’ di decisione
Chiusura rispetto alla differenza
Teorema 4.10 Se L e M sono linguaggi regolari, allora ancheL \ M e’ regolare.Prova. Osserviamo che L \ M = L ∩ M. Sappiamo gia’ che ilinguaggi regolari sono chiusi sotto il complemento e l’intersezione.
Proprieta’ dei linguaggi regolari
Il pumping lemmaProprieta’ di chiusuraProprieta’ di decisione
Chiusura rispetto al ”reverse”
Teorema 4.11 Se L e’ un linguaggio regolare, allora anche LR e’regolare.Prova 1: Sia L riconosciuto da un FA A. Modifichiamo A perrenderlo un FA per LR :
1 Giriamo tutti gli archi.
2 Rendiamo il vecchio stato iniziale l’unico stato finale.
3 Creiamo un nuovo stato iniziale p0, con δ(p0, ǫ) = F (i vecchistati finali).
Proprieta’ dei linguaggi regolari
Il pumping lemmaProprieta’ di chiusuraProprieta’ di decisione
Chiusura rispetto al ”reverse”: un’altra prova
Se L e’ un linguaggio regolare, allora anche LR e’ regolare.Prova 2: Sia L descritto da un’espressione regolare E . Costruiremoun’espressione regolare ER , tale che L(ER) = (L(E ))R .Procediamo per induzione strutturale su E .Base: Se E e’ ǫ, ∅, o a, allora ER = E .Induzione:
1 E = F + G . Allora ER = FR + GR
2 E = F .G . Allora ER = GR .FR
3 E = F ∗. Allora ER = (FR)∗
Proprieta’ dei linguaggi regolari
Il pumping lemmaProprieta’ di chiusuraProprieta’ di decisione
Proprieta’ di decisione
1 Convertire tra diverse rappresentazioni dei linguaggi regolari.
2 E’ L = ∅?
3 E’ w ∈ L?
4 Due descrizioni definiscono lo stesso linguaggio?
Proprieta’ dei linguaggi regolari
Il pumping lemmaProprieta’ di chiusuraProprieta’ di decisione
Da NFA a DFA
Supponiamo che un ǫ-NFA abbia n stati.
Per calcolare ECLOSE(p) seguiamo al piu’ n2 archi. Lofacciamo per n stati, quindi in totale sono n3 passi.
Il DFA ha 2n stati, per ogni stato S e ogni a ∈ Σ calcoliamoδD(S , a) in n3 passi. In totale abbiamo O(n32n) passi.
Se calcoliamo δ solo per gli stati raggiungibili, dobbiamocalcolare δD(S , a) solo s volte, dove s e’ il numero di statiraggiungibili. In totale: O(n3s) passi.
Proprieta’ dei linguaggi regolari
Il pumping lemmaProprieta’ di chiusuraProprieta’ di decisione
Da DFA a NFA
Dobbiamo solo mettere le parentesi graffe attorno agli stati.Totale: O(n) passi.
Da FA a espressione regolare
Dobbiamo calcolare n3 cose di grandezza fino a 4n. Totale:O(n34n).L’FA puo’ essere un NFA. Se prima vogliamo convertire l’NFA inun 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.Eliminare le ǫ-transizioni ha bisogno di O(n3) passi.Se si vuole un DFA, potremmo aver bisogno di un numeroesponenziale di passi.
Proprieta’ dei linguaggi regolari
Il pumping lemmaProprieta’ di chiusuraProprieta’ di decisione
Controllare se un linguaggio e’ vuoto
L(A) 6= ∅ per FA A se e solo se uno stato finale e’raggiungibile dallo stato iniziale in in A. Totale: O(n2) passi.
Oppure, possiamo guardare un’espressione regolare E e vederese L(E ) = ∅, considerando tutti i casi:
E = F + G . Allora L(E ) e’ vuoto se e solo se sia L(F ) cheL(G) sono vuoti.E = F .G . Allora L(E ) e’ vuoto se e solo se o L(F ) o L(G)sono vuoti.E = F ∗. Allora L(E ) non e’ mai vuoto, perche’ ǫ ∈ L(E ).E = ǫ. Allora L(E ) non e’ vuoto.E = a. Allora L(E ) non e’ vuoto.E = ∅. Allora L(E ) e’ vuoto.
Proprieta’ dei linguaggi regolari
Il pumping lemmaProprieta’ di chiusuraProprieta’ di decisione
Controllare l’appartenenza ad un linguaggio
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(ns2)passi.
Se A e’ un ǫ-NFA e ha s stati, simulare A su w prende O(ns3)passi.
Se L = L(E ), per l’espressione regolare E di lunghezza s,prima convertiamo E in un ǫ-NFA con 2s stati. Poi simuliamow su questo automa, in O(ns3) passi.
Proprieta’ dei linguaggi regolari
Equivalenza e minimizzazione di automi
Equivalenza e minimizzazione di automi
Stati equivalenti
Sia A = (Q,Σ, δ, q0,F ) un DFA, e {p, q} ⊆ Q. Definiamo
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 6≡ 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
Equivalenza e minimizzazione di automi
Esempio
Start
0
0
1
1
0
1
0
1
10
01
0
11
0
A B C D
E F G H
δ(C , ǫ) ∈ F , δ(G , ǫ) /∈ F ⇒ C 6≡ G
δ(A, 01) = C ∈ F , δ(G , 01) = E /∈ F ⇒ A 6≡ G
Equivalenza e minimizzazione di automi
Cosa si puo’ dire su A e E?
Start
0
0
1
1
0
1
0
1
10
01
0
11
0
A B C D
E F G H
δ(A, ǫ) = A /∈ F , δ(E , ǫ) = E /∈ F
δ(A, 1) = F = δ(E , 1)Quindi δ(A, 1x) = δ(E , 1x) = δ(F , x)δ(A, 00) = G = δ(E , 00)δ(A, 01) = C = δ(E , 01)Conclusione: A ≡ E .
Equivalenza e minimizzazione di automi
Algoritmo induttivo
Possiamo calcolare coppie di stati distinguibili con il seguentemetodo induttivo (algoritmo di riempimento di una tavola):Base: Se p ∈ F e q 6∈ F , allora p 6≡ q.Induzione: Se ∃a ∈ Σ : δ(p, a) 6≡ δ(q, a), allora p 6≡ q.
Esempio: Applichiamo l’algoritmo ad A:
B
C
D
E
F
G
H
A B C D E F G
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
Equivalenza e minimizzazione di automi
Correttezza dell’algoritmo
Teorema 4.20: 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
1 ∃w : δ(p,w) ∈ F , δ(q,w) /∈ F , o viceversa.
2 L’algoritmo non distingue tra p e q.
Sia w = a1a2 · · · an la stringa piu’ corta che identifica la coppia”sbagliata” {p, q}.Allora w 6= ǫ perche’ altrimenti l’algoritmo distinguerebbe p da q
(caso base). Quindi n ≥ 1.
Equivalenza e minimizzazione di automi
Consideriamo gli stati r = δ(p, a1) e s = δ(q, a1).
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 ands sono distinguibili.
Ma allora l’algoritmo distinguerebbe p da q nella parteinduttiva.
Quindi non ci sono coppie ”sbagliate” e il teorema e’ vero.
Equivalenza e minimizzazione di automi
Testare l’equivalenza di linguaggi regolari
Siano L e M linguaggi regolari (descritti in qualche forma).Per testare se L = M
1 convertiamo sia L che M in DFA.
2 Immaginiamo il DFA che e’ l’unione dei due DFA (nonimporta se ha due stati iniziali)
3 Se l’algoritmo dice che i due stati iniziali sono distinguibili,allora L 6= M, altrimenti L = M.
Equivalenza e minimizzazione di automi
Esempio
Start
Start
0
0
1
1
0
1 0
1
1
0
A B
C D
E
Possiamo vedere che entrambi i DFA accettano L(ǫ + (0 + 1)∗0).
Equivalenza e minimizzazione di automi
Esempio
Il risultato dell’algoritmo e’
B
C
D
E
A B C D
x
x
x
x
x x
Quindi i due automi sono equivalenti.
Equivalenza e minimizzazione di automi
Minimizzazione di DFA
Possiamo usare l’algoritmo per minimizzare un DFA mettendoinsieme tutti gli stati equivalenti. Cioe’ rimpiazzando p byp/
≡.
Esempio: Il DFA di prima ha le seguenti classi di equivalenza:{{A,E}, {B ,H}, {C}, {D,F}, {G}}.
Il DFA unione di prima ha le seguenti classi di equivalenza:{{A,C ,D}, {B ,E}}.
Notare: affinche’ p/≡
sia una classe di equivalenza, larelazione ≡ deve essere una relazione di equivalenza
(riflessiva, simmetrica, e transitiva).
Equivalenza e minimizzazione di automi
Transitivita’
Teorema 4.23: Se p ≡ q e q ≡ r , allora p ≡ r .
Prova: Supponiamo per assurdo che p 6≡ r .
Allora ∃w tale che δ(p,w) ∈ F e δ(r ,w) 6∈ F , o viceversa.
Lo stato δ(q,w) e’ o di accettazione o no.
Caso 1: δ(q,w) e’ di accettazione. Allora q 6≡ r .
Caso 2: δ(q,w) non e’ di accettazione. Allora p 6≡ q.
Il caso contrario puo’ essere provato simmetricamente.
Quindi deve essere p ≡ r .
Equivalenza e minimizzazione di automi
Minimizzazione di automi
Per minimizzare un DFA A = (Q,Σ, δ, q0,F ) costruiamo un DFAB = (Q/
≡,Σ, γ, q0/≡ ,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) 6≡ δ(q, a), allora l’algoritmo concluderebbe p 6≡ q, quindiB e’ ben definito. Notare anche che F/
≡contiene tutti e soli gli
stati accettanti di A.
Equivalenza e minimizzazione di automi
Esempio
Possiamo minimizzare
Start
0
0
1
1
0
1
0
1
10
01
0
11
0
A B C D
E F G H
Equivalenza e minimizzazione di automi
Esempio
Otteniamo:
Start
1
0
0
1
1
0
10
1
0A,E
G D,F
B,H C
Equivalenza e minimizzazione di automi
Notare: Non possiamo applicare l’algoritmo a NFA.Per esempio, per minimizzare
Start
0,1
0
1 0
A B
C
rimuoviamo lo stato C .Ma A 6≡ C .
Equivalenza e minimizzazione di automi
Perche’ non si puo’ migliorare il DFA minimizzato
Sia B il DFA minimizzato ottenuto applicando l’algoritmo alDFA A.
Sappiamo gia’ che L(A) = L(B).
Potrebbe esistere un DFA C , con L(C ) = L(B) e meno statidi B?
Applichiamo l’algoritmo a B ”unito con” C .
Dato che L(B) = L(C ), abbiamo qB0 ≡ qC
0 .
Inoltre, δ(qB0 , a) ≡ δ(qC
0 , a), per ogni a.
Equivalenza e minimizzazione di automi
Per ogni stato p in B esiste almeno uno stato q in C , tale chep ≡ q.
Prova:
Non ci sono stati inaccessibili, quindi p = δ(qB0 , a1a2 · · · ak),
per una qualche stringa a1a2 · · · ak .Allora q = δ(qC
0 , a1a2 · · · ak), e p ≡ q.Dato che C ha meno stati di B, ci devono essere due stati r es 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’ statocostruito dall’algoritmo.
Equivalenza e minimizzazione di automi
Grammatiche libere da contesto
Grammatiche libere da contesto
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 nellostudio dei linguaggi naturali dal 1950, e nello studio deicompilatori dal 1960.
Le grammatiche libere da contesto (CFG) sono la basedella sintassi BNF (Backus-Naur-Form).
Oggi i CFL sono importanti per XML.
Studieremo: CFG, i linguaggi che generano, gli alberisintattici, gli automi a pila, e le proprieta’ di chiusura dei CFL.
Grammatiche libere da contesto
Esempio informale di CFG
Consideriamo Lpal = {w ∈ Σ∗ : w = wR}
Per esempio: otto ∈ Lpal , madamimadam ∈ Lpal .
Sia Σ = {0, 1} e supponiamo che Lpal sia regolare.
Sia n dato dal pumping lemma. Allora 0n10n ∈ Lpal . Nelleggere 0n il FA deve passare per un loop. Se omettiamo illoop, contraddizione.
Definiamo Lpal induttivamente:
Base: ǫ, 0, e 1 sono palindromi.Induzione: Se w e’ una palindrome, anche 0w0 e 1w1 lo sono.Nessun altra stringa e’ una palindrome.
Grammatiche libere da contesto
Le CFG sono un modo formale per definire linguaggi come Lpal .
1. P → ǫ
2. P → 0
3. P → 1
4. P → 0P0
5. P → 1P1
0 e 1 sono terminali
P e’ una variabile (o nonterminale, o categoria sintattica)
P e’ in questa gramatica anche il simbolo iniziale.
1–5 sono produzioni (o regole)
Grammatiche libere da contesto
Definizione formale di CFG
Una grammatica libera da contesto e’ una quadrupla
G = (V ,T ,P ,S)
dove
V e’ un insieme finito di variabili.
T e’ un insieme finito di terminali.
P e’ un insieme finito di produzioni della forma A → α, doveA e’ una variabile e α ∈ (V ∪ T )∗
S e’ una variabile distinta chiamata il simbolo iniziale.
Grammatiche libere da contesto
Esempi
Gpal = ({P}, {0, 1},A,P), dove A ={P → ǫ,P → 0,P → 1,P → 0P0,P → 1P1}.
A volte raggruppiamo le produzioni con la stessa testa:A = {P → ǫ|0|1|0P0|1P1}.
Le espressioni regolari su {0, 1} possono essere definite dallagrammatica
Gregex = ({E}, {0, 1},A,E )
dove A =
{E → 0,E → 1,E → E .E ,E → E + E ,E → E ⋆,E → (E )}
Grammatiche libere da contesto
Esempio
Espressioni (semplici) in un tipico linguaggio di programmazione.Gli operatori sono + e *, e gli operandi sono identificatori, cioe’stringhe in L((a + b)(a + b + 0 + 1)∗)Usiamo la grammatica G = ({E , I},T ,P ,E ) doveT = {+, ∗, (, ), a, b, 0, 1} e P e’ il seguente insieme di produzioni:
1. E → I
2. E → E + E
3. E → E ∗ E
4. E → (E )
5. I → a
6. I → b
7. I → Ia
8. I → Ib
9. I → I0
10. I → I1Grammatiche libere da contesto
Derivazioni
Sia G = (V ,T ,P ,S) una CFG, A ∈ V , {α, β} ⊂ (V ∪ T )∗, eA → γ ∈ P .
Allora scriviamoαAβ ⇒
Gαγβ
o, se e’ ovvia la G ,αAβ ⇒ αγβ
e diciamo che da αAβ si deriva αγβ.
Definiamo∗
⇒ la chiusura riflessiva e transitiva di ⇒, cioe’:
Base: Sia α ∈ (V ∪ T )∗. Allora α∗
⇒ α.
Induzione: Se α∗
⇒ β, e β ⇒ γ, allora α∗
⇒ γ.
Grammatiche libere da contesto
Esempio
Derivazione di a ∗ (a + b00) da E nella grammatica delleespressioni:
E ⇒ E ∗ E ⇒ I ∗ E ⇒ a ∗ E ⇒ a ∗ (E ) ⇒
a ∗ (E + E ) ⇒ a ∗ (I + E ) ⇒ a ∗ (a + E ) ⇒ a ∗ (a + I ) ⇒
a ∗ (a + I0) ⇒ a ∗ (a + I00) ⇒ a ∗ (a + b00)
Ad ogni passo potremmo avere varie regole tra cui scegliere,ad esempioI ∗ E ⇒ a ∗ E ⇒ a ∗ (E ), oppureI ∗ E ⇒ I ∗ (E ) ⇒ a ∗ (E ).
Non tutte le scelte portano a derivazioni di una particolarestringa, per esempio
E ⇒ E + E
non ci fa derivare a ∗ (a + b00).
Grammatiche libere da contesto
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:E ⇒
rmE ∗ E ⇒
rm
E ∗ (E ) ⇒rm
E ∗ (E + E ) ⇒rm
E ∗ (E + I ) ⇒rm
E ∗ (E + I0)
⇒rm
E ∗ (E + I00) ⇒rm
E ∗ (E + b00) ⇒rm
E ∗ (I + b00)
⇒rm
E ∗ (a + b00) ⇒rm
I ∗ (a + b00) ⇒rm
a ∗ (a + b00)
Possiamo concludere che E∗
⇒rm
a ∗ (a + b00)
Grammatiche libere da contesto
Il linguaggio di una grammatica
Se G (V ,T ,P ,S) e’ una CFG, allora il linguaggio di G e’
L(G ) = {w ∈ T ∗ : S∗
⇒G
w}
cioe’ l’insieme delle stringhe su T ∗ derivabili dal simboloiniziale.
Se G e’ una CFG, chiameremo L(G ) un linguaggio libero da
contesto.
Esempio: L(Gpal ) e’ un linguaggio libero da contesto.
Grammatiche libere da contesto
Teorema 5.7:
L(Gpal ) = {w ∈ {0, 1}∗ : w = wR}
Prova: (direzione ⊇) Supponiamo w = wR . Mostriamo perinduzione su |w | che w ∈ L(Gpal ).
Base: |w | = 0, or |w | = 1. Allora w e’ ǫ, 0, or 1. Dato cheP → ǫ,P → 0, and P → 1 sono produzioni, concludiamo cheP
∗
⇒G
w in tutti i casi base.
Induzione: Supponiamo |w | ≥ 2. Dato che w = wR ,abbiamo w = 0x0, o w = 1x1, e x = xR .Se w = 0x0 sappiamo che per l’ipotesi induttiva P
∗
⇒ x .Allora
P ⇒ 0P0∗
⇒ 0x0 = w
Quindi w ∈ L(Gpal).Il caso di w = 1x1 e’ simile.
Grammatiche libere da contesto
(direzione ⊆) Assumiamo che w ∈ L(Gpal ) e dobbiamo mostrareche w = wR .Dato che w ∈ L(Gpal ), abbiamo P
∗
⇒ w .
Faremo un’induzione sulla lunghezza di∗
⇒.
Base: La derivazione P∗
⇒ w ha 1 passo.Allora w deve essere ǫ, 0, o 1, tutte palindromi.
Induzione: Sia n ≥ 1, e supponiamo che la derivazione han + 1 steps. Allora dobbiamo avere
w = 0x0∗
⇐ 0P0 ⇐ P
ow = 1x1
∗
⇐ 1P1 ⇐ P
dove la seconda derivazione ha n passi.Per l’ipotesi induttiva, x e’ una palindrome.
Grammatiche libere da contesto
Forme sentenziali
Sia G = (V ,T ,P ,S) una CFG, e α ∈ (V ∪ T )∗.
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 T ∗.
Grammatiche libere da contesto
Esempi
Prendiamo la G delle espressioni. Allora E ∗ (I + E ) e’ unaforma sentenziale perche’
E ⇒ E ∗ E ⇒ E ∗ (E ) ⇒ E ∗ (E + E ) ⇒ E ∗ (I + E )
Questa derivazione non e’ ne’ a sinistra ne’ a destra
a ∗ E e’ una forma sentenziale sinistra, perche’
E ⇒lm
E ∗ E ⇒lm
I ∗ E ⇒lm
a ∗ E
E ∗ (E + E ) e’ una forma sentenziale destra, perche’
E ⇒rm
E ∗ E ⇒rm
E ∗ (E ) ⇒rm
E ∗ (E + E )
Grammatiche libere da contesto
Alberi sintattici
Se w ∈ L(G ), per una CFG, allora w ha un albero sintattico,che ci dice la struttura (sintattica) di w
w potrebbe essere un programma, una query SQL, undocumento XML, ...
Gli alberi sintattici sono una rappresentazione alternativa allederivazioni.
Ci possono essere diversi alberi sintattici per la stessa stringa
Idealmente ci dovrebbe essere solo un albero sintattico (la”vera” struttura), cioe’ il linguaggio dovrebbe essere nonambiguo.
Sfortunatamente, non sempre possiamo rimuoverel’ambiguita’.
Grammatiche libere da contesto
Costruzione di un albero sintattico
Sia G = (V ,T ,P ,S) una CFG. Un albero e’ un albero sintattico
per G se:
1 Ogni nodo interno e’ etichettato con una variabile in V .
2 Ogni foglia e’ etichettata con un simbolo in V ∪ T ∪ {ǫ}.Ogni foglia etichettata con ǫ e’ l’unico figlio del suo genitore.
3 Se un nodo interno e’ etichettato A, e i suoi figli (da sinistra adestra) sono etichettati
X1,X2, . . . ,Xk ,
allora A → X1X2 . . . Xk ∈ P .
Grammatiche libere da contesto
Esempio
Nella grammnatica
1. E → I
2. E → E + E
3. E → E ∗ E
4. E → (E )···
il seguente e’ un albero sintattico:
E
E + E
I
Questo albero sintattico mostra la derivazione E∗
⇒ I + E
Grammatiche libere da contesto
Esempio
Nella grammatica
1. P → ǫ
2. P → 0
3. P → 1
4. P → 0P0
5. P → 1P1
il seguente e’ un albero sintattico:P
P
P
0 0
1 1
ε
Mostra la derivazione P∗
⇒ 0110.Grammatiche libere da contesto
Il prodotto di un albero sintattico
Il prodotto di un albero sintattico e’ la stringa di foglie dasinistra a destra.
Sono importanti quegli alberi sintattici dove:1 Il prodotto e’ una stringa terminale.2 La radice e’ etichettata dal simbolo iniziale.
L’insieme dei prodotti di questi alberi sintattici e’ il linguaggiodella grammatica.
Grammatiche libere da contesto
Esempio
E
E E*
I
a
E
E E
I
a
I
I
I
b
( )
+
0
0
Il prodotto e’ a ∗ (a + b00).Grammatiche libere da contesto
Sia G = (V ,T ,P ,S) una CFG, e A ∈ V . I seguenti sonoequivalenti:
1 A∗
⇒ w
2 A∗
⇒lm
w , e A∗
⇒rm
w
3 C’e’ un albero sintattico di G con radice A e’ prodotto w .
Grammatiche libere da contesto
Esempio
Costruiamo la derivazione a sinistra per l’albero
E
E E*
I
a
E
E E
I
a
I
I
I
b
( )
+
0
0
Grammatiche libere da contesto
Supponiamo di aver induttivamente costruito la derivazione asinistra
E ⇒lm
I ⇒lm
a
corrispondente al sottoalbero piu’ a sinistra, e la derivazione asinistra
E ⇒lm
(E ) ⇒lm
(E + E ) ⇒lm
(I + E ) ⇒lm
(a + E ) ⇒lm
(a + I ) ⇒lm
(a + I0) ⇒lm
(a + I00) ⇒lm
(a + b00)
corrispondente al sottoalbero piu’ a destra.
Grammatiche libere da contesto
Per la derivazione corrispondente all’intero albero, iniziamo conE ⇒
lmE ∗ E e espandiamo la prima E con la prima derivazione e la
seconda E con la seconda derivazione:
E ⇒lm
E ∗ E ⇒lm
I ∗ E ⇒lm
a ∗ E ⇒lm
a ∗ (E ) ⇒lm
a ∗ (E + E ) ⇒lm
a ∗ (I + E ) ⇒lm
a ∗ (a + E ) ⇒lm
a ∗ (a + I ) ⇒lm
a ∗ (a + I0) ⇒lm
a ∗ (a + I00) ⇒lm
a ∗ (a + b00)
Grammatiche libere da contesto
Ambiguita’ in Grammatiche e Linguaggi
Nella grammatica
1. E → I
2. E → E + E
3. E → E ∗ E
4. E → (E )· · ·
la forma sentenziale E + E ∗ E ha due derivazioni:
E ⇒ E + E ⇒ E + E ∗ E
e E ⇒ E ∗ E ⇒ E + E ∗ E
Questo ci da’ due alberi sintattici:
+
*
*
+
E
E E
E E
E
E E
EE
(a) (b)Grammatiche libere da contesto
L’esistenza di varie derivazioni di per se non e’ pericolosa, e’l’esistenza di vari alberi sintattici che rovina la grammatica.Esempio: Nella stessa grammatica
5. I → a
6. I → b
7. I → Ia
8. I → Ib
9. I → I0
10. I → I1
la stringa a + b ha varie derivazioni:
E ⇒ E + E ⇒ I + E ⇒ a + E ⇒ a + I ⇒ a + b
eE ⇒ E + E ⇒ E + I ⇒ I + I ⇒ I + b ⇒ a + b
Pero’ il loro albero sintattico e’ lo stesso, e la struttura di a + b e’quindi non ambigua.
Grammatiche libere da contesto
Definizione: Sia G = (V ,T ,P ,S) una CFG. Diciamo che G e’ambigua se esiste una stringa in T ∗ che ha piu’ di un alberosintattico.Se ogni stringa in L(G ) ha al piu’ un albero sintattico, G e’ dettanon ambigua.Esempio: La stringa terminale a + a ∗ a ha due alberi sintattici:
I
a I
a
I
a
I
a
I
a
I
a
+
*
*
+
E
E E
E E
E
E E
EE
(a) (b)
Grammatiche libere da contesto
Rimuovere l’ambiguita’ dalle grammatiche
Buone notizie: a volte possiamo rimuovere l’ambiguita’
Cattive notizie: non c’e’ nessun algoritmo per farlo in modosistematico
Ancora cattive notizie: alcuni CFL hanno solo CFG ambigue
Studiamo la grammatica
E → I | E + E | E ∗ E | (E )
I → a | b | Ia | Ib | I0 | I1
Non c’e’ precedenza tra * e +Non c’e’ raggruppamento di sequenze di operatori: E + E + Ee’ inteso come E + (E + E ) o come (E + E ) + E?
Grammatiche libere da contesto
Soluzione: Introduciamo piu’ variabili, ognuna che rappresentaespressioni con lo stesso grado di ”forza di legamento”
1 Un fattore e’ un’espressione che non puo’ essere spezzata daun * o un + adiacente. I nostri fattori sono:
1 Identificatori2 Un’espressione racchiusa tra parentesi.
2 Un termine e’ un’espressione che non puo’ essere spezzata daun +. Ad esempio, a ∗ b puo’ essere spezzata da a1∗ o ∗a1.Non puo’ essere spezzata da +, perche’ ad esempio a1 + a ∗ be’ (secondo le regole di precedenza) lo stesso di a1 + (a ∗ b), ea ∗ b + a1 e’ lo stesso di (a ∗ b) + a1.
3 Il resto sono espressioni, cioe’ possono essere spezzate con * o+.
Grammatiche libere da contesto
Usiamo F per i fattori, T per i termini, e E per le espressioni.Consideriamo la seguente grammatica:
1. I → a | b | Ia | Ib | I0 | I1
2. F → I | (E )
3. T → F | T ∗ F
4. E → T | E + T
Ora l’unico albero sintattico per a + a ∗ a e’:
F
I
a
F
I
a
T
F
I
a
T
+
*
E
E T
Grammatiche libere da contesto
Perche’ la nuova grammatica non e’ ambigua?
Un fattore e’ o un identificatore o (E ), per qualcheespressione E .
L’unico albero sintattico per una sequenza
f1 ∗ f2 ∗ · · · ∗ fn−1 ∗ fn
di fattori e’ quello che da’ f1 ∗ f2 ∗ · · · ∗ fn−1 come termine e fncome fattore, come nell’albero del prossimo lucido.
Un’espressione e’ una sequenza
t1 + t2 + · · · + tn−1 + tn
di termini ti . Puo’ essere solo raggruppata cont1 + t2 + · · · + tn−1 come un’espressione e tn come untermine.
Grammatiche libere da contesto
*
*
*
T
T F
T F
T
T F
F
..
.
Grammatiche libere da contesto
Derivazioni a sinistra e ambiguita’
I due alberi sintattici per a + a ∗ a
I
a I
a
I
a
I
a
I
a
I
a
+
*
*
+
E
E E
E E
E
E E
EE
(a) (b)
danno luogo a due derivazioni:
E ⇒lm
E + E ⇒lm
I + E ⇒lm
a + E ⇒lm
a + E ∗ E
⇒lm
a + I ∗ E ⇒lm
a + a ∗ E ⇒lm
a + a ∗ I ⇒lm
a + a ∗ a
e
E ⇒lm
E ∗ E ⇒lm
E + E ∗ E ⇒lm
I + E ∗ E ⇒lm
a + E ∗ E
⇒ a + I ∗ E ⇒ a + a ∗ E ⇒ a + a ∗ I ⇒ a + a ∗ aGrammatiche libere da contesto
In generale:
Un albero sintattico, ma molte derivazioni
Molte derivazioni a sinistra implica molti alberi sintattici.
Molte derivazioni a destra implica molti alberi sintattici.
Grammatiche libere da contesto
Teorema 5.29: Data una CFG G , una stringa terminale w ha duedistinti alberi sintattici se e solo se w ha due distinte derivazioni asinistra dal simbolo iniziale.Prova:
(Solo se.) Se due alberi sintattici sono diversi, hanno un nododove sono state usate due diverse produzioni:A → X1X2 · · ·Xk e B → Y1Y2 · · ·Ym. Le corrispondentiderivazioni a sinistra useranno queste diverse produzioni equindi saranno distinte.
(Se.) Per come costruiamo un albero da una derivazione, e’chiaro che due derivazioni distinte generano due alberi distinti.
Grammatiche libere da contesto
Ambiguita’ inerente
Un CFL L e’ inerentemente ambiguo se tutte le grammaticheper L sono ambigue.Esempio: Consideriamo L =
{anbncmdm : n ≥ 1,m ≥ 1} ∪ {anbmcmdn : n ≥ 1,m ≥ 1}.
Una grammatica per L e’
S → AB | C
A → aAb | ab
B → cBd | cd
C → aCd | aDd
D → bDc | bc
Grammatiche libere da contesto
Guardiamo la struttura sintattica della stringa aabbccdd .
S
A B
a A b
a b
c B d
c d
a
a
bGrammatiche libere da contesto
Vediamo che ci sono due derivazioni a sinistra:
S ⇒lm
AB ⇒lm
aAbB ⇒lm
aabbB ⇒lm
aabbcBd ⇒lm
aabbccdd
e
S ⇒lm
C ⇒lm
aCd ⇒lm
aaDdd ⇒lm
aabDcdd ⇒lm
aabbccdd
Puo’ essere provato che ogni grammatica per L si comporta comequesta. Il linguaggio L e’ quindi inerentemente ambiguo.
Grammatiche libere da contesto
Linguaggi regolari e grammatiche
Un linguaggio regolare e’ anche libero da contesto.
Da una espressione regolare, o da un automa, si puo’ ottenereuna grammatica che genera lo stesso linguaggio.
Grammatiche libere da contesto
Da espressione regolare a grammatica
Per induzione sulla struttura della espressione regolare:
se E = a, allora produzione S → a
se E = ǫ, allora produzione S → ǫ
se E = F + G , allora produzione S → F | G
se E = FG , allora produzione S → FG
se E = F ∗, allora produzione S → FS | ǫ
Grammatiche libere da contesto
Esempio
Espressione regolare: 0∗1(0 + 1)∗
Grammatica:
S → ABC
A → 0A | ǫ
B → 1
C → DC | ǫ
D → 0 | 1
Grammatiche libere da contesto
Da automa a grammatica
Un simbolo non-terminale per ogni stato.
Simbolo iniziale = stato iniziale.
Per ogni transizione da stato s a stato p con simbolo a,produzione S → aP .
Se p stato finale, allora produzione P → ǫ
Grammatiche libere da contesto
Esempio
Automa:
1 0
0 1q0
q2
q1 0, 1
Start
Grammatica:
Q0 → 1Q0 | 0Q2
Q2 → 0Q0 | 1Q1
Q1 → 0Q1 | 1Q1 | ǫ
La stringa 1101 e’ accettata dall’automa. Nella grammatica, ha laderivazione:
Q0 ⇒ 1Q0 ⇒ 11Q0 ⇒ 110Q2 ⇒ 1101Q1 ⇒ 1101
Grammatiche libere da contesto
Automi a pila
Automi a pila
Automi a pila
Un automa a pila (PDA) e’ in pratica un ǫ-NFA con una pila.In una transizione un PDA:
1 Consuma un simbolo di input.
2 Va in un nuovo stato (o rimane dove e’).
3 Rimpiazza il top della pila con una stringa(non fa niente, o elimina il top della pila, o mette una stringain cima alla pila)
Stack
Finitestatecontrol
Input Accept/reject
Automi a pila
Esempio
ConsideriamoLwwr = {wwR : w ∈ {0, 1}∗},
con “grammatica” P → 0P0, P → 1P1, P → ǫ. Un PDA perLwwr ha tre stati, e funziona come segue:
1 Scommette che sta leggendo w . Rimane nello stato 0, emette il simbolo di input sulla pila.
2 Scommette che sta nel mezzo di wwR . Va spontaneamentenello stato 1.
3 Sta leggendo la testa di wR . La paragona al top della pila. Sesono uguali, fa un pop della pila, e rimane nello stato 1. Senon sono uguali, si ferma.
4 Se la pila e’ vuota, va nello stato 2 e accetta la stringa.
Automi a pila
Il PDA per Lwwr come diagramma di transizione:
1 ,
ε, Z 0 Z 0 Z 0 Z 0ε , /
1 , 0 / 1 0
0 , 1 / 0 1
0 , 0 / 0 0
Z 0 Z 01 ,
0 , Z 0 Z 0/ 0
ε, 0 / 0
ε, 1 / 1
0 , 0 / ε
q q q0 1 2
1 / 1 1
/
Start
1 , 1 / ε
/ 1
Automi a pila
Definizione formale di PDA
Un PDA e’ una tupla di 7 elementi:
P = (Q,Σ,Γ, δ, q0,Z0,F ),
dove
Q e’ un insieme finito di stati,
Σ e’ un alfabeto finito di input,
Γ e’ un alfabeto finito di pila,
δ : Q × Σ ∪ {ǫ} × Γ → 2Q×Γ∗
e’ la funzione di transizione,
q0 e’ lo stato iniziale,
Z0 ∈ Γ e’ il simbolo iniziale per la pila, e
F ⊆ Q e’ l’insieme di stati di accettazione.
Automi a pila
Esempio
Il PDA
1 ,
ε, Z 0 Z 0 Z 0 Z 0ε , /
1 , 0 / 1 0
0 , 1 / 0 1
0 , 0 / 0 0
Z 0 Z 01 ,
0 , Z 0 Z 0/ 0
ε, 0 / 0
ε, 1 / 1
0 , 0 / ε
q q q0 1 2
1 / 1 1
/
Start
1 , 1 / ε
/ 1
e’ la 7-tupla
P = ({q0, q1, q2}, {0, 1}, {0, 1,Z0}, δ, q0,Z0, {q2}),
dove δ e’ data dalla tavola seguente:
Automi a pila
Esempio - funzione di transizione
0, Z0 1, Z0 0,0 0,1 1,0 1,1 ǫ, Z0 ǫ, 0 ǫ, 1
→ q0 q0, 0Z0 q0, 1Z0 q0, 00 q0, 01 q0, 10 q0, 11 q1, Z0 q1, 0 q1, 1
q1 q1, ǫ q1, ǫ q2, Z0
⋆q2
Automi a pila
Descrizioni istantanee
Un PDA passa da una configurazione ad un’altra configurazioneconsumando un simbolo di input.Per ragionare sulle computazioni dei PDA, usiamo delledescrizioni istantanee (ID) del PDA. Una ID e’ una tripla
(q,w , γ)
dove q e’ lo stato, w l’input rimanente, e γ il contenuto della pila.Sia P = (Q,Σ,Γ, δ, q0,Z0,F ) un PDA. Allora ∀w ∈ Σ∗, β ∈ Γ∗ :
(p, α) ∈ δ(q, a,X ) ⇒ (q, aw ,Xβ) ⊢ (p,w , αβ).
Definiamo∗
⊢ la chiusura riflessiva e transitiva di ⊢.
Automi a pila
Esempio
Su input 1111 il PDA
1 ,
ε, Z 0 Z 0 Z 0 Z 0ε , /
1 , 0 / 1 0
0 , 1 / 0 1
0 , 0 / 0 0
Z 0 Z 01 ,
0 , Z 0 Z 0/ 0
ε, 0 / 0
ε, 1 / 1
0 , 0 / ε
q q q0 1 2
1 / 1 1
/
Start
1 , 1 / ε
/ 1
ha le seguenti sequenze di computazioni:
Automi a pila
)0Z
)0Z
)0Z
)0Z
)0Z
)0Z
)0Z
)0Z
q2( ,
q2( ,
q2( ,
)0Z
)0Z
)0Z
)0Z
)0Z)0
Z
)0Z
)0Zq
1
q0
q0
q0
q0
q0
q1
q1
q1
q1
q1
q1
q1
q1
1111,0
Z )
111, 1
11, 11
1, 111
ε , 1111
1111,
111, 1
11, 11
1, 111
1111,
11,
11,
1, 1
ε ε ,, 11
ε ,
,(
,(
,(
,(
ε , 1111( ,
,(
( ,
( ,
( ,
( ,
( ,
( ,
( ,
( ,
Automi a pila
Valgono le seguenti proprieta’:
1 Se una sequenza di ID e’ una computazione legale per unPDA, allora lo e’ anche la sequenza ottenuta aggiungendo unastringa alla fine della seconda componente (input).
2 Se una sequenza di ID e’ una computazione legale per unPDA, allora lo e’ anche la sequenza ottenuta aggiungendo unastringa alla fine della terza componente.
3 Se una sequenza di ID e’ una computazione legale per unPDA, e la coda di un input non e’ consumata, allorarimuovendola da tutte le ID si ottiene una computazionelecita.
Automi a pila
Teorema 6.5: ∀w ∈ Σ∗, β ∈ Γ∗ :
(q, x , α)∗
⊢ (p, y , β) ⇒ (q, xw , αγ)∗
⊢ (p, yw , βγ).
Prova: Induzione sulla lunghezza della sequenza sulla destra.
Nota: Se γ = ǫ abbiamo la proprieta’ 1, e se w = ǫ abbiamola proprieta’ 2.
Nota: L’inverso del teorema e’ falso.
Dalla proprieta’ 3 abbiamoTeorema 6.6:
(q, xw , α)∗
⊢ (p, yw , β) ⇒ (q, x , α)∗
⊢ (p, y , β).
Automi a pila
Accettazione per stato finale
Sia P = (Q,Σ,Γ, δ, q0,Z0,F ) un PDA. Il linguaggio accettato
da P per stato finale e’
L(P) = {w : (q0,w ,Z0)∗
⊢ (q, ǫ, α), q ∈ F}.
Automi a pila
Esempio
Il PDA di prima accetta esattamente Lwwr .Sia P l’automa visto. Proviamo che L(P) = Lwwr .(direzione ⊇.) Sia x ∈ Lwwr . Allora x = wwR , e la seguente e’ unasequenza di computazione legale
(q0,wwR ,Z0)∗
⊢ (q0,wR ,wRZ0) ⊢ (q1,w
R ,wRZ0)∗
⊢
(q1, ǫ,Z0) ⊢ (q2, ǫ,Z0).
Automi a pila
(direzione ⊆)Osserviamo che l’unico modo in cui il PDA puo’ andare in q2 e’ see’ nello stato q1 con la pila vuota.
Quindi e’ sufficiente mostrare che se (q0, x ,Z0)∗
⊢ (q1, ǫ,Z0) allorax = wwR , per una qualche stringa w .Mostreremo per induzione su |x | che
(q0, x , α)∗
⊢ (q1, ǫ, α) ⇒ x = wwR .
Base: Se x = ǫ allora x e’ una palindrome.Induzione: Supponiamo che x = a1a2 · · · an, dove n > 0, e chel’ipotesi induttiva valga per stringhe piu’ corte.Ci sono due mosse per il PDA da ID (q0, x , α):
Automi a pila
Mossa 1: La mossa spontanea (q0, x , α) ⊢ (q1, x , α). Allora
(q1, x , α)∗
⊢ (q1, ǫ, β) implica che |β| < |α|, che implica β 6= α.Mossa 2: (q0, a1a2 · · · an, α) ⊢ (q0, a2 · · · an, a1α).In questo caso c’e’ una sequenza(q0, a1a2 · · · an, α) ⊢ (q0, a2 · · · an, a1α) ⊢ · · · ⊢ (q1, an, a1α) ⊢(q1, ǫ, α).Quindi a1 = an e
(q0, a2 · · · an, a1α)∗
⊢ (q1, an, a1α).
Per il teorema 6.6 possiamo rimuovere an. Quindi
(q0, a2 · · · an−1, a1α∗
⊢ (q1, ǫ, a1α).
Allora, per ipotesi induttiva a2 · · · an−1 = yyR . Allora x = a1yyRan
e’ una palindrome.
Automi a pila
Accettazione per pila vuota
Sia P = (Q,Σ,Γ, δ, q0,Z0,F ) un PDA. Il linguaggio accettato
da P per pila vuota e’
N(P) = {w : (q0,w ,Z0)∗
⊢ (q, ǫ, ǫ)}.
Nota: q puo’ essere uno stato qualunque.Domanda: come modificare il PDA per le palindromi per accettarelo stesso linguaggio per pila vuota?
Automi a pila
Da pila vuota a stato finale
Teorema 6.9: Se L = N(PN) per un PDAPN = (Q,Σ,Γ, δN , q0,Z0), allora ∃ PDA PF , tale che L = L(PF ).Prova: Sia
PF = (Q ∪ {p0, pf },Σ,Γ ∪ {X0}, δF , p0,X0, {pf })
dove δF (p0, ǫ,X0) = {(q0,Z0X0)}, e per ogniq ∈ Q, a ∈ Σ ∪ {ǫ},Y ∈ Γ : δF (q, a,Y ) = δN(q, a,Y ), e inoltre(pf , ǫ) ∈ δF (q, ǫ,X0).
X0
Z0X
0ε,
ε, X0
/ ε
ε, X0
/ ε
ε, X0
/ ε
ε, X0
/ ε
q/
PN
Startp0 0
pf
Automi a pila
Dobbiamo mostrare che L(PF ) = N(PN).(direzione ⊇) Sia w ∈ N(PN). Allora
(q0,w ,Z0)∗
⊢N
(q, ǫ, ǫ),
per un qualche q. Dal teorema 6.5 abbiamo
(q0,w ,Z0X0)∗
⊢N
(q, ǫ,X0).
Dato che δN ⊂ δF , abbiamo
(q0,w ,Z0X0)∗
⊢F
(q, ǫ,X0).
Concludiamo che
(p0,w ,X0) ⊢F
(q0,w ,Z0X0)∗
⊢F
(q, ǫ,X0) ⊢F
(pf , ǫ, ǫ).
(direzione ⊆) Basta esaminare il diagramma.
Automi a pila
Da stato finale a pila vuota
Teorema 6.11: Sia L = L(PF ), per un PDAPF = (Q,Σ,Γ, δF , q0,Z0,F ). Allora ∃ PDA Pn, tale cheL = N(PN).Prova: Sia
PN = (Q ∪ {p0, p},Σ,Γ ∪ {X0}, δN , p0,X0)
dove δN(p0, ǫ,X0) = {(q0,Z0X0)}, δN(p, ǫ,Y ) = {(p, ǫ)}, perY ∈ Γ ∪ {X0}, e per tutti i q ∈ Q,
a ∈ Σ ∪ {ǫ},Y ∈ Γ : δN(q, a,Y ) = δF (q, a,Y ), e inoltre ∀q ∈ F ,and Y ∈ Γ ∪ {X0} : (p, ǫ) ∈ δN(q, ǫ,Y ).
ε, any/ ε ε, any/ ε
ε, any/ ε
X0 Z 0
ε, / X0 pP
FStart
p q0 0
Automi a pila
Dobbiamo mostrare che N(PN) = L(PF ).(direzione ⊆) Basta esaminare il diagramma.(direazione ⊇) Sia w ∈ L(PF ). Allora
(q0,w ,Z0)∗
⊢F
(q, ǫ, α),
per un q ∈ F , α ∈ Γ∗. Dato che δF ⊆ δN , e teorema 6.5 dice cheX0 puo’ essere infilato sotto la pila, otteniamo
(q0,w ,Z0X0)∗
⊢N
(q, ǫ, αX0).
Il PN puo’ calcolare:
(p0,w ,X0) ⊢N
(q0,w ,Z0X0)∗
⊢N
(q, ǫ, αX0)∗
⊢N
(p, ǫ, ǫ).
Automi a pila
Equivalenza di PDA e CFG
Un linguaggio e’generato da una CFG
se e solo se e’accettato da un PDA per pila vuota
se e solo se e’accettato da un PDA per stato finale
PDA by
empty stack
PDA by
final stateGrammar
Faremo vedere solo come passare da una grammatica ad unautoma a pila (sappiamo gia’ andare da pila vuota a stato finale eviceversa). Ometteremo la costruzione di una grammatica da unautoma a pila.
Automi a pila
Da CFG a PDA
Data G , costruiamo un PDA che simula∗
⇒lm
.
Scriviamo le forme sentenziali sinistre come
xAα
dove A e’ la variabile piu’ a sinistra. Ad esempio,
(a+︸︷︷︸
x
E︸︷︷︸
A
)︸︷︷︸
α
︸ ︷︷ ︸
tail
Sia xAα ⇒lm
xβα. Questo corrisponde al PDA che ha prima
consumato x e ha Aα sulla pila, e poi, leggendo ǫ, elimina A emette β sulla pila.Piu’ formalmente, sia y tale che w = xy . Allora il PDA va nondeterministicamente dalla configurazione (q, y ,Aα) allaconfigurazione (q, y , βα).
Automi a pila
Alla configurazione (q, y , βα) il PDA si comporta come prima, ameno che ci sono terminali nel prefisso di β. In questo caso, ilPDA li elimina, se li legge nell’input.Se tutte le scommesse sono giuste, il PDA finisce l’input con la pilavuota.Formalmente, sia G = (V ,T ,Q,S) una CFG. Definiamo PG come
({q},T ,V ∪ T , δ, q,S),
doveδ(q, ǫ,A) = {(q, β) : A → β ∈ Q},
per A ∈ V , eδ(q, a, a) = {(q, ǫ)},
per a ∈ T .
Automi a pila
PDA deterministici
Un PDA P = (Q,Σ,Γ, δ, q0,Z0,F ) e’ deterministico se e solo se
1 δ(q, a,X ) e’ sempre o vuoto o con un solo elemento.2 Se δ(q, a,X ) non e’ vuoto, allora δ(q, ǫ,X ) deve essere vuoto.
Esempio: Definiamo
Lwcwr = {wcwR : w ∈ {0, 1}∗}
Allora Lwcwr e’ riconosciuto dal seguente DPDA
1 ,
Z 0 Z 0 Z 0 Z 0ε , /
1 , 0 / 1 0
0 , 1 / 0 1
0 , 0 / 0 0
Z 0 Z 01 ,
0 , Z 0 Z 0/ 0
0 , 0 / ε
q q q0 1 2
1 / 1 1
/
Start
1 , 1 / ε
/ 1
,
0 / 0
1 / 1,
,
c
c
c
Automi a pila
Mostreremo che Regolari⊂ L(DPDA) ⊂ CFLTeorema 6.17: Se L e’ regolare, allora L = L(P) per qualcheDPDA P .Prova: Dato che L e’ regolare, esiste un DFA A tale che L = L(A).Sia
A = (Q,Σ, δA, q0,F )
definiamo il DPDA
P = (Q,Σ, {Z0}, δP , q0,Z0,F ),
doveδP (q, a,Z0) = {(δA(q, a),Z0)},
per tutti i p, q ∈ Q e a ∈ Σ.Un’induzione su |w | ci da’
(q0,w ,Z0)∗
⊢ (p, ǫ,Z0) ⇔ δA(q0,w) = p
Automi a pila
E i DPDA che accettano per pila vuota?
Possono riconoscere solo CFL con la proprieta’ del prefisso.
Un linguaggio L ha la proprieta’ del prefisso se non esistonodue stringhe distinte in L, tali che una e’ un prefisso dell’altra.
Esempio: Lwcwr ha la proprieta’ del prefisso.
Esempio: {0}∗ non ha la proprieta’ del prefisso.
Teorema 6.19: L e’ N(P) per qualche DPDA P se e solo se L
ha la proprieta’ del prefisso e L e’ L(P ′) per qualche DPDA P ′.
Automi a pila
Abbiamo visto che Regolari ⊆ L(DPDA).
Lwcwr ∈ L(DPDA)\ Regolari
Ci sono linguaggi in CFL\L(DPDA).Si, per esempio Lwwr .
Cosa possiamo dire su DPDA e grammatiche ambigue?
Lwwr ha una grammatica non ambigua
S → 0S0|1S1|ǫ ma non e’ L(DPDA).
Per l’inverso abbiamoTeorema 6.20: Se L = N(P) per qualche DPDA P , allora L hauna CFG non ambigua.Prova: Guardando la prova del teorema 6.14 vediamo che se lacostruziuone e’ applicata ad un DPDA, il risultato e’ un CFG conderivazioni a sinistra uniche per ogni stringa.
Automi a pila
Il teorema 6.20 puo’ essere rafforzato:Teorema 6.21: Se L = L(P) per qualche DPDA P , allora L hauna CFG non ambigua.Prova:
Sia $ un simbolo fuori dell’alfabeto di L, e sia L′ = L$.
E’ facile vedere che L′ ha la proprieta’ del prefisso.
Per il teorema 6.20 abbiamo che L′ = N(P ′) per qualcheDPDA P ′.
Per il teorema 6.20 N(P ′) puo’ essere generato da una CFGG ′ non ambigua
Modifichiamo G ′ in G , tale che L(G ) = L, aggiungendo laproduzione
$ → ǫ
Dato che G ′ ha derivazioni a sinistra uniche, anche G ′ le ha,dato che l’unica cosa nuova e’ l’aggiunta di derivazioni
w$ ⇒lm
w
alla fine.Automi a pila
Proprieta’ dei linguaggi liberi da contesto
Proprieta’ dei linguaggi liberi da contesto
Proprieta’ di CFL
Semplificazione di una CFG: se un linguaggio e’ un CFL, hauna grammatica di una forma speciale.
Pumping Lemma per CFL: simile ai linguaggi regolari.
Proprieta’ di chiusura: alcune delle proprieta’ di chiusura deilinguaggi regolari valgono anche per i CFL.
Proprieta’ di decisione: possiamo controllare l’appartenenzae l’essere vuoto, ma, per esempio, l’equivalenza di CFL e’indecidibile.
Proprieta’ dei linguaggi liberi da contesto
Forma normale di Chomsky
Ogni CFL (senza ǫ) e’ generato da una CFG dove tutte leproduzioni sono della forma
A → BC , o A → a
dove A,B , e C sono variabili, e a e’ un simbolo terminale. Questae’ detta forma normale di Chomsky (CNF), e per ottenerladobbiamo
1 Eliminare i simboli inutili, quelli che non appaiono in nessunaderivazione S
∗
⇒ w , per simbolo iniziale S e terminale w .
2 Eliminare le produzioni ǫ, della forma A → ǫ.
3 Eliminare le produzioni unita’, cioe’ produzioni della formaA → B , dove A e B sono variabili.
4 Eliminare le produzioni con piu’ di due nonterminali sulladestra.
Proprieta’ dei linguaggi liberi da contesto
Esempio
Iniziamo dalla grammaticaE → E + T | T ∗ F | (E ) | a | b | Ia | Ib | I0 | I1T → T ∗ F | (E )a | b | Ia | Ib | I0 | I1F → (E ) a | b | Ia | Ib | I0 | I1I → a | b | Ia | Ib | I0 | I1Aggiungiamo le produzioniA → a,B → b,Z → 0,O → 1P → +,M → ∗,L → (,R →)e otteniamo la grammaticaE → EPT | TMF | LER | a | b | IA | IB | IZ | IO
T → TMF | LER | a | b | IA | IB | IZ | IO
F → LER | a | b | IA | IB | IZ | IO
I → a | b | IA | IB | IZ | IO
A → a,B → b,Z → 0,O → 1P → +,M → ∗,L → (,R →)
Proprieta’ dei linguaggi liberi da contesto
Per eliminare parti destre con piu’ di 2 nonterminali, rimpiazziamo
E → EPT con E → EC1,C1 → PT
E → TMF ,T → TMF conE → TC2,T → TC2,C2 → MF
E → LER ,T → LER ,F → LER conE → LC3,T → LC3,F → LC3,C3 → ER
La grammatica in CFN finale e’E → EC1 | TC2 | LC3 | a | b | IA | IB | IZ | IO
T → TC2 | LC3 | a | b | IA | IB | IZ | IO
F → LC3 | a | b | IA | IB | IZ | IO
I → a | b | IA | IB | IZ | IO
C1 → PT ,C2 → MF ,C3 → ER
A → a,B → b,Z → 0,O → 1P → +,M → ∗,L → (,R →)
Proprieta’ dei linguaggi liberi da contesto
Pumping lemma per CFL
Informalmente:In ogni stringa sufficientemente lunga di un CFL si possonotrovare due sottostringhe vicine che e’ possibile eliminare oripetere (insieme), ottenendo sempre stringhe del linguaggio.
Formalmente:Sia L un CFL. Esiste una costante n tale che, se z ∈ L e| z |≥ n, possiamo scrivere z = uvwxy con le seguenticondizioni:
1 | vwx |≤ n2 vx 6= ǫ3 per ogni i ≥ 0, uv iwx iy ∈ L.
Proprieta’ dei linguaggi liberi da contesto
Prova informale
Se la stringa w e’ sufficientemente lunga, l’albero sintatticoche produce w = uvwxy ha un simbolo non terminale che siripete in un cammino dalla radice ad una foglia. SupponiamoAi = Aj .
Allora puo’ essere individuato il sottoalbero con radice Aj echiamato w il suo prodotto.
Inoltre, dato il sottoalbero con radice Ai , chiamiamo vwx ilsuo prodotto.
Dato che Ai = Aj , possiamo rimpiazzare il sottoalbero di Ai
con quello di Aj , ottenendo quindi uwy , che deve ancoraappartenere a L.
Oppure possiamo rimpiazzare il sottoalbero di Aj con quello diAi , ottenendo uvvwxxy , ancora generata da L.
Proprieta’ dei linguaggi liberi da contesto
Esempio
Consideriamo L = {0n1n2n | n ≥ 1}.
Dato un n generico, scegliamo z = 0n1n2n.
Comunque noi spezziamo z in uvwxy , con | vwx |≤ n e v e x
non entrambi vuote, vwx non puo’ contenere sia 0 che 2perche’ l’ultimo 0 e il primo 2 sono lontani n+1 posti.
Ci sono i seguenti casi:
vwx non contiene 2. Allora vx ha solo 0 e 1. Quindi uwy , chedovrebbe essere in L, ha n 2, ma meno di n 0 o 1.vwx non contiene 0. Analogo.
Proprieta’ dei linguaggi liberi da contesto
Esempi
I CFL non sanno abbinare coppie con lo stesso numero disimboli, se le coppie sono intrecciate.
Esempio: L = {0i1j2i3j | i , j ≥ 1}.Dato n, scegliamo z = 0n1n2n3n. Quindi vwx contiene un solosimbolo o due simboli. In ogni caso, le stringhe generate nonsono in L.
I CFL non sanno abbinare due stringhe di lunghezza arbitraria,se sono su un alfabeto di piu’ di un simbolo.
Esempio: L = {ww | w ∈ {0, 1}∗}.Dato n, scegliamo z = 0n1n0n1n. Comunque la scomponiamo,non otteniamo stringhe di L.
Proprieta’ dei linguaggi liberi da contesto
Proprieta’ di chiusura dei CFL
Teorema 7.24: I CFL sono chiusi sotto
unione,
concatenazione,
chiusura di Kleene e chiusura positiva +
Basta mettere insieme le grammatiche:
per l’unione: S → A | B
per la concatenazione: S → AB
per la chiusura di Kleene: S → SA | ǫ
per la chiusura positiva: S → SA | A
Proprieta’ dei linguaggi liberi da contesto
Chiusura rispetto all’inversione
Teorema: Se L e CF, allora lo e’ anche anche LR .Prova: Supponiamo che L sia generato da G = (V ,T ,P ,S).Costruiamo GR = (V ,T ,PR ,S), dove
PR = {A → αR : A → α ∈ P}
Si mostra per induzione sulla lunghezza delle derivazioni in G e inGR che (L(G ))R = L(GR).
Proprieta’ dei linguaggi liberi da contesto
I CFL non sono chiusi sotto l’intersezione
Sia L1 = {0n1n2i : n ≥ 1, i ≥ 1}. Allora L1 e’ libero da contesto,con grammatica
S → AB
A → 0A1|01B → 2B |2
Inoltre, L2 = {0i1n2n : n ≥ 1, i ≥ 1} e’ libero da contesto, congrammatica
S → AB
A → 0A|0B → 1B2|12
Invece, L1 ∩ L2 = {0n1n2n : n ≥ 1} non e’ CF.
Proprieta’ dei linguaggi liberi da contesto
Intersezione tra CFL e linguaggi regolari
Teorema 7.27: Se L e’ CF, e R e’ regolare, allora L ∩ R e’ CF.Prova: Sia L accettato dal PDA
P = (QP ,Σ,Γ, δP , qP ,Z0,FP)
per stato finale, e sia R accettato dal PDA
A = (QA,Σ, δA, qA,FA)
Costruiremo un PDA per L ∩ R secondo la figura
Accept/reject
AND
PDA
stateFA
state
Input
Proprieta’ dei linguaggi liberi da contesto
Formalmente, definiamo
P ′ = (QP × QA, ,Σ,Γ, δ, (qP , qA),Z0,FP × FA)
dove
δ((q, p), a,X ) = {((r , δA(p, a)), γ) : (r , γ) ∈ δP(q, a,X )}
Possiamo provare per induzione su∗
⊢ che
(qP ,w ,Z0)∗
⊢ (q, ǫ, γ) in P
se e solo se
((qP , qA),w ,Z0)∗
⊢(
(q, δ(pA,w)), ǫ, γ)
in P ′
Proprieta’ dei linguaggi liberi da contesto
Teorema 7.29: Siano L,L1,L2 CFL e R regolare. Allora
1 L \ R e’ CF
2 L non e’ necessariamente CF
3 L1 \ L2 non e’ necessariamente CF
Prova:
1 R e’ regolare, L ∩ R e’ regolare, e L ∩ R = L \ R .
2 Se L fosse sempre CF, seguirebbe che
L1 ∩ L2 = L1 ∪ L2
sarebbe sempre CF.
3 Notare che Σ∗ e’ CF, quindi se L1 \ L2 fosse sempre CF, alloralo sarebbe sempre anche Σ∗ \ L = L.
Proprieta’ dei linguaggi liberi da contesto
Problemi indecidibili per linguaggi liberi da contesto
I seguenti problemi sono indecidibili (cioe’ non esiste nessunalgoritmo che possa risolverli):
1 Data G , e’ ambigua?
2 E’ un dato CFL inerentemente ambiguo?
3 E’ l’intersezione di due CFL vuota?
4 Dati due CFL, sono uguali?
5 Dato un CFL, e’ uguale a Σ∗?
Proprieta’ dei linguaggi liberi da contesto
Analisi sintattica
Analisi sintattica
Ruolo dell’analisi sintattica
Un compilatore deve produrre codice oggetto e deve anchecontrollare che il programma in input sia scritto secondo leregole della sua sintassi
L’analisi lessicale controlla che i token siano scritti bene, egenera una stringa di token
L’analisi sintattica prende la stringa di token
Non tutte le stringhe di token sono programmi validi
Bisogna riconoscere strighe di token valide, cioe’ ottenibilitramite la grammatica che descrive le regole della sintassi dellinguaggio
Se la stringa di token e’ valida, va creato un albero di parsing
Analisi sintattica
Eliminare l’ambiguita’
Un analizzatore sintattico deve prendere la lista di token ecostruire un albero sintattico
Se la grammatica e’ ambigua, ci sono piu’ alberi possibili
E’ necessario eliminare l’ambiguita’
Esempio:C → if E then CC → if E then C else C
Questa grammatica e’ ambigua
Il comando if E1 then if E2 then S1 else S2 ha due alberisintattici
Di solito: ogni else va accoppiato con il then piu’ vicino
Grammatica non ambigua:C → C1 | C2C1 → if E then C1 else C1C2 → if E then C | if E then C1 else C2
Analisi sintattica
Parsing top-down
Costruisce un albero di parsing per una stringa, iniziando dallaradice e creando i nodi in ordine depth-first (dato un nodo,prima lui e poi i figli da destra a sinistra, ricorsivamente)
Trova la derivazione da piu’ a sinistra per una stringa
Ad ogni passo, una produzione viene usata per trasformare unnon-terminale
Una volta scelta la produzione, bisogna individuare i simboliterminali della parte destra della produzione nella stringa ininput
Analisi sintattica
Esempio
Grammatica
E → TE′
E′ → +TE
′|ǫ
T → FT′
T′ → ∗FT
′|ǫ
F → (E )|id
con stringa id + id ∗ id .
Analisi sintattica
Parsing ricorsivo-discendente
Una procedura per ogni nonterminale
Si inizia con la procedura per il simbolo iniziale
Terminazione con successo se si scorre tutta la stringa in input
Pseudocodice non-deterministico per un nonterminale A:1 scegli una produzione per A: A → X1X2 . . .Xk
2 for (i=1 to k)3 se Xi e’ un nonterminale chiama la procedura per Xi
4 altrimenti, se Xi = simbolo corrente, passa al prossimo simbolodella stringa
5 altrimenti, errore
La produzione scelta potrebbe non essere quella giusta ⇒bisogna permettere il backtracking
Errore vuol solo dire che bisogna tornare al passo 1 perscegliere un’altra produzione per A, a meno che non ce nesiano piu’Il puntatore al simbolo corrente deve tornare indietro
Analisi sintattica
Esempio
Grammatica:S → c A dA → a b | acon stringa cad .
All’inizio, albero con la sola radice S e puntatore all’iniziodella stringa (c)
S ha solo una produzione, quindi usiamo quella
Puntatore scorre anche c
Usiamo la prima produzione per A e aggiungiamo i figli a e b
Puntatore scorre anche a, ma b e’ diverso dal prossimosimbolo della stringa (d)
Torniamo indietro e proviamo la seconda produzione per A(puntatore torna indietro alla c e poi scorre a)
Puntatore legge d che e’ uguale al possimo simbolo nellastringa
La stringa e’ finita, quindi abbiamo creato un albero di parsing
Analisi sintattica
Ricorsione a sinistra
Una grammatica e’ ”ricorsiva a sinistra” se esiste unnonterminale A tale che A
∗
⇒ Aα per qualche stringa α
I metodi di parsing top-down non possono gestiregrammatiche ricorsive a sinistra: vanno in loop perche’riscrivono sempre a sinistra
Ricorsivita’ sinistra diretta: produzione A → Aα|β
Nuove produzioni: A → βA′ e A′ → αA′|ǫ
Si puo’ eliminare anche la ricorsivita’ sinistra non diretta
Esempio:S → Aα|γA → Sβ
e’ ricorsiva a sinistra perche’ S ⇒+ Sβα
Analisi sintattica
Parser predittivi
Come i parser discendenti ricorsivi ma possono ”predire” qualeproduzione usare
guardando ad alcuni prossimi tokennon c’e’ mai bisogno di tornare indietro (backtracking)
Funzionano con grammatiche LL(k)
La prima L significa che l’input viene letto da sinistra a destraLa seconda L significa che seguono derivazioni da sinistraIl k significa che la predizione e’ basata sulla lettura anticipatadi k tokenIn pratica, si usano grammatiche LL(1)
Analisi sintattica
LL(1) vs. Parser discendenti ricorsivi
Nei parser discendenti ricorsivi
Ad ogni passo, moltre produzioni tra cui scegliereBacktracking per ritrattare le scelte sbagliate
In LL(1)
Ad ogni passo, una sola produzione (o nessuna, che vuol direerrore)Variante di parser ricorsivi discendenti senza backtracking
Analisi sintattica
Come predire quale produzione usare?
Consideriamo la grammaticaE → T + E |TT → a|a ∗ T |(E )
Difficile predire perche’
Per T: due produzioni iniziano con aPer E: non chiaro quale usare
Dobbiamo mettere insieme i prefissi comuni delle produzioni
Analisi sintattica
Esempio
La grammaticaE → T + E |TT → a|a ∗ T |(E )puo’ essere trasformata inE → TX
X → +E |ǫT → aY |(E )Y → ∗T |ǫ
Analisi sintattica
FIRST and FOLLOW
Due funzioni che ci permettono di capire quale produzionescegliere, leggendo il prossimo simbolo in input
FIRST(α) = insieme di terminali che iniziano stringhederivabili da α, dove α e’ una qualunque stringa di simboliterminali o non
Se α∗
⇒ ǫ, allora ǫ ∈ FIRST (α)
Esempio di uso: se abbiamo le produzioni A → α|β, eFIRST(α) e’ disgiunto da FIRST(β), allora basta guardare ilprossimo simbolo in input. Se e’ in FIRST(α), va scelta laproduzione A → α.
FOLLOW(A), per un nonterminale A, e’ l’insieme delterminali a che possono apparire alla destra di A in una formasentenziale
Esiste una derivazione S∗
⇒ αAaβ
Se A e’ il simbolo piu’ a destra in qualche forma sentenziale,allora $ e’ in FOLLOW(A)
Analisi sintattica
Come calcolare FIRST di un simbolo
Calcoliamo FIRST(X) per ogni simbolo X, terminale o no
Se X e’ terminale, FIRST(X) = {X}
Se X e’ non terminale e X → Y1Y2 . . .Yk ,
Se esiste i tale che a ∈ FIRST (Yi ) eǫ ∈ FIRST (Y1) ∩ . . . ∩ FIRST (Yi−1), allora a ∈ FIRST (X ).Se ǫ ∈ FIRST (Yj) per tutti i j=1,. . . , k, allora ǫ ∈ FIRST (X )Nota: tutto quello che e’ in FIRST(Y1) e’ anche in FIRST(X).Se Y1 non deriva ǫ, allora FIRST(X) = FIRST(Y1), altrimentiaggiungiamo FIRST(Y2), e cosi’ via.
Se X → ǫ, allora ǫ ∈ FIRST (X )
Analisi sintattica
Come calcolare FIRST di una stringa
Per calcolare FIRST(X1 . . .Xn):
Mettiamo in FIRST(X1, . . . ,Xn) tutti i simboli di FIRST(X1)tranne ǫ
Se ǫ ∈ FIRST (X1), mettiamo anche i simboli di FIRST(X2)tranne ǫ
Se ǫ ∈ FIRST (X1) ∩ FIRST (X2), mettiamo anche i simboli diFIRST(X3) tranne ǫ
E cosi’ via
Se ǫ in tutti i FIRST(Xi ) per tutti gli i, mettiamo ǫ inFIRST(X1 . . .Xn)
Analisi sintattica
Come calcolare FOLLOW
Mettiamo $ in FOLLOW(S), dove S e’ il simbolo iniziale
Se produzione A → αBβ, mettiamo in FOLLOW(B) tuttoFIRST(β) meno ǫ
Se produzione A → αB, o produzione A → αBβ, doveǫ ∈ FIRST (β), mettiamo in FOLLOW(B) tutto FOLLOW(A)
Analisi sintattica
Esempio
Grammatica:
E → TE′
E′ → +TE
′|ǫ
T → FT′
T′ → ∗FT
′|ǫ
F → (E )|id
FIRST(F) = FIRST(T) = FIRST(E) = {(, id}
FIRST(E’) = {+, ǫ}
FIRST(T’) = {*, ǫ}
FOLLOW(E) = FOLLOW(E’) = { ), $}
FOLLOW(T) = FOLLOW(T’) = {+, ), $}
FOLLOW(F) = {+, *, ), $}
Analisi sintattica
Grammatiche LL(1)
Se G ha le due produzioni A → α e A → β:
FIRST(α) e FIRST(β) sono due insiemi disgiunti
Da α e β non si possono derivare stringhe che iniziano con lostesso terminaleAl piu’ uno tra α e β puo’ derivare la stringa vuota
Se ǫ in FIRST(β), allora FIRST(α) e FOLLOW(A) sonodisgiunti, e simile se ǫ in FIRST(α).
Se β∗
⇒ ǫ, α non deriva nessuna stringa che inizia con unterminale in FOLLOW(A)
Se α∗
⇒ ǫ, β non deriva nessuna stringa che inizia con unterminale in FOLLOW(A)
Analisi sintattica
Tavola per il parser predittivo
Array bidimensionale M[A,a], dove A e’ un nonterminale, e ae’ un terminale o $
Idea: la produzione A → α e’ scelta se il prossimo simbolo diinput a e’ in FIRST(α). Se α
∗
⇒ ǫ, allora va scelta se a e’ inFOLLOW(A).
Per ogni produzione A → α:
Per ogni terminale a in FIRST(α), mettiamo A → α in M[A,a]Se ǫ ∈ FIRST (α), mettiamo A → α in M[A,b] per ogni b ∈FOLLOW(A)Se ǫ ∈ FIRST (α) e $ ∈ FOLLOW(A), mettiamo A → α anchein M[A,$]
Analisi sintattica
Esempio
id + * ( ) $
E E → TE’ E → TE’
E’ E’ → +TE’ E’ → ǫ E’ → ǫ
T T → FT’ T → FT’
T’ T’ → ǫ T’ → *FT’ T’ → ǫ T’ → ǫ
F F → id F → (E)
Analisi sintattica
Funziona solo per grammatiche LL(1)
Ad esempio, se la grammatica e’ ricorsiva a sinistra oambigua, la tavola avra’ una o piu’ celle con piu’ produzioni
Esempio:S → iEtSS’ | AS’ → eS | ǫ
E → b
Questa grammatica e’ ambigua
Analisi sintattica
Esempio
S → iEtSS’ | AS’ → eS | ǫ
E → b
a b e i t $
S S → A S → iEtSS’
S’ S’ → ǫ, S’ → eS S’ → ǫ
E E → b
Analisi sintattica
����������� ��
1
�������������������� ��
� �������� �� ��� ���� ���� ����� ��� � ������� �� ���� ������ �� ��
� ���������→ ���������
��→ �������������������
� �������� �� � ������� �����������������
������
��� ������������!������� �� ������ ��������� ����� � �������� �������������
�
��→ ����������
��→ ������
��→ ����������
��→ ���������������������
��→ ������������������
�����������
� "��� �� ������������ �������� ������ �� �� ����������� ����
� �� �� ���� ���� � ����
�
��→ ����������
��→ ������
��→ ����������
��→ ���������������������
��→ ������������������
������
�
�����
�����
�������
��������������
��������������� E
T E
+ int*int
T
int
T
��������� ���������
+ int*int int
���������������
��������� ���������
��������������
���������������
+ int*int int
T
��������� ���������
�������
��������������
���������������
T
+ int*int int
T
��������� ���������
�����
�������
��������������
���������������
T
+ int*int
T
int
T
��������� ���������
�����
�����
�������
��������������
���������������
T E
+ int*int
T
int
T
��������� ���������
�
�����
�����
�������
��������������
��������������� E
T E
+ int*int
T
int
T
���������� ������ ����������� ��
#� �� ������� ���������� �
����� �� ����������� �������� β ��� ����$→ β � �� ���������
�������� ����� β%����� ������������ �� β ���$����
������ �&�#��������� ����� ��������� ������������ � ���� �� ������ �
��������
� '������ � ����� ��� �� �� � ������������!���( )� � ����������� ������
( �* ��������� �� �
� + ����� �* ����������������� β � ��* $→ β � �� ��������� * ��������� ������ ��� ����� ���� ���� � ���� ��� ������ ��������
� ,�� ��� ������������ ���� �������� * ���������� �� ������� ����� ��������� ����� ���� �� � �����
�������������
� #� αβω � ������� ����� ��� �� ���� ������������!��
� -����� �� * � �������� �������� �� � �� �� ��� � ���������� $→ β
� -���� ω � �� ������ �������� ��%���*�α$ω → αβω � ���� ��� ����� ���� ���� � ����
�������
� � ��'����� � ������� �����������������*( " ������������ ������� �� ��� ��� � ��� � ��� ������ �������� ����
( " ������������ ���������� * ������ �� ����!����� �� �� ��� �� �� ��� �
� ������� ����������� � � � �� � ����( ��������� ������� � ������ ������
� ���� ����%������ ������� � ����� ��� ���
�./.0 1�1�1�.�
��������� ��� !�"��#�����$���%������#������$
��� ������������!����� ���������������� ������
#*�����������
2����������
!�"�
� #*�����+��� � ����������� ���������
� #���� �������� � ��� ������ ���������� ( "�� �������� � ������� ���� ���
-3��.4� � -3�.�4��
%�����
� -���� ��� ��������� ����� ��� � ������ ����� ������ ���������� ( 2���� �� �� ������ �������� �� ����� �� ��� ���� �� ���������� ����� ���������
� #�-�→ .4�� �� ���������%� ���� �
��.4��56��� ��-��56�
&������� ������������������ !�"� %�����
������→ ������������
�*�������� ���
�*�������� �����������
�*���������������������
�*�������������������
���
������→ ������������
������→ ��������
�*������ �����
������→ ���������������� �����
������→ ������������ � �����
����������� #'$
+ int*int int
↑
����������������
����������� #($
+ int*int int
↑
����� �����������
����������������
����������� #)$
+ int*int int
↑
����� �����������
������������������
����������������
����������� #*$
+ int*int int
↑
����� �����������
������������������
����������������
��������� � �����
����������� #+$
+ int*int int
T
����� �����������
������������������
����������������
��������� �����
��������� � �����
↑
����������� #,$
T
+ int*int int
T
����� �����������
������������������
����������������
��� �����
��������� �����
��������� � �����
↑
����������� #-$
T
+ int*int int
T����� ���
����� �����������
������������������
����������������
��� �����
��������� �����
��������� � �����
↑
����������� #.$
T
+ int*int int
T
���������
����� ���
����� �����������
������������������
����������������
��� �����
��������� �����
��������� � �����
↑
����������� #/$
T
+ int*int
T
int
T
���������
����� ���
����� �����������
������������������
����������������
�������
��� �����
��������� �����
��������� � �����
↑
����������� #'0$
T E
+ int*int
T
int
T
���������
����� ���
����� �����������
������������������
����������������
�������
�������
��� �����
��������� �����
��������� � �����
↑
����������� #''$
E
T E
+ int*int
T
int
T
���������
����� ���
����� �����������
������������������
����������������
���
�������
�������
��� �����
��������� �����
��������� � �����
↑
&������
� " ������� ���������� ���� ��� ������� � ����� ���
� ��������� ��� � �� ������� �
� 7����� ���� ���#*������� �������� � ����� �� ���
� 7����� ���� ���2�������� 8������� ������� � �� ��� �� ��� ���� ���������������� ������ ������!����� � ���� ��� �� ��� ������� ��������������
��"�����
� ��� �������*���!��������������� ������������� �� ��*������� �������
� 9�� ������ �� ��*%�:� ���:��� �����*���!���� ���� � �������������( -�*������������� �� ���� �������������6�����������������
� �����������*���!��������� ��������� ����������������*�������� ����
� �������������!��������� ��������� �:� ������������ �
� ;� �� ��*�����"2�6���������"2�( 7� ��� �� �� � ����� ������ "2
� '���������������� ������� ����� �� ��*�"2�/�
�������� !�"� %�����
'�� ������
#*���-3��.4� � -3�.�4�
2����.4��56 � ��-��56
33
&������
� " ������� ���������� ���� ��� ������� � ����� ���
� ��������� ��� � �� ������� �
� 7����� ���� ���#*������� �������� � ����� �� ���
� 7����� ���� ���2�������� 8������� ������� � �� ��� �� ��� ���� ���������������� ������ ������!����� � ���� ��� �� ��� ������� ��������������
������������ 1���� "�����!�"����������
� ���������→ �����������→ ��� ��������� �����
� �������� �� ��� � ����� �����( 9������ ������ �� ��� ��→ ��� ���� ��� ���� ����� �����
( ����������������� ���� � ��������� ����� � �
Prof. Aiken CS 143 Lecture 8 35
��������
� ����������<���� �� ������ ��������� ������ ����� ��� ��� ������� ���� �������������� �
� 9���� �� �� ���� ���� � ���� ��
#�→��α$ω → αβω
� -���� αβ � �� � ����� ���αβω
36
�������� ������
������ �������*���!���%���� ����� �� �������������� �� ��� %�� � �� ����
37
����!���
� ������� ������ � ��� ����� ���� ��� ������������
� -��������� � ���%��� ���� � ����
� '��� ���������� �� � ����� ( ���������� � ���� ����� � ����� �� ���
( " �������� � ����� �� ��� �� ���� ����������� � ���� ����� %���*� � �� ���� ���� � ����
( " ��:��� ������� �*����� ������ � �������� � �����
38
����� ����� ��������
� ������ �������*���!���%���� ����� �� ���� ���� ����� �� ���
� "�� ����� �������� � � �� ������� ����������� � ���� �����
� )����� ��������� �� � � ����� ������������ �� ������� �
� ;�� �������� ���� ������������!����� � � �� �������������� ��� � �����
39
%�������� �����������
� ,���� ���� �������� ������� ���������� ��� �����
� #����������� � ��� ������* * � ������������ � :� �� �������� ��� � �����
� 9�� ��� �� �� ��*%���������*������� �� ���� ����� ���
� 9����������* * �����%��� �� �� ����� �� ��* #2"
40
2�������
Prof. Aiken CS 143 Lecture 8 41
-����=;�
7� ����������=;�
#"2��=;�
>������� ��������
��������&%#3$
� <���� �� � ������"2
� "�&����� ������� � ������� �����
� 2�&������� ���� ���� ����� ������ ���
� 6�&������ ���������� ���������� �� �� � �������� �� ������
� "2�&�"2�/������ ����� � ��� /�������� ������������ ��� �� � ��
� #"2��"2������
4������� ������������&%
� +�������� ���������� ���:� �������� ���������� *������� ��� ������� � �� �� ��* ���� � ������
� ,���� � 6�� 6���%����� ��� ������� �����������
� ���� ����� ���� ���� ��� �������� ������ � ��� ������� ����� ���������
� 9��� ��� ���� �� ��������� ����� ����� �� ��* ""( ;� �� ��* "2�6�������� �� ���� ������� � �� ���
���� ����� ��������� ����� ���� ������� � ���� %������� 6�������� ���������������
���"���� ������
� ,���� ����� ������� � ��� �����
� -������ � ��� �� � ������ ������ ���� %������������ �����
α � ���������� � ���� ��ω � � ��* α�ω � ����� �� ������� �����*���!���
44
��� �����"����
� 7��������� � ���� ����� ���� � ��������� ����� � �����
� �� ���������� � ���� ��*� � ������������� � �����
� =��*� � ���� ������� � ���� ���� ��� %��������� �� �� ����� ����� ���� �����
45
���"���� ������
9������ �� �� �� %�������� �� ������� � ����� �������� ���� ���� �
+������� ���������� ����� ��� �� ������* �� �� ������� � ����1
46
����
� 7������� �� ��������� ������?1@ ��� �� � �������
� ����������� ���������→ ��������
��→ 1�����→ �1��
��→ ��1�
��→ ���1
"����� �������$�→ ε � $�→ 147
����
� #���� *� � �� ?����"2�8�@
� ��������������������� :� ��� ��� �� ���������� ��������� ����� ( ���-�→ 1$AB����� * ���� �� ��������������� �� ������ ���� ��� � $AB
( �� -�→ $1AB����� * ��� �� �� � ����� �� ������ ���� ��� � $��* ���� �� ��������������� �� ������ ���� ��� � AB
( �� -�→ $AB1����� * ��� �� �� � ����� �� ������ ���� ��� � $AB��* ������ ��� �������� ��������� $AB� ��-
48
����� ���������������� ������� "�����
� -���� �������� �� �� ���������� ��� ���� ��� �� ������ ����������� * ��� �� ���������� ������� ��� �� �� � ������� ���� "2�8��
� C��� �� �� ���� ���� "2�8��� ������ �������� ������ ����� "2�8�
� ' � ��� �� �� �� ������������ �"C#72���;C�C%������� �� ��� ���� ����� "2�8�
�&� �%�
� ;� �� �� ���� � �� ������� �� #� � #( #��� ����� ��� ����:� ��� ��� ��� �:� ������� �� ��� :��� ����������
� �"C#72�� �% ���� �� �������� ������������ �� �� �� �( �� ������������� ����"C#72�� �( #�-�� α13β � ����"C#72�� ���3�� γ � �� ���������%� ������� �� 3�� 1γ ����"C#72�� �1�-����*� �� :��� ���� ���*� ������ ���� ������� ���� ���� ��"C#72�� �1
� 7� �� ��������� ��� �� �� ���� ����
���������&� �%�#�$
� -�� α13β � ����"C#72�� �������� �� ������� ��� ������������ ����������� ���� ��� � 3β ��������
� )��� ������������ �� � �������������� ��� � 3
� )����� ������� �� ����3�� 1γ ������� ������������ 3�� γ
���������
� �������� �� ������� ������� � ���� �* � ���� * ������ ��� � ��� ��� � ������� ����� ���������( #� ��� �� � ������� ����� %��������������
� )��� � ��� ���� ���� ������� ��� � ������� ����� ���������
52
������
�������� �� ������� �����
( -���� ������ ��� �� �� ������� �������*���!���
( �� � ���������� ��� � ������� �����→ ���� # � � ������� ���� �� �������� �*���
( "���� ��→ ��1�����* ����� ��� �� ����� �� ���:��� ��������� ����� �� ������ �
53
������
� ;� �� �� ��� � ���� ���������� ����=���==�� ��������
�&�D�� � 1�E�"C#72�� ��&�D�� � 1�%���� 1���%���� 1�%����1��=%���� 1=%�=�� 1���%�=�� 1��E
2��������������
� " ���� ���� �� ����� ������� ���� ��� �����������������
9���./ 9���.0 1�1�1�9���.�!/9���.�
� #� 9���.� ���������� ��� � ������� �� $�→ α�( 9���.� ���� ���������� � ������� �$�
( " �� ���� � �� ���α�!/������ ���$�
( ��� ���$�!/�→ 9���.�!/ $��β ���:� �* β
� 2������ ���%�9���.6�/F9���.� ���� ���������� � ������� �� � ���� � �� ���α6 55
������
�������� �� � ������� ���� ����������� �������� ��� �� �� ������� ����� �*���!���
?�@ � ���������� ��� � ������� �����→ ���?ε@ � ���������� ��� � ������� �����→ �?��� �@ � ��� ������� ��� � ������� �����→��� ���
56
������
" �?��� �������@
��→ �1��
��→ 1�
��→ ��� ��1�
'��
-��� �� ����� ?�@ �����→ ���
-��� �� ����� ε �����→ �
-��� �� ����� ��� � �����→ ��� ���
57
5������ 2�6�
� ;C�C� %$�%����� �� �������� ��������$������������ ��� �� �� �� �
� �"C#72� ��������� �������-�� α$1β � ��* -�� α1$β � ���
� 7� � ��������� ���� �������� ���� ����
������
� ;� �� �� ��� � ���� ���������� ����=���==�� ��������
�&�D�� � �1%���� �1��E;C�C� %���&�D��� ��1�%���� 1��=%���� 1=%�=��1���%�=�� 1��E�
�������� ������� ���������� ��������&%#0$
� ' � ��� �� �� �� ;%� ������� �� ��������� #� → #� �;
� ��&��"C#72��D#� � 1#E�
� 9������ ����� �����������
� 9������ ������� $����;( #�;C�C� %$������� ����� ���������%� �������;C�C� %$�� ��
� =��*� ������� ������� ���� ���� ��
7���� �57
� #� ���������� �������� �� ������� ����
� �� ����������������� ;C�C
� #� �� ����� ����"C#72��#��1#�� -������� ������������ ���� ����;C�C������� ����� �*�����
� ����� ��� �� �� ���� ��� ��
������
;� �� �� �
��→ �����������→ ��� ��������� �����
9�������� ������ ��#� � 1�
7���� �57
63
#� → 1��
��→ 1��
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
#� → ��1 ��→ �1
��→ �1����
��→ ���1����
��→ ���1
��→ �1���
��→ 1�
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
��→ �����1
��→ ����1��
��→ 1�
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
��→ ��� ��1�
��→ 1���
��→ 1��� ���
��→ 1���
��→ ��� ���1
��→ ��1�
��→ ���1
� �
�
���
��� �
�
�
�
�
����
�
���
�+
�
�
���
� C��� �� �� ��������� ������������ ��� �� �� �� ��:���� ��� �� �������� *���� �� ����
������������� �����"���� ������
'���� ���
( 2������ �� �:��� ���� ��� ���� � ��� ��%����
( C��� �:��� ���� ���� ���� ������ �� �������������� � � �� ������ �������
65
��������� ������� ��� ���������!�"� �������
� +��� �� ��� �� �� � ������� ����� ��� ���������� �� ����� �
� #������ �� * � ������� γ ���������� ��� �� �� �� ���� �� ���� � ��� �� �� ����� � ������� �� 5
� -���� �( #*������� �������� ������� ��������� ���� �� �� ������� �
5 ��*�� � %�� ������� �������� �� �� ���� ��� ( -��������%������ ����
� ;�� �������� �� �� 5 � ��� ��� :� � ��������� �� ���-�� α� ������� �� � ��� �� �� � �� ��� :� ��� ���� ��������� ���α� #��� �� �� �� ������� ��*�� � -� +��� �� �� ����� �� �� ���� ���
������������
"���� $�→ β1γ � � ���� ������������� � ���� αβ�
#� →� α$ω → αβγω
������������� ���� ���� � ����
'��� ���� ��� �� � ���������αβ%���� ����� �������� ���������� ������� ��� ������
67
����������� ����������"���
7������ �� � ���� ������������� � ���� α ����'=-�* ������ ������� � ����%����������α%�
����� ������ �� �� ��* �����
;�� �������� �������� :���� * ��������� �� ������� ��� ���� ������� ������� α
68 69
������
� 7������� ����� � ���� �������� �������
� ������������� ��→ �1���� � ���� ������������
�
��
���
����
1�1�1
70
����������� ����###8
#� → 1��
��→ 1��
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
#� → ��1 ��→ �1
��→ �1����
��→ ���1����
��→ ���1
��→ �1���
��→ 1�
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
��→ �����1
��→ ����1��
��→ 1�
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
��→ ��� ��1�
��→ 1���
��→ 1��� ���
��→ 1���
��→ ��� ���1
��→ ��1�
��→ ���1
� �
�
���
��� �
�
�
�
�
����
�
���
�+
�
��������&%#0$
71
� � ��-����� �� *( " ���� ����� α
( ���������� �������� �
( ��'=-����������α ����� ���� �� �� �
� 2���� �� �� ��� $�→ β �( � ����� ����� $�→ β1
� #*�����( � ����� ����� $�→ β1�ω
( �:��� ��� �����* � * ��� �� ���������*�� � �
6������7�6������2�6��������������&%
� -�� C,G�% H�&( #*����5
( 2���-�� β
( -��
( �����
� ;C�CG�%5H�&�5
7�6������2�6��������������&%
� #����������� ��������������������������������� ��( #�-�� C,G�% H�&��*����5%�� ���������� ���5%�� � ������� ������ ���������
( #�-�� C,G�% H�&�����-�� β%������%����������β���� ���� �� ���� %��� �������� ���5�&�;C�C��%-�%�������� ���������� ����
( -��������
��"����� &%#0$
� "2�8��* �� ����I��������������( -�4��� ��* ���>�����������
( $�→ β1� �� A�→ ω1
� "2�8��* �� ��*���I��������������( -�4��� ��* �� ��������� ��� ��*��������
( $�→ β1� �� A�→ ω1�δ
74
&%#0$���"�����
75
#� → 1��
��→ 1��
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
#� → ��1 ��→ �1
��→ �1����
��→ ���1����
��→ ���1
��→ �1���
��→ 1�
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
��→ �����1
��→ ����1��
��→ 1�
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
��→ ��� ��1�
��→ 1���
��→ 1��� ���
��→ 1���
��→ ��� ���1
��→ ��1�
��→ ���1
� �
�
���
��� �
�
�
�
�
����
�
���
�+
�
�
�>���*���I�����������>��*"2�8������
&%
� "2�&�?"��!��!���*��� �@
� #"2�&�?#�����"2@
� #"2�&�#"2�/�( ;� ����/��������������������������
� #"2�������� ���������*��*���I��� "2�8�( +����� ���* ������������
76
&%��������
� � ��-����� ���*( " ���� ������ α
( ������������������� �
( ��'=- ���������� α ����� �������� �� �
� 2���� �� �� ��� $�→ β �( � ����� ����� $�→ β1
� #*�����( � ����� ����� $�→ β1�ω
77
( ��∈ =����>�$�
&%���������#���9$
� #��������������������:��������%�� ��� �� �� ������ #"2
� "��������� ��������������*�������������� ������( "��� �� ��* #"2������:����������:������������� ���� �� ������� �����
78
��"������ &%
79
#� → 1��
��→ 1��
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
#� → ��1 ��→ �1
��→ �1����
��→ ���1����
��→ ���1
��→ �1���
��→ 1�
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
��→ �����1
��→ ����1��
��→ 1�
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
��→ ��� ��1�
��→ 1���
��→ 1��� ���
��→ 1���
��→ ��� ���1
��→ ��1�
��→ ���1
� �
�
���
��� �
�
�
�
�
����
�
���
�+
�
�
=����>����&�D�J��%�K�E=����>����&�D�J��%�J��%�K�E
,���� �������� ���������#"2
���!����������������������
� +������ �� ��*����������#"2�( ��������������� �� ��*� ������
� 9���� ���� ������ ������������� �� �� ��*��� ��������*� � �������������� ( �������������������������������
80
���!����������������������
� �������� ���� ��� �� �� �( � → �������������������������
� � '=-����:��� ��� �� �� ������������� �������������������( � → ������1���������→ ��1����
( �� ����������������*���I���
� '�*� � ��* ?� * ��� ������ ����� �� ��������� ���@ �������:������������������ ������� ���������
81
7����������������������������� &%
/1 #� +��� '=-����;01 #� �./F.�K � �������� ���������� ��L1 2� � ����� � �������� ������ #�K
� #� α�ω � �������� ������������ ����� +����� ���� �������α� # + ������ α%�� �������������� ������
� " ���� α ����� ������������ �����
� # + �� α �� ��� %��� ������������������ #*����� $�→ β1� �γ ∈ ���� ����������� �� 2���� $�→ β. ∈ �∈ =����>�$�� ' ��������� � ������ ��������
82
&%��:�����
�������� ���� '=-�M ���#� � -�������� �����K / �*���
83
��"���������;��� <����=
84
#� → 1��
��→ 1��
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
#� → ��1 ��→ �1
��→ �1����
��→ ���1����
��→ ���1
��→ �1���
��→ 1�
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
��→ �����1
��→ ����1��
��→ 1�
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
��→ ��� ��1�
��→ 1���
��→ 1��� ���
��→ 1���
��→ ��� ���1
��→ ��1�
��→ ���1
� �
�
���
��� �
�
�
�
�
����
�
���
�+
�
/
0
LN
OP
Q
R
S
/8
//
&%��:�����
�������� ���� '=-�M ���#� � -�������� �����K / �*���
��� � �����K L������������=����>��� �*���
85
��"������������ ; <����=
86
#� → 1��
��→ 1��
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
#� → ��1 ��→ �1
��→ �1����
��→ ���1����
��→ ���1
��→ �1���
��→ 1�
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
��→ �����1
��→ ����1��
��→ 1�
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
��→ ��� ��1�
��→ 1���
��→ 1��� ���
��→ 1���
��→ ��� ���1
��→ ��1�
��→ ���1
� �
�
���
��� �
�
�
�
�
����
�
���
�+
�
/
0
LN
OP
Q
R
S
/8
//
��"������������ ; <����=
87
#� → 1��
��→ 1��
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
#� → ��1 ��→ �1
��→ �1����
��→ ���1����
��→ ���1
��→ �1���
��→ 1�
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
��→ �����1
��→ ����1��
��→ 1�
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
��→ ��� ��1�
��→ 1���
��→ 1��� ���
��→ 1���
��→ ��� ���1
��→ ��1�
��→ ���1
� �
�
���
��� �
�
�
�
�
����
�
���
�+
�
/
0
LN
OP
Q
R
S
/8
//
&%��:�����
�������� ���� '=-�M ���#� � -�������� �����K / �*���
��� � �����K L������������=����>��� �*���
��� ��� ���K // �*���
88
��"������������ <�; ���=
89
#� → 1��
��→ 1��
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
#� → ��1 ��→ �1
��→ �1����
��→ ���1����
��→ ���1
��→ �1���
��→ 1�
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
��→ �����1
��→ ����1��
��→ 1�
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
��→ ��� ��1�
��→ 1���
��→ 1��� ���
��→ 1���
��→ ��� ���1
��→ ��1�
��→ ���1
� �
�
���
��� �
�
�
�
�
����
�
���
�+
�
/
0
LN
OP
Q
R
S
/8
//
��"������������ <�; ���=
90
#� → 1��
��→ 1��
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
#� → ��1 ��→ �1
��→ �1����
��→ ���1����
��→ ���1
��→ �1���
��→ 1�
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
��→ �����1
��→ ����1��
��→ 1�
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
��→ ��� ��1�
��→ 1���
��→ 1��� ���
��→ 1���
��→ ��� ���1
��→ ��1�
��→ ���1
� �
�
���
��� �
�
�
�
�
����
�
���
�+
�
/
0
LN
OP
Q
R
S
/8
//
��"������������ <�; ���=
91
#� → 1��
��→ 1��
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
#� → ��1 ��→ �1
��→ �1����
��→ ���1����
��→ ���1
��→ �1���
��→ 1�
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
��→ �����1
��→ ����1��
��→ 1�
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
��→ ��� ��1�
��→ 1���
��→ 1��� ���
��→ 1���
��→ ��� ���1
��→ ��1�
��→ ���1
� �
�
���
��� �
�
�
�
�
����
�
���
�+
�
/
0
LN
OP
Q
R
S
/8
//
&%��:�����
�������� ���� '=-�M ���#� � -�������� �����K / �*���
��� � �����K L������������=����>��� �*���
��� ��� ���K // �*���
��� ����� �K L���K�∈ =����>����������1��→���
92
��"������������ <����;=
93
#� → 1��
��→ 1��
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
#� → ��1 ��→ �1
��→ �1����
��→ ���1����
��→ ���1
��→ �1���
��→ 1�
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
��→ �����1
��→ ����1��
��→ 1�
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
��→ ��� ��1�
��→ 1���
��→ 1��� ���
��→ 1���
��→ ��� ���1
��→ ��1�
��→ ���1
� �
�
���
��� �
�
�
�
�
����
�
���
�+
�
/
0
LN
OP
Q
R
S
/8
//
��"������������ <����;=
94
#� → 1��
��→ 1��
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
#� → ��1 ��→ �1
��→ �1����
��→ ���1����
��→ ���1
��→ �1���
��→ 1�
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
��→ �����1
��→ ����1��
��→ 1�
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
��→ ��� ��1�
��→ 1���
��→ 1��� ���
��→ 1���
��→ ��� ���1
��→ ��1�
��→ ���1
� �
�
���
��� �
�
�
�
�
����
�
���
�+
�
/
0
LN
OP
Q
R
S
/8
//
��"������������ <����;=
95
#� → 1��
��→ 1��
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
#� → ��1 ��→ �1
��→ �1����
��→ ���1����
��→ ���1
��→ �1���
��→ 1�
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
��→ �����1
��→ ����1��
��→ 1�
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
��→ ��� ��1�
��→ 1���
��→ 1��� ���
��→ 1���
��→ ��� ���1
��→ ��1�
��→ ���1
� �
�
���
��� �
�
�
�
�
����
�
���
�+
�
/
0
LN
OP
Q
R
S
/8
//
��"������������ <����;=
96
#� → 1��
��→ 1��
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
#� → ��1 ��→ �1
��→ �1����
��→ ���1����
��→ ���1
��→ �1���
��→ 1�
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
��→ �����1
��→ ����1��
��→ 1�
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
��→ ��� ��1�
��→ 1���
��→ 1��� ���
��→ 1���
��→ ��� ���1
��→ ��1�
��→ ���1
� �
�
���
��� �
�
�
�
�
����
�
���
�+
�
/
0
LN
OP
Q
R
S
/8
//
&%��:�����
�������� ���� '=-�M ���#� � -�������� �����K / �*���
��� � �����K L������������=����>��� �*���
��� ��� ���K // �*���
��� ����� �K L���K�∈ =����>����������1��→���
��� �����K N���K�∈ =����>����������1��→�����
97
��"������������ <�6;=
98
#� → 1��
��→ 1��
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
#� → ��1 ��→ �1
��→ �1����
��→ ���1����
��→ ���1
��→ �1���
��→ 1�
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
��→ �����1
��→ ����1��
��→ 1�
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
��→ ��� ��1�
��→ 1���
��→ 1��� ���
��→ 1���
��→ ��� ���1
��→ ��1�
��→ ���1
� �
�
���
��� �
�
�
�
�
����
�
���
�+
�
/
0
LN
OP
Q
R
S
/8
//
��"������������ <�6;=
99
#� → 1��
��→ 1��
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
#� → ��1 ��→ �1
��→ �1����
��→ ���1����
��→ ���1
��→ �1���
��→ 1�
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
��→ �����1
��→ ����1��
��→ 1�
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
��→ ��� ��1�
��→ 1���
��→ 1��� ���
��→ 1���
��→ ��� ���1
��→ ��1�
��→ ���1
� �
�
���
��� �
�
�
�
�
����
�
���
�+
�
/
0
LN
OP
Q
R
S
/8
//
��"������������ <�6;=
100
#� → 1��
��→ 1��
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
#� → ��1 ��→ �1
��→ �1����
��→ ���1����
��→ ���1
��→ �1���
��→ 1�
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
��→ �����1
��→ ����1��
��→ 1�
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
��→ ��� ��1�
��→ 1���
��→ 1��� ���
��→ 1���
��→ ��� ���1
��→ ��1�
��→ ���1
� �
�
���
��� �
�
�
�
�
����
�
���
�+
�
/
0
LN
OP
Q
R
S
/8
//
��"������������ <�6;=
101
#� → 1��
��→ 1��
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
#� → ��1 ��→ �1
��→ �1����
��→ ���1����
��→ ���1
��→ �1���
��→ 1�
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
��→ �����1
��→ ����1��
��→ 1�
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
��→ ��� ��1�
��→ 1���
��→ 1��� ���
��→ 1���
��→ ��� ���1
��→ ��1�
��→ ���1
� �
�
���
��� �
�
�
�
�
����
�
���
�+
�
/
0
LN
OP
Q
R
S
/8
//
&%��:�����
�������� ���� '=-�M ���#� � -�������� �����K / �*���
��� � �����K L������������=����>��� �*���
��� ��� ���K // �*���
��� ����� �K L���K�∈ =����>����������1��→���
��� �����K N���K�∈ =����>����������1��→�����
���K O���K�∈ =����>����������1��→�
102
��"���������6;=
103
#� → 1��
��→ 1��
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
#� → ��1 ��→ �1
��→ �1����
��→ ���1����
��→ ���1
��→ �1���
��→ 1�
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
��→ �����1
��→ ����1��
��→ 1�
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
��→ ��� ��1�
��→ 1���
��→ 1��� ���
��→ 1���
��→ ��� ���1
��→ ��1�
��→ ���1
� �
�
���
��� �
�
�
�
�
����
�
���
�+
�
/
0
LN
OP
Q
R
S
/8
//
��"���������6;=
104
#� → 1��
��→ 1��
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
#� → ��1 ��→ �1
��→ �1����
��→ ���1����
��→ ���1
��→ �1���
��→ 1�
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
��→ �����1
��→ ����1��
��→ 1�
��→ 1�����
��→ 1���
��→ 1��� ���
��→ 1���
��→ ��� ��1�
��→ 1���
��→ 1��� ���
��→ 1���
��→ ��� ���1
��→ ��1�
��→ ���1
� �
�
���
��� �
�
�
�
�
����
�
���
�+
�
/
0
LN
OP
Q
R
S
/8
//
&%��:�����
�������� ���� '=-�M ���#� � -�������� �����K / �*���
��� � �����K L������������=����>��� �*���
��� ��� ���K // �*���
��� ����� �K L���K�∈ =����>����������1��→���
��� �����K N���K�∈ =����>����������1��→�����
���K O���K�∈ =����>����������1��→�
���K ��
105
5������ 2�6����7�6���
� ' ��� ���� '=-� �� �����������
� '������� ��� �� ���
� -�� C,��% �%�������� �� �� ��������������� � ���� �� �� ��
� ;C�C� %-�%�������� �� �� ������������������ � -���� �� �� ��
6���� 2�6�#�>7$
� ;C�CG�%-H�&�5 ���� �� →- �� �5
� ;C�C � � �� ��� � �������� ����� ������� ���'=-
Prof. Aiken CS 143 Lecture 8 107
6���� 7�6���#�>�$
9������ �� �� �� ����� � ( #��� ����� $�→ α1 β �;C�CG�% H�&�5 ���� -�� C,G�% H�&��*����5����� �*������ � ��� �� �� 5�
( #��� ����� $�→ α1 � �∈ =C""CT�$� �$�≠ #� ���� -�� C,G�% H�&������� ��� $�→ α
( #��� ����� #� → #1 ���� -�� C,G�%KH�&� ��
( -��������%�-�� C,G�% H�&�����
108
&%���������7�����!�
#� �&�>K�� ������� ���������
#� 5�&�8
#������ �� * ����� �� /������ #� → 1#
#� �� 6�&�� ����4%�/��
�� �
�� ����G���U�� ���� 6�% G5HH���
�*����6������*�� G5��H%�6��
����$�→ -��
�����-��� ���%�
���*��$%�����G���U�� ���� 6�%$H�
����* ������� ��4
������* ��� �������������
109
����������� ���������������
1
�������� ������
� ���������� �� ��� �� � ������ � �������� ��� �� � ������� ������������� ������� �� � ������ � ������������� ���������������
� ����� �� � ������ ���� ���� �� �������� ����� � �������������� ����
� � ������� �������� ��� ��� ���������� ���� ����� � �������� �� �� ����� �����!���� ���� �����������" #����$������ �#�����" %������ � ������� ����&��� � ������ �����#���#������� ��� ������� ���
�#�������!�� �#���� ��� �����������!� &����� �� ��� ��$���������������� ������ ����
� '����� &���� �&������ ������ �!� � � �������� ���� ����" '����� ��� ��� ���������� ���� �!� � ��&��� ���� �����������
���� ������ ���� � ��������������
�������� ������ ����������
� %���� �� ��� � �� ������ &����� (�������)�� �*��+ �� &��� ������������
&��� ��* ������ ��� ���&��� �� �� ����),����*�+,
� ���� �� &��� ��*����� ������" ����+ - ��� ����� ������� !���" ����+ .����������� ������� )�� �*
� /����������&���� ������������ &��� �
" %������� ���� �������������� ��� ��� ������������ ��������� ����!����� � �������� ��
����� ����� ����� �� ��
� 0�� %1�*�" �� ��� �����%1�*���� ��� ������ ���� �����%1�2�
� 0�� %)%1 �� 3�!�� %1�" (� ��� �����%1�2���������������� ��� �� �������
" '� � ���� ��� � ���� ���������!� ������ ������ �%1
" 0�� ���� ���
������������ �����
� ��� ��� �%1������� ����� ��� �!� � ������ �����)�� ������� �� �� ��� � ������������ ���$4%%45�)��� ����� �������� ����� �� ������� )�� �
� 6�������� ������������������!� � ���%1������ �� ������� " ������ ���� �� ��� �� ���� �����)�� ������ � ������ ����� � ��
�������� � �������������� ����
� '����&����� ����� ��� �������������� ���� ����������� � ��������� �7)�� ������8
� 6����%1�*� �*���� � ���������� 6����� � ��������� �� ��� � ������ ����������� )�� ��
" &���� ����� ��� ����� �� ������� )�� � � ����� �� �� ��� � ���������� �
� %������� ���� ����� ������ ���������������� )�� ������������� ��� �� ������ ��$4%%45�)�
�� !"�#���$ % �������� ����������
� 9%4�(1#�6� " '��� ��� �����7)�� ��:����8 ���6�������� ���
�� ��� �� :�� ����������� 7:�������8 ���� ��� �����$61�/����
� ;4/4�6�<� " '��� ��� �����7)�� ��<����8 ���6���������� 7)���<�����8����6
" ' ����� ���9%4�(1#
����� �������������
� ���� �������� �9%4�(1#�7�� � ���=8�
� )���� ���� ��������� �� ������� 9%4�(1#���;4/4
%���� ����������������
� )9/64�7���8�.�!����> ����� ��� ������ �����7)�� �������8���;4/4�������.�>������ �������������
� )9/64�7���8�.������ � ��)�� � ����� ��� ������ �����7)�� �����8���)�� ���� ��
� )9/64�7��=8�.������� ����� 6�� �����������7������=8
� ����� � � ���������������������� � ���� %1�*�� ;4/47��)8�.�> � ���� �� ���� ����� �� ;4/4�
&���������
!�������
� 4��� ���������� �%1�*���� ���!� %1�*�
� '������ ���������� �%1�*����� �������!� ����� �����%1�*���� � �&��� � ��� ���� ���� ������� �!� �� ��� �����%1�2�
����
� /�& �� ����������%1���%)%1�� ��� ��� ����� ������" ?���� ��������� ������������� � ���9
" %1��&����� &���� �������� ������
� ;��������!� %)%1 ������ � ����%1���� � ��� �� ������ ���� %1
&��� ����
� 0���� ������ ���� ������� �� %1�*�������������� �������!��� ������ ������� �� ����� ���� ���� !��� � ��� @� ��A�
� B������� ���������� %1�*������ � ��� ��������������� ����� ��� ���� � ��� ��� � ��� ������ � ��� ��
� � ��� � � ���� ���� � �������!���C����������������� ������ ���!� ������
� ���� � ���� ���� � ������� �����C�����
&��� ����
*� 9 ������ ����� �� � �������%1�*�
+� 0������ ������ ���� � ��� �� � ����
D� /�& �� )9/64��� ������ � �������������� �� & ������ ������
E� /�& �� ;4/4 �;4/4���<�.3 ��" ���� ����� �� ���*��F����
" 3��� ����� �� ���� ���� �!� !��� � ��� � �� ��;4/4��*�<�� 9 ���;4/4��*�<���.�� ���;4/4��+�<���.�F
� (�� ���������� �� %)%1�*�������������� � ��!��� �������
Macchine di Turing, problemi ricorsivi e
ricorsivamente enumerabili
Macchine di Turing, problemi ricorsivi e ricorsivamente enumerabili
Problemi che i calcolatori non possono risolvere
E’ importante sapere se un programma e’ corretto, cioe’ faquello che ci aspettiamo.
E’ facile vedere che il programma contente solo il comandoprintf(‘‘ciao’’) stampa ciao.
Ma il programma in Fig. 8.2 del libro?
Stampa ciao, dato un input n se e solo se l’equazionexn + yn = zn ha una soluzione dove x , y e z sono interi.
Sappiamo ora (ultimo teorema di Fermat) che stampa ciao,con l’input n = 2, e cicla per sempre su input n > 2.
Ci sono voluti 300 anni per provarlo.
Possiamo sperare di avere un programma che prova lacorrettezza di programmi?
Macchine di Turing, problemi ricorsivi e ricorsivamente enumerabili
L’ipotetico programma H che testa “ciao”
Supponiamo che esista un programma H tale che, dato unqualunque programma P e un input I , dice si se P con input I
stampa ”ciao”, altrimenti dice no.
Hello-worldtester
HP
I yes
no
Modifichiamo il comando di stampa di no di H in ciao.Otteniamo il programma H1
P
I
H1
yes
hello, world
Macchine di Turing, problemi ricorsivi e ricorsivamente enumerabili
Modifichiamo H1 in modo che l’input I sia lo stesso P . Otteniamoil programma H2:
H2
P
yes
hello, world
H2 stampa si se P con input P stampa ciao, altrimenti stampaciao.
Macchine di Turing, problemi ricorsivi e ricorsivamente enumerabili
H2 non puo’ esistere
Diamo H2 come input ad H2.
H2
H2
yes
hello, world
Se H2 stampa si, avrebbe dovuto stampareciao.Se H2 stampa ciao, avrebbe dovuto stampare si.Quindi H2 non puo’ esistere.Quindi neanche H puo’ esistere.Quindi il problema affrontato e’ indecidibile: non esiste nessunprogramma che, dato un programma qualsiasi e un input, sappiadire se quel programma con quell’input stampa ciao.
Macchine di Turing, problemi ricorsivi e ricorsivamente enumerabili
Problemi indecidibili
Problemi per cui non c’e’ nessun programma che li possarisolvere.
Problema: appartenenza di una stringa ad un linguaggio.
Il numero di linguaggi diversi su un alfabeto non e’ numerabile.
I programmi (stringhe finite su un alfabeto) sono numerabili:li ordino per lunghezza, e poi lessicograficamente ⇒ primoprogramma, secondo programma, ecc.
Quindi esistono infinitamente piu’ linguaggi che programmi.
Quindi devono esistere problemi indecidibili (Godel 1931).
Macchine di Turing, problemi ricorsivi e ricorsivamente enumerabili
La macchina di Turing (Turing, 1936)
X2
Xi
Xn
X1
control
Finite
. . .BBB B. . .
Una TM fa una mossa in funzione del suo stato, e del simbolosotto la testina di lettura del nastro.In una mossa, una TM
1 cambia stato
2 scrive un simbolo del nastro nella cella sotto la testina
3 muove la testina di una cella verso destra o verso sinistra
Macchine di Turing, problemi ricorsivi e ricorsivamente enumerabili
Definizione formale come automa
Una macchina di Turing deterministica e’ una 7-tupla
M = (Q,Σ,Γ, δ, q0,B ,F ),
dove
Q e’ un insieme finito di stati,
Σ e’ un insieme finito di simboli di input,
Γ e’ un insieme finito di simboli di nastro,
δ e’ una funzione di transizione da Q × Γ a Q × Γ× {L,R},
q0 e’ lo stato iniziale,
B ∈ Γ e’ il simbolo blank, e
F ⊆ Q e’ l’insieme di stati finali.
Macchine di Turing, problemi ricorsivi e ricorsivamente enumerabili
Descrizioni istantanee
Una TM cambia configurazione dopo ogni mossa.Usiamo le descrizioni istantanee (ID) per descrivere leconfigurazioni.Una ID e’ una stringa della forma
X1X2 · · ·Xi−1qXiXi+1 · · ·Xn
dove
1 q e’ lo stato della TM
2 X1X2 · · ·Xn e’ la porzione non-blank del nastro
3 La testina e’ sopra il simbolo i -esimo
Macchine di Turing, problemi ricorsivi e ricorsivamente enumerabili
Le mosse e il linguaggio di una TM
Useremo ⊢M
per indicare una mossa di M da una configurazione ad
un’altra.• Supponiamo δ(q,Xi ) = (p,Y ,L). AlloraX1X2 · · ·Xi−1qXiXi+1 · · ·Xn ⊢
MX1X2 · · · pXi−1YXi+1 · · ·Xn
• Se δ(q,Xi ) = (p,Y ,R), abbiamoX1X2 · · ·Xi−1qXiXi+1 · · ·Xn ⊢
MX1X2 · · ·Xi−1YpXi+1 · · ·Xn
Indichiamo la chiusura riflessiva e transitiva di ⊢M
con∗
⊢M.
• Una TM M = (Q,Σ,Γ, δ, q0,B ,F ) accetta il linguaggio
L(M) = {w ∈ Σ∗ : q0w∗
⊢M
αpβ, p ∈ F , α, β ∈ Γ∗}
Macchine di Turing, problemi ricorsivi e ricorsivamente enumerabili
Una TM per {0n1n : n ≥ 1}
M = ({q0, q1, q2, q3, q4}, {0, 1}, {0, 1, X , Y , B}, δ, q0, B, {q4})
dove δ e’ data dalla tabella seguente
0 1 X Y B
→ q0 (q1,X ,R) (q3,Y ,R)q1 (q1, 0,R) (q2,Y ,L) (q1,Y ,R)q2 (q2, 0,L) (q0,X ,R) (q2,Y ,L)q3 (q3,Y ,R) (q4,B ,R)
⋆q4
Macchine di Turing, problemi ricorsivi e ricorsivamente enumerabili
Possiamo rappresentare M con il seguente diagramma di
transizione
/Y Y
/Y Y
/Y Y
0/0
X/0
/X X
/B B
/ Y1
/Y Y
0/0
Startq q q
q q
0 1 2
3 4
Macchine di Turing, problemi ricorsivi e ricorsivamente enumerabili
Una TM con “output”
La seguente TM calcola
m·
− n = max(m − n, 0)
0 1 B
→ q0 (q1,B ,R) (q5,B ,R)q1 (q1, 0,R) (q2, 1,R)q2 (q1, 1,L) (q2, 1,R) (q4,B ,L)q3 (q3, 0,L) (q3, 1,L) (q0,B ,R)q4 (q4, 0,L) (q4,B ,L) (q6, 0,R)q5 (q5,B ,R) (q5,B ,R) (q6,B ,R)
⋆q6
Macchine di Turing, problemi ricorsivi e ricorsivamente enumerabili
Il diagramma di transizione e’
/1 1/0 B
1 / B
1 / B
0/0
/1 1
/B B
/B B
0/0/0 B
1 / B
B / 0
0/0 /1 1
/B B
Startq q q
q q
0 1 2
q
q0 / 1
4
3
5 6
Macchine di Turing, problemi ricorsivi e ricorsivamente enumerabili
Accettazione per arresto
Una TM si arresta se entra in uno stato q guardando unsimbolo di nastro X e non ci sono mosse possibili, cioe’δ(q,X ) non e’ definita.
Se una TM accetta una stringa, possiamo assumere che siarresti (basta rendere indefinito δ(q,X ) per ogni q
accettante).
Se non accetta, non possiamo fare in modo che si arresti.
Linguaggi ricorsivi: esiste una TM che si arresta su ognistringa (sia accettata che no).
Linguaggi ricorsivamente enumerabili: esiste una TM che siarresta se la stringa e’ accettata.
Problema decidibile: esiste una TM che si arresta sempre.
Macchine di Turing, problemi ricorsivi e ricorsivamente enumerabili
Altri modelli di TM
Estensioni:
piu’ nastri
non-determinismo
Restrizioni:
nastro illimitato solo in una direzione e divieto di sostituire unsimbolo del nastro con B
due stack al posto del nastro
due contatori (mossa: cambio stato e +1 o -1 da uncontatore)
Tutti i modelli sono equivalenti: accettano i linguaggiricorsivamente enumerabili (tesi di Church, 1936).
Macchine di Turing, problemi ricorsivi e ricorsivamente enumerabili
TM e computer
Da TM a computer: basta avere sempre memoria daaggiungere, per simulare il nastro infinito.
Da computer a TM: vari nastri (memoria, istruzione, indirizzodi memoria, file di input, nastro ausiliario), controllo finito pereseguire una istruzione dopo l’altra leggendo e scrivendo inastri.
Differenza di tempo tra computer e TM: polinomiale. La TMpuo’ simulare n passi di un computer in O(n3) passi.
Macchine di Turing, problemi ricorsivi e ricorsivamente enumerabili
Linguaggi ricorsivamente enumerabili
D’ora in poi: calcolatore = macchina di Turing
L e’ ricorsivamente enumerabile se L = L(M) per una TMM. M si ferma se accetta una stringa, ma potrebbe nonfermarsi se non la accetta.
Macchine di Turing, problemi ricorsivi e ricorsivamente enumerabili
Un linguaggio ricorsivamente enumerabile
Consideriamo il linguaggio formato dalle coppie (M,w) taliche:
M e’ una TM (codificata in binario) con alfabeto {0,1}w e’ una stringa di 0 e 1M accetta w
Se questo problema e’ indecidibile, allora lo e’ anche ilproblema in cui una TM puo’ avere qualunque alfabeto.
Primo passo: codificare una TM come una stringa di 0 e 1.
Macchine di Turing, problemi ricorsivi e ricorsivamente enumerabili
Codice per una TM
Possiamo associare ad ogni stringa binaria un indice intero 1,2, 3, ..., cosi’ enumeriamo le stringhe: ǫ e’ la prima stringa, 0la seconda, 1 la terza, 00 la quarta, 01, la quinta, ...
Ordinamento per lunghezza, con stringhe lunghe ugualiordinate lessicograficamente.
Simbolo wi per la stringa i -esima
Vogliamo fare la stessa cosa anche per le TM.
Macchine di Turing, problemi ricorsivi e ricorsivamente enumerabili
Codice per una TM
Per rappresentare M = (Q, {0, 1},Γ, δ, q1 ,B ,F} come una stringabinaria, dobbiamo assegnare interi agli stati, ai simboli di nastro, ealle direzioni L e R:
Supponiamo che gli stati siano q1, q2, . . . , qr . Stato iniziale:q1, stato finale q2
Supponiamo che i simboli di nastro siano X1,X2, . . . ,Xs .Inoltre: 0 = X1, 1 = X2, B = X3.
L = D1 e R = D2.
Macchine di Turing, problemi ricorsivi e ricorsivamente enumerabili
Codice per una TM
Per la funzione di transizione: se δ(qi ,Xj) = (qk ,Xl ,Dm), lacodifica e’ 0i10j10k10l10m (mai due 1 consecutivi).
Per un’intera TM: codici per tutte le transizioni, separati da11: C111C211 . . . Cn−111Cn
Esempio: M = ({q1, q2, q3}, {0, 1}, {0, 1,B}, δ, q1 ,B , {q2})δ e’ definita da: δ(q1, 1) = (q3, 0,R), δ(q3, 0) = (q1, 1,R),δ(q3, 1) = (q2, 0,R), δ(q3,B) = (q3, 1,L).Codici per le regole di transizione:01001000101000001010100100000100100101000001000100010010
Codice per M:01001000101001100010101001001100010010010100110001000100010010Anche altri codici, elencando le transizioni in ordine diverso.
Macchine di Turing, problemi ricorsivi e ricorsivamente enumerabili
Codici e TM
Data una TM M, abbiamo associato un intero i : M e’ lai -esima TM, scritta Mi .
Molti interi non corrispondono a nessuna TM. Esempio:11001 o 001110.
Se w1 non e’ un codice valido, allora diciamo che Mi e’ la TMche si arresta subito per qualunque input (un solo stato enessuna transizione). Quindi L(Mi) = ∅.
Per codificare (M,w): codice di M seguito da 111 seguito daw.
Macchine di Turing, problemi ricorsivi e ricorsivamente enumerabili
Il linguaggio di diagonalizzazione
Il linguaggio di diagonalizzazione Ld e’ l’insieme dellestringhe wi tali che wi 6∈ L(Mi).
Tutte le stringhe w tali che M con codice w non accetta w .
Matrice con TM sulle righe e stringhe sulle colonne ⇒ ladiagonale corrisponde a stringhe wi e TM Mi . Le stringhe diLd corrispondono agli 0 della diagonale.
E’ possibile che la diagonale complementata sia una riga? No,perche’ la diagonale complementata e’ in disaccordo con ogniriga in almeno una posizione.
⇒ Ld non puo’ essere accettato da nessuna TM.
Macchine di Turing, problemi ricorsivi e ricorsivamente enumerabili
Linguaggi ricorsivi
L e’ ricorsivo se L = L(M) per una TM M tale che:
se w ∈ L, allora M la accetta (e si arresta)
se w 6∈ L, allora M non la accetta ma si arresta.
Problema (dell’accettazione di L): e’ decidibile se L e’ ricorsivo,altrimenti e’ indecidibile.
Macchine di Turing, problemi ricorsivi e ricorsivamente enumerabili
Classi di linguaggi
ricorsivi = decidibili = M si arresta sempre
ricorsivamente enumerabili = M si arresta se accetta
non ricorsivamente enumerabili. Esempio: Ld .
Macchine di Turing, problemi ricorsivi e ricorsivamente enumerabili
Proprieta’ dei linguaggi ricorsivi
Teorema 9.3: Se L e’ ricorsivo, anche L e’ ricorsivo.Prova: Se L e’ ricorsivo, esiste M che si arresta sempre.Modifichiamo M in M ′ in modo che M ′ accetti quando M nonaccetta, e viceversa. Anche M ′ si arresta sempre e accetta L.Allora L e’ ricorsivo.
Conseguenza: se L e’ RE, ma L non e’ RE, allora L non puo’ esserericorsivo.
Macchine di Turing, problemi ricorsivi e ricorsivamente enumerabili
Proprieta’ dei linguaggi RE
Teorema 9.4: Se L e L sono RE, allora L e’ ricorsivo.Prova: Sia L = L(M1) e L = L(M2). Costruiamo M che esegue inparallelo (due nastri, due testine) M1 e M2. Se l’input e’ in L, M1
lo accetta e si ferma, quindi anche M accetta e si ferma. Se l’inputnon e’ in L, allora M2 lo accetta e si ferma, quindi M lo rifiuta masi ferma. Quindi M si ferma in ogni caso.
Macchine di Turing, problemi ricorsivi e ricorsivamente enumerabili
L e L
Dove possono stare L e L?
sia L che L ricorsivi
ne’ L ne’ L sono RE
L e’ RE ma non ricorsivo, e L non e’ RE
L e’ RE ma non ricorsivo, e L non e’ RE
Non e’ possibile che un linguaggio sia ricorsivo e l’altro sia RE oneanche RE (teorema 9.3).Non e’ possibile che siano entrambi RE ma non ricorsivi (teorema9.4).
Macchine di Turing, problemi ricorsivi e ricorsivamente enumerabili
Linguaggio universale, riduzioni, e teorema di Rice
Linguaggio universale, riduzioni, e teorema di Rice
Il linguaggio universale
Il linguaggio universale Lu e’ l’insieme delle stringhe binarieche codificano una coppia (M,w) dove w ∈ L(M).
Esiste una TM U, detta TM universale, tale che Lu = L(U).
U ha tre nastri: uno per il codice di M e w , uno per il nastrodi M, e uno per la codifica dello stato di M. Cosi’ U simulaM su w , e accetta (M,w) se e solo se M accetta w .
Dato che alcune TM M hanno linguaggi non ricorsivi maricorsivamente enumerabili, non si fermano quando la stringaw in input non e’ del linguaggio. Anche U avra’ lo stessocomportamento su (M,w). Quindi Lu e’ RE e non ricorsivo.
Linguaggio universale, riduzioni, e teorema di Rice
Il problema dell’arresto
Data una TM M, definiamo H(M) l’insieme delle stringhe w
tali che M si arresta con input w .
Consideriamo il linguaggio che contiene le coppie (M,w) taliche w ∈ H(M).
Anche per questo linguaggio esiste una TM che prende ininput le coppie (M,w) tali che w ∈ H(M), e simula ilcomportamento di M su w . Quindi l’insieme di tali coppie e’un linguaggio RE ma non ricorsivo.
Quindi, non esiste nessun algoritmo che possa dire se unprogramma termina o no. Esiste pero’ un algoritmo che, se ilprogramma in input termina, si ferma, e se non termina cicla.
Linguaggio universale, riduzioni, e teorema di Rice
Proprieta’ di chiusura dei linguaggi ricorsivi
I linguaggi ricorsivi sono chiusi sotto le seguenti operazioni:
unione
intersezione
concatenazione
chiusura di Kleene
Basta costruire una TM che simula le TM dei linguaggi dati, evedere come si comporta, cioe’ se si puo’ fermare sempre o soloquando accetta una stringa.
Linguaggio universale, riduzioni, e teorema di Rice
Proprieta’ di chiusura dei linguaggi RE
I linguaggi RE sono chiusi sotto le seguenti operazioni:
unione
intersezione
concatenazione
chiusura di Kleene
Linguaggio universale, riduzioni, e teorema di Rice
RE e ricorsivo
Dato un linguaggio ricorsivo e uno RE, consideriamo la loro
unione: RE
intersezione: RE
concatenazione: RE
chiusura di Kleene: RE
Se L1 ricorsivo e L2 RE, L2 − L1 e’ RE e L1 − L2 non e’ RE
Linguaggio universale, riduzioni, e teorema di Rice
Riduzione
Dato un problema P1 indecidibile, vogliamo vedere se un altroproblema P2 e’ indecidibile o no.
Basta mostrare che, se potessimo risolvere P2, alloraprotremmo usare la sua soluzione per risolvere P1. Questatecnica e’ detta riduzione di P1 a P2.
Ridurre P1 a P2 significa convertire qualunque stringa di P1 inuna stringa di P2, e qualunque stringa non in P1 in unastringa non in P2.
Supponiamo che esista un algoritmo che risolve P2. Data unastringa w per P1, la convertiamo in un’altra stringa x per P2.Poi usiamo l’algoritmo di soluzione per P2 per decidere se x e’in P2 o no. Qualunque sia la risposta, e’ valida anche per w
in P1. Percio’, dall’algoritmo che risolve P2, abbiamocostruito un algoritmo che risolve P1.
Linguaggio universale, riduzioni, e teorema di Rice
Riduzioni
Se P1 si riduce a P2, allora P2 e’ difficile almeno quanto P1.
Se P1 non e’ ricorsivo, allora neanche P2 e’ ricorsivo.
Se P1 non e’ RE, neanche P2 e’ RE.
Teorema 9.7: Se esiste una riduzione da P1 a P2, allora:
se P1 e’ indecidibile, lo e’ anche P2
se P1 non e’ RE, non e’ RE neanche P2
Linguaggio universale, riduzioni, e teorema di Rice
Due linguaggi
Consideriamo due linguaggi:
Le = {M|L(M) = ∅}
Lne = {M|L(M) 6= ∅}
Vogliamo capire se sono ricorsivi, o RE, o neanche RE.
Linguaggio universale, riduzioni, e teorema di Rice
Lne e’ RE
Lne = {M|L(M) 6= ∅}
Basta mostrare che esiste una MdT che lo accetta.
Basta prendere una M non-deterministica che, data Mi ininput, non-deterministicamente simula Mi su tutte le possibiliw. Se c’e’ una w che e’ accettata da Mi , allora M accetta Mi .
Linguaggio universale, riduzioni, e teorema di Rice
Lne non e’ ricorsivo
Lne = {M|L(M) 6= ∅}
Lo dimostriamo dando una riduzione da Lu a Lne . Visto cheLu non e’ ricorsivo, non lo puo’ essere neanche Lne .
Per la riduzione, dobbiamo convertire ogni coppia (M,w) taleche w ∈ L(M) in una MdT M ′ tale che w ∈ L(M) se e solo seL(M ′) 6= ∅
M ′ e’ una MdT che (ignora il suo input e) simula M su w. SeM accetta w, allora M’ accetta il suo input. Quindi L(M’) none’ vuoto. Se M non accetta w, allora M’ non accetta nessuninput. Quindi L(M’) e’ vuoto.
Linguaggio universale, riduzioni, e teorema di Rice
Le non e’ RE
Le = {M|L(M) = ∅}
Dato che Lne non e’ ricorsivo, e che Le e’ il complemento diLne , Le non puo’ essere ricorsivamente enumerabile.
Se lo fosse, allora sarebbero entrambi ricorsivi.
Linguaggio universale, riduzioni, e teorema di Rice
Proprieta’ dei linguaggi
Tulle le proprieta’ non banali di una TM (cioe’ dei linguaggiRE) sono indecibili.
Esempio: essere un linguaggio libero dal contesto. Controllarese una TM accetta un linguaggio libero dal contesto e’indecidibile.
Proprieta’ dei linguaggi RE: insieme di linguaggi RE.
Proprieta’ banale: se viene soddisfatta da tutti i linguaggi oda nessuno.
Se P e’ una proprieta’ di linguaggi, il linguaggio LP e’l’insieme dei codici delle TM Mi tali che L(Mi ) e’ unlinguaggio in P. P e’ decidibile se LP e’ decidibile.
Linguaggio universale, riduzioni, e teorema di Rice
Teorema di Rice
Ogni proprieta’ non banale dei linguaggi RE e’ indecidibile.
Prova:
Sia P una proprieta’ non banale i dei linguaggi RE.
Allora deve esistere un linguaggio RE L che abbia la proprieta’P. Sia ML una TM che accetta L.
Ridurremo Lu a LP , dimostrando che LP e’ indecidibile, datoche Lu e’ indecidibile.
Input alla riduzione: coppia (M,w). Output: una TM M ′. M ′
e’ tale che L(M ′) = ∅ se M non accetta w , e L(M ′) = L se M
accetta w .
M ′ simula M su w . Se M non accetta w , M ′ non accettanessuna stringa x in input. Se M accetta w , M ′ simula ML sux , percio’ accettera’ esattamente L. Dato che L ha laproprieta’ P, M ′ e’ in LP .
Linguaggio universale, riduzioni, e teorema di Rice
Esempi di problemi indecidibili
Tutti i problemi sulle TM che riguardano i linguaggi accettati sonoindecidibili.Esempi:Il linguaggio accettato da una TM e’ vuoto?Il linguaggio accettato da una TM e’ finito?Il linguaggio accettato da una TM e’ regolare?Il linguaggio accettato da una TM e’ libero dal contesto?Il linguaggio accettato da una TM contiene la stringa ab?Il linguaggio accettato da una TM contiene tutti i numeri pari?
Linguaggio universale, riduzioni, e teorema di Rice
Non tutto e’ indecidibile
Problemi che riguardano gli stati di una TM, e non il linguaggioaccettato, possono essere decidibili.Esempi:Se una TM ha cinque stati.Se esiste un input tale che una TM faccia almeno cinque passiprima di fermarsi.Se una TM esegue una certa transizione.Se una TM passa per lo stato p.Se una TM non passa mai per lo stato p.Se una TM passa dallo stato p allo stato q in al piu’ tre passi.
Linguaggio universale, riduzioni, e teorema di Rice
Problemi intrattabili, classi P e NP
Problemi intrattabili, classi P e NP
Problemi intrattabili
Ci occuperemo solo di problemi decidibili, cioe’ ricorsivi.
Tra loro, alcuni sono detti trattabili, se si puo’ provare chesono risolvibili in tempo polinomiale in modo deterministico.
Gli altri sono detti intrattabili.
Problemi intrattabili, classi P e NP
Classe P
Una Tm M ha complessita’ in tempo T(n) se, dato un inputw di lunghezza n, M si ferma dopo al massimo T (n) passi.
Esempi: T (n) = 5n2 + 3n, o T (n) = 4n + 3n2
Un linguaggio L e’ nella classe P se esiste un polinomio T (n)tale che L = L(M) per una TM deterministica M concomplessita’ in tempo T (n).
Se la complessita’ non e’ polinomiale, si dice che e’esponenziale, anche se T (n) non e’ un esponenziale.
Esempio: T (n) = nlog2n. Cresce piu’ velocemente diqualunque polinomio, ma piu’ lentamente di qualunqueesponenziale 2cn
Problemi intrattabili, classi P e NP
Esempio di problema in P
Problema: trovare un albero di copertura di peso minimo inun grafo.
Grafo: nodi, archi con peso (intero).
Albero di copertura: sottoinsieme degli archi che connettatutti i nodi senza cicli.
Peso minimo: se il peso totale dei suoi archi e’ minimo fratutti gli alberi di copertura.
Problemi intrattabili, classi P e NP
Algoritmo di Kruskal
Componente connessa di un nodo: nodi raggiungibili da luicon gli archi selezionati finora.
All’inizio: nessun arco, quindi ogni nodo e’ una componenteconnessa da solo.
Ad ogni passo, si considera un altro arco, di peso minimo: seunisce due nodi in componenti separate, lo scelgo e unisco lecomponenti, altrimenti non lo scelgo (creerebbe un ciclo).
Finche’ tutti gli archi sono stati esaminati, o il numero degliarchi scelti e’ uguale al numero dei nodi meno 1 (tutticonnessi).
Problemi intrattabili, classi P e NP
Complessita’ in tempo
Se m nodi e e archi, tempo O(e(e +m)):
Ad ogni passo, in tempo O(e) scelgo un arco, in tempo O(m)riunisco due componenti. Ci sono al massino e passi.
Quindi ha una complessita’ in tempo polinomiale.
Problemi intrattabili, classi P e NP
Classe NP
Un linguaggio L e’ nella classe NP (non deterministicapolinomiale) se esiste una TM non deterministica M tale cheL = L(M) e, quando M ha un input lungo n, al massimo faT (n) mosse con T (n) polinomio.
Dato che ogni TM deterministica e’ una TMnon-deterministica, allora P ⊆ NP .
Una TM non deterministica polinomiale puo’ esaminare unnumero esponenziale di strade ”in parallelo”. Quindi sembrache sia impossibile che P = NP . Ma nessuno lo ha maiprovato.
Problemi intrattabili, classi P e NP
Algoritmo non-deterministico con tempo polinomiale
prima fase (non deterministica): genero una stringa
seconda fase: controllo se la stringa appartiene al linguaggio(algoritmo deterministico con tempo polinomiale)
Problemi intrattabili, classi P e NP
Problema del commesso viaggiatore (TSP)
Input: grafo con pesi interi sugli archi + limite di peso W .
Problema: se il grafo ha un circuito Hamiltoniano di pesototale al massimo W .
Circuito Hamiltoniano: insieme di archi che connettono i nodiin un unico ciclo in cui ogni nodo appare una sola volta.
In un grafo di m nodi, il numero di cicli distinti cresce come ilfattoriale di m, che cresce piu’ di 2cm.
Qualunque algoritmo di soluzione sembra dover esaminaretutti (o un numero esponenziale) di cicli e calcolare il loropeso totale.
Con un computer non-deterministico, potremmo scegliere inogni ramo una permutazione dei nodi e calcolare il suo peso intempo polinomiale. Quindi il problema e’ in NP.
Problemi intrattabili, classi P e NP
Riduzioni polinomiali
Stesso concetto delle riduzioni gia’ viste, solo con l’aggiuntadel vincolo che deve essere fatta in tempo polinomiale
Riduzione: da una istanza (stringa accettata) di P1 ad una diP2
Se P1 e’ riducibile a P2: se P2 e’ in P, allora lo e’ anche P1.Se P1 non e’ in P, neanche P2 lo e’.
Intuizione: P2 e’ difficile almeno tanto quanto P1.
Problemi intrattabili, classi P e NP
Problemi NP-completi
Un linguaggio L e’ NP-completo se
e’ in NPper ogni altro linguaggio L′ in NP, esiste una riduzionepolinomiale di L′ a L.
Esempio: problema del commesso viaggiatore.
Sono i problemi piu’ difficili tra quelli in NP.
Teorema 10.4: Se P1 e’ NP-completo e P2 e’ in NP, e possoridurre polinomialmente P1 a P2, allora P2 e’ NP-completo.Prova: la riduzione polinomiale e’ transitiva.
Teorema 10.5: Se un problema NP-completo e’ in P, alloraP=NP.
Problemi intrattabili, classi P e NP
Problemi NP-ardui
Un problema e’ NP-arduo se ogni problema in NP e’ riducibilepolinomialmente a lui.
Non e’ detto che sia in NP.
Quindi potrebbe anche non avere un algoritmonon-deterministico polinomiale (se non e’ in NP).
Problemi intrattabili, classi P e NP
Il problema della soddisfacibilita’
Espressioni Booleane:
variabili a due valori: 1 (vero) e 0 (falso)
operatori binari ∧ (and logico) e ∨ (or logico)
operatore unario ¬ (negazione logica)
parentesi per raggruppare
Esempio: x ∧ ¬(y ∨ z)
Problemi intrattabili, classi P e NP
SAT
Un assegnamento T di valori alle variabili soddisfal’espressione Booleana E se il valore di E (cioe’ E (T )) e’ 1(vero).
E e’ soddisfacibile se esiste almeno un T tale che E (T ) = 1.
Esempio: x ∧ ¬(y ∨ z) e’ soddisfacibile (x=1,y=0,z=0)
Esempio: x ∧ (¬x ∨ y) ∧ ¬y non e’ soddisfacibile
Problema (SAT): data E , e’ soddisfacibile?
Linguaggio: insieme delle espressioni Booleane soddisfacibili.
Problemi intrattabili, classi P e NP
Codifica di SAT
Da un problema SAT ad una stringa su un alfabeto.
Alfabeto: {∧,∨,¬, (, ), 0, 1, x}
0 e 1 servono per rappresentare l’indice di una variabile.
Esempio: x1 ∧ ¬(x2 ∨ x3) diventa x1 ∧ ¬(x10 ∨ x11).
Se E ha m variabili, la codifica ha O(mlogm) simboli.
Problemi intrattabili, classi P e NP
Teorema di Cook (1971): SAT e’ NP-completo
Prima parte: SAT e’ in NP.
Basta prendere una TM non-deterministica che genera tuttigli assegnamenti in parallelo (2n se n variabili).
Per ogni assegnamento, controlla se e’ soddisfacibile (intempo polinomiale).
Quindi esiste una TM non-deterministica polinomiale cherisolve SAT.
Seconda parte: Dato un qualunque L in NP, esiste unariduzione polinomiale da L a SAT.
Problemi intrattabili, classi P e NP
Forme normali
Letterale: variabile o variabile negata. Es.: x , ¬y .
Clausola: OR di piu’ letterali. Es.: x , x ∨ ¬y .
Forma normale congiuntiva (CNF): AND di una o piu’clausole. Es.: (x ∨ y) ∧ (¬x ∨ z).
k-CNF: se le clausole hanno k letterali.
CSAT: una data espressione Booleana in CNF e’soddisfacibile?
kSAT: una data espressione Booleana in k-CNF e’soddisfacibile?
CSAT, 3SAT e kSAT per k ≥ 3 sono NP-completi. Algoritmilineari per 1SAT e 2SAT.
Problemi intrattabili, classi P e NP
Riduzioni
Da espressione Booleana a CNF in tempo polinomiale ⇒CSAT e’ NP-completo.
Da CSAT a 3SAT in tempo lineare ⇒ 3SAT e’ NP-completo.
Problemi intrattabili, classi P e NP
Da CSAT a 3SAT
CNF: e1 ∧ e2 ∧ . . . ∧ ek
Se ei = x , due nuove variabili u e v , e sostituiamo x con(x ∨ u ∨ v) ∧ (x ∨ u ∨ ¬v) ∧ (x ∨ ¬u ∨ v) ∧ (x ∨ ¬u ∨ ¬v)
Se ei = (x ∨ y), nuova variabile z e sostituiamo ei con(x ∨ y ∨ z) ∧ (x ∨ y ∨ ¬z).
Se ei = (x1 ∨ . . . ∨ xm) con m ≥ 4, nuove variabiliy1, y2, . . . , ym−3, e sostituiamo ei con (x1 ∨ x2 ∨ y1) ∧ (x3 ∨¬y1 ∨ y2)∧ . . . (xm−2 ∨¬ym−4∨ ym−3)∧ (xm−1 ∨ xm ∨¬ym−3).
Se xj vera, settiamo y1, · · · , yj−2 vere e yj−1, yj+1, · · · , ym−3
falseSe tutte le x sono false, non e’ possibile rendere vere m − 2clausole con m − 3 variabili (le y)
Problemi intrattabili, classi P e NP
2SAT e’ in P
Prendiamo una variabile x e diamo valore 1 (vero)
In ogni clausola con ¬x , l’altro letterale deve essere vero
Esempio: in (¬x ∨ ¬y), y deve essere falso (0)
Continuiamo settando le variabili il cui valore e’ ”forzato”
Problemi intrattabili, classi P e NP
Finche’ ...
Puo’ succedere una di tre cose:1 una contraddizione: una variabile forzata ad essere sia vera che
falsa2 tutte le variabili con valore forzato sono state settate, ma
ancora ci sono clausole non soddisfatte3 si ottiene un assegnamento che da’ valore vero all’espressione
Problemi intrattabili, classi P e NP
Caso 1 e 3
Caso 1: ci puo’ essere un assegnamento che da’ valore verosolo con l’altro valore per la variabile x. Ricominciamo conl’altro valore per x.
Caso 2: ci sono ancora variabili e clausole che non sonosettate. Eliminiamo le clausole soddisfatte, e ripartiamo.
Caso 3: la risposta e’ ”si” (trovato un assegnamento chesoddisfa l’espressione).
Problemi intrattabili, classi P e NP
Problema degli insiemi indipendenti (IS)
Insiemi indipendenti (IS): dato un grafo, esiste un insiemeindipendente di dimensione almeno k?
Insieme indipendente = sottoinsieme I di nodi di G dovenessuna coppia di nodi di I e’ collegata da un arco di G.
Riduzione polinomiale da 3SAT a IS: da un’espressione E in3-CNF con m clausole ad un grafo G tale che E soddisfacibilese e solo se G ha un insieme indipendente di dimensione m.
Problemi intrattabili, classi P e NP
Da 3SAT a IS
Se E = e1 ∧ e2 ∧ . . . ∧ em, construisco un grafo con 3m nodi.
Ogni nodo [i , j] rappresenta il j-esimo letterale di ei .
Arco tra [i , j] e [i , k] (diversi letterali della stessa clausola): unsolo nodo per clausola.
Arco tra [i1, j1] e [i2, j2] se uno rappresenta x e l’altro ¬x .
Limite = m.
Da insieme indipendente con m nodi ad assegnamento chesoddisfa E .
Da assegnamento che soddisfa E ad insieme indipendente didimensione m.
Problemi intrattabili, classi P e NP
Problema della copertura per nodi (NC)
Copertura per archi di un grafo: insieme di archi tale che ogninodo e’ toccato da almeno un arco. Copertura minimale seogni altra copertura ha piu’ archi.
Se un grafo ha una copertura per archi di k elementi:polinomiale.
Copertura per nodi (NC): insieme di nodi che contiene almenoun estremo di ogni arco.
Se un grafo ha una copertura per nodi con non piu’ di k nodi:NP-completo.
Riduzione da IS a NC: il complemento di un insiemeindipendente e’ una copertura per nodi, e viceversa.
Problemi intrattabili, classi P e NP
Problema del circuito Hamiltoniano (HC)
Problema: se un grafo ha un circuito Hamiltoniano.
HC caso speciale di TSP, con pesi tutti a 1 ⇒ facile ridurreHC a TSP in tempo polinomiale.
DHC: HC con archi orientati.
DHC e’ NP-completo: riduzione 3SAT a DHC.
HC e’ NP-completo: riduzione da DHC a HC.
TSP e’ NP-completo: riduzione da HC a TSP.
Problemi intrattabili, classi P e NP
Riduzione da DHC a HC
Da Gd (grafo orientato) a Gu (grafo non orientato)
Nodo v di Gd ⇒ 3 nodi v0, v1, v2
Archi:
∀v di Gd , archi (v0, v1) e (v1
, v2)arco v → w ⇒ arco (v2
,w 0)
Gu ha un circuito Hamiltoniano sse Gd ha un circuitoHamiltoniano orientato
Prova:
Se v1, . . . , vn, v1 circuito Hamiltoniano orientato di Gd , allorav01 , v
11 , v
21 , v
02 , v
12 , v
22 , . . . , v
01 circuito Hamiltoniano di Gu
v1i ha solo 2 nodi adiacenti (v2
i e v0i ), quindi uno lo deve
precedere e uno lo deve seguire in un circuito Hamiltoniano ⇒
schema 012012...0 oppure 210210...2 ⇒ circuito Hamiltonianoorientato di Gd fatto con gli archi corrispondenti a v → w ow → v
Problemi intrattabili, classi P e NP
Riduzione da HC a TSP
Da grafo G a grafo pesato G ′
Stessi archi e nodi di G
Peso 1 su tutti gli archi
Limite k = numero n di nodi di G
G ′ ha un circuito Hamiltoniano di peso n sse G ha un circuitoHamiltoniano
Problemi intrattabili, classi P e NP
Complemento
Se un problema e’ in P, anche il suo complemento e’ in P
Prendiamo l’algoritmo deterministico polinomiale e scambiamoil ”si” con il ”no” (stati finali con stati non finali, e viceversa)
Se un problema e’ in NP, non sappiamo se il suocomplemento e’ in NP in generale
Co-NP: linguaggi i cui complementi sono in NP
Si pensa che nessun problema NP-completo abbia ilcomplemento in NP, quindi che nessun problemaNP-completo sia in co-NP
Se P = NP, allora Co-NP = NP
Problemi intrattabili, classi P e NP
Esempio: SAT
Il complemento di SAT (tutte le espressioni Booleane che nonsono soddisfacibili, piu’ le stringhe che non sono espressioniBooleane) sembra non essere in NP
Possiamo considerare (non-deterministicamente) unassegnamento alle variabili e controllare in tempo polinomialese soddisfa l’espressione
Se devo dimostrare che non c’e’ nessun assegnamento chesoddisfa l’espressione, devo guardare tutti gli assegnamenti
Problemi intrattabili, classi P e NP