Slides CC PDF

Linguaggio: un insieme di stringhe
Stringa: una sequenza di simboli da un

alfabeto
Linguaggi Esempio:
Stringhe: gatto, cane, casa
Linguaggio: {gatto, cane, casa}
Alfabeto:   a, b, c,, z
15/08/20 1 15/08/20 2
Linguaggi sono usati per descrivere Alfabeti e Stringe

problemi di calcolo: Un alfabeto è un insieme di simboli
Esempio Alfabeto:   a, b
PRIMI  {2,3,5,7,11,13,17, }
Una stringa è una sequenza di
simboli da un alfabeto
Pari  {0,2,4,6,}
a
Esempio Stringhe u  ab
ab
v  bbbaaa
Alfabeto:   { 0,1,2, ,9} abba
w  abba
aaabbbaabab
15/08/20 3 15/08/20 4
Alfabeto dei numeri decimali Alfabeto dei numeri unari   {1}
  { 0,1,2, ,9}
Numeri unari : 11 111 1111 11111
102345 567463386
Numeri decimali: 1 2 3 4
Alfabeto dei numeri binari   { 0,1} Zero?
100010001 101101111
15/08/20 5 15/08/20 6
Operazioni su stringhe
w  a1a2  an abba
w  a1a2  an ababaaabbb
v  b1b2 bm bbbaaa
Concatenazione Inverso
wv  a1a2  anb1b2 bm abbabbbaaa w R  an a2a1 bbbaaababa
15/08/20 7 15/08/20 8
Lunghezza di una stringa Lunghezza della concatenazine
w  a1a2  an uv  u  v
Lunghezza: w n
Esempio: u  aab, u  3
v  abaab, v  5
Esempi: abba  4
aa  2
uv  aababaab  8
a 1
uv  u  v  3  5  8
15/08/20 9 15/08/20 10
Stringa vuota Sottostringa

Una stringa con nessuna lettera è denotata: Sottostringa di una stringa:
 o Una sequenza consecutiva di caratteri:
Osservaziones: Stringa Sottostringa

 0 abbab ab
abbab abba
w  w   w
abbab b
abba  abba  abba  abba abbab bbab
15/08/20 11 15/08/20 12
Prefisso e Suffisso Altre operazioni
abbab wn  
ww w
Prefisso Suffisso
 

n
 abbab w  uv
bbab Esempio: abba 2  abbaabba
a
Prefisso
ab bab
Suffisso
0
abb ab Definizione: w 
abba b
abba 0  
abbab 
15/08/20 13 15/08/20 14
L’operazione * L’operazione +
 * : L’insieme di tutte le possibili stringe che   : L’insieme di tutte le possibili stringe che
è possibile generare a partire dall’alfabeto è possibile generare a partire dall’alfabeto 
 eccetto 
  a, b   a, b
*   , a, b, aa, ab, ba, bb, aaa, aab, *   , a, b, aa, ab, ba, bb, aaa, aab,
    * 
   a, b, aa, ab, ba, bb, aaa, aab,
15/08/20 15 15/08/20 16
Linguaggi. estensionali Esempi di linguaggi
Un linguaggio su un alfabeto 
Alfabeto   {a , b }
È un qualsiasi sottoinsieme di *
Esempio: Un linguaggio infinito L  {a nb n : n  0}
  a, b
*   , a, b, aa, ab, ba, bb, aaa, 
linguaggio :  ab abb  L
L
linguaggio : a, aa, aab aabb
linguaggio : { , abba, baba, aa, ab, aaaaaa} aaaaabbbbb
15/08/20 17 15/08/20 18
Numeri primi Numeri pari e dispari
alfabeto   { 0,1,2, ,9} alfabeto   { 0,1,2, ,9}

Linguaggio:
EVEN  {x : x  * e x è pari}
PRIMES  {x : x   * and x is prime} EVEN  { 0,2,4,6, }
PRIMES  {2,3,5,7,11,13,17,} ODD  {x : x  * e x è dispari}

