75
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 lezione Ricevimento: 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 e uno alla fine. Possono sostituire lo scritto. Esame: Scritto e, se richiesto dal docente, colloquio orale. Cinque appelli: due a fine corso (Dicembre-Gennaio), uno alla fine del II trimestre (Aprile), uno a Luglio, uno a Settembre. I lucidi per i capitoli 1-7 del libro principale sono basati sui lucidi in inglese di G¨ osta 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.4 ALC) 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 descrivere calcoli e computazioni Per eseguire un programma, deve essere tradotto in una forma che puo’ essere capita da un calcolatore compilatore Principi e tecniche utili non solo per costruire compilatori, ma in molte altre aree dell’informatica: linguaggi di programmazione, architettura, teoria dei linguaggi, algoritmi, ingegneria del software, ecc. Docente: Francesca Rossi Automi e Linguaggi Formali

Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

  • Upload
    ngomien

  • View
    218

  • Download
    0

Embed Size (px)

Citation preview

Page 1: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

Page 2: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

Page 3: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

Page 4: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

Page 5: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

Page 6: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

Page 7: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

Page 8: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

Page 9: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

Page 10: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

Page 11: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

Page 12: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

Page 13: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

Page 14: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

Page 15: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

Page 16: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

Page 17: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

Page 18: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

Page 19: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

Page 20: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

Page 21: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

Page 22: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

Page 23: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

Page 24: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

Page 25: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

Page 26: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

Page 27: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

Page 28: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

Page 29: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

Page 30: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

*

*

*

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

Page 31: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

Page 32: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

Page 33: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

Page 34: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

Page 35: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

Page 36: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

Page 37: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

Page 38: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

Page 39: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

Page 40: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

Page 41: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

Page 42: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

Page 43: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

Page 44: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

��������� ���������

+ 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

Page 45: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

���������� ������ ����������� ��

#� �� ������� ���������� �

����� �� ����������� �������� β ��� ����$→ β � �� ���������

�������� ����� β%����� ������������ �� β ���$����

������ �&�#��������� ����� ��������� ������������ � ���� �� ������ �

��������

� '������ � ����� ��� �� �� � ������������!���( )� � ����������� ������

( �* ��������� �� �

� + ����� �* ����������������� β � ��* $→ β � �� ��������� * ��������� ������ ��� ����� ���� ���� � ���� ��� ������ ��������

� ,�� ��� ������������ ���� �������� * ���������� �� ������� ����� ��������� ����� ���� �� � �����

�������������

� #� αβω � ������� ����� ��� �� ���� ������������!��

� -����� �� * � �������� �������� �� � �� �� ��� � ���������� $→ β

� -���� ω � �� ������ �������� ��%���*�α$ω → αβω � ���� ��� ����� ���� ���� � ����

�������

� � ��'����� � ������� �����������������*( " ������������ ������� �� ��� ��� � ��� � ��� ������ �������� ����

( " ������������ ���������� * ������ �� ����!����� �� �� ��� �� �� ��� �

� ������� ����������� � � � �� � ����( ��������� ������� � ������ ������

� ���� ����%������ ������� � ����� ��� ���

�./.0 1�1�1�.�

��������� ��� !�"��#�����$���%������#������$

��� ������������!����� ���������������� ������

#*�����������

2����������

!�"�

� #*�����+��� � ����������� ���������

� #���� �������� � ��� ������ ���������� ( "�� �������� � ������� ���� ���

-3��.4� � -3�.�4��

Page 46: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

%�����

� -���� ��� ��������� ����� ��� � ������ ����� ������ ���������� ( 2���� �� �� ������ �������� �� ����� �� ��� ���� �� ���������� ����� ���������

� #�-�→ .4�� �� ���������%� ���� �

��.4��56��� ��-��56�

&������� ������������������ !�"� %�����

������→ ������������

�*�������� ���

�*�������� �����������

�*���������������������

�*�������������������

���

������→ ������������

������→ ��������

�*������ �����

������→ ���������������� �����

������→ ������������ � �����

����������� #'$

+ int*int int

����������������

����������� #($

+ int*int int

����� �����������

����������������

����������� #)$

+ int*int int

����� �����������

������������������

����������������

����������� #*$

+ int*int int

����� �����������

������������������

����������������

��������� � �����

Page 47: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

����������� #+$

+ 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

���������

����� ���

����� �����������

������������������

����������������

�������

�������

��� �����

��������� �����

��������� � �����

Page 48: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

����������� #''$

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

Page 49: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

��������

� ����������<���� �� ������ ��������� ������ ����� ��� ��� ������� ���� �������������� �

� 9���� �� �� ���� ���� � ���� ��

#�→��α$ω → αβω

� -���� αβ � �� � ����� ���αβω

36

�������� ������

������ �������*���!���%���� ����� �� �������������� �� ��� %�� � �� ����

37

����!���

� ������� ������ � ��� ����� ���� ��� ������������

� -��������� � ���%��� ���� � ����

� '��� ���������� �� � ����� ( ���������� � ���� ����� � ����� �� ���

( " �������� � ����� �� ��� �� ���� ����������� � ���� ����� %���*� � �� ���� ���� � ����

( " ��:��� ������� �*����� ������ � �������� � �����

38

����� ����� ��������

� ������ �������*���!���%���� ����� �� ���� ���� ����� �� ���

� "�� ����� �������� � � �� ������� ����������� � ���� �����

� )����� ��������� �� � � ����� ������������ �� ������� �

� ;�� �������� ���� ������������!����� � � �� �������������� ��� � �����

39

%�������� �����������

� ,���� ���� �������� ������� ���������� ��� �����

� #����������� � ��� ������* * � ������������ � :� �� �������� ��� � �����

� 9�� ��� �� �� ��*%���������*������� �� ���� ����� ���

� 9����������* * �����%��� �� �� ����� �� ��* #2"

40

2�������

Prof. Aiken CS 143 Lecture 8 41

-����=;�

7� ����������=;�

#"2��=;�

>������� ��������

Page 50: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

��������&%#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

Page 51: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

����

� #���� *� � �� ?����"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

Page 52: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

������

� ;� �� �� ��� � ���� ���������� ����=���==�� ��������

�&�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�

Page 53: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

�������� ������� ���������� ��������&%#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

Page 54: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

��������� ������� ��� ���������!�"� �������

� +��� �� ��� �� �� � ������� ����� ��� ���������� �� ����� �

� #������ �� * � ������� γ ���������� ��� �� �� �� ���� �� ���� � ��� �� �� ����� � ������� �� 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�ω

( �:��� ��� �����* � * ��� �� ���������*�� � �

Page 55: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

( ��∈ =����>�$�

Page 56: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

&%���������#���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

Page 57: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

��"���������;��� <����=

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

//

Page 58: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

��"������������ <�; ���=

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

//

Page 59: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

��"������������ <����;=

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

//

Page 60: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

&%��:�����

�������� ���� '=-�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

Page 61: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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�� ���� ���

Page 62: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

������������ �����

� ��� ��� �%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

Page 63: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

&��� ����

� 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

Page 64: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

Page 65: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

− 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

Page 66: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

Page 67: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

Page 68: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

Page 69: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

Page 70: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

Page 71: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

Page 72: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

Page 73: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

Page 74: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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

Page 75: Docente: FrancescaRossi AutomieLinguaggiFormali · Pumping lemma per linguaggi liberi da contesto (cap.7 ALC) Macchine di Turing, problemi ricorsivamente enumerabili (cap.8 ALC) Riduzioni

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