Verifica se un Linguaggio Regolare è vuoto

Verifica se un Linguaggio Regolare è vuoto
Se si suppone di usare la rappresentazione del linguaggio nella sua forma di automa
a stati finiti il problema puo’ essere formulato nel modo seguente:
• Se esiste un cammino dallo stato S ad uno stato accettante ! Z allora il linguaggio non è vuoto
• Se non esiste una cammino dallo stato iniziale a qualche stato accettante ! Z il linguaggio è vuoto
• Se esiste una cammino dallo stato iniziale S ad un qualche stato accettante ! Z e che attraversa
almeno due volte uno stesso stato il linguaggio è infinito
Equivalenza di linguaggi regolari
E’ conveniente mettere due descrittori di linguaggi regolari sotto forma di automa a stati
finiti deterministici in modo da favorirne il confronto.
Il confronto verrà fatto trasformando i due automi nella loro forma minimale e, a meno
di una ridenominazione degli stati, verificare se i due automi minimali coincidono.
[Questo procedimento funziona in quanto si può dimostrare come la forma minimale di un
automa è unico].
Verifica dell’equivalenza di stati
Due stati p e q con p " q si dicono equivalenti (e quindi sostituibili da un unico stato che
si comporti come p e q messi insieme) se:
p e q sono entrambi finali o entrambi non finali, e
Per ogni simbolo di input a, presi s = #(p, a) r = #(q, a) s e r sono lo stesso stato o sono
equivalenti.
Due stati non equivalenti si dicono distinguibili, nel qual caso esiste almeno un simbolo di
input che li distingue.
Esempio
1
0
A
0
E
1
1
B
1
Basta trovare una stringa che
renda distinguibili due stati
0
0
F
0
C
D
1
1
0
G
1
1
H
A
G
0
$ 0
A B
G G
1 01
F C
E E
A dist G
NO NO NOSI
0
A
E
$ 1 0 00 01
A F B G C
E F H G C
A equ E
NO NO NO NO NO
O essere sicuri che ogni possibile
stringa renda equivalente due stati
B
H
$ 0 1
B G C
H G C
NONONO
B equ H
Algoritmo marca-stati
Si rappresentano in una matrice triangolare di coordinate
q1, q2, …, qn x q0, q1, …, qn-1 tutti i possibili accoppiamenti tra stati
1.
Se p è uno stato accettante e q è uno stato non accettante la
coppia {p,q} è marcata distinguibile [questa eventualità è
segnalata da un flag X]
2.
Siano p e q due stati per cui un simbolo di input a ! ! porta
a due stati r=#(p,a) e s= #(q,a) che sappiamo essere
distinguibili, allora anche la coppia {p,q} è distinguibile.
q1
q2
q3
q4
q5
q6
q7
Supposto essere q7
uno stato finale
X X X X X X X
q0 q1 q2 q3 q4 q5 q6
Praticamente due stati risultano equivalenti se non siamo riusciti a dimostrare la loro
distinguibilità
Esempio di esecuzione
1
0
A
0
1
E
1
1
B
0
0
F
0
C
B
C
D
E
F
G
H
D
1
1
0
G
1
1
H
0
0
B
C
D
E
F
G
H
x
x x
x x x
x x
x x x
x x x
x
x
A B C
x
x
x x x
x x x x
D E F G
(E, A)
#(E,0) = H
#(A,0) = B
#(E,1) = F
#(A,1) = F
x
x x
x x x
BH x x
x x x
x x x
x
x
A B C
(G, A)
#(G,0) = G
#(A,0) = B
#(G,1) = E
#(A,1) = F
Stati equivalenti
(A, E) (B, H) (D, F)
Si prodece da sinistra
verso destra e
dall’alto verso il
basso
x
x
x X x
x x x x
D E F G
(G, E)
#(G,0) = G
#(E,0) = H
#(G,1) = E
#(E,1) = F
Complessità dell’algoritmo marca stati
•
•
•
•
•
•
L’algoritmo visita ripetutamente la matrice da sinistra verso destra e dall’alto
verso il basso. Ogni visita richiede O(n2) passi, dove n è il numero degli stati.
La visita della matrice deve essere ripetuta perchè la distinguibilità di una coppia
di stati può dipendere dalla distinguibilità di una coppia di stati che la precede
nell’ordine di visita, e che non è stata finora decisa.
Basta ripetere la visita k volte, dove k è la lunghezza del cammino più lungo
presente nel grafo, per essere sicuri di aver deciso la distinguibilità di ogni coppia
di stati, visto che la distinguibilità di una coppia si stati si basa su quella dei loro
successori.
In un grafo, la lunghezza del cammino (aciclico) più lungo k è limitata
superiormente da n, il numero degli stati.
Quindi se semplicemente ripetiamo la visita n volte, l’algoritmo decide la
distinguibilità di tutte le coppie, con complessità O(n3)
In realtà la ripetizione della visita per n volte è necessaria solo nel caso peggiore.
Si possono fare ottimizzazioni per limitare il numero di ripetizioni a quelle
strattamente necessarie, ma la complessità del caso peggiore resta O(n3)
Minimizzazione di automi
Teorema Se per ogni stato q di un DFA si crea un blocco tra q e tutti gli stati equivalenti a q,
allora l’insieme dei blocchi distinti rappresenta una partizione dell’insieme degli stati.
Ne deriva che ogni stato appartiene ad un blocco e che ogni blocco contiene stati tra di
loro equivalenti, mentre due stati scelti da blocchi distinti non lo sono.
Ad esempio il grafo visto in precedenza produce la partizione:
{A,E} {B,H} {D,F} {C} {G}
In quanto {A,E} {B,H} {D,F} sono elementi della partizione calcolati con l’algoritmo
marca-stati, mentre C e G non essendo allocati in blocchi esistenti danno origine a
blocchi distinti.
Minimizzazione di Automi
Dato un DFA A= < !,K, #, Z,S> l’algoritmo opera nel seguente modo:
1. Togliere gli stati irraggiungibili a partire dallo stato iniziale
2. Con l’algoritmo marca-stati calcolare le coppie di stati tra di loro equivalenti
3. Costruire la partizione degli stati in blocchi ciascuno dei quali contiene stati equivalenti.
4. Costruire il DFA equivalente B=< !,K’,%,Z’,S’> considerando per l’automa B:
a) come stati K’ i blocchi prima calcolati.
b) come stato iniziale S’ il blocco contenente lo stato iniziale di A
c) come stati Finali Z’ l’insieme dei blocchi che contengono gli stati finali di A
[si fissano gli
stati di B]
[si fissano gli
archi di B]
d) Siano Q1, Q2,…Qn i blocchi prima calcolati, ciascun blocco corrisponderà ad
uno stato nell’automa B, e ciascun blocco contiene stati equivalenti dell’automa A.
Sia a un simbolo di input e Qi un blocco. Allora deve esistere un blocco Qj
tale
per cui per ogni stato q ! Qi , #(q,a) è un elemento di Qj si ha pertanto
% (Qi,a) = Qj
Esempio di Minimizzazione
Q1
1
0
A
0
1
E
1
1
B
0
0
F
1
Q2
Q4
Q5
Qi = {A,E} {B,H} {D,F} {C} {G}
0
C
D
1
1
Q3
0
G
0
1
H
1
Q5
1
0
Q3
1
0
Q1
#(A,0) = B
#(E,0) = H
%(Q1,0) = Q2
0
0
Q2
#(A,1) = F
#(E,1) = F
0
0
1
Q4
%(Q1,1) = Q3
1
Riassunto
Linguaggi regolari
Teorema di equivalenza tra i vari descrittori di linguaggi regolari
Determinismo e non determinismo
Equivalenza tra Automi Determinisstici e non deterministici
Proprietà di chiusura dei linguaggi regolari
Minimizzazione di automi
Grammatiche libere dal contesto
G = < VN,VT,P,S >
VN - Insieme finito di simboli detti Non terminali
VT - Insieme finito di simboli detti Terminali
!
!!
V = VN ! VT, VN "#, VT "#,
VN $ VT =#
S-. Simbolo distinto o Assioma del Linguaggio
!!
S % VN
P - Insieme di Produzioni o Regole di Riscrittura
!
!!
P & VN x V*
Processo di generazione
La Grammatica G con produzioni
E
10
1. E ! E + T | E - T | T
2. T ! T * F | T / F | F
3. F ! ( E ) | i
E
Genera stringhe aritmetiche
!
Esempio: la stringa a + b * c è derivata da E
T
T
T
F
nel seguente modo:
E "E + T !!
"T +T ! !
" T + T * F!
"F+T*F!
" i +T * F!
" i + T * i!
" i +F * i!
" i +i * i!
pertanto:
E "* a + b*c
(regola 1)
(regola 1)
(regola 2)
(regola 2)
(regola 3)
(regola 3)
(regola 2)
(regola 3)
F
F
a
+
b
*
c
- E’ conveniente avere un ordine di applicazione delle regole?
- L’albero di generazione può essere costruito in modi diversi?
- E’ possibile costruire per la medesima stringa alberi di
!derivazione diversi?
Alberi di derivazione
E
E
1. E # E + T | E - T | T
2. T # T * F | T / F | F
3. F # ( E ) | i
T
T
T
F
F
F
a
+
Data una grammatica non contestuale G tutte le stringhe s da essa
generabili possono essere rappresentate tramite un albero aventi le seguenti proprietà:
b
*
c
1. La radice è etichettata con il simbolo iniziale S
2. Ogni nodo interno è etichettato con un simbolo non terminale ! VN
3. Ogni foglia è etichettata da un simbolo terminale o dalla stringa vuota "
4. Se il nodo K è etichettato con un simbolo non terminale A ed ha k figli etichettati con i simboli
!1 ,......., !k allora esiste una produzione della forma A # !1 ,......., !k
5. Se S $* w e w è una stringa di caratteri terminali allora w è rappresentata dalle foglie dell’albero.
Parentesi bilanciate
La Grammatica G11 genera stringhe di parentesi bilanciate
S ! " | SS | (S)
due possibili derivazioni sono:
S # SS # S (S) # (S) (S) # (S) ( ) # ( ) ( )
S # SS # ( S ) S # ( ) S # ( ) ( S ) # ( ) ( )
S
S
(
S
!
S
)
(
S
!
)
La Derivazione come classe di equivalenza
Data una grammatica G è possibile pervenire alla generazione di una stringa con processi di
generazione diverse. Date due generazioni D e D’:
D = x1 ! x2 ! ...... ! xn
D’ = x’ ! x’ ! ...... ! x’
1
2
n
se si verifica che :
1. " i ! k xi = x’i
2. xk-1 = x’ k-1 = u A v B w con u,v,w # V* e A, B # VN
3. xk = u y v B w, con A $ y # P
4. x’ k = u Av z w, con B$ z # P
5. xk+1 = x’ k+1= u y v z w
"
si dirà che D precede D’ e si scriverà
""
D prec D’
u y v B w !u y v z w . . . .
xk-1 = x’ k-1 = u A v B w
"
"
"
uAvzw!uyvzw....
Esempio
D1 = S ! SS ! (S) S ! ((S)) S ! (( )) S ! (( ))( S) ! (( )) ( )
D2 = S ! SS ! (S) S ! ((S)) S ! ((S )) (S) ! (( ))( S) ! (( )) ( )
!
Pertanto D1 prec D2
D2 = S ! SS ! (S) S ! ((S)) S ! ((S )) (S) ! (( ))( S) ! (( )) ( )
D3 = S ! SS ! (S) S ! ((S)) S! ((S )) (S)! (( S))( ) ! (( )) ( )
pertanto D2 prec D3
Esempio cont.
D
4
D
5
D
6
D
7
D
8
= S ! SS ! (S) S ! (S) S ! (S )( ) ! (( S))( ) ! (( )) ( )
= S ! SS ! S (S) ! (S) (S) ! ((S)) (S) ! (( ))( S) ! (( )) ( )
= S ! SS ! S (S) ! (S) (S) ! ((S)) (S) ! (( S))( ) ! (( )) ( )
= S ! SS ! S (S) ! (S) (S) ! (S )( ) ! ((S))( ) ! (( )) ( )
= S ! SS ! S (S) ! S ( ) ! (S )( ) ! ((S))( ) ! (( )) ( )
prec
D
1
prec D2
prec
D
3
prec
D
5
prec D6
leftmost derivation
prec
prec
D
4
D
prec
prec
D
8
7
rightmost derivation