ODD  {1,3,5,7, }
15/08/20 19 15/08/20 20
Somma unaria Radici
alfabeto:   {1,, } Alfabeto:   {1, # }

Linguaggio: Linguaggio:
ADDITION  {x  y  z : x  1n , y  1m , z  1k , SQUARES  {x # y : x  1n , y  1m , m  n 2 }
nm k}
11  111  11111  ADDITION 11#1111  SQUARES

111  111  111  ADDITION 111#1111  SQUARES
15/08/20 21 15/08/20 22
Nota che : Operazioni sui linguaggi

Le stesse degli insiemi
Insieme vuoto   { }  { } a, ab, aaaa  bb, ab  {a, ab, bb, aaaa}
Dimensione insiemi
a, ab, aaaa  bb, ab  {ab}
{}    0 {}  1 a, ab, aaaa  bb, ab  a, aaaa
Lunghezza di una stringa Complemento: L   * L
 0 a, ba   , b, aa, ab, bb, aaa,

15/08/20 23 15/08/20 24
Inverso Concatenazione
Definizione: LR  {w R : w  L} Definizione: L1L2  xy : x  L1, y  L2 
Esempio: ab, aab, babaR  ba, baa, abab
L  {a nb n : n  0} Esempio: a, ab, bab, aa
 ab, aaa, abb, abaa, bab, baaa

LR  {b n a n : n  0}
15/08/20 25 15/08/20 26
Altre operazioni
Definizione: Ln   
LL L
n L  {a nb n : n  0}
a, b3  a, ba, ba, b 
aaa, aab, aba, abb, baa, bab, bba, bbb L2  {a nb n a mb m : n, m  0}
0
Casi speciale: L  
aabbaaabbb L2
a , bba , aaa 0  
15/08/20 27 15/08/20 28
Star-Closure-intensione (Kleene *) Chiusure
Tutte le stringhe che possono essere costruite
da L Definizione: L  L1  L2  
L*  L0  L1  L2 
Definizione: Lo stesso come L* without the 
Esempio:  , 
a, bb,  a, bb, 
 
a, bb*  
 aa , abb , bba , bbbb ,


a, bb  aa, abb, bba, bbbb, 

aaa, aabb, abba, abbbb, aaa, aabb, abba, abbbb,
 
15/08/20 29 15/08/20 30
Deterministic Finite Automaton (DFA)
Input Tape
Deterministic stringa
Output
Finite Automata “accettato ”
Finite
or
Automaton
E linguaggi regolari “rigettato”
Simulatore http://www.jflap.org/
15/08/20 1 15/08/20 2
testa Configurazione iniziale Analizzare l’Input

Input Tape
a b b a a b b a
Input String
a, b a, b
q5 q5
a, b a, b
b a a b b a a b
q0 a q1 b q2 b q3 a q4 q0 a q1 b q2 b q3 a q4
Stato iniziale
15/08/20 3 15/08/20 4
a b b a a b b a
a, b a, b
q5 q5
a, b a, b
b a a b b a a b
15/08/20 5 15/08/20 6
Input finito Un caso rigettato
a b b a a b a
Input String
a, b a, b
q5 q5
a, b a, b
b a a b b a a b
accettato
15/08/20 7 15/08/20 8
a b a a b a
a, b a, b
q5 q5
a, b a, b
b a a b b a a b
15/08/20 9 15/08/20 10
Un altro caso rigettato

Input finito
Nastro vuoto
a b a ( )
Input finito
a, b a, b
reject
q5 q5
a, b a, b
b a a b b a a b
rigettato
15/08/20 11 15/08/20 12
Linguaggio accettato: L  abba  Per accettare una stringa :
Devono essere esaminati tutti i caratteri di

Input e l’ultimo stato è uno stato finale
a, b
q5
Per rigettare una stringa :
a, b
b a a b
q0 a q1 b q2 b q3 a q4 Tutti i caratteri di input sono stati esaminati
E non si è raggiunto uno stato finale
15/08/20 13 15/08/20 14
Un altro esempio
Language Accepted: L  {a n b : n  0 }
a a, b a a, b
b a, b b a, b
q0 q1 q2 q0 q1 q2
Stato trap state

finale
15/08/20 15 15/08/20 16
Un altro esempio Definizione formale
un automa deterministico formale(DFA)
Alfabeto:   {1}
1
M  Q, ,  , q0 , F 
Q : insieme degli stati
q0 q1
1
 : alfabeto di input   
Linguaggio accettato:
 : funzione di transizione
q0 : stato iniziale
EVEN  {x : x   * and x is even}
 { , 11, 1111, 111111, } F : insieme degli stati di accettazione
15/08/20 17 15/08/20 (finale) 18
Insieme degli stati Q Alfabeto di input 

esempio   :l’alfabeto di input non contene 
Q  q0 , q1, q2 , q3 , q4 , q5  esempio
a, b   a, b a, b
q5 q5
a, b a, b
b a a b b a a b
15/08/20 19 15/08/20 20
Stato iniziale q0 Insieme stati finali F Q
esempio esempio
a, b F  q4  a, b
q5 q5
a, b a, b
b a a b b a a b
15/08/20 21 15/08/20 22
Funzione di transizione
 :Q  Q
esempio:
 q0 , a   q1
 ( q, x )  q
x a, b
q q
q5
Descrive il risultato della a a, b
b a b
Transizione dallo stato q q0 a q1 b q2 b q3 a q4
Con simbolo x
15/08/20 23 15/08/20 24
 q0 , b   q5  q2 , b   q3
a, b a, b
q5 q5
a a, b a a, b
b a b b a b
15/08/20 25 15/08/20 26
Tavola di transizione per  Funzione estesa di transizione

symbols
 * : Q  *  Q
 a b
q0 q1 q5
q1 q5 q2  * (q ,w )  q 
states
q2 q5 q3
a, b
q3 q4 q5
q4 q5 q5 Descrive lo stato che risulta dopo aver
q5
q5 q5 q5 Esaminata la stringa w
a a, b
b a b a partire dallo stato q
q0 a q1 b q2 b q3 a q4
15/08/20 27 15/08/20 28
esempio:  * q0 , ab   q2  * q0 , abbbaa   q5
a, b
a, b
q5
q5
a a, b
a, b b a b
b a a b q0 a q1 b q2 b q3 a q4
15/08/20 29 15/08/20 30
Caso speciale:
 * q1 , bba   q4 Delta*(q, aw)=Delta*(delta(q,a), w);

Delta*(q, Lambda)=q
a, b
Per ogni stato q
q5
a, b
 * q ,    q
b a a b
15/08/20 31 15/08/20 32
:  * q ,w   q 
Implica che vi è un cammino di transizione

Complessità costante sull’input
w   1 2  k
1 2 k
q q
Alcuni stati possono essere ripeturi
q w q
15/08/20 33 15/08/20 34
Deterministic Finite Automaton (DFA) U(automa, input)=automa(input)

symbols
Input Tape  a b
stringa q0 q1 q5
Output
q1 q5 q2 
“accettato ” states q2 q5 q3
a, b
Finite q3 q4 q5
or
Automaton q4 q5 q5
“rigettato” q5
q5 q5 q5 a, b
b a a b
15/08/20 35 15/08/20 36
Linguaggio accettato da un DFA
Per un DFA M  Q, ,  , q0 , F 
Linguaggio di un DFA: M
È denotato come L M  Il linguaggio accettato da M:
E contiene tutte le stringhe
Accettate da M 
L M   w   * :  * q0 ,w   F 
Un linguaggio L 
È accettato (o riconosciuto) q0 w q q  F
Da un DFA M se L M    L
15/08/20 37 15/08/20 38
DFA esempi
Linguaggio rifiutato da M :   {a , b }
a, b

L M   w   :  q0 ,w   F
* *
 a, b
w q0 q0
q0 q q  F
L (M )  { } L (M )   *
Linguaggio vuoto Tutte le stringhe
15/08/20 39 15/08/20 40
  {a , b } L M  = { tutte le stringhe binarie
che contengono
a, b
la sottostringa 001 }
0,1
1 0
q0 a, b q0 1
 0 0 00 1 001
L (M )  {  }
Linguaggio che riconosce le 0
15/08/20
Stringa vuota 41 15/08/20 42
L M  = { tutte le stringhe binarie che non

Contengono 001 }

L(M )  awa : w  a , b 
*
 a
b
1 0 b
0,1
q0 a q2 q3
1
0 1 b a
 0 00 001
q4
0
a, b
15/08/20 43 15/08/20 44
Linguaggi regolari Esempi di linguaggi regolari:
Definizione:
abba  , ab, abba
Un linguaggio L è regolare se esiste un
DFA M che lo accetta ( L(M )  L ) {a nb : n  0} awa : w  a , b * 
{ tutte stringhe {a,b}* con prefisso ab }
{ all binary strings without substring 001}
I linguaggi accettati da tutti i DFA formano {x : x  {1} * and x is even}

la famiglia dei linguaggi regolari { } {  } {a , b } *
Abbiamo visto in precedenza gli
automi regolari che li definiscono
15/08/20 45 15/08/20 46
Esitono linguaggi che non sono regolari:
L {a nb n : n  0}
ADDITION  {x  y  z : x  1n , y  1m , z  1k ,
nm k}
Non esiste nessun DFA che accetta

Questo linguaggio (vedremo più avanti)
15/08/20 47
Automa finito deterministico
calcolo finito e deterministico
Non-Deterministic sequenziale, un segmento di lng
Finite Automata dell’input
15/08/20 1 15/08/20 2
Automi non deterministici (NFA)
alfabeto = {a} alfabeto = {a}
q1 a q2 Due scelte q1 a q2
a a
q0 q0
a a
q3 q3
15/08/20 3 15/08/20 4
Prima delle due scelte
alfabeto = {a} a a
Due scelte q1 a q2 finale q1 a q2

a a
q0 q0
a a
q3 Nessuna transizione q3
15/08/20 5 15/08/20 6
Prima scelta Prima scelta
a a a a
Abbiamo consumato tutto l’input
q1 a q2 q1 a q2 “accettato”
a a
q0 q0
a a
q3 q3
15/08/20 7 15/08/20 8
Seconda scelta Seconda scelta
a a a a
Input non può essere tutto usato
q1 a q2 q1 a q2
a a
q0 q0 Automa si ferma
a a
q3 q3 “rigettato”
15/08/20 9 15/08/20 10
un NFA accetta una stringa:

Se esiste una computazione che accetta
la stringa
aa È accettato dal NFA:
Tutta la stringa di input è stata letta e l’automa “accettato”

Si trova in uno stato finale q1 a q2 q1 a q2
a a
q0
a
q0
a
“rigettato”
q3 q3
Perchè la
Computazione Questa computazione
accetta aa è ignorata
15/08/20 11 15/08/20 12
Esempio computazione Prima scelta
che rigettà
a a
“rigettato”
q1 a q2 q1 a q2
a a
q0 q0
a a
q3 q3
15/08/20 13 15/08/20 14
Seconda scelta Seconda scelta
a a
q1 a q2 q1 a q2
a a
q0 q0
a a
q3 q3 “reject”
15/08/20 15 15/08/20 16
Un altro esempio Prima scelta
a a a a a a
q1 a q2 q1 a q2
a a
q0 q0
a a
q3 q3
15/08/20 17 15/08/20 18
First Choice Second Choice
a a a a a a
Input cannot be consumed
q1 a q2 “reject” q1 a q2
a a
q0 q0
a a
Automaton halts
q3 q3
15/08/20 19 15/08/20 20
Second Choice An NFA rejects a string:
Se non vi è una computazione del NFA
a a a che accetta la stringa.
Input non viene tutto consumato
q1 a q2
a Per ogni computazione:
Automaton halts • tutto l’input è consumato e l’automa
q0 • non ha raggiunto uno stato finale
a
q3 “reject” O
• L’input non è stato tutto consumato
15/08/20 21 15/08/20 22
aaa È rigettato dal NFA: Linguaggio accettato: L  {aa}
“rigettato” q1 a q2
q1 a q2 q1 a q2
a a a
q0 q0
a a “rigettato” q0
q3 q3 a
q3
Tutte le possibili computazioni
non raggiungono uno stato finale
15/08/20 23 15/08/20 24
Lambda transizione
a a
q0 a q1  q2 a q3 q0 a q1  q2 a q3
15/08/20 25 15/08/20 26
La testina dell’input non si muove
a a a a
q0 a q1  q2 a q3 q0 a q1  q2 a q3
15/08/20 27 15/08/20 28
Esempio di non accettazione
Tutto l’input è esaminato
(rigettato)
a a a a a
“accettato”
q0 a q1  q2 a q3 q0 a q1  q2 a q3
stringa aa è accettata
15/08/20 29 15/08/20 30
(la testina non si muove)
a a a a a a
q0 a q1  q2 a q3 q0 a q1  q2 a q3
15/08/20 31 15/08/20 32
Input non viene analizato tutto
a a a
Linguaggio accettato: L  {aa}
Automa si ferma
“rigettato”
q0 a q1  q2 a q3 q0 a q1  q2 a q3
stringa aaa è rigettata

15/08/20 33 15/08/20 34
Un altro NFA
Esiste una computazione si a b

Per ogni computazione no
q0 a q1 b q2  q3

15/08/20 35 15/08/20 36
a b a b
“accept”
q0 a q1 b q2  q3 q0 a q1 b q2  q3
 
15/08/20 37 15/08/20 38
Un altra stringa
a b a b a b a b
q0 a q1 b q2  q3 q0 a q1 b q2  q3
 
15/08/20 39 15/08/20 40
a b a b a b a b
q0 a q1 b q2  q3 q0 a q1 b q2  q3
 
15/08/20 41 15/08/20 42
a b a b a b a b
q0 a q1 b q2  q3 q0 a q1 b q2  q3
 
15/08/20 43 15/08/20 44
Linguaggio accettato
a b a b L  ab, abab, ababab, ...

 ab
“accept”
q0 a q1 b q2  q3 q0 a q1 b q2  q3
 
15/08/20 45 15/08/20 46
NFA esempio Remarks:

•Il simbolo  non appare mai
•sul nastro di input
•Semplici automata:
0 M1 M2
q0 q1 0, 1 q2
1 q0 q0
 L(M1 ) = {} L(M 2 ) = {λ}

15/08/20 47 15/08/20 48
Formal Definition of NFAs Funzione di transizione 
M  Q, ,  , q0 , F 
 q , x   q1 , q2 , , qk 
Q : Set of states, i.e. q0 , q1, q2 
q1
: Input aplhabet, i.e. a, b   x Stati risultanti con
: Transition function q x
q1 una transizione
x
con simbolo x
q0 : Initial state
qk
F : Accepting states
15/08/20 49 15/08/20 50
 q0 , 1  q1  (q1,0)  {q0 , q2}
0 0
q0 q1 0, 1 q q0 q1 0, 1 q
2 2
1 1
 
15/08/20 51 15/08/20 52
 (q0 ,  )  {q2 }  (q2 ,1)  
0 0
q0 q1 0, 1 q q0 q1 0, 1 q
2 2
1 1
 
15/08/20 53 15/08/20 54
*
Funzione di transizione estesa 
La stessa cosa  ma applicata a stringhe
 * q0 , aa   q4 , q5 
 * q0 , a   q1 
q4 q5 q4 q5
a a a a
q0 a q1 b q2  q3 q0 a q1 b q2  q3
 
15/08/20 55 15/08/20 56
In generale
q j   * qi ,w  : vi è un cammino da qi a q j
 * q0 , ab   q2 , q3 , q0  con label w
qi w qj
q4 q5
a a
w   1 2  k
q0 a q1 b q2  q3 1 2 k
qi qj

15/08/20 57 15/08/20 58
Grado di non determinismo di un nodo per Grado di non determinismo di un automa, il

ogni nodo il numero di archi con la stessa grado massimo di non determinismo di tutti
label. gli archi.
2 a 2
a
1 1 a 3
a λ
3
a a
4
4
15/08/20 59 15/08/20 60
The Language of an NFA M w m  L M 
Il linguaggio accettato da M è:  * (q0 ,w m )
L M   w 1 ,w 2 ,...wn  qi
wm
q0 w
qk qk  F
dove  * (q0 ,w m )  {qi ,..., qk , , q j } m
wm qj
E vi è un qk  F (stato finale)
15/08/20 61 15/08/20 62
F  q0 ,q5  F  q0 ,q5 

q4 q5 q4 q5
a a a a
q0 a q1 b q2  q3 q0 a q1 b q2  q3
 

 * q0 , aa   q4 , q5  aa  L(M ) 
 * q0 , ab   q2 , q3, q0  ab  LM 
F F
15/08/20 63 15/08/20 64
F  q0 ,q5  F  q0 ,q5 
q4 q5 q4 q5
a a a a
q0 a q1 b q2  q3 q0 a q1 b q2  q3
 

 * q0 , abaa   q4 , q5  aaba  L(M )  * q0 , aba   q1  aba  LM 
F F
15/08/20 65 15/08/20 66
δ*(stato, cW)=
{
q4 q5 delta_*(q,W)
con q elemento dell’insieme {delta(stato, c)}
a a
}
q0 a q1 b q2  q3
q   * q ,   Per ogni stato

L M   ab  *  ab  * {aa }
15/08/20 67 15/08/20 68
1

NFA accettano i linguaggi regolari
2 q   * q,   Per ogni stato
15/08/20 69 15/08/20 70
Equivalenza tra macchine Esempio di macchine equivalenti
NFA M1
Definizione: 0
LM1   {10} *
q0 q1
macchina M1 è equivalente alla macchina M 2 1
se L M 1   L M 2  DFA M2 0,1
0
LM 2   {10} *
q0 q1 1 q2
1
0
15/08/20 71 15/08/20 72
Teorema: dimostrazione: mostreremo
Linguaggi a

Linguaggi
Accettati
Linguaggi
regolari
Accettati  Linguaggi
regolari
da NFA da NFA
Linguaggi AND
Accettati da un Linguaggi a
DFA
Accettati  Linguaggi
regolari
NFA e DFA hanno lo stesso potere di computazione, da NFA
Accettano gli stessi inguaggi.
15/08/20 73 15/08/20 74
Parte prima Parte seconda
Linguaggi a Linguaggi a
Accettati  Linguaggi
regolari
Accettati  Linguaggi
regolari
da NFA da NFA
Ogni nfa può essere tradotto in un nfa
ogni DFA è banalmente un NFA
Ogni linguaggioL accettato da un DFA

Ogni linguaggio L accettato da un NFA
È anche accettato da un NFA
È anche accettato da un DFA
15/08/20 75 15/08/20 76
Conversione da NFA a DFA  * (q0 , a )  {q1 , q2 }
a a
NFA M NFA M
q0 a q1  q2 q0 a q1  q2
b b
DFA M DFA M
q0  q0  a
q1, q2 
15/08/20 77 15/08/20 78
 * (q0 , b )   Insieme vuoto  * (q1 , a )  {q1 , q2 }

M a M a  * (q2 , a )  
NFA NFA
a  a  unione
q0 q1 q2 q0 q1 q2
b b q1, q2 
a
DFA M DFA M
q0  a q0  a
q1, q2  q1, q2 
b b
 trap state 
15/08/20 79 15/08/20 80
 * (q1 , b )  {q0 }
M a  * (q2 , b )  {q0 } M a
NFA NFA
a  unione a 
q0 q1 q2 q0 q1 q2
b q0  b
b a b a
DFA M DFA M
q0  a q0  a
q1, q2  q1, q2 
b b
  a, b trap state
15/08/20 81 15/08/20 82
Fine della costruzione Procedura generale

M a
NFA
q0 a q1  q2 q1  F Input: NFA M
b
Output: un equivalente DFA M
a con LM   L(M )
DFA M b
q0  a
q1, q2 
q1, q2  F 
b
 a, b
15/08/20 83 15/08/20 84
Step della procedura
NFA ha gli stati q0 , q1, q2 ,...
step
1. Stato iniziale NFA: q0
DFA ha gli stati definiti dall’insieme delle

parti
, q0 , q1 , q0 , q1 , q1 , q2 , q3 , .... stato iniziale del DFA:q0 
15/08/20 85 15/08/20 86
esempio step
NFA M a 2. per ogni stato DFA {qi , q j ,..., qm }

q0 a q1  q2
calcolo nel NFA
b
 * qi , a 
unione

  * qj ,a   {qk , ql,..., qn }
DFA M
...
q0    * qm , a 
addiziona questa nuova transizione al DFA
15/08/20 87 15/08/20
 
 {qi , q j ,..., qm }, a  {qk , ql,..., qn }
88
esempio * (q0 , a )  {q1, q2 }
a
NFA M
q0 a q1  q2 step
b 3. Ripeti lo step 2 per ogni stato nel DFA e
simboli nell’alfabeto finchè non vi sono più
stati che possono essere addizionati al DFA
 q0 , a   q1, q2 
DFA M
q0  a
q1, q2 
15/08/20 89 15/08/20 90
esempio step
M a
NFA 4. {qi , q j ,..., qm }
q0 a q1  q2 Per ogni stato DFA
b
a
DFA M b Se qualche q j è uno stato di
a accettazione del NFA
q0  q1, q2  Allora {qi , q j ,..., qm }
b è uno stato di accettazione del DFA
 a, b
15/08/20 91 15/08/20 92
Example Step della procedura
M a
NFA
q0 a q1  q2 q1  F step
b 1. Stato iniziale NFA: q0
a
DFA M b
q0  a
q1, q2  stato iniziale del DFA:q0 
q1, q2  F 
b
 a, b
15/08/20 93 15/08/20 94
step
2. per ogni stato DFA {qi , q j ,..., qm }
step
calcolo nel NFA
3. Ripeti lo step 2 per ogni stato nel DFA e
 * qi , a  simboli nell’alfabeto finchè non vi sono più
unione

  * qj ,a   {qk , ql,..., qn }
stati che possono essere addizionati al DFA
...
  * qm , a 
addiziona questa nuova transizione al DFA
15/08/20
 
 {qi , q j ,..., qm }, a  {qk , ql,..., qn }
95 15/08/20 96
step Lemma:
4. Per ogni stato del DFA {qi , q j ,..., qm } Se traduciamo un NFA M in un DFA M
Allora i due automata sono equivalenti:
se è presente uno stato q j finale, L M   L M 
accettante, del NFA
dimostrazione:
Dobbiamo dimostrare che: L M   L M 
allora, {qi , q j ,..., qm }
è uno stato accettante del DFA e
L M   L M 
15/08/20 97 15/08/20 98
Mostriamo che: L M   L M   considera w L(M ) NFA

NFA contenuto in DFA
q0 w qf
Dobbiamo provare che:
simboli
w L(M ) w  L(M ) w   1 2  k
1 2 k
q0 qf
15/08/20 99 15/08/20 100

Simboli, lng 1 Mostriamo che se w L(M )
ricordiamo
i
qi qj
w   1 2  k
1 2 k
NFA M: q0 qf
Denota un sotto cammino tale che
simboli allora
  i 
qi qj 1 2 k
DFA M:
{q0 } {q f ,}
state
w  L(M ) state
label label
15/08/20 101 15/08/20 102
In modo piu generale , Dimostrazione per induzione su |v|

mostreremo che se in M :
(stringa arbitraria) v  a1a2  an v  a1
Base induzione: |v | 1
a1 a2 an
NFA M: q0 qi qj ql qm
a1
NFA M: q0 qi
allora
a1
DFA M:
{q0 } {qi ,}
a1 a2 an
DFA M:
{q0 } {qi ,} {q j ,} {ql ,} {qm ,} [ vero per come costruito M  ]
15/08/20 103 15/08/20 104
Ipotesi induttiva: 1 | v | k Step induttivo: | v | k  1
v  a1a2 ak v  a1a2 ak ak 1  vak 1
 
v
Supponiamo valga Vero per costruzione di M
ak ak
q0 a1
qi
a2
qj qc qd NFA M: q0 a1
qi
a2
qj qc qd ak 1 qe
NFA M:
v
a1 a2 ak a1 a2 ak ak 1
DFA M  : DFA M:
{q0} {qi ,} {q j ,} {qc ,} {qd ,} {q0} {qi ,} {q j ,} {qc ,} {qd ,} {qe ,}
15/08/20 105 15/08/20

v 106
Quindi se w L(M ) allora: LM   LM  dimostrato

w   1 2  k e L M   L M  banale
1 2 k
M: q0 qf
NFA
allora
1 2 k quindi: L M   L M 
DFA M  :
{q0 } {q f ,}
w  L(M )
Fine lemma
15/08/20 107 15/08/20 108
Definizione sintattica
L’espressioni regolari di base : ,  , 
Date le espressioi regolari r1 e r2

Espressioni regolari
r1  r2
Ricordo: un linguaggio è regolare
se è riconosciuto da un NFA r1  r2
(=DFA) Sono espressioni regolari
r1 *
r1 
15/08/20 1 15/08/20 2
Una semantica: Linguaggi associati alle passo

espressioni regolari
Per le espressioni regolari di base: per le espressioni regolari r1 e r2
L    Lr1  r2   Lr1   Lr2 
Lr1  r2   Lr1  Lr2 

L    
Lr1 *   Lr1  *
La   a
Lr1   Lr1 
15/08/20 3 15/08/20 4
Linguaggi associati alle espressioni per linguaggi regolari L1 e L2
regolari dimostreremo che:
Lr  : linguaggio associato all’espressione r
Unione: L1  L2
Concatenatione: L1L2
esempio Star: L1 * sono linguaggi
L(a  b  c) *   , a, bc, aa, abc, bca,... regolari
Reversal: L1R
Complemento: L1
Intersezione: L1  L2
15/08/20 5 15/08/20 6
diremo: linguaggi regolari sono chiusi sotto Useremo nfa con un solo stato finale
NFA
a
Unione: L1  L2 2 stati di
a b
Concatenatione: L1L2 accettazione
b
Star: L1 *
Equivalente
Reversal: L1R a
1 solo stato
NFA
a b
Di accettazione
Complemento: L1 
b

Intersezione: L1  L2
15/08/20 7 15/08/20 8
In Generale Caso estremo
NFA
NFA senza stato di accettazione
Equivalent NFA Addizioniamo

 Uno stato di
Un solo
 Accettazione
Stato di Senza transizione

accettazione
15/08/20 9 15/08/20 10
Prendiamo due linguaggi Esempio

Linguaggio regolare L1 linguaggio regolare L2 M1
n0
a
LM1   L1 LM 2   L2 L1  {a nb} b
NFA M1 NFA M2
M2
b a
L2  ba
Un solo stato di accettazione Un solo stato di accettazione
15/08/20 11 15/08/20 12
Unione Esempio
NFA per L1  L2 NFA per
n
L1  L2  {a b}  {ba}
M1
L1  {a nb}
a

b

 M2
 L2  {ba}
b a
15/08/20 13 15/08/20 14
Funzione transizione
Evitiamo le transizioni con le lambda dell’automa unione, N, a
transizioni. partire dalle delta di
Mostriamo che a partire da due automi N_1 e N_2.
(N_1,N_2) , si può costruire l'automa
unione dei due linguaggi definiti dagli
automi precedenti.
Gli stati del nuovo automa sono

l’unione degli stati precedenti,
K_1 e K_2, più un nuovo stato
iniziale q’_0.
15/08/20 15 15/08/20 16
Concatenazione esempio
NFA per L1L2 NFA per L1L2  {a nb}{ba}  {a nbba}
M1 M2
L1  {a nb}
 a
L2  {ba}
b  b a
15/08/20 17 15/08/20 18
Star esempio
NFA per L1 * w  w1w2  wk
 wi  L1 NFA per L1*  {a nb} *
M1 
  L1 *
  L1  {a nb}
a
 b 


15/08/20 19 15/08/20 20
Reverse esempio
NFA per L1R M1

a
L1 M1 M1 L1  {a nb} b
M1
1. Reverse tutte le transizioni
a
L1R  {ba n } b
2. Stato iniziale quello finale,
quello finale stato iniziale
15/08/20 21 15/08/20 22
Complemento esempio
M1
L1 M1 L1 M1
a a, b
L1  {a nb} b a, b
prendiamo il DFA che accetta L1 M1

a, b
1. Stati non finale diventano finale, L1  {a, b} * {a nb} a
e vice-versa, resta lo stato iniziale. b a, b
15/08/20 23 15/08/20 24
Intersezione
leggi DeMorgan : L1  L2  L1  L2
L1 regolari L1 , L2 regolari
mostriamo L1  L2 L1 , L2 regolari
L2 regolari regolari
L1  L2 regolari
L1  L2 regolari
L1  L2 regolari
15/08/20 25 15/08/20 26
esempio esempio:
n0 m0
n m
L1  {a nb} regolari L1  {a b} L2  {ab }
L1  L2  {ab} M1 M2
L2  {ab, ba} regolari regolari
a b
q0 b q1 p0 a p1
a, b b a
q2 p2
a, b a, b
15/08/20 27 15/08/20 28
In Generale
Useremo nfa con un solo stato finale
NFA
NFA
a
b 2 stati di
a
accettazione
b
Equivalent NFA
Equivalente
a
NFA 1 solo stato  Un solo
a b
Di accettazione  Stato di
b  
 accettazione
15/08/20 29 15/08/20 30
Complemento Chiusura rispetto intersezione
L1 M1 L1 M1 macchina M1 macchina M2

DFA per L1 DFA per L2
Costruiamo un DFA M che accetta L1  L2

1 prendiamo il DFA che accetta L1
2. Stati non finale diventano finale,

M Simula in parallelo M1 e M 2
e vice-versa
15/08/20 31 15/08/20 32
DFA M1 DFA M2
Stati in M q0 p0
stato iniziale stato iniziale
qi , p j
DFA M
Stato in M1 Stato in M2
q0 , p0
nuovo stato iniziale
15/08/20 33 15/08/20 34
DFA M1 DFA M2 DFA M1 DFA M2
q1 a q2 p1 a p2 qi pj pk
transizione transizione accettazione stato accettazione stati
DFA M
DFA M qi , p j qi , pk
q1, p1 a q2 , p2 nuovo accettazione stati
Nuova transizione
15/08/20 35 15/08/20 36
esempio: Intersezione automata
L  {a nb}  {ab n }  {ab}
n0 m0
n m a, b
L1  {a b} L2  {ab }
M1 M2 q0 , p0 a q0 , p1 b q1, p1 a q2 , p2
a b b a b a
q0 b q1 a
p0 p1 q1, p2 b q0 , p2 q2 , p1
a, b b a
q2 p2 a b
a, b a, b a, b
15/08/20 37 15/08/20 38
Se appariene ad entrambi
M Simula in parallelo M1 e M 2
Sia la stringa di lunghezza n
Esistono due cammini di lunghezza n, uno per ogni
automa. Dallo stato iniziale a quello finale.
Se lng 1 vero, dimostrare vero per n+1. M accettazione stringa w Se e solo se:
Ultimo tratto da n a n+1 arco nei due automa e arco
automa costruito. Considera stringa n e considera M1 accetta w string
come stato finale quello prima dello stato finale, vedi
arco che riconosce il carattere n, simula i due automi. e M 2 accetta w string
Continua ad andare indietro fino a raggiungere lo stato
iniziale.
Nell’automa costruito esiste un cammino L ( M )  L ( M1 )  L ( M 2 )

di lng n che li simula
15/08/20 39 15/08/20 40
Teorema
Espressioni regolari e
linguaggi regolari
Linguaggi
Generati da
 Linguaggi
regolari
15/08/20 41 15/08/20 42
Dimostrazione - Parte 1 Base induzione

Espressioni regolari di base: ,  , 
Linguaggi corrispondente
Generati da  Linguaggi
regolari
NFAs
Espressioni regolari L( M1 )    L()
per ogni espressione regolare r Linguaggi

L( M 2 )  {}  L( )
il linguaggio L(r ) è regolare regolari
a
Dimostrazione per induzione sulla lunghezza L( M 3 )  {a}  L(a )
r
15/08/20 43 15/08/20 44
Ipotesi induttiva Passo induttivo
Proviamo che:
supponi Lr1  r2 
Per le espressioni regolari r1 e r2,
L(r1 ) e L(r2 ) sono linguaggi regolari.
Lr1  r2 
Sono linguaggi
regolari
Esistono due automi uno per
ogni linguaggio
Lr1 *
Lr1 
15/08/20 45 15/08/20 46
Ricorda che, per def. di espressione regolare Per ipotesi induttiva :

L(r1 ) e L(r2 ) sono linguaggi regolari
Lr1  r2   Lr1   Lr2 
Inoltre sappiamo, slides precedenti:

Lr1  r2   Lr1  Lr2 
I linguaggi regolari sono chiusi rispetto:
Unione Lr1   Lr2 
Lr1 *  Lr1 *
Concatenatzione Lr1  Lr2 
Lr1   Lr1  Star Lr1 *
15/08/20 47 15/08/20 48
Usando la chiusura dele operazioni Stella e puntino. esercizio
Possiamo costruire un NFAM tale che:
L(M )  L(r )
Stella: torna indietro con
esempio: r  r1  r2 lambda.
L(M )  L(r )
L(M1 )  L(r1 ) Puntino: collega i finali del primo
con l’iniziale con un lambda.

L(M2 )  L(r2 ) 
15/08/20 49 15/08/20 50
dim - Part 2
Poichè L è regolare , allora esiste un
Linguaggi NFA M che lo accettà
Generati da  Linguaggi
regolari
L( M )  L
Per ogni linguaggio regolareL esiste
una espressione regolare r conL( r )  L
Convertiremo un NFA che accetta L Prendiamo l’automa con

In una espressione regolare un solo stato finale
15/08/20 51 15/08/20 52
b b
da M costruiamo l’equivalente Un altro esempio:
a
Generalized Transition Graph q0 q1 a, b q2
Nel quale i caratteri di transizione, transition
labels, sono espressioni regolari b
Esempio: Il corrispondente
M Generalized transition graph Transition labels b b
a c a c Sono espressioni a
regolari q0 q1 a  b q2
a, b ab
b
15/08/20 53 15/08/20 54
b b
Ridurre gli stati: Espressione regolare che si ottiene:
a
q0 q1 a  b q2
bb * a b
b
q0 bb * (a  b) q2
Transition labels
sono espressioni bb * a b r  (bb * a) * bb * (a  b)b *
regolari
q0 bb * (a  b) q2
L(r )  L( M )  L
15/08/20 55 15/08/20 56
Stato iniziale solo archi uscenti, nessuno Se k=2 slide precedente
rientrante
Solo uno finale tutti entranti e nessun Altimenti
uscente. prendiamo lo stato da eliminare q
Per gli altri stati sono presenti archi uscenti Per ogni q_i e q_j collegati via q
per tutti gli altri stati ed entranti da tutti
gli altri stati e su se stesso. Se non esiste  * q _ 1, q _ j   ( R _ 1)( R _ 2) * ( R _ 3)  ( R _ 4)
un arco da q_i a q_j creiamo un arco con vai da q_i a q, R_1
label insieme vuoto  gira su q, (R_2)*
vai da q a q_j, R_3
direttamente da q_i a q_j, R_4
15/08/20 57 15/08/20 58
In generale
Rimuovere uno stato: e
d c
qi q qj
a b
ae * d ce * b
ce * d
qi qj
ae * b
15/08/20 59 15/08/20 60
Per ogni q_i e q_j collegati via q
vai da q_i a q, R_1 vai da q_i a q, R_1

gira su q, (R_2)*
via da q a q_j, R_3 gira su q, (R_2)*
direttamente da q_i a q_j, R_4 vai da q a q_j, R_3
direttamente da q_i a q_j, R_4
 * q _ 1, q _ j   ( R _ 1)( R _ 2) * ( R _ 3)  ( R _ 4)
15/08/20 61 15/08/20 62
Algoritmo: Eliminare
uno stato alla volta fino
a che restano 2 stati.
Dimostrazione algoritmo funziona ovvero

l’automa iniziale G e G’, meno uno stato,
accettano lo stesso linguaggio
G’ con due stati allora otteniamo
espressione regolare.
Vero per k-1 provare per k+1.
15/08/20 63 15/08/20 64
Presentazione standard di un linguaggio
Prendiamo una stringa che viene accettata, regolare
esiste un cammino che accetta la stringa se
non usa lo stato da eliminare bene G e G’ Linguaggio regolare
accettano la stringa. In slang:
«Se G non usa lo stato da eliminare: bene G’ «si
fa lo stesso giro» »;
Se G usa lo stato da eliminare allora in G’ lo DFA
stato in oggetto non esiste ma nei nuovi archi
tutte le sottostringhe che venivano Espressione
riconosciute tramite lo stato eliminato sono NFA
regolare
descritte dalle espressioni regolari sugli archi
15/08/20 65 15/08/20 66
esempio Linguaggi associati alle espressioni

Epressione regolare: a  b   a * regolari
Lr  : linguaggio associato all’espressione r
La  b   a *  La  b  La *
 La  b  La *
esempio
  La   Lb   La  *
L(a  b  c) *   , a, bc, aa, abc, bca,...
 a  b a *
 a, b , a, aa, aaa,...
 a, aa, aaa,..., b, ba, baa,...
15/08/20 67 15/08/20 68
Esempio esempio
Espressione regolare r  a  b  * a  bb  Espressione regolare r  aa  * bb  * b
Lr   a, bb, aa, abb, ba, bbb,... Lr   {a 2nb 2mb : n, m  0}
15/08/20 69 15/08/20 70
esempio esempio
Espressione regolare r  (0  1) * 00 (0  1) * Espressione regolare r  (1  01) * (0   )
L(r ) = { tutte le stringhe che contengono 00 } L(r )

= { tutte le stringhe senza sottostringhe 00 }
15/08/20 71 15/08/20 72
Ripetere il processo finchè
Due stati restano il grafo risultante
sarà il seguente
Grafo iniziale Grafo risultante
r1 r4
r3
q0 qf
r2
L’espressione regolare risultante:
r  r1 * r2 (r4  r3r1 * r2 ) *
L(r )  L( M )  L
15/08/20 73
Definizione formale G  (V , T , S , P )
Grammatica:
G  V , T , S , P 
Tutte le produzioni P sono della forma:
Insieme delle variabili
A s
Insieme Start Insieme delle
simboli Stringhe di
variabile produzioni
terminali Variabili e non
terminali
15/08/20 1 15/08/20 2
Grammatica lineare
Linguaggio di una grammatica:
Le grammatiche con al massimo una variabile
Per una grammatica G con start S sul lato destro della produzione
* Esempio:
L(G )  {w : S  w, w  T *}
S  aSb S  Ab
Stringhe di terminali o  S  A  aAb
A
terminali
15/08/20 3 15/08/20 4
Grammatica non lineare Grammatica lineare
Grammatica G : S  SS
Grammatica G : SA
S 
A  aB | 
S  aSb
B  Ab
S  bSa
L(G )  {w : na ( w)  nb ( w)} L(G )  {a nb n : n  0}
Numeri di a nella stringa w

15/08/20 5 15/08/20 6
Grammatica lineare a destra Grammatiche lineare sinistra

Tutte le produzioni hanno la forma Tutte le produzioni hanno A  Bx
A  xB la forma:
o o
A x A x
esempio: S  abS Stringa di S  Aab Stringhe

terminali Esempio: di terminali
S a A  Aab | B
Ba
15/08/20 7 15/08/20 8
Grammatiche regolari
Una grammatica regolare è qualsiasi I linguaggi generati da una grammatica
grammatica lineare a destra o a sinistra regolare è un linguaggio regolare
G2
Esempio: Examples:
G1 S  Aab
G1 G2
S  Aab S  abS A  Aab | B
S  abS
A  Aab | B S a Ba
S a
Ba L(G1 )  (ab) * a L(G2 )  aab(ab) *
15/08/20 9 15/08/20 10
Teorema
Grammatiche regolari
Linguaggi
Generati da
grammatiche
 Linguaggi
regolari
generano linguaggi regolari regolari
15/08/20 11 15/08/20 12
Teorema - Part 1 Teorema - Part 2
Linguaggi Linguaggi
regolari
regolari
grammatiche grammatiche
regolari regolari
Ogni grammatica regolare Ogni linguaggio regolare
Genera un liguaggio generale È generato da una grammatica regolare
15/08/20 13 15/08/20 14
Proof – Part 1 Il caso della Grammatica
Linguaggi sia G una right-linear grammatica

regolari
grammatiche proveremo: L(G ) è regolare
regolari
Il linguaggio L(G ) generato da

Una grammatica regolare G è regolare M
idea: costruiamo una NFA
con L( M )  L(G )
15/08/20 15 15/08/20 16
Grammatica G è right-linear Construiamo NFA M tale che
ogni stato è una variabile della grammatica :
Esempio: S  aA | B A
A  aa B
S VF
Bb B|a
B speciale
S  aA | B stato finale
A  aa B
15/08/20 17
Bb B|a
15/08/20 18
Addizioniamo un arco per ogni produzione:
a A a A
S VF S VF

B B
S  aA S  aA | B
15/08/20 19 15/08/20 20
A A
a a a a
S a VF S a VF
 
B B
S  aA | B
S  aA | B b
A  aa B
A  aa B
15/08/20 21
B  bB
15/08/20 22
A A
a a a a
S a VF S a VF
 a  a
B B
S  aA | B
b b
A  aa B
B  bB | a S  aA  aaaB  aaabB  aaaba
15/08/20 23 15/08/20 24
NFA M Grammatica In Generale
A G una right-linear grammatica G
a S  aA | B
a Ha le variabili: V0 ,V1,V2 ,
A  aa B
S a
B  bB | a
 VF
a
E le produzioni: Vi  a1a2 amV j
B
L( M )  L(G )  or
b
aaab * a  b * a Vi  a1a2 am
15/08/20 25 15/08/20 26
Costruiamo un NFA M tale che: per ogni produzione: Vi  a1a2 amV j
Ogni variabile Vi corrisponde ad un nodo: Addizioniamo transizioni e nodi intermedi
V1 V3
Vi a1 a2 ………
am V
V0 j
VF
V2
V4
stato finale
15/08/20 27 15/08/20 28
per ogni produzione: Vi  a1a2 am otteniamo NFA M come questo:
a9
Addizioniamo transizioni e nodi intermedi
a2 a4
a1 V1 V3
a3 a5
V0
a1 a2 am a3 a4
Vi ……… VF VF
a8 a9
V2 a5
V4
Vale che: L(G )  L( M )

15/08/20 29 15/08/20 30
dimostrazione - Part 2
qualsiasi linguaggio regolare L è generato
Linguaggi da una grammatica regolare G
regolari
grammatiche
regolari idea:
ogni linguaggio regolare L è generato sia M NFA con L  L(M ) .

da qualche grammatica regolare G
costruiamo da M una grammatica G
regolare tale che L( M )  L(G )
15/08/20 31 15/08/20 32
Poichè L è regolare convertiamo M in una right-linear
è un NFA M tale che L  L(M ) grammatica b
b M
a a
Esempio: q0 q1 q2
M a
q0 a q1 q2
 b
q0  aq1
 b q3
L  ab * ab(b * ab) * q3
L  L(M )
15/08/20 33 15/08/20 34
b b
M a M a
a a
q0 q1 q2 q0 q1 q2
q0  aq1
q0  aq1 b b
 q1  bq1 
q1  bq1 q3 q3
q1  aq2
q1  aq2
q2  bq3
15/08/20 35 15/08/20 36
L(G )  L( M )  L In Generale
b per qualsiasi transizione:
G a
q p
q0  aq1 M a
a
q0 q1 q2
q1  bq1
addizioniamo la produzione:
q1  aq2  b
q  ap
q2  bq3 q3
q3  q1
variable terminal variable
q3  
15/08/20 37 15/08/20 38
per qualsiasi stato finale : Since G è right-linear grammatica

qf
G è grammatica regolare
Addizioniamo la qf  con
produzione: L(G )  L( M )  L
15/08/20 39 15/08/20 40
Come possiamo provare che un linguaggio
{a nb n : n  0} L
linguaggi Non-regolari non è regolare?
{vv R : v {a, b}*}
Dobbiamo provare che non vi è
linguaggi regolari Nessun DFa or NFa or RE
che lo accetta
a *b b*c  a Difficulty: non è facile da provare
b  c ( a  b) * (perchè vi sono infiniti dfa, nfa e re)
etc... Solution: usare il Pumping Lemma !!!

L
15/08/20 1 15/08/20 2
Pigeonhole Principle
4 pigeons
a pigeonhole deve
Contenere due pigeons
3 pigeonholes
15/08/20 3 15/08/20 4
il Pigeonhole Principle
n pigeons n pigeons
m pigeonholes
........... a pigeonhole deve
nm Contenere minimo
due pigeons
m pigeonholes nm
........... ...........
15/08/20 5 15/08/20 6
considera il cammino di una “stringa lunga’’ :

(lunghezza almeno 4)
aaaab
considera un DFa con 4 stati uno stato è ripetuto nel cammino di aaaab
q1 a q2 a q3 a q2 a q3 b q4
b
b b
b
b b
q1 a a b
q2 q3 q4
q1 a q2 a q3 b q4
a a
a a
15/08/20 7 15/08/20 8
considera il cammino di a “long’’ stringa: aabb
il stato è ripetuto da a, risultato del (lunghezza almeno 4)
pigeonhole principle
Dal pigeonhole principle:
cammino di aaaab uno stato è ripetuto nel cammino di aabb
Pigeons: q1 a q2 a q3 a q2 a q3 b q4 a a b q4 b
q1 q2 q3 q4
(cammino stati)
b
Sono più degli b b
Cesti: q1 q2 q3 q4 q1 a q2 a q3 b q4
(stati dell’automata) stato
15/08/20
Ripetuto
9 15/08/20
a a 10
In Generale: se| w |  # states of DFA

il stato è ripetuto come risultato del
Per il pigeonhole principle,
pigeonhole principle
uno stato è ripetuto nel cammino W
cammino di aabb cammino di w  1 2  k
a a b b  2 ....  i q  i 1 ....
Pigeons: q1 q2 q3 q4 q4
q1 1 i
j
qi ....  k
 j 1
qz
(stati del cammino)
sono di più
arbitrario DFa
Nests: q1 q2 q3 q4
q1 1 2
...... qi ......  k q z
(automaton stati) ripetuto
Stati automa
stato stato ripetuto
15/08/20 11 15/08/20 12
| w |  # states of DFA  m
Pigeons: (stati del cammino) cammino di w

q1 .... qi .... qi .... qz
Sono di
il Pumping Lemma
Più degli
cesti: q1 q2 .... qi .... qm1 qm

( stati dell uno stato è
automata) ripetuto
15/08/20 13 15/08/20 14
prendi un linguaggio regolare infinito L prendiamo una stringa w L con | w |  m

(contiene un numero infinito di stringhe) (numero di
stati del DFa)
Almeno uno stato è ripetuto
Sia un DFa che accetta L nel cammino di w
cammino in DFa di
w  1 2  k
m
stati 1  2 ...... q ......  k
stato ripetuto in DFa
15/08/20 15 15/08/20 16
Ci saranno molti stati ripetuti
Possiamo scrivere w  xyz

prendiamo il primo stato ripetuto q
In una dimensione il cammino di: w

Una dimensione del cammino di : w
prima seconda prima seconda
occorrenza
occorrenza occorrenza occorrenza
 i 1 j  j 1 k  2 ....  i q i 1 .... j  j 1
1  2 ....  i q .... q .... 1 q ....  k
unico stato x  1 i y   i 1 j z   j 1 k
15/08/20 17 15/08/20 18
osservazione: lunghezza | x y |  m numero

w x y z di stati
Nel DFa:
del DFa
contiene solo
y prima occorrenza di q y
... ...
unici stati
j  i 1 j  i 1
1
... i
q  j 1... ... k 1
... i
q poichè, in xy
nessuno è stato
x z x ripetuto (eccetto q) 20
15/08/20 19 15/08/20
osservazione: lunghezza | y | 1 Non badiamo alla forma della stringa z
Vi è almeno un loop
z può avere pezzi di cammino di x and y
y y
... ...
j
z
 i 1
q ... q
15/08/20 21 15/08/20
x 22
stringa addizionale: la stringa xz stringa addizionale : la stringa xyyz

è accettata è accettata
Non fa il loop
y segue loop y
2 volte
... ...
j  i 1 j  i 1
1
... i
q  j 1... ... k 1
... i
q  j 1... ... k
x z x z
15/08/20 23 15/08/20 24
addizionale stringa: la stringa xyyyz In Generale: la stringa x yi z
è accettata è accettata i  0, 1, 2, ...
3 volte il loop y y
i volte il loop
... ...
j  i 1 j  i 1
1
... i
q  j 1... ... k 1
... i
q  j 1... ... k
x z x z
15/08/20 25 15/08/20 26
quindi: x yi z  L i  0, 1, 2, ... il Pumping Lemma:

• dato un linguaggio regolare infinito L
linguaggio accettato dal DFa
• esiste an intero m (lunghezza critica)
y
... • per ogni stringa w L con lunghezza | w |  m
• possiamo scrivere w x y z
j  i 1
1
... i
q  j 1... ... k
• con |x y|  m e | y | 1
x z • tale che: x yi z  L i  0, 1, 2, ...

15/08/20 27 15/08/20 28
nel libro sipster : applicazioni applicazioni
lunghezza Critica = m lunghezza Pumping p
del
Pumping Lemma
15/08/20 29 15/08/20 30
supponiamo vogliamo provare che

osservazione:
Un linguaggio infinito L non è regolare
ogni linguaggio di dimensione finita è regolare
(possiamo facilmente costruire an NFa
che accetta ogni stringa nel linguaggio) 1. assumiamo l’ opposto: L è regolare
2. il pumping lemma deve valere per L

quindi, ogni linguaggio non-regolare 3. usiamo il pumping lemma per ottenere una
è di dimensione infinita contradizione
(contiene an infinito numero di stringhe)
4. quindi, L non è regolare
15/08/20 31 15/08/20 32
Spiegazione Step 3: come avere una contradizione
Note: È sufficiente mostrare che
1. Let msia la lunghezza critica for L
solo una stringa w L
2. Scegliamo una stringa particolare w L genera una contradizione
che soddisfa la condizione di lunghezza | w | m
3. scrivere w  xyz
Non dobbiamo ottenere
4. mostriamo che w  xy i z  L Per qualche i  1
contradizioni per ogni w L
5. Questo ci dà una contradizione, poichè dal
pumping lemma w  xy i z  L
15/08/20 33 15/08/20 34
Esempi di applicazioni del Pumping Lemma

L  {a nb n : n  0}
teorema: il linguaggio L  {a nb n : n  0}
assumiamo per contradizione
non è regolare
che L è un linguaggio regolare
dim: Usa il Pumping Lemma Since L è infinito

Possiamo applicare il Pumping Lemma
15/08/20 35 15/08/20 36
L  {a nb n : n  0} Dal Pumping Lemma:
m m
sia m la lunghezza critica per L possiamoscrivere w  a b  x y z
Con lunghezza | x y |  m, | y | 1
Prendiamo a stringa w such che: w  L
m m
e lunghezza | w| m
w  xyz  a mb m  a...aa...aa...ab...b
m m x y z
prendiamo wa b
k
allora: y  a , 1  k  m
15/08/20 37 15/08/20 38
x y z  a mb m y  ak, 1  k  m x y z  a mb m y  ak, 1  k  m
Dal Pumping Lemma: x y2 z  L

dal Pumping Lemma: x yi z  L
mk m
i  0, 1, 2, ...
xy 2 z  a...aa...aa...aa...ab...b  L
allora: x y2 z  L x y y z
allora: a m k b m  L
15/08/20 39 15/08/20 40
a m k b m  L k≥ 1
aaabbb =xyz
1 caso x=aa y=a z=bbb MA: L  {a nb n : n  0}
aa aa bbb
2 caso x=aaab y=b z=b

aaab bb b
a mk b m  L
3 caso
x=aa y=ab z=bb contradizione!!!
aa ababab bb
15/08/20 41 15/08/20 42
quindi: l’assunzione che che L

è un linguaggio regolare
linguaggio Non-regolare {a nb n : n  0}
non è vera
Linguaggio regolare
L(a*b* )
Conclusione: L non è un linguaggio regolare
END dim
15/08/20 43 15/08/20 44
a*b*
aayabybb=xyz y=a
aa aa a bbb
aaa bbbbb
y=ab
aaabbbb
15/08/20 45
Initial Stack Symbol
Stack Stack
Pushdown Automata
PDA
stack
$ z top
testina
bottom Simboli speciali

Che appaiono al tempo 0
15/08/20 1 15/08/20 2
Pushdown Automaton -- PDA Gli stati

Input String
Input Pop Push
Stack simbolo simbolo simbolo
States
q1 a, b  c q2
15/08/20 3 15/08/20 4
a, b  c a,   c
q1 q2 q1 q2
input input
 a   a   a   a 
stack stack c
b top c b top b
h diventa h h Push h
e e e e
$ $ $ $
15/08/20 5 15/08/20 6
a, b   a,   
q1 q2 q1 q2
input input
 a   a   a   a 
stack stack
b top b top b
h Pop h h immutato h
e e e e
$ $ $ $
15/08/20 7 15/08/20 8
Pop da uno stack vuoto Non-Determinismo
a, b  c
q1 q2 PDAs sono non-deterministici
input
Permettono transizioni non deterministiche
 a 
stack Pop Automa si ferma! q2
a, b  c
top , b  c
q1 q1 q2
Se l’automata tenta di fare un pop
a, b  c
  transition
da uno stack vuoto allora si ferma q3
la computazione e rigetta l’input
15/08/20 9 15/08/20 10
Esempio di PDA L( M )  {a nb n : n  0}
Idea di base:
1. Push le a’s 2. Verifica le b’s in input

n n
PDA M: L( M )  {a b : n  0} nello stack con le a’s nello stack
3. Match
a,   a b, a   a,   a b, a   trovato
q0  ,    q1 b, a   q2  , $  $ q3 q0  ,    q1 b, a   q2  , $  $ q3
15/08/20 11 15/08/20 12
Esempio di esecuzione: Time 0 Time 1
Input Input
a a a b b b a a a b b b
$ $
Stack Stack
Stato a,   a b, a   a,   a b, a  
corrente
q0  ,    q1 b, a   q2  , $  $ q3 q0  ,    q1 b, a   q2  , $  $ q3
15/08/20 13 15/08/20 14
Time 2 Time 3
Input Input a
a a a b b b a a a a b b b a
$ $
Stack
Stack
a,   a b, a   a,   a b, a  
q0  ,    q1 b, a   q2  , $  $ q3 q0  ,    q1 b, a   q2  , $  $ q3
15/08/20 15 15/08/20 16
Time 4 Time 5
a a
Input Input
a a
$ $
Stack Stack
a,   a b, a   a,   a b, a  
q0  ,    q1 b, a   q2  , $  $ q3 q0  ,    q1 b, a   q2  , $  $ q3
15/08/20 17 15/08/20 18
Time 6 Time 7
Input a Input
$ $
Stack Stack
a,   a b, a   a,   a b, a  
q0  ,    q1 b, a   q2  , $  $ q3 q0  ,    q1 b, a   q2  , $  $ q3
15/08/20 19 15/08/20 20
Time 8 Una stringa è accettata se
Input vi è una computazione tale che:
a a a b b b
tutti gli input sono “consumati”
$
E
Stack
lo stato raggiunto è uno stato di accettazione
a,   a b, a  
Non teniamo conto di quello che c’è nello
accettato
Stack alla fine dello stato di accettazione
q0  ,    q1 b, a   q2  , $  $ q3
15/08/20 21 15/08/20 22
Esempio di Time 0 non acettazione : Time 1

non acettazione: Input
a a b Input a a b
$ $
Stack Stack
Stato a,   a b, a   Stato a,   a b, a  
corrente corrente
q0  ,    q1 b, a   q2  , $  $ q3 q0  ,    q1 b, a   q2  , $  $ q3
15/08/20 23 15/08/20 24
non acettazione : Time 2 non acettazione : Time 3
Input Input a
a a b a a a b a
$ $
Stack Stack
corrente corrente
q0  ,    q1 b, a   q2  , $  $ q3 q0  ,    q1 b, a   q2  , $  $ q3
15/08/20 25 15/08/20 26
non acettazione : Time 4 non acettazione : Time 4

Input a Input a
a a b a a a b a
$ $
Stack Stack
reject
corrente corrente
q0  ,    q1 b, a   q2  , $  $ q3 q0  ,    q1 b, a   q2  , $  $ q3
15/08/20 27 15/08/20 28
Non esiste una computazione accettante Un altro esempio di PDA
Per aab .
La stringa aab è rigettata dal PDA.
PDA M: L( M )  {vv R : v  {a, b} }
a,   a a, a  
a,   a b, a   b,   b b, b  
q0  ,    q1 b, a   q2  , $  $ q3
q0 ,    q1 , $  $ q2
15/08/20 29 15/08/20 30
Basic Idea: L( M )  {vv R : v  {a, b}}
R
1. Push v 3. verifica v in
aby aa y a y aba=xyz 2. Congettura
Nello stack Input con v nello
metà
abcy cba stack
Dell’input
a,   a a, a   4. Verifica
b,   b b, b   trovata
q0 ,    q1 , $  $ q2
15/08/20 31 15/08/20 32
esecuzione: Time 0 Time 1
Input Input
a b b a a b b a
a
$ $
Stack Stack
a,   a a, a   a,   a a, a  
b,   b b, b   b,   b b, b  
q0 ,    q1 , $  $ q2 q0 ,    q1 , $  $ q2
15/08/20 33 15/08/20 34
Time 2 Time 3
Input Input
b b
a b b a a b b a
a Congettura sei a
$ Metà input $
Stack Stack
a,   a a, a   a,   a a, a  
b,   b b, b   b,   b b, b  
q0 ,    q1 , $  $ q2 q0 ,    q1 , $  $ q2
15/08/20 35 15/08/20 36
Time 4 Time 5
Input Input
b
a b b a a b b a
a a
$ $
Stack Stack
a,   a a, a   a,   a a, a  
b,   b b, b   b,   b b, b  
,    , $  $ ,   
q0 q1 q2 q0 q1  , $  $ q2
15/08/20 37 15/08/20 38
Time 6 esecuzione: Time 0

Input Input
a b b a a b b a
$ $
Stack Stack
a,   a a, a   a,   a a, a  
b,   b b, b   b,   b b, b  
accept
q0 ,    q1 , $  $ q2 q0 ,    q1 , $  $ q2
15/08/20 39 15/08/20 40
Altro esempio: Time 0
A,b cancella Input
b l
final a b b b
b e
a $
l
l Stack
a,   a a, a  
$ no
b,   b b, b  
q0 ,    q1 , $  $ q2
15/08/20 41 15/08/20 42
Time 1 Time 2
Input Input
b
a b b b a b b b
a a
$ $
Stack Stack
a,   a a, a   a,   a a, a  
b,   b b, b   b,   b b, b  
q0 ,    q1 , $  $ q2 q0 ,    q1 , $  $ q2
15/08/20 43 15/08/20 44
Time 3 Time 4
Input Input
b b
a b b b a b b b
Congettura sei a a
A metà dell’input $ $
Stack Stack
a,   a a, a   a,   a a, a  
b,   b b, b   b,   b b, b  
q0 ,    q1 , $  $ q2 q0 ,    q1 , $  $ q2
15/08/20 45 15/08/20 46
Time 5 Un altra computazione sulla stessa stringa:

Input Non ci sono possibili transizioni. Input Time 0
a b b b Input non è a b b b
a
stato consumato $ $
Stack Stack
a,   a a, a   a,   a a, a  
b,   b b, b   b,   b b, b  
,   
q0 q1  , $  $ q2 q0 ,    q1 , $  $ q2
15/08/20 47 15/08/20 48
Time 1 Time 2
Input Input
b
a b b b a b b b
a a
$ $
Stack Stack
a,   a a, a   a,   a a, a  
b,   b b, b   b,   b b, b  
q0 ,    q1 , $  $ q2 q0 ,    q1 , $  $ q2
15/08/20 49 15/08/20 50
Time 3 Time 4 b
Input b Input b
b b
a b b b a b b b
a a
$ $
Stack Stack
a,   a a, a   a,   a a, a  
b,   b b, b   b,   b b, b  
q0 ,    q1 , $  $ q2 q0 ,    q1 , $  $ q2
15/08/20 51 15/08/20 52
Time 5 b
Non esiste nessuna computazione
Input b
No stato di che accetta abbb
b
a b b b accettazione a abbb  L(M )
$
Stack
a,   a a, a   a,   a a, a  
b,   b b, b   b,   b b, b  
q0 ,    q1 , $  $ q2 q0 ,    q1 , $  $ q2
15/08/20 53 15/08/20 54
Basic Idea: L( M )  {vv R : v  {a, b}}
1. Push v 3. verifica v in
R
Input Pop Push
2. Congettura simbolo
Nello stack Input con v nello simbolo simbolo
metà
stack
Dell’input
a,   a a, a   4. Verifica
q1 a, b  c q2
b,   b b, b   trovata
q0 ,    q1 , $  $ q2
15/08/20 55 15/08/20 56
Pushing & Popping Strings Esempio: a , eb  cdf
q1 q2
input
Input Pop Push  

 a 
  a 
symbol string string
stack
top c push
e top d
a , w1  w2 pop string
q1 q2 b f
string h diventa h
e e
$ $
15/08/20 57 15/08/20 58
q1
a , eb  cdf
q2 altro PDA esempio
L( M )  {w  {a, b}* : na ( w)  nb ( w)}
Transizioni
equivalenti PDA M
pop
a, e   lam, b   a, $  0$ b, $  1$
q1 a, 0  00 b, 1  11
,    a, 1   b, 0  
push
l,   f l,   d l,   c q
2
q1
, $  $ q2
15/08/20 59 15/08/20 60
esecuzione: Time 0 Time 1
Input Input
a b b b a a a b b b a a
0
$ $
a, $  0$ b, $  1$ a, $  0$ b, $  1$
Stack Stack
a, 0  00 b, 1  11 a, 0  00 b, 1  11
a, 1   b, 0   a, 1   b, 0  
current
state , $  $ q2 , $  $ q2
q1 q1
15/08/20 61 15/08/20 62
Time 3 Time 4
Input Input
0 1
$ $
a, $  0$ b, $  1$ a, $  0$ b, $  1$
Stack Stack
a, 0  00 b, 1  11 a, 0  00 b, 1  11
a, 1   b, 0   a, 1   b, 0  
q1
, $  $ q2 q1
, $  $ q2
15/08/20 63 15/08/20 64
Time 5 Time 6
Input Input
a b b b a a 1 a b b b a a 1
1 1
$ $
a, $  0$ b, $  1$ a, $  0$ b, $  1$
Stack Stack
a, 0  00 b, 1  11 a, 0  00 b, 1  11
a, 1   b, 0   a, 1   b, 0  
q1 , $  $ q2 q1 , $  $ q2
15/08/20 65 15/08/20 66
Time 7 Time 8
Input Input
1
$ $
a, $  0$ b, $  1$ a, $  0$ b, $  1$
Stack Stack
a, 0  00 b, 1  11 a, 0  00 b, 1  11
a, 1   b, 0   a, 1   b, 0  
accept
q1
, $  $ q2 q1
, $  $ q2
15/08/20 67 15/08/20 68
a , w1  w2
q1 q2
Formalismo per I PDA
Funzione di transizione:
 (q1 , a ,w 1 )  {(q2 ,w 2 )}
15/08/20 69 15/08/20 70
q2 Formal Definition
a , w1  w2
Pushdown Automaton (PDA)
q1
M  (Q, Σ, Γ, δ, q0 , z , F ) Accept
a , w1  w3 q3 states
States
Funzione di transizione : Input Stack

alphabet Transition Initial start
 (q1 , a ,w 1 )  {(q2 ,w 2 ), (q3,w 3 )} Stack
function state symbol
alphabet
15/08/20 71 15/08/20 72
Delta
Instantaneous Description
: Stato x Inputx Stack -> P {(Stato, Stack)}
( q, u , s )
Current Current
Remaining
state stack
input
Delta sigma_input x
contents
15/08/20 73 15/08/20 74
Example: Instantaneous Description Example: Instantaneous Description

(q1, bbb, aaa$) (q2 , bb, aa$)
a a
Time 4: Input a Time 5: Input a
$ $
Stack Stack
a,   a b, a   a,   a b, a  
q0  ,    q1 b, a   q2  , $  $ q3 q0  ,    q1 b, a   q2  , $  $ q3
15/08/20 75 15/08/20 76
Una computazione:
scriviamo: (q0 , aaabbb,$)  (q1, aaabbb,$) 

(q1, aabbb, a$)  (q1, abbb, aa$)  (q1, bbb, aaa$) 
(q2 , bb, aa$)  (q2 , b, a$)  (q2 ,  ,$)  (q3 ,  ,$)
(q1, bbb, aaa$)  (q2 , bb, aa$)
Time 4 Time 5 a,   a b, a  
q0  ,    q1 b, a   q2  , $  $ q3
15/08/20 77 15/08/20 78
Language of PDA
(q0 , aaabbb,$)  (q1, aaabbb,$) 
Linguaggio L (M ) accettato da PDA M :
(q1, aabbb, a$)  (q1, abbb, aa$)  (q1, bbb, aaa$) 
(q2 , bb, aa$)  (q2 , b, a$)  (q2 ,  ,$)  (q3 ,  ,$) 
L( M )  {w : (q0 , w, z )  (q f ,  , s)}
Per convenienza scriviamo:
 Initial state Accept state

(q0 , aaabbb,$)  (q3 ,  ,$) Stack può essere anche non
vuoto, quindi s qualsiasi.
15/08/20 79 15/08/20 80
Esempio:  
n n
(q0 , aaabbb,$)  (q3 ,  ,$) (q0 , a b ,$)  (q3 ,  ,$)
aaabbb  L(M ) a nb n  L(M )
PDA M : PDA M :
a,   a b, a   a,   a b, a  
q0  ,    q1 b, a   q2  , $  $ q3 q0  ,    q1 b, a   q2  , $  $ q3
15/08/20 81 15/08/20 82
quindi: L( M )  {a nb n : n  0}
PDA M :
a,   a b, a  
q0  ,    q1 b, a   q2  , $  $ q3
15/08/20 83
Context free
Ogni produzioni ha la forma:

Normal Forms A  stringa
per
grammatiche Context-free
variabile Terminali o costanti
15/08/20 1 15/08/20 2
Chomsky Normal Form esempi:
Ogni produzioni ha la forma: S  AS S  AS

S a S  AAS
A  SA A  SA
A  BC or Aa
Ab A  aa
variabile variabile terminal Chomsky Not Chomsky

Normal Form Normal Form
15/08/20 3 15/08/20 4
Conversione nella Chomsky Normal Form Introduciamo nuove variabili per i terminali:
Ta , Tb , Tc
esempio: S  ABa
Not Chomsky S  ABTa
A  aab Normal Form
S  ABa A  TaTaTb
B  Ac
A  aab B  ATc
B  Ac Ta  a
Convertiamo questa grammatica nella Tb  b
Chomsky Normal Form
Tc  c
15/08/20 5 15/08/20 6
Introduciamo una nuova variabile intermedia Introduciamo la variabile intermedia : V2

Per rompere la prima produzione: V1
S  AV1
S  AV1 S  AV1
S  ABTa V1  BTa
V1  BTa V1  BTa
A  TaTaTb A  TaV2
A  TaTaTb A  TaTaTb
B  ATc V2  TaTb
B  ATc B  ATc
Ta  a B  ATc
Ta  a Ta  a
Tb  b Ta  a
Tb  b Tb  b
Tc  c Tb  b
Tc  c Tc  c
15/08/20 7 15/08/20 Tc  c 8
grammatica in Chomsky Normal Form:
In generale:
S  AV1
V1  BTa Per ogni grammatica context-free
A  TaV2 (che non produce  )
Iniziale grammatica non in Chomsky Normal Form
V2  TaTb
S  ABa B  ATc
Possiamo ottenere:
A  aab Ta  a una grammatica equivalente
B  Ac Tb  b in Chomsky Normal Form
15/08/20
Tc  c 9 15/08/20 10
La procedura Poi, per ogni simbolo :a

Nuova variabile: Ta
First remove:
Nuova produzione Ta  a
variabili che si possono
annulare
Nelle produzioni con lunghezza maggiore o
uguale a due
(variabili inutili, optional) a Ta
produzioni della
poni al posto di forma A a
il non terminale
Non necessitano di cambio!
15/08/20 11 15/08/20 12
Rimpiazza Observations
ogni produzione A  C1C2 Cn
• Chomsky normal forms are good
con A  C1V1 for parsing and proving theorems
V1  C2V2

Vn 2  Cn 1Cn • It is easy to find the Chomsky normal
form for any context-free grammatica
Nuove variabili intermedie : V1, V2 , ,Vn2

15/08/20 13 15/08/20 14
15/08/20 15 15/08/20 16
15/08/20 17 15/08/20 18
15/08/20 19 15/08/20 20
15/08/20 21 15/08/20 22
15/08/20 23 15/08/20 24
15/08/20 25
Gli stati dell’automa , Variabili della
grammatica e vale l’opposto.
applicazioni
Le variabili context free sono gli stati del
del PDA?
Pumping Lemma W y Z x K, W yy Z xx K, W yyy Z xxx K
Qualcosa di più complicato dobbiamo
considerare sia la variabile che genera la y
(Y) e sia la variabile che genera la x (X)
Stato YX ?
15/08/20 1 15/08/20 2
Quando ho un linguaggio se «provo» che le Il Pumping Lemma:

parole possono essere scritte • dato un linguaggio regolare infinito L
X y_i Y
A* a, aa, aaa, • esiste un intero m (lunghezza critica)
A*B* due pezzi le A e le B indipendenti
•Per ogni stringa w L con lunghezza | w |  m
W y_i Z x_i K • possiamo scrivere w x y z

A_n B_n no regolare
AA BB non indipendenti • con | x y|  m e | y | 1
• tale che: x yi z  L i  0, 1, 2, ...

15/08/20 3 15/08/20 4
L  {vv R : v  *}
Teorema: Il linguaggio
L  {vv R : v  *}   {a, b}

assumiamo per contradizione
non è regolare che L sia un linguaggio regolare
Proof: Usiamo il Pumping Lemma poichè L è infinito

15/08/20 5 15/08/20 6
L  {vv R : v  *} Dal Pumping Lemma:
sia m la lunghezza critica per L Possiamo scrivere: w  a m b m b m a m  x y z
con lunghezza: | x y |  m, | y | 1
Prendiamo una stringa w tale che: w  L
m m m m
con lunghezza
| w| m w  xyz  a...aa...a...ab...bb...ba...a
x y z
prendiamo w  a mb mb m a m
allora: y  ak, 1  k  m
15/08/20 7 15/08/20 8
x y z  a mb mb m a m y  ak, 1  k  m x y z  a mb mb m a m y  ak, 1  k  m
dal Pumping Lemma: x yi z  L m+k m m m

i  0, 1, 2, ... xy 2 z = a...aa...aa...a...ab...bb...ba...a ∈ L
x y y z
allora: x y2 z  L
allora: a m  k b mb m a m  L
15/08/20 9 15/08/20 10
a m  k b mb m a m  L k 1 Considerare i casi
con y tra le b, tra le
a e tra ab.
ma: L  {vv R : v  *}
m+k m m m
xy 2 z = a...aa...aa...a...ab...bb...ba...a ∈ L
a m  k b mb m a m  L x y y z
CONTRADIZIONE!!!
15/08/20 11 15/08/20 12
quindi: L’assunzione che L è Teorema: il linguaggio
un linguaggio regolare non
L  {a nbl c nl : n, l  0}
è vera
non è regolare
Conclusione: L Non è un linguaggio regolare Proof: Usiamo il Pumping Lemma
END OF PROOF
15/08/20 13 15/08/20 14
L  {a nbl c nl : n, l  0}
L  {a nbl c nl : n, l  0}
sia m la lunghezza critica di L
assumiamo per contradzione
che L sia un linguaggio regolare Prendiamo una stringa w tale che: w  L
e lunghezza | w| m
poichè L è infinito allora
possiamo applicare il Pumping Lemma
prendiamo w  a mb m c 2 m
15/08/20 15 15/08/20 16
Dal Pumping Lemma:
x y z  a mb m c 2 m y  ak, 1  k  m
possiamo scrivere w  a m b m c 2m  x y z
con lunghezzas | x y |  m, | y | 1
Dal Pumping Lemma: x yi z  L
m m 2m
i  0, 1, 2, ...
w  xyz  a...aa...aa...ab...bc...cc...c
x y z
allora: x y 0 z = xz ∈ L
allora: y  ak, 1  k  m
15/08/20 17 15/08/20 18
x y z  a mb m c 2 m y  ak, 1  k  m a mk b mc 2m  L k 1
Dal Pumping Lemma: xz  L

ma: L  {a nbl c nl : n, l  0}
mk m 2m
xz  a...aa...ab...bc...cc...c  L
x z a mk b mc 2m  L
mk m 2m Contradizione.
allora: a b c L
15/08/20 19 15/08/20 20
Vedere gli altri casi. La y tra le Teorema: il linguaggio L  {a n! : n  0}
b, tra le c, tra ab, tra bc.
Non è regolare
La nostra assunzione che L n!  1  2  (n  1)  n

sia un linguaggio regolare
non è vera
Conclusione: L non è un linguaggio regolare
dimostrazione: Usiamo il Pumping Lemma
END OF PROOF
15/08/20 21 15/08/20 22
L  {a n! : n  0}
L  {a n! : n  0}
sia m la lunghezza critica of L
assumiamo che L
sia un linguaggio regolare prendiamo una stringa w tale che: w  L
lunghezza | w| m
poichè L è infinito
prendiamo w  a m!
15/08/20 23 15/08/20 24
Dal Pumping Lemma: x y z  a m! y  ak , 1  k  m
Possiamo scrivere w  a m!  x y z
con lunghezza | x y |  m, | y | 1
Dal Pumping Lemma: x yi z  L
m m! m
m! i  0, 1, 2, ...
w  xyz  a  a...aa...aa...aa...aa...a
x y z
allora: x y2 z  L
allora: y  ak , 1  k  m
15/08/20 25 15/08/20 26
x y z  a m! y  ak , 1  k  m a m! k  L 1 k  m

poichè: L  {a n! : n  0}
mk m!m
xy 2 z  a...aa...aa...aa...aa...aa...a  L
x y y Deve esistere p tale che:
z
m! k  p!
allora: a m! k  L
15/08/20 27 15/08/20 28
ovvero: m! k  m! m per m 1
a m! k  L 1 k  m
 m! m!
 m!m  m!
 m!(m  1) ma: L  {a n! : n  0}
 (m  1)!
m! k  (m  1)! a m! k  L
contradizione
m! k  p! Per ogni p
15/08/20 29 15/08/20 30
quindi: La nostra assunzione che L

È un linguaggio regolare
Applicazioni del
Non è vera
Pumping Lemma
context free
Conclusione: L Non è un linguaggio regolare
END OF PROOF
15/08/20 31 15/08/20 32
The Pumping Lemma:
Per un linguaggio infinito context-free L m>=
Esiste un intero m tale che (2_numero delle variabili
della grammatica)-1
per ogni stringa w  L, | w | m
Perché?
possiamo scrivere w  uvxyz
Con lunghezze | vxy | m and | vy | 1
E deve essere:
i i
uv xy z  L, for all i  0
15/08/20 33 15/08/20 34
linguaggi Non-context free

Teorema: il linguaggio
{a nb nc n : n  0} {vv : v {a, b}} L  {vv : v {a, b}*}
non è context free
linguaggi Context-free
{a nb n : n  0} {ww R : w  {a, b}*} Dim.: Usiamo il Pumping Lemma

Perché? Per i linguaggi context-free
15/08/20 35 15/08/20 36
L  {vv : v {a, b}*} L  {vv : v {a, b}*}
Assumiamo per assurdo che L Pumping Lemma ci dà un magico numero m
è context-free tale che da li in poi due pezzi della stringa
si ripetono.
Prendiamo
una stringa di L con lunghezza almeno m
poichè L è context-free e infinito
Possiamo applicare il pumping lemma sia: a mb m a mb m  L
15/08/20 37 15/08/20 38
L  {vv : v {a, b}*} L  {vv : v {a, b}*}

a mb m a mb m  uvxyz | vxy | m | vy | 1
possiamo scrivere: a mb m a mb m  uvxyz
con lunghezze | vxy | m e | vy | 1

Esaminiamo tutti i possibili “posti”
Dove la stringa vxy può essere
Pumping Lemma dice: in a mb m a mb m
uvi xy i z  L per tutti i  0

15/08/20 39 15/08/20 40
L  {vv : v {a, b}*} L  {vv : v {a, b}*}
a mb m a mb m  uvxyz | vxy | m | vy | 1 a mb m a mb m  uvxyz | vxy | m | vy | 1
Case 1: vxy È nel primo am Case 1: vxy è nel primo am
v  a k1 y  a k2 k1  k 2  1 v  a k1 y  a k2 k1  k 2  1
m m m m m  k1  k 2 m m m
a ...... a b ...... b a ...... a b ...... b a ................ a b ...... b a ...... a b ...... b
u vx y z u v2 x y2 z
15/08/20 41 15/08/20 42
L  {vv : v {a, b}*} L  {vv : v {a, b}*}

Case 1: vxy è nel primo am Case 1: vxy è nel primo am
a m  k1  k2 b m a mb m  uv 2 xy 2 z  L a m  k1  k2 b m a mb m  uv 2 xy 2 z  L
k1  k2  1 Ma dal pumping lemma abbiamo: uv 2 xy 2 z  L
Contradizione!!!
15/08/20 43 15/08/20 44
L  {vv : v {a, b}*} L  {vv : v {a, b}*}
Case 2: v È nel primo am Case 2: v è nel primo am

y È nel primo bm y è nel primo bm
v  a k1 y  b k2 k1  k 2  1 v  a k1 y  b k2 k1  k 2  1
m m m m m  k1 m  k2 m m
a ...... a b ...... b a ...... a b ...... b a ............ a b ............ b a ...... a b ...... b
u v x y z u v2 x y2 z
15/08/20 45 15/08/20 46
L  {vv : v {a, b}*} L  {vv : v {a, b}*}

Case 2: v è nel primo am Case 2: v È nel primo am

y è nel primo bm y È nel primo bm
a m  k1 b m  k2 a mb m  uv 2 xy 2 z  L a m  k1 b m  k2 a mb m  uv 2 xy 2 z  L
k1  k2  1 Dal Pumping Lemma: uv 2 xy 2 z  L
Contradizione!!!
15/08/20 47 15/08/20 48
L  {vv : v {a, b}*} L  {vv : v {a, b}*}
Case 3: v Sovrappone sul primo a mb m Case 3: v Sovrappone sul primo a mb m

y È nel primo bm m
y è nel primo b
v  a k1 b k2 y  b k3 k1, k 2  1 v  a k1 b k2 y  b k3 k1, k 2  1
m m m m m k2 k1 m  k3 m m
a ...... a b ...... b a ...... a b ...... b a ...... a b ... b a ... a b ......... b a ...... a b ...... b
u v xy z u v2 x y2 z
15/08/20 49 15/08/20 50
L  {vv : v {a, b}*} L  {vv : v {a, b}*}

m m
Case 3: v Sovrappone sul primo a mb m Case 3: v Sovrappone sul primo a b
y È nel primo bm y È nel primo bm
a mb k2 a k1 b m  k3 a mb m  uv 2 xy 2 z  L a mb k2 a k1 b k3 a mb m  uv 2 xy 2 z  L
2 2
k1, k 2  1 dal Pumping Lemma: uv xy z  L
assurdo!!!
15/08/20 51 15/08/20 52
L  {vv : v {a, b}*} Altri casi: vxy È dentro a mb m a mb m
a mb m a mb m  uvxyz | vxy | m | vy | 1
or
m
Case 4: v È nel primo a a mb m a mb m
y Sovrappone a mb m
or
Analisi simile al caso 3 a mb m a mb m
m m m m
Analisi simile al caso 1:
a ...... a b ...... b a ...... a b ...... b
uv x y z a mb m a mb m
15/08/20 53 15/08/20 54
Altri casi: vxy sovrappone a mb m a mb m Vi sono altri casi da considerare
or Poichè | vxy | m , è impossibile vxy

Sovrapporre a
a mb m a mb m m m m m
a b a b
O, esclusivo
Analisi simile ai casi 2,3,4: a mb m a mb m

O, esclusivo
m m m m
a b a b
a mb m a mb m
15/08/20 55 15/08/20 56
Linguaggi Non-context free
In tutti i casi raggiungiamo un assurdo
{a nb nc n : n  0} {ww : w  {a, b}}
quindi: {a n! : n  0}
Il punto di partenza che
L  {vv : v {a, b}*}
è context-free è sbagliato
{a nb n : n  0} {ww R : w  {a, b}*}

Conclusione: L Non è context-free
15/08/20 57 15/08/20 58
linguaggi Non-context free

Teorema: il linguaggio
n n n {ww : w  {a, b}}
{a b c : n  0} n2 n
L  {a b : n  0}
n2 n {a n! : n  0} non è context free
{a b : n  0}
n n R Dim: Usiamo il Pumping Lemma

{a b : n  0} {ww : w  {a, b}*}
per linguaggi context-free
15/08/20 59 15/08/20 60
n2 n n2 n
L  {a b : n  0} L  {a b : n  0}
assumiamo per assurdo che L Pumping Lemma ci da m
è context-free
Prendiamo una stringa di L

Con lunghezza almeno m
poichè L è context-free ed è infinito
sia: m2 m
possiamo applicare il pumping lemma a b L
15/08/20 61 15/08/20 62
n2 n n2 n
L  {a b : n  0} L  {a b : n  0}
m2 m
m2 m a b  uvxyz | vxy | m | vy | 1
Prendiamo m: a b  uvxyz
con lunghezze | vxy | m e | vy | 1

Esaminiamo tutte le possibili posizioni
Della stringa vxy in m2 m

Pumping Lemma dice: a b
uvi xy i z  L Per tutte le i0

15/08/20 63 15/08/20 64
n2 n n2 n
L  {a b : n  0} L  {a b : n  0}
m2 m m2 m
a b  uvxyz | vxy | m | vy | 1 a b  uvxyz | vxy | m | vy | 1
k
Sotto caso in cui: v  a k1 y  b 2
Caso interessante: v è in a m
y è in b m Con 1  k1  k 2  m
k
sia v  a k1 y  b 2 con 1  k1  k 2  m Sia i=0
abbiamo:
m2 m m 2  k1 m  k 2
a ..................... a b ...... b a ............... a b ... b
u v x y z u 0x 0 z
15/08/20 65 15/08/20
v y
66
n2 n
L  {a b : n  0} Vediamo il rapporto tra il
2
numero di a e di b quando i=0
a m b m  uvxyz | vxy | m | vy | 1
Sia i=0: (m  k 2 ) 2  (m  1) 2
 m 2  2m  1
v  a k1 y  b k2 1  k1  k 2  m
 m 2  k1
m 2  k1 m  k 2
a b  uv 0 xy 0 z m 2  k1  (m  k 2 ) 2
15/08/20 67 15/08/20 68
m 2  k1  (m  k 2 ) 2 Casi
Caso 1. v e y sono una serie di a, quindi pumping v e y
aumentano le a ma non le b
m 2  k1 m  k2 Caso 2. v e y sono una serie di b, quindi pumping v e y
a b  uv 0 xy 0 z  L aumentano le b ma non le a.
Caso 3 (interessante) visto prima
Ma via PL: v è una serie di a e y è una serie di b.
Si potrebbe pensare che crescono secondo
uv 0 xy 0 z  L le regole del linguaggio. Ma le a dovrebbero
crescere rispetto alle brispettando il fatto
che le tutte le a sono di lunghezza quadratic
assurdo!!! rispetto al numero delle b. Questo non è possibile
Perche le v, quindi le a, crescono linearmente
(allo stesso modo) delle y , ovvero delle b.
15/08/20 69 15/08/20 70
In tutti i casi otteniamo un assurdo
dal Pumping Lemma: uv 0 xy 0 z  L

quindi: L’assunzione che
0 0
uv xy z  L
n2 n
L  {a b : n  0}
m 2  k1 m  k2
a b  uv 0 xy 0 z  L è context-free è sbagliata
Conclusion: L Non è context-free

15/08/20 71 15/08/20 72
Teorema:
Context-Free linguaggi
PDA sono equivalenti
ai
linguaggi
(grammatiche)
 accettati da
PDA
linguaggi Context-Free
15/08/20 1 15/08/20 2
dimostrazione - Step 1:
dimostrazione - step 1
Context-Free linguaggi
linguaggi  accettati by trasforma le
(grammatiche) PDAs
grammatiche Context-Free
in
Traduci ogni grammatica context-free G PDAs
In un PDA M con: L(G )  L( M )
15/08/20 3 15/08/20 4
Prendiamo una grammatica context-free G
Tradurremo G in un PDA M tale che:
L(G )  L( M )
Useremo solo leftmost
15/08/20 5 15/08/20 6
Grammatica consideriamo le
Derivazioni Leftmost Procedura di conversione:
Leftmost Variabile per ogni per ogni

Terminali produzione in G
variabile o terminali terminale in G
 Aw a
 xAy Addiziona
  i  j Bzy le transizioni
, A  w a, a  
produzione Applicata
Variabili
A   i  j Bz
o Terminali
,   S , $  $
Terminali Variabile q0 q1 q2
15/08/20 7 15/08/20 8
esempio Esempio:
grammatica
S  aSTb Input a b a b
S b PDA
T  Ta  , S  aSTb  , S  aSTb $
Time 0
T  , S  b , S  b Stack
 , T  Ta a, a    , T  Ta a, a  
, T   b, b   , T   b, b  
,   S , $  $ ,   S , $  $
q0 q1 q2 q0 q1 q2
15/08/20 9 15/08/20 10
derivazione: S derivazione: S  aSTb a

S
Input a b a b Input a b a b
T
S b
 , S  aSTb $  , S  aSTb $
Time 1 Time 2
, S  b Stack , S  b Stack
 , T  Ta a, a    , T  Ta a, a  
, T   b, b   , T   b, b  
q0  ,   S q1 , $  $ q2 q0  ,   S q1 , $  $ q2
15/08/20 11 15/08/20 12
derivazione:S  aSTb a derivazione:S  aSTb  abTb
S b
T T
b b
 , S  aSTb $  , S  aSTb $
Time 3 Time 4
 , T  Ta a, a    , T  Ta a, a  
, T   b, b   , T   b, b  
q0  ,   S q1 , $  $ q2 q0  ,   S q1 , $  $ q2
15/08/20 13 15/08/20 14
derivazione:S  aSTb  abTb derivazione:S  aSTb  abTb  abTab

b T
T a
b b
 , S  aSTb $  , S  aSTb $
Time 5 Time 6
 , T  Ta a, a    , T  Ta a, a  
, T   b, b   , T   b, b  
q0  ,   S q1 , $  $ q2 q0  ,   S q1 , $  $ q2
15/08/20 15 15/08/20 16
derivazione:S  aSTb  abTb  abTab  abab derivazione:S  aSTb  abTb  abTab  abab
T
a a
b b
 , S  aSTb $  , S  aSTb $
Time 7 Time 8
 , T  Ta a, a    , T  Ta a, a  
, T   b, b   , T   b, b  
q0  ,   S q1 , $  $ q2 q0  ,   S q1 , $  $ q2
15/08/20 17 15/08/20 18
derivazione:S  aSTb  abTb  abTab  abab derivazione:S  aSTb  abTb  abTab  abab
b
 , S  aSTb $  , S  aSTb $
Time 9 Time 10
 , T  Ta a, a    , T  Ta a, a  
, T   b, b   , T   b, b  
accettaz
q0  ,   S q1 , $  $ q2 q0  ,   S q1 , $  $ q2
15/08/20 19 15/08/20 20
Procedura di conversione: esempio
grammatica
per ogni per ogni S  aSTb
produzione in G PDA
terminale in G S b
Aw a T  Ta  , S  aSTb
Addiziona T  , S  b
le transizioni  , T  Ta a, a  
, A  w a, a   , T   b, b  
,   S , $  $ ,   S , $  $
q0 q1 q2 q0 q1 q2
15/08/20 21 15/08/20 22
configurazione istantanea definizione:
Proviamo a dimostrare il (q1, bbb, aaa$)

teorema a
Time n: Input a
Ricordiamo la notazione a a a b b b a
di configurazione
istantanea e di passo di $
computazione. Stack
a,   a b, a  
q0  ,    q1 b, a   q2  , $  $ q3
15/08/20 23 15/08/20 24
configurazione istantanea
(q2 , bb, aa$)
passo di computazione.
a
Time n+1: Input a
a a a b b b a (q1, bbb, aaa$)  (q2 , bb, aa$)
$
Time n Time n+1
Stack
a,   a b, a  
q0  ,    q1 b, a   q2  , $  $ q3
15/08/20 25 15/08/20 26
PDA simula le derivazioni leftmost Procedura di conversione:

grammatica PDA calcolo
per ogni per ogni
Leftmost derivazione (q0 ,  1  k k 1  n ,$) produzione in G terminale in G
S  ( q1 ,  1  k k 1  n , S $) Aw a
 
Addiziona
  1  k X 1  X m  ( q1 ,  k 1  n , X 1  X m $)
le transizioni
  , A  w a, a  
  1  k k 1  n  ( q2 ,  ,$)
simboli Contenuti ,   S , $  $
esaminati Dello Stack
q0 q1 q2
15/08/20 27 15/08/20 28
esempio grammatica Calcolo PDA
grammatica
Derivazione Leftmost
S  aSTb (q0 , abab,$)
PDA S  (q1 , abab, S $)
S b
 , S  aSTb  aSTb  (q1 , bab, STb$)
T  Ta  (q1 , bab, bTb$)
, S  b  abTb
T   (q1 , ab, Tb$)
 , T  Ta a, a    abTab  (q1 , ab, Tab $)
, T   b, b    abab  (q1 , ab, ab$)

 (q1 , b, b$)
 (q1 ,  ,$)
,   S , $  $  (q2 ,  ,$)
q0 q1 q2
15/08/20 29 15/08/20 30
grammatica grammatica
calcolo del PDA calcolo del PDA
Leftmost derivazione Leftmost derivazione
 
 
 xAy  (q1 ,  i  n , Ay $)
 xAy  (q1 ,  i  n , Ay $)
  i  j Bzy  (q1 ,  i  n ,  i  j Bzy $)
  i  j Bzy  (q1 ,  i  n ,  i  j Bzy $)
 (q1 ,  i 1  n ,  i 1  j Bzy $)
Produzione Applicata Transizione applicata
Transizione applicata
A   i  j Bz leggi  i dall’input
, A   i  j Bz  i , i  
E rimuovilo dallo stack
q0  ,   S q1 , $  $ q2 q0  ,   S q1 , $  $ q2
15/08/20 31 15/08/20 32
grammatica Il processo viene ripetuto con successiva
PDA calcolo
Leftmost derivazione  variabile leftmost


 xAy  (q1 ,  i  n , Ay $)
 xAy 
  i  j Bzy  (q1 ,  i  n ,  i  j Bzy $)
  i  j Bzy  (q1 ,  j 1  n , Bzy $)
 (q1 ,  i 1  n ,  i 1  j Bzy $)   i  j j 1  k Cpzy  (q1 ,  j 1  n ,  j 1  k Cpzy $)


 (q1 ,  j 1  n , Bzy $)
 (q1 ,  k 1  n , Cpzy $)
ultima Transizione applicata
tutti simboli  i  j Produzione applicata
 j , j  
Sono stati rimossi B   j 1  k Cp E cosi via
Dal top dello stack
q0  ,   S q1 , $  $ q2
15/08/20 33 15/08/20 34
dimostrato che:
Proof - step 2
grammatica G
Genera la PDA M
Se e accetta w Tradurre
stringa w
solo se i PDA
* (q0 , w,$)  (q2 ,  ,$)
Sw in
grammatiche Context-Free
quindi L(G )  L( M )
15/08/20 35 15/08/20 36
Prendi un qualsiasi PDA M Prima di tutto modifica PDA M tale che:
1. PDA ha un solo stato di accettazione
Traduremmo M 2. Svuota tutta la pila prima di accettare

In una grammatica G context-free
3. Per ogni transizione o
tale che: L(M )  L(G ) push un simbolo
oppure
pop un simbolo
ma non entrambe le cose
15/08/20 37 15/08/20 38
Inoltre abbiamo: 1. il PDA deve avere un solo stato di

accettazione
PDA M1 vecchi
• - nuovo simbolo iniziale @ Stati di
accettazione
nuovo
• - stato di accettazione nello stack solo @ PDA M , 
 Stato di
 accettazione
,   
qf

 , 
15/08/20 39 15/08/20 40
2. Nuovo simbolo iniziale dello stack 3. Nello stato di accetazione
Top of stack
lo stack contiene
Z Vecchio simbolo iniziale
solo il simbolo @
@ Simbolo ausiliario stack
PDA M3 Stack vuoto
x    {@}
PDA M2 vecchio nuovo
PDA M1 Stato di
, x  Stato di
,   @ ,   Z PDA M2
accettazione accettazione
,    , @   qf
M1 pensa ancora che Z è il simbolo iniziale

15/08/20 41 15/08/20 42
4. Ogni transizione ha un push oppure un pop

Mai le due cose insieme.
,   
PDA M3 qi qj
, a  b
PDA M3 qi qj
qi
,    ,   
PDA M4 qj
, a   ,   b q
PDA M4 qi j
dove  è un qualsiasi simbolo
15/08/20 43 15/08/20
dell’alfabeto di input 44
Esempio: M a,   a
b, a  
PDA M4 è il PDA completamente
modificato secondo le regole precedenti
q
Notiamo che il nuovo simbolo iniziale @ non M4 a,   a

, a  
, b  
è mai usato in nessuna transizione b, a   , Z  
q0
,   a , @  
,   @ q2 q3 , a   q4 q5
q1 ,   Z
15/08/20 45 15/08/20 46
PDA
Costruzione della grammatica caso 1: per ogni stato
q
variabili: Aqi ,q j
stati del PDA grammatica
Aqq  
15/08/20 47 15/08/20 48
PDA PDA
caso 2: per ogni tre stati caso 3: per ogni coppia di transizioni
p q r a,   t b,t   q
p r s
grammatica grammatica
Apq  Apr Arq Apq  aArs b
15/08/20 49 15/08/20 50
PDA Esempio: PDA

Stato Iniziale Stato accettazione
q0 qf M4 a,   a
, a  
, b  
b, a   , Z  
q0
,   a , @  
grammatica
,   @ q2 q3 , a   q4 q5
q1 ,   Z
Variabile Start Aq0qf
15/08/20 51 15/08/20 52
grammatica caso 2: da triple di stati
Aq0q0  Aq0q0 Aq0q0 | Aq0q1 Aq1q0 | Aq0q2 Aq2q0 | Aq0q3 Aq3q0 | Aq0q4 Aq4q0 | Aq0q5 Aq5q0
caso 1: da stati singoli
Aq0q0  

Aq1q1   Aq0q5  Aq0q0 Aq0q5 | Aq0q1 Aq1q5 | Aq0q2 Aq2q5 | Aq0q3 Aq3q5 | Aq0q4 Aq4q5 | Aq0q5 Aq5q5

Aq2q2  
Aq3q3  
Aq4q4  
Aq5q5   Variabile Start Aq0q5
15/08/20 53 15/08/20 54
PDA caso 3: da coppie di transizioni

caso 3: per ogni coppia di transizioni M4 a,   a
, a  
, b  
b, a   , Z  
q0
a,   t b,t   q
p r s ,   @ q2 ,   a
q3 , a   q4
, @  
q5
q1 ,   Z
grammatica
Aq0q5  Aq1q4 Aq2q4  aAq2q4 Aq2q2  Aq3q2 b
Apq  aArs b Aq1q4  Aq2q4 Aq2q2  aAq2q2 b Aq2q4  Aq3q3
Aq2q4  aAq2q3 Aq2q4  Aq3q4
15/08/20 55 15/08/20 56
Supponiamo che il PDA M è stato tradotto L(G )  L(M )
In una grammatica context-free G Dobbiamo mostrare che se G ha
una derivazione:

Dobbiamo provare L(G )  L(M ) Aq0qf  w (stringa di terminali)
O in modo equivalente Allora vi è un calcolo in M che accetta w :

L(G )  L(M ) L(G )  L(M ) 
( q0 , w, @) ( q f ,  , @)
15/08/20 57 15/08/20 58
partiamo con una p e una q qualsiasi. Dopo aver provato

il passo precedente 
Aq0qf w
Se in G vi è una derivazione: abbiamo:

Apq w 
(q0 ,w ,  ) (qf , ,  )
Allora vi è un calcolo in M : Poichè non c’è nessuna

( p ,w ,  ) (q , ,  ) transizione 
Con il simbolo @ (q0 , w, @) (q f ,  , @)
15/08/20 59 15/08/20 60
Lemma: Dim intuitiva:
 Apq    w
se Apq  w (stringa di terminali)
Allora vi è un calcolo
dallo stato p allo stato q
sulla stringa w Case 1: Apq  Apr Arq    w
Che lascia lo stack vuoto:

( p ,w ,  ) (q , ,  ) Case 2: Apq  aArs b    w
15/08/20 61 15/08/20 62
Type 2 Type 3
Case 1: Apq  Apr Arq    w Case 2: Apq  aArs b    w
altezza altezza
Stack Stack
r s
p r q p a b q
Input string Generato da Apr Generato da Arq Input string Generato da Ars
15/08/20 63 15/08/20 64
Formale : base: Apq  w
(Uno step di derivazione)
Proviamo l’asserto per induzione
Sul numero di step della derivazione: caso 1 produzione che deve essere usata è:
App  
Apq    w Quindi p q e w 
Numero di step Questo calcolo nel PDA esiste (banale):


( p , ,  ) ( p , ,  )
15/08/20 65 15/08/20 66
Ipotesi induttiva: Step induttivo Data:
Apq    w Apq    w
con k Step di derivazione con k 1 step

di derivazione
Quindi abbiamo, per ipotesi induttiva: Dobbiamo provare:
 
( p ,w ,  ) (q , ,  ) ( p ,w ,  ) (q , ,  )
15/08/20 67 15/08/20 68
Apq    w
Case 1: Apq  Apr Arq    w
k 1 derivazione steps
k  1 steps
Sia: w  yz
Case 1: Apq  Apr Arq    w
Apr    y Arq    z
Case 2: Apq  aArs b    w Massimo k steps Massimo k steps
15/08/20 69 15/08/20 70
 
Apr    y Arq    z ( p , y ,  ) (r , ,  ) (r , z ,  ) (q , ,  )
massimo k steps massimo k steps
 
( p , yz ,  ) (r , z ,  ) (q , ,  )
Per ipotesi induttiva Per ipotesi induttiva, poichè w  yz

in PDA: in PDA:
  
( p , y ,  ) (r , ,  ) (r , z ,  ) (q , ,  ) ( p ,w ,  ) (q , ,  )
15/08/20 71 15/08/20 72
Ars    y
Case 2: Apq  aArs b    w
Massimo k steps
k 1 steps
Possiamo scrivere
w  ayb
Per ipotesi induttiva ,
il PDA calcola:
Ars    y 
(r , y ,  ) (s , ,  )
Massimo k steps
15/08/20 73 15/08/20 74
Apq  aArs b    w a, t b,t   q

p r s
La grammatica contiene la produzione

Apq  aArs b
( p , ayb ,  )  (r , yb ,t ) (s , b ,t )  (q , ,  )
e il PDA contiene la transizione
a, t b,t   q
p r s
15/08/20 75 15/08/20 76
sappiamo
  
(r , y ,  ) (s , ,  ) (r , yb ,t ) (s , b ,t ) ( p , ayb ,  )  (r , yb ,t ) (s , b ,t )  (q , ,  )
( p , ayb ,  )  (r , yb ,t ) poichè w  ayb

Inoltre sappiamo
(s , b ,t )  (q , ,  ) 
( p ,w ,  ) (q , ,  )
quindi:

( p , ayb ,  )  (r , yb ,t ) (s , b ,t )  (q , ,  )
Fine
15/08/20 77 15/08/20 78
q1 a, b → w q2
λ, b → w
q1 q2
primavera 2016 1 primavera 2016 2
a, b → w1 q2 λ , b → w1 q2
a, b → w1 q2 λ , b → w1 q2
q1 q1
q1 q1
a , b → w2 q3 a , b → w2 q3
a , c → w2 q3 λ , c → w2 q3

L
n n
L( M ) = {a b : n ≥ 0}
!
a, λ → a b, a → λ "
L( M ) = {a nb n : n ≥ 0}
q0 a, λ → a q1 b, a → λ q2 λ , $ → $ q3
" #
L( M ) = {vv R : v ∈ {a, b}*}
a, λ → a a, a → λ a, λ → a a, a → λ
b, λ → b b, b → λ b, λ → b b, b → λ
q0 λ, λ → λ q1 λ, $ → $ q2 q0 λ, λ → λ q1 λ, $ → $ q2

(
% & #' ⊆ % & #'
% & #' L = {a nb n } ∪ {a nb 2n }
%
*
& #' ⊂ *
n≥0
++
L∉ L∈
, L & )
)
, L & #)
& #) L
L = {a nb n } ∪ {a nb 2n }
L = {a nb n } ∪ {a nb 2n }
L & #)
& #)
- % & #) L
S → S1 | S 2 {a nb n } ∪ {a nb 2n }
L
S1 → aS1b | λ {a nb n }
S 2 → aS2bb | λ {a nb 2n }
M L( M ) = {a nb n } ∪ {a nb 2n }
L = {a nb n } ∪ {a nb 2n }
a nb n
& )
a nb n bn
.
" M L
a nb 2 n
M L( M ) = {a nb n } ∪ {a nb 2n } {a nb nc n }
& #)
% & #)
a nb n
M
1
a nb n bn a*b*
/ 0 & )
L ∪ {a nb nc n } 2
& #)
L ∪ {a nb nc n }
( L = {a nb n } ∪ {a nb 2n }) ( L = {a nb n } ∪ {a nb 2n })
% 3
& #)

M L( M ) = {a nb n } ∪ {a nb 2n } L ∪ {a nb nc n }
a nb n bn
% ) M
% ) M′
M
) a nb n bn
M b
c
M′ L( M ′) = {a nc n } ∪ {a nc 2n } λ λ
M′
a nc n cn
a nc n cn
.
L ∪ {a nb nc n }
4 & #) L = {a nb n } ∪ {a nb 2n }
& )
L ∪ {a nb nc n } & #)
' & )
The CYK Algorithm The CYK Algorithm
• Il problema dell’appartenenza:
– Problema:
• Data una grammatica grammar G e una stringa w
– La grammatica è scritta in Chomsky Normal Form
– G = (V, ∑ ,P , S) dove – Viene usata una tecnica chiamata “dynamic
» V insieme finito di variabili programming” o “table-filling algorithm”
» ∑ (alfabeto) insieme finito di simboli terminali-
» P insieme finito di produzioni
» S simbolo iniziale (elemento distintivo di V)
» V e ∑ sono insiemi disgiunti
– G genera un linguaggio, L(G),
– Domanda :
• w appartiene al L(G)?
08/15/20 1 08/15/20 2
Chomsky Normal Form Costruire una Triangular Table

• Normal Form è descritta da un insieme di X5, 1
condizioni che ogni regola della grammatica deve X4, 1 X4, 2
soddisfare.
X3, 1 X3, 2 X3, 3
• Context-free grammar è in CNF, ogni regola ha la
X2, 1 X2, 2 X2, 3 X2, 4
seguente forma:
– A  BC al massimo due simboli sul lato destro X1, 1 X1, 2 X1, 3 X1, 4 X1, 5
– Aa a simbolo terminale w1 w2 w3 w4 w5
– Sλ stringa vuota
Tavola per una stringa ‘w’ che ha lunghezza 5
Dove B, C Є V – {S}
08/15/20 3 08/15/20 4
Esempio CYK Algorithm Constructing The Triangular Table
S  AB | BC
• Prendiamo la seguente grammatica: A  BA | a
B  CC | b
– CNF grammatica G C  AB | a
• S  AB | BC
• A  BA | a
• B  CC | b
• C  AB | a {B} {A, C} {A, C} {B} {A, C}
– w sia baaba b a a b a
– E’ baaba in L(G)?
Calcolare la riga più bassa
08/15/20 5 08/15/20 6
Costruire la Triangular Table

• X2 , 1 = (X1 , 1 , X1 , 2)
•  {B}{A,C} = {BA, BC}
• Step:
– Trovare, se esistono, le regole che producono BA {S, A}
or BC {B} {A, C} {A, C} {B} {A, C}
– Sono due : S e A S  AB | BC b a a b a
– X2 , 1 = {S, A} A  BA | a
B  CC | b
C  AB | a
08/15/20 7 08/15/20 8
Constructing The Triangular Table
• X2 , 2 = (X1 , 2 , X1 , 3)
•  {A, C}{A,C} = {AA, AC, CA, CC} = Y
• Step:
– Trovare, se esistono, le regole che producono Y {S, A} {B}
– Esiste una : B {B} {A, C} {A, C} {B} {A, C}
S  AB | BC
– X2 , 2 = {B} A  BA | a b a a b a
B  CC | b
C  AB | a
08/15/20 9 08/15/20 10
• X2 , 3 = (X1 , 3 , X1 , 4)
•  {A, C}{B} = {AB, CB} = Y
• Steps:
– Trovare, se esistono, le regole che producono Y {S, A} {B} {S, C}
– sono: S e C {B} {A, C} {A, C} {B} {A, C}
S  AB | BC
– X2 , 3 = {S, C} A  BA | a b a a b a
B  CC | b
C  AB | a
08/15/20 11 08/15/20 12
Constructing The Triangular Table
• X2 , 4 = (X1 , 4 , X1 , 5)
•  {B}{A, C} = {BA, BC} = Y
• Steps:
– Trovare, se esistono, le regole che producono Y {S, A} {B} {S, C} {S, A}
– Cono: S and A {B} {A, C} {A, C} {B} {A, C}
S  AB | BC
– X2 , 4 = {S, A} A  BA | a b a a b a
B  CC | b
C  AB | a
08/15/20 13 08/15/20 14
• X3 ,1 = (X1 , 1 , X2 , 2) , (X2 , 1 , X1 , 3)
•  {B}{B} U {S, A}{A, C}= {BB, SA, SC, AA, AC} = Y
• Steps: Ø
– Nessuna {B} {A, C} {A, C} {B} {A, C}
S  AB | BC
– X3 , 1 = Ø A  BA | a b a a b a
 CC | b
– Nessun elemento in questo insieme BC  AB | a
08/15/20 15 08/15/20 16
• X3 , 2 = (X1 , 2 , X2 , 3) , (X2 , 2 , X1 , 3)
•  {A, C}{S, C} U {B}{B}= {AS, AC, CS, CC, BB} = Y
• Step: Ø {B}
– una: B {B} {A, C} {A, C} {B} {A, C}
S  AB | BC
– X2 , 4 = {B} A  BA | a b a a b a
B  CC | b
C  AB | a
08/15/20 17 08/15/20 18
• X3 , 3 = (X1 , 3 , X2 , 4) , (X2 , 3 , X1 , 5)
•  {A,C}{S,A} U {S,C}{A,C}
= {AS, AA, CS, CA, SA, SC, CA, CC} = Y Ø {B} {B}
• Step: {S, A} {B} {S, C} {S, A}
– Trovare, se esistono, le regole che producono Y {B} {A, C} {A, C} {B} {A, C}
– una: B b a a b a
S  AB | BC
– X3 , 5 = {B} A  BA | a
B  CC | b
C  AB | a
08/15/20 19 08/15/20 20
• X4 , 1 = (X1 , 1 , X3 , 2) , (X2 , 1 , X2 , 3) • X4 , 2 = (X1 , 2 , X3 , 3) , (X2 , 2 , X2 , 4)
• (X3, 1 , X1 , 4) • (X3, 2 , X1 , 5)
• Step: • Step:
– Trovare, se esistono, le regole che producono Y – Trovare, se esistono, le regole che producono Y
– una: B – una: B
– X4 , 1 = {?} S  AB | BC – X4 , 1 = {?} S  AB | BC
A  BA | a A  BA | a
B  CC | b B  CC | b
C  AB | a C  AB | a
08/15/20 21 08/15/20 22
Finale Triangular Table domanda

{S, A, C}  X5, 1 – sia G la grammatical CNF
Ø {S, A, C} • S  AB | BC
• A  BA | a
Ø {B} {B}
• B  CC | b
{S, A} {B} {S, C} {S, A} • C  AB | a
{B} {A, C} {A, C} {B} {A, C} – w is ababa
b a a b a – Domanda: ababa è in L(G)?
- Tavola per la stringa ‘w’ ha lunghezza 5

- The algorithm popola la triangular table
08/15/20 23 08/15/20 24
Construire una Triangular Table
• E’ baaba in L(G)? • Ogni riga corrisponde a una lunghezza delle
sottostringhe.
Si – La riga più in basso – Stringhe di lng 1
– Seconda riga – Stringhe di lng 2
Possiamo vedere che S è nell’insieme X1n dove .
.
‘n’= 5
– Riga più in alto – la stringa ‘w’
la cella X51 = (S, A, C) allora
S Є X15 allora baaba Є L(G)
08/15/20 25 08/15/20 26
Costruire una Triangular Table teorema

• Xi, i è l’insieme delle variabili tale che A è
A  wi una produzione di G • The CYK Algorithm calcola correttamente X i j
• Comparare al massimo n coppie di insieme per tutti i e j; allora w è in L(G) iff S è in X1n.
calcolati in precedenza • Perchè? Spiegazione, esercizio scrivere la
(Xi, i , Xi+1, j ), (Xi, i+1 , Xi+2, j ) … (Xi, j-1 , Xj, j ) dimostrazione.
• Complessità O(n3).
08/15/20 27 08/15/20 28
• let the input be a string L consisting of n characters: a1 ... an.
• let the grammar contain r nonterminal symbols R1 ... Rr , with start symbol
R1 .
• let P[n,n,r] be an array of booleans. Initialize all elements of P to false. {S, A, C}  X5, 1
• for each s = 1 to n
• for each unit production Rv -> as
Ø {S, A, C}
• set P[1,s,v] = true ; Generata la prima riga- Ø {B} {B}
• for each L = 2 to n
{S, A} {B} {S, C} {S, A}
• for each s = 1 to n-L+1
• for each p = 1 to L-1 {B} {A, C} {A, C} {B} {A, C}
• for each production Ra -> Rb Rc
b a a b a
• if P[p,s,b] and P[L-p,s+p,c] then set P[L,s,a] = true
• if P[n,1,1] is true then L is member of language

• else L is not member of language
08/15/20 29 08/15/20 30
for each L = 2 to n
for each s = 1 to n-L+1
for each p = 1 to L-1
for each production Ra -> Rb Rc
if P[p,s,b] and P[L-p,s+p,c] then set P[L,s,a] = true
(5)n-
X5, 1 X5, 1
L+1=s
(4)n- X4, 1 X4, 2
X4, 1 X4, 2
L+1=s X3, 1 X3, 2 X3, 3 L=3, s=1
(3)n-L+1 X2, 1 X2, 2 X2, 3 X2, 4
X3, 1 X3, 2 X3, 3
=s
X1, 1 X1, 2 X1, 3 X1, 4 X1, 5
(2)n-
X2, 1 X2, 2 X2, 3 X2, 4
L+1=s w1 w2 w3 w4 w5
X1, 1 X1, 2 X1, 3 X1, 4 X1, 5 Tavola per una stringa ‘w’ che ha lunghezza 5
08/15/20 w1 w2 w3 w4 w5 31 08/15/20 32
for each L = 2 to n for each L = 2 to n
for each s = 1 to n-L+1 for each s = 1 to n-L+1
for each p = 1 to L-1 for each p = 1 to L-1
for each production Ra -> Rb Rc for each production Ra -> Rb Rc
if P[p,s,b] and P[L-p,s+p,c] then set P[L,s,a] = true if P[p,s,b] and P[L-p,s+p,c] then set P[L,s,a] = true
X5, 1
X5, 1 X4, 1 X4, 2
X4, 1 X4, 2 L=4, s=2 X3, 1 X3, 2 X3, 3
X3, 1 X3, 2 X3, 3 X2, 1 X2, 2 X2, 3 X2, 4
X2, 1 X2, 2 X2, 3 X2, 4 X1, 1 X1, 2 X1, 3 X1, 4 X1, 5
X1, 1 X1, 2 X1, 3 X1, 4 X1, 5
w1 w2 w3 w4 w5
w1 w2 w3 w4 w5
08/15/20 33 08/15/20 34
Un algoritmo di forza bruta per testare se un
grafo G contiene una cricca con k vertici, e per
trovare qualsiasi cricca di questo tipo che esso
contiene, deve esaminare ciascun sottografo
con almeno k vertici e controllare per vedere
se forma una cricca. Questo algoritmo impiega Altre modelli di Computazione
il tempo O(nk k2): ci sono O(nk) sottografi da
controllare, ciascuno dei quali ha O(k2) spigoli
la cui presenza in G deve essere controllata.
Pertanto, il problema può essere risolto in
tempo polinomiale ogni qual volta k sia una
costante fissa. Quando k fa parte dell'entrata
del problema, tuttavia, il tempo è
esponenziale.[6]
15/08/2020 2
Church’s Thesis:
modelli di Computazione
tutti I modelli di computazione

•Turing Machines sono equivalenti
•Recursive Functions
•Post Systems
•Rewriting Systems Turing’s Thesis:
una computazione è meccanica se e solo se

Può essere eseguita da una Turing Machine
15/08/2020 3 15/08/2020 4
Church’s e Turing’s Thesis sono simili
Funzioni ricorsive
esempio:
Church-Turing Thesis
f ( n)  n 2  1
Domain Range
3 f (3)  10 10
15/08/2020 5 15/08/2020 6
funzioni ricorsive Primitive di Base
We need a way to define functions Zero function: z ( x)  0
Successor function: s ( x)  x  1
We need a set of basic functions
Projection functions: p1( x1, x2 )  x1
p2 ( x1, x2 )  x2
15/08/2020 7 15/08/2020 8
Costruire funzioni più complicate : Ogni funzione costruita a partire dalle
Funzioni di base e chiuse rispetto composizione
Composizione: f ( x, y )  h( g1( x, y ), g 2 ( x, y )) e ricorsione è chiamata:
Primitive Recursive Function
Ricorsione primitiva:
f ( x,0)  g1( x)
f ( x, y  1)  h( g 2 ( x, y ), f ( x, y ))
15/08/2020 9 15/08/2020 10
A Primitive Recursive Function: add ( x, y )
add (3,2)  s (add (3,1))

add ( x,0)  x (projection)  s ( s (add (3,0)))
 s ( s (3))
 s ( 4)
add ( x, y  1)  s (add ( x, y )) 5
(successor function)
15/08/2020 11 15/08/2020 12
Primitive Recursive Function: Teorema:
mult ( x, y ) l’insieme delle funzioni primitive recursive
è countable
mult ( x,0)  0 dim:

Ogni funzione ricorsiva primitiva
Può essere codificata come una stringaa
Enumeriamo tutte le stringhe in proper
mult ( x, y  1)  add ( x, mult ( x, y )) order
Possiamo verificare se una stringa
15/08/2020 13 15/08/2020 14
Teorema
vi è una funzione che non
è primitiva ricorsiva Definiamo la funzione g (i )  fi (i )  1
Dimostrazione: g Differisce da ogni fi

Enumeriamo le funzioni ricorsive primitive
g Non è primitiva ricorsiva

f1, f 2 , f3 , 
È calcolabile?
15/08/2020 15 15/08/2020
Fine Dimostrazione 16
Una funzione specifica che non è   Recursive Functions
Recursive Primitive :
y ( g ( x, y ))  smallest y such that g ( x, y )  0
Ackermann’s function:
A(0, y )  y  1
A( x,0)  A( x  1,1) Accerman’s function è
A( x, y  1)  A( x  1, A( x, y ))   Recursive Function
Cresce molto velocemente,

Piu veloce di ogni funzione primitive recursive
15/08/2020 17 15/08/2020 18
Post Systems
  Recursive Functions • Axioms
• Productions
Primitive recursive functions

Molto simile alle grammatiche
senza restrizione
15/08/2020 19 15/08/2020 20
esempio: Unary Addition Una produzione:
V1  V2  V3  V11  V2  V31
Assioma: 1  1  11
1  1  11  11  1  111  11  11  1111
Produzioni:
V1  V2  V3  V11  V2  V31
V1  V2  V3  V1  V21  V31 V1  V2  V3  V1  V21  V31
15/08/2020 21 15/08/2020 22
Post systems are good for

Teorema:
proving mathematical statements
A language is recursively enumerable
from a set of Axioms
(semidecidibile)
if and only if
a Post system generates it
15/08/2020 23 15/08/2020 24
Matrix Grammars
Rewriting Systems Esempio:
They convert one stringa to another P1 : S  S1S2
P2 : S1  aS1, S2  bS2c
• Matrix Grammars
P3 : S1   , S2  
• Markov Algorithms
Derivazioni:
• Lindenmayer-Systems
S  S1S 2  aS1bS2c  aaS1bbS2cc  aabbcc
Un insieme di produzioni sono
Very similar to unrestricted grammars
applicate in parallelo
15/08/2020 25 15/08/2020 26
Markov Algorithms
P1 : S  S1S2 Grammatiche che producono
P2 : S1  aS1, S2  bS2c 
P3 : S1   , S 2  
Esempio: ab  S
aSb  S
L  {a nb nc n : n  0}
S  .
Teorema: Derivation:
if and only if aaabbb  aaSbb  aSb  S  
a Matrix grammar generates it
15/08/2020 27 15/08/2020 28
*
In general: L  {w : w  }
ab  S
aSb  S
S  .
Teorema:

L  {a nb n : n  0}
if and only if
a Markov algorithm generates it
15/08/2020 29 15/08/2020 30
Lindenmayer-Systems Lindenmayer-Systems are not general

Sistemi paralleli di “rewriting systems” As recursively enumerable languages
Esempio: a  aa
Extended Lindenmayer-Systems: ( x, a, y )  u
context
Derivation: a  aa  aaaa  aaaaaaaa
Teorema:
2n if and only if an
L  {a : n  0}
Extended Lindenmayer-System generates it
15/08/2020 31 15/08/2020 32
Considera una Turing Machine deterministica
M che decide un linguaggio L
Per ogni stringa w la computazione di M
Complessità temporale termina usando una quantità finita
di transizioni

Iniziale Accetta
stato o rifiuta w
15/08/20 1 15/08/20 2
Consideriamo ora, tutte le stringhe di

Lunghezza n
Tempo di Decisione = #transizioni TM (n ) = massimo tempo richiesto

per decidere (calcolare)
Una qualsiasi stringa di
 lunghezza n
stato accettare
Iniziale or rigettare w
15/08/20 3 15/08/20 4
Classe Complessità temporale : TIME (T (n ))
Tutti i linguaggi decidibili da una

Turing Machine deterministica
in tempo O (T (n ))
L1 L2
L3
15/08/20 5 15/08/20 6
Esempio: L1  {a n b : n  0 } Altri esempi nella stessa classe

TIME (n )
Può essere deciso in tempo O (n )
L1  {a n b : n  0 }
TIME (n ) {ab n aba : n , k  0 }
{b n : n è pari}
L1  {a n b : n  0 }
{b n : n  3k }
15/08/20 7 15/08/20 8
Esempi nella classe
TIME (n 2 )
{a n b n : n  0 }
{ww R : w  {a , b }}
{ww : w  {a , b }}
15/08/20 9 15/08/20 10
Esempi nella classe:

TIME (n 3 )
Anche su sipster algoritmi tempo Polinomiale : TIME (n k )
CYK algorithm
L2  { G, w : w è generata da una grammatica costante k  0
context - free G}
Rappresentano gli algoritmi trattabili:

Moltiplicazione tra matrici
L3  { M1 , M2 , M3 : n  n matrices Per piccoli k possiamo decidere
il risultato velocemente
and M1  M2  M3 }
15/08/20 11 15/08/20 12
architetture
chiaramente: TIME (n k 1 )  TIME (n k )
Multitape = singolo tape in
tempo quadratico
TIME (n k 1 )
Anche sul sipster
TIME (n k )
15/08/20 13 15/08/20 14
La Classe di Complessità temporale P Class P

{a n b }
k
P  TIME (n )
{a n b n }
k 0 {ww }
Representa: CYK-algorithm
•Algoritmi che usano tempo polinomiale
•Problemi “trattabili”
15/08/20 15 15/08/20 16
Dato un grafo e due nodi: esiste Dato un grafo e due nodi: esiste
un cammino da un nodo all’altro? un cammino da un nodo all’altro?
s t
Step 1 : 1
Step 4: 1
Step 2,3 : m (numero dei nodi)
15/08/20 17 15/08/20 18
Qualche problema non in P Ricordiamo:

poly ( k )
algoritmi calcolabili TIME (2 )

in tempo esponenziale k
TIME (2 n )
NonDeterminismo =
Determinismo in tempo
Rappresentano algoritmi intrattabili
esponenziale (dim anche
Per alcuni input ci possono volere sipster)
secoli per trovare la soluzione
15/08/20 19 15/08/20 20
uno Problema del Cammino
Problema: Cammino Hamiltonian Hamiltonian
un cammino in un grafo
(orientato o non orientato) s t
è detto hamiltoniano se
esso tocca tutti i vertici
del grafo
domanda: vi è un Cammino Hamiltoniano
una e una sola volta.
da s a t?
tocca tutti i vertici del grafo
15/08/20 21 15/08/20 22
Non esistono algoritmi

efficienti per la risoluzione
del «problema del cammino
s hamiltoniano», l'unico
t
metodo di risoluzione è
rappresentato
dall'enumerazione totale,
ovvero nell'enumerazione di
si tocca tutti i vertici del tutti i possibili cammini sul
grafo una e una sola grafo fino a che non si trovi
volta. il cammino voluto.
15/08/20 23 15/08/20 24
poly ( k )
ab, ba Permutazione di n elementi Una soluzione : TIME (2 )

Arriva c Lavorare su tutti i cammini
Possibili posizioni: Avanti, Dietro,
mezzo(posizione 2);tre nuovi elementi L = {<G,s,t>: vi è un Cammino Hamiltonian
per ogni elemento di partenza in G da s a t}
cab, acb,abc, cba, bca, bac (3!) n!=nx(n-1)x…. nxnxn...
Arriva d prendiamo per esempio abc
k
Avanti, Dietro, posizione 2, posizione 3 L  TIME (n!)  TIME (2 n ) k=2
(Aa2b3cD); sono 4 nuovi elementi per
ogni elemento di partenza Permutazione di tempo Esponenzale
Per ogni tripla n elementi
6*4= 24=4! problema Intrattabile
15/08/20 25 15/08/20 26
Esempio: Il problema della cricca

due
problema della cricca
dato un grafo e dato un k
trovare un insieme di k nodi dove

ciascun elemento è connesso con tutti
gli altri.
Esiste una cricca di grado 5?
15/08/20 27 15/08/20 28
Il problema della cricca
Tutte le permutazioni di 5 elementi
e verificare che ogni elemento è
connesso con tutti gli altri.
5! X 5!
Per precisione 5!x(5-1)x(4-1)…x1
Esiste una cricca di grado 5.
15/08/20 29 15/08/20 30
tre Esempio: commesso viaggiatore

5 5
3 3
4 1 2 4 1 2
2 2
6 6
10 10
8 8
3 3
domanda: quale è la via più veloce quale è la via più veloce

Per connettere tutte le città? Per connettere tutte le città?
15/08/20 31 15/08/20 32
quattro: il Problema della soddisfacibilità
Una soluzione : ricerca tutti i cammini,
Hamiltoniani, ovvero tutti i cammini
espressioni Booleani in
che toccano tutti i vertici una sola volta. Conjunctive Normal Form:
k
ricorda L  TIME (n!)  TIME (2 n )
t1  t2  t3    tk clausole
quindi
L = {shortest hamiltonian paths} ti  x1  x2  x3    x p
Variabili
domanda: è l’espressione soddisfacibile?

15/08/20 33 15/08/20 34
Esempio: ( x1  x2 )  ( x1  x3 ) Esempio: ( x1  x2 )  x1  x2
Non soddisfacibile
soddisfacibile: x1  0, x2  1, x3  1 ( x1  x2 )  x1
soddisfacibile
( x1  x2 )  ( x1  x3 )  1
15/08/20 35 15/08/20 36
Non-determinismo: prima definizione
L  {w : w soddisfacibile}
La classe dei linguaggi: NTIME (T (n ))
k
L  TIME (2 n ) Turing Machine Non-Deterministica:
i rami di computazione sono limitati
Algoritmo: da un T(n)
ricerca , in modo esaustivo,
su tutti i possibili valori delle variabili Linguaggi decidibili da una mdTuring
Tavole di verità, n variabili , 2 ^ n non deterministica in tempo O (T (n ))
15/08/20 37 15/08/20 38
Non-determinismo: seconda definizione

uno
Problema: Cammino Hamiltonian
un cammino in un grafo
(orientato o non orientato)
è detto hamiltoniano se
esso tocca tutti i vertici
Decide per ogni stringa (w) di del grafo
lunghezza n con l’aiuto di una una e una sola volta.
stringa c in tempo O(T(n))
15/08/20 39 15/08/20 40
Problema del Cammino Problema del Cammino Esempio
Hamiltonian Hamiltoniano Stringa giusta che ci
dà il cammino.
s t
domanda: vi è un Cammino Hamiltoniano

da s a t?
tocca tutti i vertici del grafo
15/08/20 41 15/08/20 42
Esempio
due
.
problema della cricca
dato un grafo e dato un k
problema della cricca, dato un k
trovare un insieme di k elementi dove
trovare un insieme di k nodi dove
gli altri. Stringa giusta che ci dà la
gli altri.
cricca.
il Problema della soddisfacibilità
Valori di verità giusti

15/08/20 43 15/08/20 44
quattro: il Problema della soddisfacibilità Esempio
.
espressioni Booleani in
Conjunctive Normal Form:
t1  t2  t3    tk clausole
ti  x1  x2  x3    x p
Variabili il Problema della soddisfacibilità
domanda: è l’espressione soddisfacibile? Valori di verità giusti

15/08/20 45 15/08/20 46
Due definizioni sono uguali? NdT Verificatore Trovare la

stringa
Verificatore NdT Ricorda che se NdT accetta s allora
Assumiamo che V è limitata da n^k. esiste un cammino, c, che ci porta
Prendiamo tutte le stringhe di all’accettazione.
lunghezza n^k : Sia Ndt N costruiamo un verificatore V
NdT: Su input w di lunghezza n: V: input (w,c)
1.Non deterministicamente seleziona 1.Simula NdT sull’input w scegliendo il
stringa c di lng al massimo n^k; cammino indicato da c.
2.Calcola V su (w,c); 2.Se V accetta allora accetta,
3.Se V accetta allora accetta altrimenti rigetta
altrimenti rifiuta
15/08/20 47 15/08/20 48
Esempio: L  {ww} L  {ww}
tempo necessario
algoritmo Non-Deterministico
per accettare una stringa ww : Usiamo una two-tape Turing machine
•Usiamo una two-tape Turing machine Congetturiamo la metà della stringa O (| w |)

e la copiamo w sul secondo nastro
•Congetturiamo la metà della stringa
e la copiamo w sul secondo nastro Compariamo i due nastri O(| w |)
•Compariamo i due nastri tempo totale: O(| w |)

15/08/20 49 15/08/20 50
NTIME (n) L  {w : expression w is satisfiable}
L  {ww}
L  NP
Il problema della soddisfacibilità è un

NP - Problem
15/08/20 51 15/08/20 52
L  {w : expression w is satisfiable} In modo simile possiamo definire
NTIME (T (n))
Tempo necessario per n variabili:
•Congetturiamo un assegnazione O(n) Per ogni funzione temporale : T (n)

di valore alle variabili
•Verifichiamo che questo assegnamento O(n)

sia soddisfacibie
Esempi: NTIME (n 2 ), NTIME (n3 ),...
Total tempo: O (n)
15/08/20 53 15/08/20 54
La classe NP osservazione:
Non-Deterministic Polynomial time
NP   NTIME (n k )
P  NP
Per ogni k
P  TIME (n k ) Deterministic Non-Deterministic

Polynomial Polynomial
15/08/20 55 15/08/20 56
NP-Completezza
Problema aperto: P  NP ?
Un problema è NP-complete se:
Esempio: il problema della sodisfacibilità •E’ in NP

ha un algoritmo deterministico
che lo risolva in tempo polinomiale? •Ogni NP problema si può ridurre
•al problema di partenza
Non conosciamo la risposta
(in tempo polinomiale)
15/08/20 57 15/08/20 58
Osservazione: Osservazione :
Se possiamo risolvere un problema Se proviamo che

NP-complete non possiamo risolvere un problema
in tempo Deterministic Polynomial (P tempo) NP-complete
Allora avremo che : in tempo Deterministic Polynomial (P tempo)
Allora abbiamo:
P  NP P  NP
15/08/20 59 15/08/20 60
Teorema diCook’: Altri problemi NP-Complete :
•Il commesso viaggiatore

Il problema della soddisfacibilità è
NP-complete
•Vertex cover
Dimostrazione:
•Hamiltonian Path
Convertire una Non-Deterministic Turing
Machine Tutti questi problemi si possono ridurre
In una espressione booleana al problema della soddisfacibilità
in (congiuntiva) conjunctive normal form
15/08/20 61 15/08/20 62
Osservazione:
tempo complessità:
sarebbe molto strano che NP-complete Il numero di passi (step)
problemi sono in P durante una computazione
I problemi NP-complete hanno algoritmi

in tempo esponenziale
spazio complessità:
spazio usato
Approssimazioni di questi problemi
durante una computazione
Sono in P
15/08/20 63 15/08/20 64
TM (n )
algoritmi calcolabili nk
in tempo esponenziale
TIME (2 )
tempo
poly ( k )
TIME (2 2 )
1 2 3 4  n  Rappresentano algoritmi intrattabili

Lunghezza della stringa
Per alcuni input ci possono volere
secoli per trovare la soluzione
Massimo tempo per accettare
una stringa di lunghezza n
15/08/20 65 15/08/20 66
algoritmi
Tempo Polinomiale Non-Deterministico
L  NTIME (n k )
15/08/20 67
La classe NP
Non-Deterministic Polynomial time
NP
Per ogni k
NP   NTIME (n k )
Linguaggi NP-completi
La classe P
Deterministic Polynomial time
Per ogni k
P  TIME (n k )
15/08/20 1 15/08/20 2
Una funzione f:A->B

è calcolabile in tempo polinomiale se esiste una Nota che se A≤B e B è polinomiale
macchina M che calcola la funzione f in tempo allora anche A è polinomiale.
polinomiale Sia M che decide B,
w w0f(w) Sia f che riduce A a B
Sia x elemento di A
Un linguaggio A è riducibile in tempo
1.Calcola f(x)
polinomiale a un linguaggio B , A≤B, se esiste 2.Calcola M(f(x))
una funzione polinomiale f tale che
per ogni x : x∈A implica f(x) ∈ B
15/08/20 3 15/08/20 4
NP-Completezza
A<=B
Un problema A è NP-completo se:
Pari<=Dispari
Dispari<=Pari
•A è in NP
X è elemento di Pari
(div 2 (resto=0))
•Ogni problema NP è riducibile
Dispari
X è elemento di dispari ad A
Non (div 2) (in tempo polinomiale)
15/08/20 5 15/08/20 6
Osservazione:
NP
completi Se possiamo risolvere un problema
F NP-complete
polinomiali in tempo Deterministico Polinomiale
allora :
NP P  NP
15/08/20 7 15/08/20 8
Osservazione :
Se proviamo che Un Linguaggio L è NP-completo se:
non possiamo risolvere un problema
NP-complete • L è in NP, e
in tempo Deterministico Polinomiale
Allora : • Ogni Linguaggio in NP può essere
ridotto a L in Tempo Polinomiale
P  NP
15/08/20 9 15/08/20 10
Decidibili
Formule SAT: literal
NP
( x1  x2  x3 )  ( x3  x5  x6 )  ( x3  x6  x4 )  ( x4  x5  x6 )
P NP-complete
?
L: letterale o letterale negato
O: Gruppi di L collegati da ∨
Sat: Gruppi di O collegati da ∧
15/08/20 11 15/08/20 12
Un Linguaggio NP-completo Sia L  NP , un arbitrario linguaggio
Teorema di Cook-Levin : Definiamo una riduzione Polinomiale of L to
Linguaggio SAT (satisfiability problem) SAT
è NP-complete Sia M Macchina di Turing Nondeterministica
Dim: che decide L in Tempo polinomiale
Part1: SAT è in NP
(gia provato) Per ogni stringa w costruiamo in Tempo
Part2: ridurre tutti i Linguaggi NP Polinomiale una espressione Booleana  (M ,w )
al problema SAT tale che: w  L   ( M , w) è soddisfacibile
in Tempo Polinomiale
15/08/20 13 15/08/20 14
Tutte le computaz. q0 Considera una q0
of M sulla stringa q qj Computazione qi qj

w
i
accettante Profon
Prof dità
| w | n
ondità
nk
…
…
…
…
nk
…
…
accept accept
…
…
reject accept reject accept
(foglia più profonda) (foglia più profonda)

reject reject
15/08/20 15 15/08/20 16
Cammino di computazione n
Sequenze di Macchina M Nastro
q0
configurazioni
qi
w
Stato iniziale
qj
1: q0  1 2  n nk nk
2:   1 qi  2  n
…

qm 2n k
nk  x :   1  l qa  l1  n k
qa
Massima area di calcolo sul nastro
accettato Stato accettazione
k
w   1 2  n durante n steps (passi) temporali
15/08/20 17 15/08/20 18
Tableau delle configurazioni

1: #    q0  1  2   n    # Alfabeto del Tableau
2: #     1 qi  2   n    #
C  {# }  {alfabeta nastro}  {insieme degli stati}
……
 {# }  {1 ,  ,  r }  {q1 ,  , q t }
Configurazione accettante
x: #      1  2  3  qa  l1  nk # Dimensione finita (costante)
Righe identiche
   1  2  3 nk #
nk : #    qa  l1 
nk nk
2n k  3
15/08/20 19 15/08/20 20
Per ogni cella con posizione i, j Esempio:
nk  3
E per ogni simbolo nell’alfabeto
1: #    q0  1  2   n    #
del tableau s C 2: #     1 qi  2   n    #
Definiamo la variabile xi , j ,s
x1,1,#  1 x 2,n k 3,q  1

tale che se la cella i , j contiene il simbolo s i
allora xi , j ,s  1 altrimenti xi , j ,s  0 x1,1,   0 x 2,n k 3,#  0
15/08/20 21 15/08/20 22
 (M ,w ) è costruito con le variabili xi , j ,s Ci rende sicuri che ogni cella

 cell nel tableau contiene esattamente
un simbolo
 (M ,w )  cell   start   accept  move
  
Quando la formula è sodisfatta allora descrive
cell 
all i , j  s C

 s ,t C

    xi , j ,s    xi , j ,s  xi , j ,t 


  s t 
una computazione di accettazione nel
tableau della macchina M su input w
Ogni cella contiene Ogni cella contiene
almeno un simbolo al massimo un simbolo
15/08/20 23 15/08/20 24
Dimensione di  cell :  start il tableau parte con la
configurazione iniziale
  
cell 
all i , j  s C

 s ,t C

    xi , j ,s    xi , j ,s  xi , j ,t 

 start  x1,1,#  x1,2,    x1,n k 1,
  s t   x1,n k 2,q  x1,n k 3,    x1,n k n 2,
0 1 n
2  x1,n k n 3,  x1,2n k 2,    x1,2n k 2,#

( 2n 3)k  ( |C |  |C |2 )
Descrive la configurazione iniziale

 O (n 2k )
Nella riga 1 del tableau
15/08/20 25 15/08/20 26
Dimensione di  start :  accept Cicomputazione

da la sicurezza che La
raggiunge stato di
 start  x1,1,#  x1,2,   Accettazione
 x1,n k 1,  x1,n k 2,q  x1,n k 3,  
0 1
 accept   xi , j ,q
 x1,2n k 2,  x1,2n k 3,# all i , j
all q F
Stati di accettazione
2n k  3  O (n k ) Uno stato di accettazione deve apparire
Da qualche parte nel tableau
15/08/20 27 15/08/20 28
Size of  accept : move Ci rende sicuri che il tableau
ci da una sequenza valida di
configurazioni
 accept   xi , j ,q
all i , j
all q F
move è espresso in termini di

windows legali
(2n k  3)2  O (n 2k )
15/08/20 29 15/08/20 30
Tableau
Possibili windows Legali
a q1 b a q1 b
a  b, R q2 a c
Per ogni Window a a q2
i,j,
elemento
a q1 b
centrale q2 a c
superiore q1 b  c , L q2 a a q1 a b a
2x6 area di celle a a b a b q2
b  a,R
window Legali obbediscono alle transizioni
15/08/20 31 15/08/20 32
Possibili window illegali
Altre finestre legali
# b a
a b a a q1 b
# b a
a  b, R a a a q1 a a
b b b
La b in a?
q1 b  c , L q2
c b b
b q1 b
q2 b q2
b  a,R
Due stati
15/08/20 33 15/08/20 34
move   (window (i, j) is legal)

all i, j
j
i a q1 b window (i,j) è legale:
q2 a c j
j j
(è legale)
i a q1 b i a q1 b i a a q1
Formula: q2 a c a a q2 a a b 
xi , j ,a  xi , j 1,q1  xi , j  2,b ((is legal) e (is legal) e (is legal))
 xi 1, j ,q2  xi 1, j 1,a  xi 1, j  2,c Tutte le possibili celle legali
nella posizione (i , j )
15/08/20 35 15/08/20 36
Dimensione di move : Dimensione di  (M ,w ) :
Dimensione di una formula per una window  (M ,w )  cell  start   accept  move
Legale in una cella i,j: 6
O (n 2k )  O (n k )  O (n 2k
)  O (n 2k
)
x Numero di possibili legal window
in una cella i,j: al max |C |6  O (n 2k )
Costruita in Tempo O (n 2k )
x Numero di possibili celle: (2n  3)n
k k
Quindi Polinomiale in n
 6
6 | C | (2n  3)n  O (n
k k 2k
)
15/08/20 37 15/08/20 38
poichè,
w  L   (M ,w ) is satisfiable
 (M ,w )  cell   start   accept  move e
 (M ,w ) è costruita
Abbiamo che:
w  L   (M ,w ) is satisfiable
L è riducibile in tempo Polinomiale a SAT
END OF Dim
15/08/20 39 15/08/20 40
Osservazione 1: leggi: Distributività
La  (M ,w ) formula può essere convertita
in CNF (conjunctive normal form) formula P  (Q  R )  (P  Q )  (P  R )
 (M ,w )  cell  start   accept  move

P  (Q  R )  (P  Q )  (P  R )
gia CNF
NOT CNF
Ma può essere convertita
in CNF (distribuitività)
15/08/20 41 15/08/20 42
Osservazione 2:
La  (M ,w ) formula può essere 3CNF formula: literal
Convertita in una formula 3CNF ( x1  x2  x3 )  ( x3  x5  x6 )  ( x3  x6  x4 )  ( x4  x5  x6 )
clause
Ogni clausola ha tre letterali
a1  a2    al 
Conv Linguaggio:
erti 3CNF-SAT ={ w : w è una formula

3CNF soddisfacibile
a1  a2  z1   (z1  a3  z 2 )  (z 2  a4  z 3 )    (zl 3  al 1  zl )
Nuove z 15/08/20 44
15/08/20 43
Esempio di riduzione Tempo-Polinomiale:
CNF-SAT e
Ridurremo il problema
3CNF-SAT sono
Linguaggi NP-completi 3CNF-satisfiability
al
(sappiamo che sono NP Linguaggi) problema CLIQUE
15/08/20 45 15/08/20 46
Una 5-cricca (Clique) nel grafo G Teorema: 3CNF-SAT è riducibile

In Tempo Polinomiale
a CLIQUE
Dim: Una riduzione in Tempo Polinomiale

da un problema all’altro
Linguaggio:
CLIQUE = { G, k  : grafo G
Transformare una formula in un grafo
contiene un k -clique}
15/08/20 47 15/08/20 48
Una 5-cricca (Clique) nel grafo G Teorema: 3CNF-SAT è riducibile
In Tempo Polinomiale
a CLIQUE
Dim: Una riduzione in Tempo Polinomiale

da un problema all’altro
Linguaggio:
CLIQUE = { G, k  : grafo G
Transformare una formula in un grafo
contiene un k -clique}
15/08/20 49 15/08/20 50
3CNF formula: Transformare una formula in un grafo

literal
Esempio:
( x1  x2  x3 )  ( x3  x5  x6 )  ( x3  x6  x4 )  ( x4  x5  x6 ) (x 1  x 2  x 4 )  (x 1  x 2  x 4 )  (x 1  x 2  x 3 )  (x 2  x 3  x 4 )
Clause 2
clause Creare I nodi: x1 x2 x4 Clause 3
Ogni clausola ha tre letterali x1 x1
Clause 1 x2
Linguaggio: x2
3CNF-SAT ={ w : w è una formula x4 x3

Clause 4
3CNF soddisfacibile
x2 x3 x4
15/08/20 51 15/08/20 52
(x 1  x 2  x 4 )  ( x 1  x 2  x 4 )  (x 1  x 2  x 3 )  ( x 2  x 3  x 4 ) (x 1  x 2  x 4 )  (x 1  x 2  x 4 )  (x 1  x 2  x 3 )  (x 2  x 3  x 4 )
x1 x2 x4 x1 x2 x4
x1 x1 x1 x1
x2 x2 x2 x2
x4 x3 x4 x3
x2 x3 x4 x2 x3 x4
Addizionare un arco da un letterale  Grafo risultante

A ogni altro letterale in ogni clausola salvo a 
15/08/20 53 15/08/20 54
Teorema:
If: a. Linguaggio A is NP-complete
( x 1  x 2  x 4 )  (x 1  x 2  x 4 )  ( x 1  x 2  x 3 )  ( x 2  x 3  x 4 )  1
x1  1 b. Linguaggio B is in NP
x2  0
x3  0
x1 x2 x4
c. A è riducibile Tempo Polinomiale a B
x1 x1
x4  1
Then: B is NP-complete
x2 x2
Dim:
x4 x3
Ogni linguaggio L in NP
x2
È riducibile in Tempo Polinomiale a A
x3 x4
La formula è sodisfacibile se e solo se il grafo ha

un 4-clique End of Dim
allora,L è riducibile inTempo Polinomiale
a B (somma di due riducibilità Polinomiali dà
15/08/20 55
una riduzione Polinomiale)
15/08/20 56
Corollario: CLIQUE è NP-complete
Osservazione:
Dim: SE si dimostra che un Linguaggio

a. 3CNF-SAT è NP-complete NP-complete
b. CLIQUE è in NP (gia visto) è in P allora:
c. 3CNF-SAT è riducibile Polinomiale a CLIQUE P  NP

(gia visto)
Applichiamo il teorema precedente

A=3CNF-SAT e B=CLIQUE
15/08/20 57 15/08/20 58
• Considera una Turing Machine deterministica
• M che decide un linguaggio L
Complessità spaziale
o meglio La complessità spaziale di M (deterministica) è
Complessità nello spazio una funzione f:N->N, dove f(n) è il numero
massimo di celle che M usa su ogni input di
lunghezza n.
Per ogni stringa w la computazione di M(w) termina usando una
quantità finita di spazio f(n), (senza limitazione di tempo)
15/08/2020 1
Consideriamo tutte le stringhe di

• Considera una Turing Machine non deterministica Lunghezza n e T una funzione da N->N
• M che decide un linguaggio L
SpaceM (T (n)) =Linguaggi decidibili (calcolabili)
La complessità spaziale di M è una funzione in spazio O(T(n)) deterministicamente
per una qualsiasi stringa di
f:N->N, dove f(n) è il numero massimo di celle lunghezza n
che per ogni ramo della computazione M usa
su ogni input di lunghezza n. NSpaceM T ((n)) =Linguaggi decidibili (calcolabili)
in spazio O(T(n)) non deterministicamente
per una qualsiasi stringa di
lunghezza n
15/08/2020 4
Esempio: L1  {a n b : n  0} Altri esempi nella stessa classe
Space(n)
Può essere deciso in spazio O (n )
L1  {a n b : n  0 }
{ab n aba : n , k  0}
{b n : n is even }
{b n : n  3k }
15/08/2020 5 15/08/2020 6
Esempi nella classe

Space(O(n k ))
Macchine calcolabili
Space(n )
in spazio Polinomiale
deterministico . costante k  0
n n
{a b : n  0 }
{ww R : w  {a , b }}
Macchine calcolabili NSpace(O (n k ))
{ww : w  {a , b }} in spazio Polinomiale
Non deterministico. costante k  0
15/08/2020 7 15/08/2020 8
La Classi di Complessità spaziale
chiaramente: Space(n k 1 )  Space(n k ) PSpace   PSpace(n k )
k 0
NSpace(n k 1 k
)  NSpace(n ) Rapresenta:
•Algoritmi deterministici che usano spazio polinomiale
•Problemi “trattabili nello spazio”
NPSpace   NPSpace(n k ) NP
Rapresenta: k 0
•Algoritmi non deterministici che usano spazio polinomiale
15/08/2020 9 15/08/2020 10
tempo complessità:
Il numero di passi (step)

durante una computazione Ricorda che una macchina di Turing
deterministica M simula una macchina di
Turing M’ non deterministica con una
complessità di tempo esponenziale rispetto
spazio complessità: alla complessità di M.
spazio usato
durante una computazione .
15/08/2020 11
teorema di Savitch dimostra che nello spazio la
complessità di questa simulazione,
non determinismo -> determinismo,
aumenta in modo al più quadratico.
Un primo tentativo potrebbe essere quello di

simulare tutti i possibili rami di computazione (di
lunghezza finita) di NMdT, ma questo non
permette di sovrascrivere l’area di memoria
utilizzata, perché occorre tenere traccia delle
scelte nondeterministiche fatte su un ramo
specifico per scegliere un prossimo ramo.
1, 2 11,12, 111,112,121, 122 …….

Ogni passo deve tenere traccia del
cammino percorso. Nota che se usiamo
Metodo
uno spazio f(n) il tempo che possiamo Non
usare su quello spazio è 2^O(f(n)) step determinismo
Verso
(perché?) ed ogni step può essere una determinismo
scelta non deterministica e quindi può Perché non
funziona
accadere di dover memorizzare stringhe
di lunghezza 2^O(f(n))
1,2,11,12,21,22, …
Le scelte fatte per percorrere Memoria che si può
tutti i possibili cammini sono Memoria che ci riutilizzare
esponenziali in numero, anche se serve per
percorrere tutti i
lo spazio necessario per calcolarli cammini.
è polinomiale. Esponenziale
Dunque, questo tentativo richiede

spazio esponenziale.
Si consideri una MdT non deterministica arbitraria.
YELDABILITY PROBLEM Preso un intero t positivo, e due configurazioni c1

Verificare se una MNdT con input w può e c2 di NMdT Diremo che c1 produce c2 in un
passare da una configurazione iniziale c1 a numero minore o uguali di passi t se NMdT può
quella finale c2 in un numero di passi produrre c2 a partire da c1 in t (o meno passi).
minore o uguale a un numero dato t (time).
(dove t verrà scelto come il numero C_1 t
massimo di operazioni che MNdT pq2

necessita per accettare w). pq1
pq
C_2
input c1,c2 e t, dove t≥0.
c1,c2 sono configurazioni che usano al più
uno spazio f(n) (se lo spazio occupato è CANYELD ha come input anche
minore possiamo raggiungere spazio f(n) tutti gli stati e i collegamenti
aggiungendo caratteri blank); tra di loro ovvero la delta
sia t una potenza del 2 (t=2p per qualche p maggiore o uguale a 0), possibile?.
Ritorniamo per un momento sull’affermazione
Analizziamo la complessità di spazio di M.
M = “Su input w: L’output è il risultato di
CANYIELD(cstart, caccept, 2d*f(n))”
• Ogni volta che CANYIELD si autochiama (ricorsione) memorizza
lo stato corrente (i valori c1,c2 e t) così da poter essere M deve sapere il valore di f(n) quando invoca
richiamati (usati) al ritorno dalla ricorsione. CANYIELD, questo lo dobbiamo calcolare. Quindi
• Ciascun livello della ricorsione quindi usa spazio O(f(n)) la complessità aumenta.
aggiuntivo.
• Il numero delle chiamate ricorsive è invece pari a d*f(n).
Un modo semplice per risolvere questo problema
Dunque, lo spazio totale usato da N: d*f(n)*O(f(n))=O(f2(n))
è quello di modificare M (chiamata M’) in modo
che provi per f(n) = 1,2,3, … Per ogni valore f(n)
=i
,
M’ usa CANYIELD per accettare e determinare se la configurazione è

raggiungibile. Fine corso
Per garantire che M’ non continui ad aumentare i (e quindi a

Questo è quello che conosciamo:
consumare spazio) nei casi in cui NMdT non accetta w, si effettua il
P ⊆ NP ⊆ PSPACE=NPSPACE ⊆ EXPTIME.
seguente controllo prima di passare da i a i+1 (nuovo valore di
Tuttavia non conosciamo se qualcuna delle inclusioni
f(n)):
possa essere sostituita con un uguaglianza.
Utilizzando CANYIELD, controlla che MNdT può raggiungere una
Sappiamo che
configurazione che utilizza più di i celle del nastro (da cstart). Se
P≠EXPTIME.
questo non accade: non ha alcun senso cercare per i+1 quindi M’
Quindi sappiamo che l’ultima delle tre inclusioni deve
va in reject.
essere necessariamente un inclusione (non una
uguaglianza).
Per memorizzare il valore i (f(n)): occorre spazio O(log f(n)). Inoltre,
questo spazio può essere riciclato ad ogni iterazione. P ⊆ NP ⊆ PSPACE=NPSPACE ⊆ EXPTIME.
P≠EXPTIME.
Dunque, la complessità dello spazio di M’ rimane O(f2(n)).
Consideriamo solo le T_funzioni calcolabili ad una sola variabile. s, n, s, n ….
Enumeriamole (Lista) Essendo D una funzione ad una sola variabile calcolabile sarà nella Lista,
f o, f 1, f 2, f 3…. ora costruiamo il complemento di D , chiamiamola C
Chiamiamo questa lista, Lista. cosi definita
Sia il problema dell’alt decidibile, allora esiste una funzione H C(n)= s se D(n)=n e C(n)=n se D(n)=s.
Tale che Anche C è calcolabile, sia f C .
H(n)= s(i) se f n(n) converge ; Quindi esiste una riga nella matrice che la descrive
n(o) se f n (n) diverge Sia k il punto della matrice in cui C( la riga che descrive C) incontra D (la diagonale)
Usando H possiamo calcolare una tabella cosi definita Cosa accade?
f o, f 1, f 2, f 3…. 0, 1, 2,3❑….
0 s s n s … fo s s n s …
1 n n s n … f1 n n s n …
2 s n s s …. f2 s n s s …
3 s s s n … f3 s s s n …
………………………………………………………….. D ….
fC n s n s
Letta in questo modo per esempio
Crit
(2, f 3)=s f C (C )
vuol dire H(3)=s ovvero f 3(2) converge.

deve essere il compleme n ¿ di
(3, f 1)= n
vuol dire H(1)=n ovvero f 1 (3) converge.
f C ( C ).
Prendiamo la diagonale
f o (0), f 1(1), f 2 (2), f 3 (3).
la diagonale definisce una nuova funzione calcolabile ad una sola variabile

questa funzione è cosi definita
D(n)= f n (n),
Nel nostro caso
Una macchina di Turing
Tape
...... ......
Macchine di Turing Read-Write head

Control Unit
15/08/20 1 15/08/20 2
il Tape
...... ......
No limiti – lunghezza potenzialmente infinita
...... ...... Read-Write head
Read-Write head la head ad ogni transizione (time step):
1. legge un simbolo
2. scrive un simbolo
Le testa si muove Left or Right 3. si muove Left or Right
15/08/20 3 15/08/20 4
esempio:
Time 1
Time 0
...... a b k c ......
...... a b a c ......
Time 1 Time 2
...... ...... ...... a f k c ......
a b k c
1. Reads a 1. Reads b
2. Writes k 2. Writes f
3. Moves Left 3. Moves Right
15/08/20 5 15/08/20 6
la String Input Stati & Transizioni
Read Write
stringa di input Move Left
Blank symbol
......   a b a c    ......
q1 a  b, L q2
head
Move Right
Head parte dalla posizione più a sinistra
della stringa di input q1 a  b, R q2
15/08/20 7 15/08/20 8
esempio:
Time 1
Time 1 ...... ......
  a b a c   
......   a b a c    ......
q1
Sei in q_1 q1
leggi a , Time 2
stato corrente
cambia a in b ...... ......
e vai a right   a b b c   
q2
q1 a  b, R q2
q1 a  b, R q2
15/08/20 9 15/08/20 10
esempio: esempio:
Time 1 Time 1
......   a b a c    ...... ......   a b a c    ......
q1 q1
Time 2 Time 2
......   a b b c    ...... ......   a b b c g   ......
q2 q2
q1 a  b, L q2   g, R
q1 q2
15/08/20 11 15/08/20 12
Determinismo Funzione di Transizione Parziale
macchine di Turing sono deterministiche esempio:
......   a b a c    ......
permesso Non permesso
a  b, R q2 a  b, R q2 q1
q1 q1
a  b, R q2 permesso:
q3 a  d, L q3
b  d, L Nessuna transizione
q1
per simbolo input c
nessuna transizione lambda è permessa b  d, L q3
15/08/20 13 15/08/20 14
Halting Halt esempio 1:
......   a b a c    ......
La macchina si ferma nello stato
in cui si trova
q1
se non vi è nessuna transizione
da eseguire
q1 Nessuna transizione da q1
HALT!!!
15/08/20 15 15/08/20 16
Halt esempio 2: Stati di accettazione
q1 q2 permesso
......   a b a c    ......
q1
q1 q2 Non permesso
a  b, R q2
Nessuna transizione
•Stati di accettazione non hanno transizioni
q1 possibile da q1
in uscita
b  d, L q3 sul simbolo c
•La macchina si ferma e accetta.
15/08/20 HALT!!!17 15/08/20 18
Accettazione
Osservazione:
se macchina si ferma Nell’accettare una stringa di input,
Accettare stringa
in uno stato di non è necessario esaminare tutti
In Input
accettazione i simboli nella stringa.
se macchina si ferma
in uno stato di
RIGETTARE stringa NON- accettazione o
In Input
se la macchina entra
in un infinite loop
15/08/20 19 15/08/20 20
La gerarchia dei linguaggi
linguaggi accettati da una
macchina di Turing
a nb n c n ? ww ? a nb n c n ww
linguaggi Context-Free Context-Free linguaggi

n n R n n R
a b ww a b ww
linguaggi Regolari Regular linguaggi
a* a *b * a* a *b *
15/08/20 21 15/08/20 22
macchinaTuring esempio
Time 0   a a a  
Input alphabet   {a , b } q0
Accetta il linguaggio: a*
a  a, R a  a, R
  , L   , L
q0 q1 q0 q1
15/08/20 23 15/08/20 24
Time 1   a a a   Time 2   a a a  
q0 q0
a  a, R a  a, R
  , L   , L
q0 q1 q0 q1
15/08/20 25 15/08/20 26
Time 3   a a a   Time 4   a a a  
q0 q1
a  a, R a  a, R Halt & accettazione
  , L   , L
q0 q1 q0 q1
15/08/20 27 15/08/20 28
Rejection esempio
Time 0   a b a   Time 1   a b a  
q0 q0
Nessuna transizione
a  a, R a  a, R Halt & Reject
  , L   , L
q0 q1 q0 q1
15/08/20 29 15/08/20 30
Una macchina semplice per linguaggio a *

Time 0   a a a  
Ma con alfabeto di input   {a }
q0
Accetta il linguaggio: a*
Halt & accettazione
q0
q0
Non è necessario esaminare l’input
15/08/20 31 15/08/20 32
esempio Infinito Loop Time 0   a b a  
una macchina di Turing
q0
Per il linguaggio a * b( a  b) *
b  b, L b  b, L
a  a, R a  a, R
  , L   , L
q0 q1 q0 q1
15/08/20 33 15/08/20 34
Time 1   a b a   Time 2   a b a  
q0 q0
b  b, L b  b, L
a  a, R a  a, R
  , L   , L
q0 q1 q0 q1
15/08/20 35 15/08/20 36
Time 2   a b a  
A causa dell’ infinite loop:
q0
  a b a  
Infinite loop
Time 3 •lo stato accettazione non può
q0 •essere raggiunto
Time 4   a b a  
•La macchina non si ferma
q0
•La stringa di input è “rejected-rigettata”
Time 5   a b a  
q0
15/08/20 37 15/08/20 38
--- xxayyb aaaabbbb

Basic Idea: {a nb n } q_0 a ->X q_1 Xaaabbbb
Match a con le b: q_1 devo scavalcare XaaaYbbb
tutte le a tutte le Y u b XXaaYbbb
Repeat:
b->Y vai stato q_2
La a piu a sinistra cambiala in x XXaaYYbb
q_2 vai a L scavalcando
trova la b piu a sinistra cambiala con y XXXaYYbb
tutte le Y e tutte le a
Until non vi sono più a o b fino a raggiungere una X XXXaYYYb
Spostare R q_0 XXXXYYYb
Se rimane una a o una b reject XXXXYYYYb
15/08/20 39 15/08/20 40
Turing macchina esempio
Time 0  a a b b  
Machina di Turing per il linguaggio {a nb n }
n 1 q0
q4 y  y, R y  y, L q4 y  y, R y  y, L
y  y, R a  a, R a  a, L y  y, R a  a, R a  a, L
  , L   , L
y  y, R a  x, R b  y, L y  y, R a  x, R b  y, L
q3 q0 q1 q2 q3 q0 q1 q2
x  x, R x  x, R
15/08/20 41 15/08/20 42
Time 1  x a b b   Time 2  x a b b  
q1 q1
q4 y  y, R y  y, L q4 y  y, R y  y, L
  , L   , L
q3 q0 q1 q2 q3 q0 q1 q2
x  x, R x  x, R
15/08/20 43 15/08/20 44
Time 3  x a y b   Time 4  x a y b  
q2 q2
q4 y  y, R y  y, L q4 y  y, R y  y, L
  , L   , L
q3 q0 q1 q2 q3 q0 q1 q2
x  x, R x  x, R
15/08/20 45 15/08/20 46
Time 5  x a y b   Time 6  x x y b  
q0 q1
q4 y  y, R y  y, L q4 y  y, R y  y, L
  , L   , L
q3 q0 q1 q2 q3 q0 q1 q2
x  x, R x  x, R
15/08/20 47 15/08/20 48
Time 7  x x y b   Time 8  x x y y  
q1 q2
q4 y  y, R y  y, L q4 y  y, R y  y, L
  , L   , L
q3 q0 q1 q2 q3 q0 q1 q2
x  x, R x  x, R
15/08/20 49 15/08/20 50
Time 9  x x y y   Time 10  x x y y  
q2 q0
q4 y  y, R y  y, L q4 y  y, R y  y, L
  , L   , L
q3 q0 q1 q2 q3 q0 q1 q2
x  x, R x  x, R
15/08/20 51 15/08/20 52
Time 11  x x y y   Time 12  x x y y  
q3 q3
q4 y  y, R y  y, L q4 y  y, R y  y, L
  , L   , L
q3 q0 q1 q2 q3 q0 q1 q2
x  x, R x  x, R
15/08/20 53 15/08/20 54
Time 13  x x y y   Osservazione:
q4
Se modifichiamo
Halt & accettazione La macchina per il linguaggio {a nb n }
q4 y  y, R y  y, L
y  y, R a  a, R a  a, L
  , L
Facilmente possiamo costruire
y  y, R a  x, R n n n
b  y, L Una macchina per il linguaggio {a b c }
q3 q0 q1 q2
x  x, R
15/08/20 55 15/08/20 56
Funzione Transizione
Definizione formale
q1 a  b, R q2
di
macchina di turing
 (q1, a )  (q2 , b, R)
15/08/20 57 15/08/20 58
Turing macchina:
Funzione Transizione
Input Tape
alfabeto alfabeto
stati
q1 c  d, L q2
M  (Q, , ,  , q0 , , F )
 (q1, c)  (q2 , d , L) Transition accettazion

function stati
iniziale blank
15/08/20 59 15/08/20
stato 60
Configurazione
Tipo della delta
Input   c a b a  
Stati xAI U AN->
Stati x AI U AN x Op q1
Op =L. R descrizione istantanea: ca q1 ba
15/08/20 61 15/08/20 62
Time 4 Time 5 Time 4 Time 5

 x a y b    x a y b    x a y b    x a y b  
q2 q0 q2 q0
Time 6 Time 7
 x x y b    x x y b  
Una mossa q2 xayb  x q0 ayb
q1 q1
(dà)
Un calcolo
q2 xayb  x q0 ayb  xx q1 yb  xxy q1 b
15/08/20 63 15/08/20 64
configurazione Iniziale : q0 w
q2 xayb  x q0 ayb  xx q1 yb  xxy q1 b
stringa di input

w
Notazione equivalente: q2 xayb  xxy q1 b
 a a b b  
q0
15/08/20 65 15/08/20 66
il linguaggio accettato Se un linguaggio L è accettato da

Una macchina di Turing M
Per ogni macchina Turing M
A noi diciamo cheL è:
 •Turing Riconoscibile
L( M )  {w : q0 w  x1 q f x2 }
Accettato in forma Alfabeto
standard Altri nomi usati:
q_o w da* w q_f
stato iniziale accettazione stato •Turing accettati
•Recursivamente Enumerabili
15/08/20 67 15/08/20 68
Alfabeto L definito a partire da
quell’alfabeto
L turing riconoscibile
w elemento A* M(w) raggiunge Calcolare funzioni con
lo stato finale se w appartiene macchine di Turing
ad L
non lo raggiunge ? Altrimenti
Non raggiunge uno stato finale.
Ma questo non vuol dire che la
macchina si ferma
15/08/20 69 15/08/20 70
Una funzione f (w) ha: Una funzione può avere molti parametri:
Dominio: D Regione dei risultati: S esempio: funzione Addizione
f ( x, y )  x  y
f (w)
w D f ( w)  S
15/08/20 71 15/08/20 72
Definizione:
dominio degli interi
Una funzione f è calcabile se
Decimali: 5 vi è una macchina di Turing M tale che:
Binari: 101
0->1 Configurazione iniziale Configurazione Finale
1->11  w   f (w) 
Unario: 11111
n-> n+1 1
q0 qf
Useremo rapresentazione unaria : stato iniziale Stato di accettazione
Più facile da usare con le macchine di Turing Per tutti w D dominio
15/08/20 73 15/08/20 74
In altre parole : esempio

A Una funzione f è calcabile se
la funzione f ( x, y )  x  y è calcolabile
Vi è una macchina di Turing M tale che:
 x, y Sono interi
q0 w  q f f ( w)
macchina Turing :
configurazione configurazione stringa di input: x0 y unario
iniziale Finale
Output stringa: xy 0 unario
Per tuttew D dominio
15/08/20 75 15/08/20 76
x y x y
Start  1 1  1 0 1  1  Start  1 1  1 0 1  1 
q0 q0 stato iniziale
iniziale stato
x y
il 0 è il delimitatore che
Fine  1 1  1 1 0 
Separa I due numeri
q f stato finale
15/08/20 77 15/08/20 78
macchina Turing f ( x, y )  x  y
lo 0 ci può aiutare se usiamo
per la funzione
il risultato per un altra operazione
Ricordarsi di
eliminare due 1
alla fine
1  1, R 1  1, R 1  1, L
x y
q0 0  1, R q1   , L q2 1  0, L q3
Fine  1 1  1 1 0 
  , R
q f stato finale q4
15/08/20 79 15/08/20 80
esempio di esecuzione: Time 0
Consideriamo i numeri naturali x y
senza lo zero x  11 (=2)
 1 1 0 1 1 
Quindi basta avere n= 1alla n
y  11 (=2) q0
Final Result
x y
 1 1 1 1 0 
q4
15/08/20 81 15/08/20 82
Time 0  1 1 0 1 1  Time 1  1 1 0 1 1 
q0 q0
1  1, R 1  1, R 1  1, L 1  1, R 1  1, R 1  1, L
q0 0  1, R q1   , L q2 1  0, L q3 q0 0  1, R q1   , L q2 1  0, L q3
  , R   , R
q4 q4
15/08/20 83 15/08/20 84
Time 2  1 1 0 1 1  Time 3  1 1 1 1 1 
q0 q1
1  1, R 1  1, R 1  1, L 1  1, R 1  1, R 1  1, L
q0 0  1, R q1   , L q2 1  0, L q3 q0 0  1, R q1   , L q2 1  0, L q3
  , R   , R
q4 q4
15/08/20 85 15/08/20 86
Time 4  1 1 1 1 1  Time 5  1 1 1 1 1 
q1 q1
1  1, R 1  1, R 1  1, L 1  1, R 1  1, R 1  1, L
q0 0  1, R q1   , L q2 1  0, L q3 q0 0  1, R q1   , L q2 1  0, L q3
  , R   , R
q4 q4
15/08/20 87 15/08/20 88
Time 6  1 1 1 1 1  Time 7  1 1 1 1 0 
q2 q3
1  1, R 1  1, R 1  1, L 1  1, R 1  1, R 1  1, L
q0 0  1, R q1   , L q2 1  0, L q3 q0 0  1, R q1   , L q2 1  0, L q3
  , R   , R
q4 q4
15/08/20 89 15/08/20 90
Time 8  1 1 1 1 0  Time 9  1 1 1 1 0 
q3 q3
1  1, R 1  1, R 1  1, L 1  1, R 1  1, R 1  1, L
q0 0  1, R q1   , L q2 1  0, L q3 q0 0  1, R q1   , L q2 1  0, L q3
  , R   , R
q4 q4
15/08/20 91 15/08/20 92
Time 10  1 1 1 1 0  Time 11  1 1 1 1 0 
q3 q3
1  1, R 1  1, R 1  1, L 1  1, R 1  1, R 1  1, L
q0 0  1, R q1   , L q2 1  0, L q3 q0 0  1, R q1   , L q2 1  0, L q3
  , R   , R
q4 q4
15/08/20 93 15/08/20 94
Un altro esempio
Time 12  1 1 1 1 0  Che
La funzione raddoppia è calcolabile
q4 il numero
di 1
1  1, R 1  1, R 1  1, L
Macchina di Turing :
stringa di input: x unario

q0 0  1, R q1   , L q2 1  0, L q3
  , R Output string: xx unario

HALT & accettazione q4
15/08/20 95 15/08/20 96
x macchina Turing f ( x)  2 x
Pseudocodice per
Start  1 1  1  • ogni 1 diventa $
q0 stato iniziale • Repeat:
• trova il $ più a destra, cambia in 1
2x
• vai alla fine a destra, inserisci 1
Finish  1 1  1 1 1  Until no $ rimangono
q f stato accettazione
15/08/20 97 15/08/20 98
esempio
Turing macchina per Start Finish
f ( x)  xx
 1 1   1 1 1 1 
q0 q3
1  $, R 1  1, L 1  1, R
1  $, R 1  1, L 1  1, R
q0   , L q1 $  1, R q2
q0   , L q1 $  1, R q2
  , R   1, L   , R   1, L
q3
q3
15/08/20 99 15/08/20 100
Copia a distanza di una stringa altro esempio
Es 1111 dà 111101111
1 if x y
La funzione f ( x, y ) 
È calcolabile 0 if x y
Input: x0 y
Output: 1 or 0
15/08/20 101 15/08/20 102
macchina di Turing Pseudocodice:
• Repeat
verifica ogni 1 da x con 1 fda y Mettere insieme macchine di

Until tutti gli 1 di x or y sono verificate turing
• If un 1 da x non è verificato
cancella tape, scrivi 1 ( x  y)
else
15/08/20
cancella tape, scrivi 0 ( x  y) 103 15/08/20 104
esempio: x  y if x  y
f ( x, y ) 
Block Diagram
0 if x  y
x, y
Turing
input output Adder x y
macchina
x, y x y
Comparatore
x y Eraser 0
15/08/20 105 15/08/20 106

Vari modelli
Lezioni tratte dal gambosi etc, vai su ada.
1 2
3 4
5 6
7 8
9 10
11 12
13 14
15 16
Una limitazione delle macchine di Turing
Turing Machines sono “hardwired”
Macchina Turing Universale Eseguono un solo

programma
Computer Reali sono ri-programmabili
15/08/20 1 15/08/20 2
Soluzione: Universal Turing Machine Universal Turing Machine

•Simula ogni altra Macchina di Turing M
Attributi:
Input della Universal Turing Machine:
• macchina Riprogrammabile
• Simula ogni altra Macchina di Turing Descrizione delle transizioni di M
stringa di input di M
15/08/20 3 15/08/20 4
Tape 1 Tape 1
Tre nastri
Descrizione di M Descrizione di M
Universal
Tape 2
Turing Descriviamo le Turing machines M
Machine Come una stringa di simboli:
Contenuti del nastro di M
Tape 3
codifichiamo M Come una
stringa di simboli
15/08/20 Stato di M 5 15/08/20 6
Codifica degli stati

codice Alfabeto
Stati: q1 q2 q3 q4 
Simboli: a b c d 
codifica: 1 11 111 1111
codifica: 1 11 111 1111
Codifica dei movimenti della Head
Mossa: L R
codifica: 1 11
15/08/20 7 15/08/20 8
codifica delle transizione Codifica Turing Machine
Transizione:  (q1, a )  (q2 , b, L) Transizione:

 (q1, a )  (q2 , b, L)  (q2 , b)  (q3 , c, R)
codifica: 1 0 1 0 11 0 11 0 1
Codifica:
separatore
1 0 1 0 11 0 11 0 1 00 11 0 110 111 0 111 0 11
separatore
15/08/20 9 15/08/20 10
Nastro due, tre : simuliamo

Tape 1 della Universal Turing Machine contiene:
(q_1,c, q_new, c_new, op)
Codifica binaria Consideriamo tutti gli stati e tutti i caratteri (perché? Si può fare
M diversamente?)
della macchina da simulare
Una lista
{(q,c, q_new, c_new, op) Per tutti gli stati q, Per tutti i caratteri
Tape 1 c}
Al primo posto
1 0 1 0 11 0 11 0 10011 0 1 10 111 0 111 0 1100 
q_0 per tutti i caratteri
q_1 per tutti i caratteri
----
q_n per tutti i caratteri.
15/08/20 11 15/08/20 12
Carattere osservato terzo nastro,
Stato da applicare secondo nastro
In rosso i codici I=0
puntatore primo nastro su q_I
puntatore secondo nastro su carattere osservato C
QUI Guardo C e prendo la stringa che comincia co q_I,C
Primo nastro gli input: Macchina $ input Copio nel terzo nastro (q_I,C,q_new,c_new,op)
Copiamo Macchina secondo nastro , /* eseguire l’operazione*/
Copiamo input terzo nastro C diventa c-new nel secondo nastro
Eseguo op sul secondo nastro che sposta la testina
/*Ora cosa devo fare? Da q_I devo passare a q-new */
I=new
Andare su q_I nel primo nastro
/*Come farlo? Devo spostare, sul primo nastro fino a che non
trovo q_new*/
Andare Qui se q_I non è finale
15/08/20 13 15/08/20 14
Carattere osservato terzo nastro,

Stato da applicare secondo nastro Una Turing Machine è descritta
/* puntatore secondo nastro su q_0, puntatore terzo nastro primo carattere C */
Come una stringa di 0’s e 1’s
I=0
c=primo carattere
Label:
il valore di I ci dà lo stato q_I quindi:
il valore del carattere osservato, c, ci dà (q_I, c)
Eseguiamo l’operazione (q_I, c, q_n, nuovoc, op); L’insieme delle Turing machines
Ovvero I=n; c=nuovoc Forma un linguaggio:
c=carattere a op dell’osservato op=L,R
Spostiamo il puntatore del terzo nastro secondo op (L,R)
Spostiamo il puntatore del secondo nastro su q_n; Ogni stringa di questo linguaggio è
Vai a Label la Codifica binaria di una Turing Machine
15/08/20 15 15/08/20 16
Insiemi contabili
Linguaggio delle Turing Machines
Insieme infiniti sono:
L = { 010100101011, (Turing Machine 1) Countable (enumerabili)
00100100101111, (Turing Machine 2) or
111010011110010101, …… Uncountable (non enumerabili)
…… }
15/08/20 17 15/08/20 18
Countable set: Esempio: L’insieme dei numeri pari

Esiste una corrispondenza uno a uno
tra
Gli elementi dell’insieme Interi pari: 0, 2, 4, 6, 
(positive)
e
Numeri naturali (interi positivi)
corrispondenza:
(ogni elemento dell’insieme è associato ad un numero naturale

Interi positivi: 1, 2, 3, 4, 
tale che non esistono due elementi che sono associati
allo stesso numero
2n Corrisponde a n 1
15/08/20 19 15/08/20 20
approccio banale Nominatore 1
Esempio: L’insieme dei numeri razionali
1 1 1
Numeri razionali: , , ,
1 2 3
Corrispondenza:
1 3 7
Numeri razionali: , , , 
2 4 8 interi positivi: 1, 2, 3, 
Non funziona:
Non analizeremo mai 2 2 2
, , ,
Numeri con nominatore 2: 1 2 3
15/08/20 21 15/08/20 22
Approccio migliore
P_1 1 1 1 1 1 1 1 1
 P_1(1 P_1(2) P_1(3) 
1 2 3 4 1 2 3 4
)
2 2 2 P_2(1) 2 2 P_2(2) 2
P_2  
1 2 3 1 2 3
3 3 P_3(1) 3 3
 
1 2 1 2
4 4
 
15/08/20
1 23 15/08/20
1 24
Oppure
1 1 1 1 1 1 1 1
 
1 2 3 4 1 2 3 4
2 2 2 2 2 2
 
1 2 3 1 2 3
3 3 3 3
 
1 2 1 2
4 4
 
15/08/20
1 25 15/08/20
1 26
1 1 2 1 2
Numeri razionali: , , , , , 
P_1(1) 1 2 1 3 2
P_1(2) P_2(1)
P_1(3) P_2(2) P_3(1)
P_1(4) P_2(3) P_3(2) P_4(1) Corrispondenza:
I=1 interi positivi: 1, 2, 3, 4, 5, 

J=1,I
P_I(J)
15/08/20 27 15/08/20 28
Definizione
un insieme è countable se esiste Sia S un insieme di stringhe (linguaggio)
un enumeration procedure
(enumeratore)
Un enumerator per S è una Turing Machine
che definisce la corrispondenza con i
che genera (scrive sul nastro)
numeri naturali
tutte le stringhe S una per una
e
Ogni stringa è generata in tempo finito
15/08/20 29 15/08/20 30
stringhe s1, s2 , s3 ,   S Osservazione:

Se esiste per S un enumeratore,
Allora l’insieme è countable
Enumerator output s1, s2 , s3 , 

Machine per S (sul nastro)
L’ enumeratore descrive la corrispondenza
di S con i numeri naturali
Tempo finito: t1 , t 2 , t3 ,
15/08/20 31 15/08/20 32
Esempio: L’insieme delle stringhe Enumeratore banale:
è countable S  {a , b , c }  Produrre le stringhe in ordine lessicografico

s1  a
s2  aa
 aaa
aaaa
......
Approccio:
Descriviamo un enumeratore per S No buono:
le stringhe con primo carattere b
non vengono fuori
15/08/20 33 15/08/20 34
Procedura migliore : Ordine proprio s1  a

s2  b lunghezza 1
(Canonical, proper, Order)  c
aa
1. Produci tutte le stringhe di lunghezza 1
ab
ac
2. Produci tutte le stringhe di lunghezza 2 Produce stringhe in ba
Proper Order: bb lunghezza 2
bc
3. Produci tutte le stringhe di lunghezza 3 ca
cb
cc
4. Produci tutte le stringhe di lunghezza 4
aaa
.......... aab
aac lunghezza 3
......
15/08/20 35 15/08/20 36
Codifica degli stati
q1 q2 q3 q4  codifica delle transizione

Stati:
Transizione:  (q1, a )  (q2 , b, L)

codifica: 1 11 111 1111
Codifica dei movimenti della Head codifica: 1 0 1 0 11 0 11 0 1
Mossa: L R separatore
codifica: 1 11
15/08/20 37 15/08/20 38
Teorema: L’insieme di tutte le Enumerator:

Turing Machines
è countable Repeat
1. Genera le stringhe binarie di
Proof: Ogni macchina di Turing può essere 0’s e 1’s in proper order
codificata
Con una stringa binaria di 0’s e 1’s 2. Check se la stringa generate
Definite un enumeration procedure descrive una Turing Machine
Per l’insieme delle stringhe che if YES: print string sull’output tape
Descrivono le Turing Machine if NO: ignora string
15/08/20 39 15/08/20 40
Binary strings Turing Machines
Insiemi incontabili
0 definizione: Un insieme è uncountable L 
1
00
se non è countable, ovvero
01 se non esiste un enumeratore
 che lo enumera
1 0 1 0 11 0 11 0 0 s1 Vogliamo provare che vi è un linguaggio
1 0 1 0 11 0 11 0 1 1 0 1 0 11 0 11 0 1
che non è accettato da nessuna macchina di
 s2 Turing
1 0 11 0 1010010101101 1 0 11 0 1010010101101

End of Proof
15/08/20 41 15/08/20 42
Tecnica: Teorema:
Se S è un infinito enumerabile, allora

1_ Turing machines sono countable
l’insieme delle parti 2 S di S non è
enumerabile.
2_ Linguaggi sono uncountable
(Vi sono più linguaggi che Turing Machines)
15/08/20 43 15/08/20 44
Proof: Gli elementi dell’insieme delle parti 2 S
hanno la forma:
Poichè S è enumerabile, possiamo scrivere

S  {s1, s2 , s3 ,}
{s1, s3}
Elementi di S {s5 , s7 , s9 , s10 }
……
Assurdo: Sia l’insieme delle parti 2 S
enumerabile
15/08/20 45 15/08/20 46
Codifichiamo ogni insieme

Osservazione:
con una stringa binaria di 0 e 1.
Ogni stringa binaria infinita corrisponde
Elementi a un elemento dell’ insieme delle parti
Insieme delle Codifica Binaria :
parti esempio: 10 0111 0 
(in ordine arbitrario)
s1 s2 s3 s4 
: s1, s4 , s5 , s6 ,}  2
Corrispondente a {
S
{s1} 1 0 0 0 
{s2 , s 3 } 0 1 1 0 
{s1, s 3 , s4 } 1 0 1 1 
15/08/20 47 15/08/20 48
assumiamo (per assurdo) Insieme delle Supponiamo che la seguente sia
Che l’ Insieme delle parti 2 S Parti elementi
Codifica Binaria
è enumerabile
t1 1 0 0 0 0 
allora: possiamo enumerare gli elementi
dell’ insieme delle parti t2 1 1 0 0 0 
t3 0 
2 S  {t1, t2 , t3 ,} 1 1 0 1
t4 1 1 0 0 1 
15/08/20 49 15/08/20
  50
Prendiamo la diagonale e complementiamola
t1 1 0 0 0 0 
Stringa binaria t  0011
t2 1 1 0 0 0  Corrisponde ad un
elemento dell’Insieme
t3 1 1 0 1 0  delle parti 2 S : t  {s3 , s 4 , }  2S
t4 1 1 0 0 1 
Stringa binaria: t  0011

15/08/20 51 15/08/20 52
allora, t deve essere uguale a qualche ti Poichè abbiamo ottenuto una contradizione
t  ti a partire dall’ipotesi che 2 S è contabile:
L’ insieme delle Parti S 2
ma, di S è uncountable
il i-th bit nella codifica t è
il complemento i-th del bit di ti , allora:
FINE
t  ti Per ogni i
Contradizione!!!
15/08/20 53 15/08/20 54
Una applicazione: Linguaggi
Considera l’alfabeto : A  {a, b} Considera alfabeto : A  {a, b}

L’insieme delle stringhe: L’insieme delle stringhe:
S  {a, b}*  { , a, b, aa, ab, ba, bb, aaa, aab,} S  {a, b}*  { , a, b, aa, ab, ba, bb, aaa, aab,}
infinito e countable infinito e countable
(possiamo enumerare le stringhe Ogni linguaggio è un sottoinsieme di S:

in ordine proprio)
L  {aa, ab, aab}
15/08/20 55 15/08/20 56
Considera alfabeto : A  {a, b}
Considera l’alfabeto : A  {a, b}
countable
L’insieme delle stringhe: Turing machines: M1 M 2 M3 
S  A*  {a, b}*  { , a, b, aa, ab, ba, bb, aaa, aab,} accetta
infinito e countable
Linguaggi accettati da
Ricorda: L’insieme delle parti di S Turing Machines: L1 L2 L3 
contiene tutti i linguaggi: countable
2 S  {,{},{a},{a, b},{aa, b},...,{aa, ab, aab},}
uncountable
Denota: X  {L1, L2 , L3 ,} Nota: X  2S
countable
15/08/20 57 15/08/20
S  {a , b } 
*
58
Linguaggi accettati da
Conclusione:
Turing machines: X countable
Esiste un linguaggio L  non accettato
da nessuna Turing Machine:
Tutti i possibili linguaggi:
2 S uncountable
X  2S L  2S and L  X
S
quindi: X 2 (linguaggio L  non può essere descritto
da nessun algoritmo)
since X  2S , we have X  2S 
15/08/20 59 15/08/20 60
Linguaggi Non Turing-Accettabili Nota che: X  {L1, L2 , L3 ,}
L È un multi-set (elementi possono ripetersi)
Poichè un linguaggio può essere riconosciuto
da più di una Turing machine
Linguaggi
Turing-Accettabili
Anche se esaminiamo i doppioni il risultato
è di nuovo un insieme countable poichè ogni elemento
corrisponde a un intero positivo
15/08/20 61 15/08/20 62
Linear-Bounded Automa:
Come una Macchina di Turing

con una differenza:
Lo spazio dove è memorizzato l’input
La gerarchia di Chomsky è il solo spazio che può essere
utilizzato
15/08/20 63 15/08/20 64
Linear Bounded Automa (LBA)
Definiamo i LBA come macchine
Input string non deterministiche
[ a b c d e ]
Working space
Limite a Limite a Problema aperto:
in tape
sinistra destra LBA NonDeterministici
hanno lo stesso potere dei
Tutta la computazione si svolge tra i due limiti LBA Deterministici ?
15/08/20 65 15/08/20 66
Esempio linguaggio accettato da un LBA: Grammatica Context-Sensitive :
L  {a nb n c n } L  {a n!} produzioni
uv
LBA hanno più potere dei PDA

(pushdown automata) Stringhe di variabili Stringhe di variabili
e terminali e terminali
LBA hanno meno potere delle Turing Machines |u|  |v|

e:
15/08/20 67 15/08/20 68
Teorema:
Il linguaggio {a nb n c n }
è context-sensitive:
Un linguaggio L è context sensitive
S  abc | aAbc è accettato da Linear-Bounded automa

Devo provare il
Ab  bA contrario
Ac  Bbcc Dato L (data la grammatica per
bB  Bb L) devo costruire una LB che
riconosce tutte e solo le parole
aB  aa | aaA di L
15/08/20 69 15/08/20 70
stringa elemento di L la Grammatiche senza limitazioni:

macchina mi deve dire si
stringa non è elemento di L Produzioni
la macchina mi deve dire no uv
S  abc | aAbc
S
Ab  bA alt
stringa
Stringhe di variabili Stringhe di variabili
Ac  Bbcc Tutte le
regole e terminali e terminali
bB  Bb
S Se 1n non
uguale 2n
aB  aa | aaA
15/08/20 71 15/08/20 72
The Chomsky gerarchia
Teorema:
Non Turing-Acceptable
Un linguaggio L è Turing-Acceptable
Se L è generato da Turing-Acceptable
una grammatica senza restrizione
decidable
Perchè? Come fare? Context-sensitive
Context-free
Regular
15/08/20 73 15/08/20 74
appartenenza
Domanda: dato un linguaggio regolare L
problemi decidibili e una stringa w
(decidibile?) Possiamo verificare se w  L ?
per linguaggi regolari
Risposta: Prendiamo un DFA che L
accetta L
e verifichiamo se w è
accettato.
15/08/20 75 15/08/20 76
DFA Domanda: dato un linguaggio regolare L
w Come possiamo verificare
w L se L è vuoto: ( L  ) ?
DFA Risposta: Prendiamo il DFA che accettà L

w
w L Verifichiamo se esiste almeno
un cammino da uno stato iniziale
ad uno stato di accettazione
15/08/20 77 15/08/20 78
DFA Domanda: Dato un linguaggio regolare L

Come possiamo verificare
L Se L è finito?
Prendiamo il DFA che accetta L

DFA Risposta:
Verifichiamo se vi è un cammino con
L un loop.
15/08/20 79 15/08/20 80
DFA
Domanda: dato linguaggi regolari L1 e L2
Come possiamo verificare che
L è infinito
L1  L2
DFA Risposta: Trova se

( L1  L2 )  ( L1  L2 )  
L è finito
15/08/20 81 15/08/20 82
( L1  L2 )  ( L1  L2 )   ( L1  L2 )  ( L1  L2 )  
L1  L2   and L1  L2   L1  L2   or L1  L2  
L1 L2 L L2 L1 L1 L1 L2 L2 L1
2
L1  L2 L2  L1 L1  L2 L2  L1
L1  L2 L1  L2
15/08/20 83 15/08/20 84
appartenenza:
per grammatiche context-free G

problemi decidibili Se la stringa w L(G )
per
linguaggi Context-Free
appartenenza : Parsers
• “Exhaustive search parser” o “non

determinismo”
• CYK parsing algorithm
15/08/20 85 15/08/20 86
Teorema: Turing machine una grammatica senza restrizione
Un linguaggio L è Turing-Acceptable ? =Qualsiasi carattere
Se L è generato da
Stati= non terminali, car =terminali
una grammatica senza restrizione
Q c:= Q ? c Q c= c Q
Grammatica definire Turing machine Delta(Q, c)=(Q, c, L) Qc=Q?c

(linear bounded uguale) Delta(Q, c)=(Q, c, R)
Se Spostandosi trovo il blank Delta(Q,
S Tutte le
regole
input=st
ringa
c)=(Q, c, L) F:= fermo la
genrata Delta(Q, b)=(Q, c, R|L)
computazione
altrimenti
15/08/20 87 15/08/20 88
linguaggi decidibili
Ricordiamo che:
un linguaggio A è decidibile,
Problemi se vi è una Turing machine M (decisore)
indecidibili che accetta il linguaggio A e
(unsolvable problems) e si ferma su ogni stringa di input
Decision
Turing Machine M On Halt:
YES
Accept
Input
Decisore per
stringa NO
A Reject
15/08/20 1 15/08/20 2
linguaggi indecidibili
linguaggi indecidibili = linguaggi non decidibili
Non esiste un procedimento di decisione
(decisore):
Definizione
Non esiste una Turing Machine
Un problema computazionale è decidibile che accetta il linguaggio
se il corrispondente linguaggio è decidibile e prende una decisione (halts)
per ogni stringa di input.
(la macchina può prendere decisioni per qualche stringa
ma non per tutte)
15/08/20 3 15/08/20 4
Per un linguaggio indecidibile,
Definizione. Turing accettabile
Il corrispondente problema è
Abbiamo una Turing Machine (Algorithm) che
indecidibile (unsolvable):
1_ per ogni input abbiamo una risposta se la
stringa appartiene al linguaggio(yes)
Non esiste una Turing Machine (Algorithm) 2_ ma nulla possiamo dire se la stringa non
che per ogni input appartiene al linguaggio
dà una risposta
(yes (appartiene al linguaggio)
or no (non appartiene al linguaggio)
(chiaramente per alcuni input si)
15/08/20 5 15/08/20 6
Abbiamo gia mostrato che esistono linguaggi Membership Problem

indecidibili:
Input: •Turing Machine M
•String w
L
Turing-Acceptable L Question: M accetta w ?
w L(M ) ?
Decidable
linguaggio corrispondente:
ATM  { M , w : M è una Turing machine che
accetta la stringa w}
15/08/20 7 15/08/20 8
Teorema: ATM è indecidibile Supponiamo che ATM è decidibile
(The membership problem non è decidible)
Input Esiste una macchina H:

string
M,w
Supponiamo che ATM sia decidibile M accetta w
M Decisore
per ATM YES
H
w NO M rigetta w
15/08/20 9 15/08/20 10
Cambiamo, diagonalizziamo, definiamo la macchina Diag:

ATM
Semplifichiamo Diag . ATM
Definiamo Diag
Diag accetta (yes) se H dice no; ovvero se M( w) =no Descrizione di Diag:
Diag rigetta (no) se dice si; ovvero se M( w) =s Diag accetta M se M rigetta M
H
Diag rigetta M se M accetta M
Diag:
M,w M, w
Decisore ATM
M YES no M Decisore
per YES M Rigetta M w
per ATM
w H NO yes H NO
w
M Accetta M w
15/08/20 11 15/08/20 12
ATM
Descrizione di Diag: Descrizione di D:

Diag accetta (yes) Diag se Diag rigetta Diag (no)
Diag accetta M se M rigetta M
Diag rigetta (no) Diag se Diag accetta Diag (yes)
Al posto di M sostituiamo Diag
M, w
Cosa accade?:
Decisore
M ATM YES M Rigetta M
w
per
Diag accetta Diag se Diag rigetta Diag (!!)
w H NO M Accetta M
w
Diag rigetta Diag se Diag accetta Diag (!!)

15/08/20 13 15/08/20 14
Abbiamo mostrato:
Definizione di
Turing accettabile
ATM
M accetta D se M(D)
Decidable raggiunge uno stato finale.
Nulla è stato detto su cosa

accade quando M rifiuta D
15/08/20 15 15/08/20 16
ATM  { M , w : M è una Turing machine che Halting Problem
accetta la stringa w} Input: •Turing Machine M
ATM è Turing-Acceptable (semidecidibile) •String w
Turing machine che accetta ATM : domanda: M si ferma nel processo

di calcolo con stringa di input w?
1. Run M on input w
M,w 2. If M accepts w linguaggio corrispondente:
then accept M,w HALTTM  { M , w : M è una Turing machine che
si ferma sull' input w }
15/08/20 17 15/08/20 18
Teorema: HALTTM è indecidibile

ATM  { M , w : M è una Turing machine che (The halting problem non è risolvibile)
accetta la stringa w}
dim:
HALTTM  { M , w : M è una Turing machine che idea di base:
Supponiamo che HALTTM è decidibile;
si ferma sull' input w }
Proveremo che:
ogni linguaggio Turing-Acceptable
è decidibile
contradizione!
15/08/20 19 15/08/20 20
Supponiamo che HALTTM è decidibile sia L un linguaggio Turing-Accettabile
Turing-Semidecidibile
Input
string sia ML la Turing Machine che accetta L
M,w
M
Decisore per
YES M w alt Proviamo che L è decidibile:
w HALTTM Costruiamo un decisore per L

NO
Mw No alt
15/08/20 21 15/08/20 22
Decider per L Quindi L è decidibile

Decider for
HALTTM
ML
NO poichè L è stato scelto
reject s
ML halts on s ? and halt arbitrariamente, ogni linguaggio (Turing-)
YES semidecidibile è decidibile
s
Input ML halts Ma vi è un linguaggio Turing-Accettabile
accept s
string and accepts
and halt (semidecidibile) che è indecidibile (Teor,
Run ML
with input s visto in precedenza)
ML halts
reject s
and rejects
and halt
Contradizione!!!!
END OF PROOF
15/08/20 23 15/08/20 24
Un altra dimostrazione
Supponi che HALTTM è decidibile
Teorema: HALTTM è indecidibile
(The halting problem non è decidibile) Input
string Decisore
dim: M,w per HALTTM
Idea di base:
M YES Mw
Per assurdo: assumiamo che
l’ halting problem decidibile;
H
w NO
Cercheremo di ottenere una contradizione Mw
via diagonalizzazione
15/08/20 25 15/08/20 26
Guardiamo Costruiamo la macchina H :

dentro H
Decider per HALTTM
H Loop forever
H qaccept YES
H qacceptYES qa qb
Input string:
M,w q0 M,w q0 M halts on w?
M ferma su w ?
qreject NO
qreject NO
If M halts on input w Then Loop Forever

Else Halt
15/08/20 27 15/08/20 28
Costruiamo la macchina F: calcola F con input se stesso
F
F Copy F F ,F
Copy M M, M
F
on tape
H
M
on tape
H
If F halts on input F
Then F loops forever on input F
If M halts on input M
Else F halts on input F
Then loop forever
Else halt contradizione!!!
END OF PROOF
15/08/20 29 15/08/20 30
h (codiceM, x) =1 se M con input x termina

Idem
=0 se M con input x non termina
precedente
Supponiamo che il predicato sia calcolabile, esista

cioè una macchina di Turing h che calcola la
funzione h. Costruiamo la macchina h' che calcola
il predicato
h'(codiceM) =1 se M con input CodiceM termina

=0 se M con input CodiceM non termina
90 31 90 32
h' è la composizione di due macchine:
la prima con input codiceM fornisce codiceM b codiceM,
h'(codiceM) =1 se M (codiceM ) termina
la seconda è la macchina h che calcola il predicato della
terminazione. =0 se M( codiceM ) non termina
In altre parole h' è la macchina che verifica se una MT
termina quando le viene fornito in input il proprio codice. h"(codiceM) = 0 se h'(codiceM) = 0 (se M( codiceM ) non termina)
= indefinito altrimenti (se M (codiceM ) termina)
Possiamo ora costruire una nuova macchina h" che prende in )
input codiceM e calcola la funzione:
h"(codiceM) = 0 se h'(codiceM) = 0
= indefinito altrimenti termina con 0 se h' si è fermata con 0 e
si mette a ciclare, se h' si è fermata con 1
90 33 90 34
calcoliamo h"(codiceh") : Abbiamo mostrato
h"(codiceh") = indefinito se h"(codiceh") è definita

= 0 se h"(codiceh") è indefinita
indecidibile HALTTM
In ogni caso abbiamo una contraddizione. Quindi non può
esistere la macchina H.
Decidable
h"(DM) =0 se h'(DM) = 0 Fine

=indefinito altrimenti idem
h'(DM) =1 se M (DM ) termina
=0 se M( DM ) non termina
90 35 15/08/20 36
Adesso proviamo che: HALTTM è Turing-Acceptable (semidecidibile)
Turing machine che accetta HALTTM:

Turing-Accettabile HALT
TM
1. Run M on input w
Decidable
M,w
2. If M halts on w
then accept M,w
15/08/20 37 15/08/20 38
Abbiamo gia mostrato che esistono linguaggi ATM

Supponiamo w=<M> e
indecidibili:
calcoliamo D(<M> , <M> )
L Input
Turing-Acceptable L string Decisore
accetta
M ,w
per ATM
M YES M rigetta <M>
Decidable
H
<M> NO M accetta<M>
rigetta
15/08/20 L 39 15/08/20 40
Teorema: ATM è indecidibile
Allora avremo un decisore cosi definito:
(The membership problem non è risolvibile)
Input
Proof: string Decisore
Idea di base: M,w per ATM
Assumiamo che ATM è decidibile; M M accetta w
YES
Proveremo che ogni linguaggio
è Turing-Acceptable
H
w NO M rigetta w
assurdo!
15/08/20 41 15/08/20 42
Descrizione come stringa di ML Cambiamo, diagonalizziamo, chiamiamo la macchina Diag.

ATM
Decisore per L
Diag accetta se ATM dice yes ovvero se M( w) =no
Diag rigetta se dice no ovvero se M( w) =s
ATM
accetta
Decisore per ATM
ML YES Diag:
accept s
(and halt) M,w
ML accepts s ?
Decisore
s NO reject s
M per A YES M rigetta w
TM
(and halt)
w H NO M accetta w
Sia ML il decisore per il rigetta
15/08/20
linguaggio L 43 15/08/20 44
Descrizione di Diag: ATM
Diag accetta M se M rigetta M Mostriamo che:

Turing-Acceptable ATM
Decisore
M, w
per ATM
M YES M Rigetta M
w Decidable
H
w
NO M Accetta M
w
15/08/20 45 15/08/20 46

Slides CC PDF

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Slides CC PDF

Caricato da

Copyright:

Formati disponibili

Linguaggio: un insieme di stringhe

Stringa: una sequenza di simboli da un

Alfabeto:   a, b, c,, z

Linguaggi sono usati per descrivere Alfabeti e Stringe

Alfabeto dei numeri binari   { 0,1} Zero?

wv  a1a2  anb1b2 bm abbabbbaaa w R  an a2a1 bbbaaababa

Stringa vuota Sottostringa

Osservaziones: Stringa Sottostringa

Numeri primi Numeri pari e dispari

alfabeto   { 0,1,2, ,9} alfabeto   { 0,1,2, ,9}

PRIMES  {2,3,5,7,11,13,17,} ODD  {x : x  * e x è dispari}

alfabeto:   {1,, } Alfabeto:   {1, # }

11  111  11111  ADDITION 11#1111  SQUARES

Nota che : Operazioni sui linguaggi

 0 a, ba   , b, aa, ab, bb, aaa,

Definizione: LR  {w R : w  L} Definizione: L1L2  xy : x  L1, y  L2 

Esempio: ab, aab, babaR  ba, baa, abab

L  {a nb n : n  0} Esempio: a, ab, bab, aa

 ab, aaa, abb, abaa, bab, baaa

testa Configurazione iniziale Analizzare l’Input

Input finito Un caso rigettato

Un altro caso rigettato

Devono essere esaminati tutti i caratteri di

Stato trap state

Insieme degli stati Q Alfabeto di input 

Tavola di transizione per  Funzione estesa di transizione

 * q1 , bba   q4 Delta*(q, aw)=Delta*(delta(q,a), w);

Implica che vi è un cammino di transizione

Deterministic Finite Automaton (DFA) U(automa, input)=automa(input)

L M  = { tutte le stringhe binarie che non

I linguaggi accettati da tutti i DFA formano {x : x  {1} * and x is even}

Esitono linguaggi che non sono regolari:

Non esiste nessun DFA che accetta

Automi non deterministici (NFA)

alfabeto = {a} alfabeto = {a}

Due scelte q1 a q2 finale q1 a q2

Prima scelta Prima scelta

un NFA accetta una stringa:

Tutta la stringa di input è stata letta e l’automa “accettato”

Seconda scelta Seconda scelta

First Choice Second Choice

aaa È rigettato dal NFA: Linguaggio accettato: L  {aa}

La testina dell’input non si muove

(la testina non si muove)

stringa aaa è rigettata

Esiste una computazione si a b

a b a b L  ab, abab, ababab, ...

NFA esempio Remarks:

 L(M1 ) = {} L(M 2 ) = {λ}

 q0 , 1  q1  (q1,0)  {q0 , q2}

Grado di non determinismo di un nodo per Grado di non determinismo di un automa, il

F  q0 ,q5  F  q0 ,q5 

L M   ab  *  ab  * {aa }

Equivalenza tra macchine Esempio di macchine equivalenti

Parte prima Parte seconda

Ogni linguaggioL accettato da un DFA

 * (q0 , b )   Insieme vuoto  * (q1 , a )  {q1 , q2 }

Fine della costruzione Procedura generale

DFA ha gli stati definiti dall’insieme delle

NFA M a 2. per ogni stato DFA {qi , q j ,..., qm }

Mostriamo che: L M   L M   considera w L(M ) NFA

15/08/20 99 15/08/20 100

In modo piu generale , Dimostrazione per induzione su |v|

 * q1 , bba   q4 Delta(q, aw)=Delta(delta(q,a), w);