Sei sulla pagina 1di 38

1

TEORIA DEI LINGUAGGI


Cosa un linguaggio?
Alfabeto = insieme di simboli (caratteri ascii)
Stringa
insieme finito di simboli di un alfabeto
c e la stringa vuota (talvolta denotata da )
|s| rappresenta la lunghezza di una stringa.
Linguaggio un insieme di stringhe
C, linsieme vuoto un linguaggio
{c} il linguaggio contenente la sola stringa vuota
Linsieme di tutti I possibile ptogrammi C un linguaggio
Linsieme di tutti I possibili identificatori in un linguaggio un
linguaggio
2
Terminologia
Dato un alfabeto
T = {a, b}
su di esso si possono definire infiniti linguaggi
L1 = {a, aa, ab, aab} L2 = {a,b}
L3 = linguaggio contenente lo stesso numero di a e
di b
Definizioni
Cardinalit di un linguaggio = numero di stringhe
appartenenti al linguaggio
Frase = stringa appartenente al linguaggio
Linguaggio infinito = linguaggio con cardinalit
infinita
Linguaggio finito = linguaggio con cardinalit finita
Linguaggio vuoto u = linguaggio con cardinalit 0
stringa vuota = c oppure
3
Operazioni su stringhe
Concatenamento
x = a y = bc
x y = abc
s c = s c s = s
Sottostringhe
x = bc
Riflessione
x = ab
y = ba
Potenza m-esima
s
n
=
s s s .. s ( n times)
s
0
=
c
x = a
x
4
= aaaa
y = ab
y
3
= ababab
Operazioni su i linguaggi
Concatenamento
L1 = {a, b}
L2 = {c, d}
L = L1 L2 =
= {xy | x e L1, y e L2} =
= {ac, ad, bc, bd}
Unione
L1 = {a, b}
L2 = {c, d}
L = L1 L2=
= {x e L1 L2} =
= {a, b, c, d}
Potenza m-esima
L
m
= L
m-1
L
L
0
= u
Esempio
L = {a, b}
L
3
= L
2
L
= {aa, ab, ba, bb} {a, b} =
= {aaa, aba, baa, bba, aab,
abb,
bab, bbb}
4
Linguaggio universale
Definiamo linguaggio universale (monoide libero) su un
alfabeto T linsieme di tutte le stringhe di tale alfabeto
Il linguaggio universale si pu definire come limite
dellelevamento a potenza
L* = stella di Kleene =

n=0
L
n
= L
0
L
1
L
2
.
Positive Closure
L
+
=
n=1
L
n
= L
1
L
2
.

Esempi di Linguaggi
L
1
= {a,b,c,d} L
2
= {1,2}
L
1
L
2
= {a1,a2,b1,b2,c1,c2,d1,d2}
L
1
L
2
= {a,b,c,d,1,2}
L
1
3
= tutte le stringhe di lunghezza 3 (con a,b,c,d}
L
1
*
= tutte le stringhe con a,b,c,d e la stringa vuota
L
1
+
= non include la stringa vuota
5
Grammatiche
Per descrivere un linguaggio sia esso un linguaggio
naturale o un linguaggio di programmazione necessario
definire un insieme di regole a cui deve sottostare ogni
frase del linguaggio per essere corretta.
Tali regole devono specificare tutte o solo le stringhe
appartenenti al linguaggio
Per fare ci necessario quindi introdurre:
una grammatica: cio una specifica formale di tutte le
strutture di frase (o frasi) consentite
un algoritmo di riconoscimento: cio un metodo per
analizzare le frasi e determinare la loro struttura
Grammatiche generative
Una Grammatica generativa pu essere pensata
come un insieme di regole che generano tutte e sole
le frasi del linguaggio
Noam Chomsky ha definito quattro classi di
complessit per le grammatiche generative
Chomsky Hierarchy.
6
The Chomsky Hierarchy
Tipo 0
Tipo 1
Tipo 2
Tipo 3
Tipo 0 - Grammatiche generali - Macchina di Turing
Tipo1 - Grammatiche Dipendenti dal Contesto
Tipo 2 - Grammatiche non contestuali - Automi a Pila
Tipo 3 - Grammatiche regolari - Automi a stati finiti
Grammatiche generative
Una grammatica generativa G espressa come una quadrupla G=(V, E, P,
S),
dove:
V linsieme dei non terminali o variabile (nel seguito utilizzeremo le
lettere maiscule)
E linsieme finito di terminali (utilizzaremo le lettere minuscole)
P linsieme finito delle produzioni o regole nella forma
o|
S un simbolo speciale appartenente allinsieme dei non terminali V
chiamato assioma
Normalmente V E = C.
Ogni simbolo della grammatica un elemento di V E.
7
Grammatiche regolare (tipo 3)
Una grammatica regolare (RG) denotata da G = (V, E, P,S),
dove V l insieme dei non terminali, E linsieme dei terminali,
S un non-terminale chiamato assioma, P un insieme finito di
produzioni, con ogni produzione nella forma
A |,
con: A e V e | e (V E)*.
produzione in una grammatica regolare regolare le produzioni possono
consistere in produzioni come le seguenti
A aB, B b (grammatiche lineari destre)
oppure
B Ab, A a (grammatiche lineari sinistre)
Generalmenre, le lettere greche minuscole denotano stringhe
in (V E)*.
Esempio di grammatica
V = {S}
E = {a, b}
P = {S c (stringa vuota)
S abS
S = {S}
Stringhe appartenenti al linguaggio:
S abS ab
S abS ababS abab
8
Nelle grammatiche di tipo 3, il solo non terminale
nella parte destra (RHS) della produzione sempre si
trova alla fine della regola (o alternativamente
allinizio)
Le grammatiche di tipo 3 sono molto restrittive (non
si possono utilizzare per la sintassi dei linguaggi di
programmazione) ma i loro riconoscitori sono molto
efficenti.
Cosa un linguaggio regolare?
Sono tutti e soli i linguaggi che si possono generare
con grammatiche generative di tipo 3
Un linguaggio che pu essere espresso mediante le
operazioni di concatenamento, unione e stella di
Kleene applicate un numero finito di volte a
linguaggi unitari e al linguaggio vuoto
Ogni linguaggio finito regolare
9
Automi a stati finiti
Un riconoscitore per un linguaggio un programma che
prende iuna stringa x e risponde si se x una frase del
linguaggio, no altrimenti.
Chiameremo Automa a stati finiti il riconoscitore per il
linguaggi regolari
Un automa a stati finiti pu essere deterministico (DFA o DFSA)
o non deterministico (NFA o NFSA)
Sia DFA che NFA riconoscono I linguaggi regolari
deterministico piu veloce, ma talvonta poco compatto
non-deterministico piu lento, ma piu compatto
Per la costruzione degli analizzatori lessicali si utilizzano
automi deterministici.
Finite state automata (FSA)
Un FSA ha:
un insieme finito di stati
un insieme di transizioni (o mosse) da uno stato ad un
altro stato etichettato da caratteri di E
uno stato speciale chiamato stato iniziale S
0
un insieme di stati finali o di accettazione (stringa
valida)
10
Gli automi a stati finiti sono rappresentati graficamente da un
digramma di transizioni.
Iniziamo dallo stato iniziale
Il carattere di input a genera una transizione dallo stato
corrente ad uno altro stato se esiste una mossa dallo stato
corrente etichettata con il carattere di input
Se non esiste una mossa etichetata con il carattere di unput
la stringa valida se lo stato di accettazione (stato finale)
Esempio
(a b (c)
+
)
+
.
Non-Deterministic Finite Automaton
(NFA)
Un automa a stati finiti non-deterministico (NFA) un modelllo matematico
che consiste di:
S un insieme di stati
E - un insieme di simboli di input (alfabeto)
mosse una funzione che data una coppia stato-simbolo restituisce uno
stato, cio
Mossa : S x E S
s
0
- uno stato iniziale, s
0
e S
F un insieme di stati finali F _ S
In un NFA sono consentite
c-mosse. In altre parole, esistono transizioni che non consumano simboli
due mosse che da uno stato per effetto dello stesso simbolo portano a
due stati diversi
Un NFA accetta una stringa x, se e solo se esiste un cammino dallo stato
iniziale ad uno stato finale tale ogni arco sia etichettato coni simboli in x
11
Costruzione del riconoscitore di un
FSA
lettera = a .. z, A..Z
cifra = 0..9
Del un qualsiasi carattere diverso da a..z e 0..9
0
2
1
lettera | _
lettera | cifra
Del
2
1
0
Error
1
1
Error
1
Error
a..z 0..9
Error
Error
1
-
Error
2
Error
del
SI
NO
NO
FINALI
12
NFA (Esempio)
1 0 2
a b
start
a
b
0 rappresenta lo stato iniziale s
0
{2} linsieme degli stati finali F
E = {a,b}
S = {0,1,2}
La funzione di transizione e descritta
dalla tabella
a b
0 {0,1} {0}
1 _ {2}
2 _ _
Grafo di transizione di un NFA
Il linguaggio riconosciuto da questo NFA
(a | b)
*
a b
Esempio: commenti C++
13
Espressioni regolari
Una espressione regolare puo essere:
c (la stringa vuota) e denota il linguaggio {c}
simbolo terminale a, a una espressione regolare
se R una espressione regolare R* una espressione regolare (R*
chiamate stella di kleene o chiusura di R). Per esempio: (ab)* genera: c, ab,
abab, etc.
se R una espressione regolare R
+
una espressione regolare. Per esempio:
(ab)
+
genera: ab, abab, etc.
se R e S sono espressioni regolari, R S (oppure R|S) una espressione
regolare che si comporta come R o S
se R e S sono espressioni regolari, R S (oppure RS) una espressione
regolare che descrive la concatenazione di R seguito da S
[a-z] una abbreviazione per denotes a|b|c|..|z
Espressioni regolare
Espressioni regolai sopra un alfabeto E
Espressione reg. Linguaggio
c {c}
ae E {a}
(r
1
) | (r
2
) L(r
1
) L(r
2
)
(r
1
) (r
2
) L(r
1
) L(r
2
)
(r)
*
(L(r))
*
(r) L(r)
(r)
+
= (r)(r)
*
(r)? = (r) | c
14
Esempi
(c|d|e)(a|b)
rappresenta il linguaggio
L = {ca, cb, da, db, ea, eb}
(a|b)*c(a|b)*
rappresenta linsieme di stringhe con zero o piu a
seguite da c, seguite da zero o piu b
(a b (c)
+
)
+
15
Espressioni regolari
Le parentesi possono essere omesse nelle espressioni regolare
utilizzando le regole di precedenza
* highest
concatenation next
| lowest
ab
*
|c means (a(b)
*
)|(c)
Esempi
E = {0,1}
0|1 => {0,1}
(0|1)(0|1) => {00,01,10,11}
0
*
=> {c ,0,00,000,0000,....}
(0|1)
*
=> tutte le stringhe con 0 e 1, compresa la stringa vuota
Definizioni Regolari
LA scrittura di espressioni regolari per alcuni linguaggi pu essere
complessa perche le espressioni regolari che lo descrivono possono essere
complesse, In questo caso si usano le definizioni regolari.
Noi possiamo attribuire dei nomi come simboli per la definizione di altre
espressioni regolari.
Una definizione regolare una sequenza di definizioni nella forma:
d
1
r
1
dove d
i
un nome
e
d
2
r
2
r
i
una espressione regolare sui simboli
. E{d
1
,d
2
,...,d
i-1
}
d
n
r
n
16
Definizioni regolari
Esempio: Identificatori in C
lettera A | B | ... | Z | a | b | ... | z
cifra 0 | 1 | ... | 9
identificatore lettera (lettera | cifra )
*
SE noi scriviamo direttamente lespressione regolare avremo
(A|...|Z|a|...|z) ( (A|...|Z|a|...|z) | (0|...|9) )
*
Esempio: Numeri interi senza segno
cifra 0 | 1 | ... | 9
cifra cifra
+
opt-fraction ( . cifra ) ?
opt-exponent ( E (+|-)? cifra ) ?
unsigned-num cifra opt-fraction opt-exponent
Proprieta algebriche
Assioma Descrizione
r |s = s|r | e commutativo
r |(s|t) = r |(s|t) | associativo
(rs)t = r (st) La concatenazione
associativa
r (s|t) = rs|rt
(s|t)r = sr |tr
La concatenazione gode della
prorpriet distributiva su |
cr = r
rc = r
c lelemento neutro per la
concatenazione
r
*
= ( r |c)
*
r
**
= r
*
* idenpotente
17
Grammatiche regolari - Automi a stati
finiti (FSA)
Esiste una corrispondenza biunivoca tra grammatiche
regolari ed FSA
Esempio
Espressione regolare : a*bc*
Grammatica regolare:
V = {S, A, C}
T = {a, b, c}
P = { S A
A aA
A bC
C cC
C c}
S = {S}
a
P0
b
P1
c
18
Esempio
V = {S}
T = {a, b}
P = {S c
S abS
S = {S}
P1
a
b
P0
Esempio
Grammatica per il linguaggio dei numeri interi
V = {S,D}
T = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
P = {S D
S D S
D 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 }
S = {S}
Grammatica per il linguaggio dei numeri interi (non sono accettati numeri come 04)
V = {S,D}
T = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
P = {S D
S 0
S D S
D 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 }
S = {S}
0,1,2,3,9
0,1,2,39
P1 P0
1,2,3,9
0,1,2,39
P1 P0
P2
0
19
Esempio
Esempio
V = {S}
T = {a, b}
P = {S c
S abS
S = {S}
Il seguente FSA riconosce a*b*
non a
n
b
n
La ricorsione necessaria per modellare a
n
b
n
(Cio non un FSA
b
a
P0
b
P1
Le grammatiche regolari sono troppo restrittive per
i linguaggi di programmazione e pertanto non sono
sufficienti per la costruzione dei compilatori
Per esempio, le grammatiche regolari non possono
generare il linguaggio a
n
b
n
con n > 1 (Nota che
tale linguaggio corrisponde al Begin e End dei
linguaggi di a programmazione)
Esistono altri tipi di grammatiche generative che
possono generare tale linguaggio.
.
20
Espressioni regolari - Grammatica
regolare
Esiste una corrispondenza biunivoca tra linguaggio
regolare ed espressione regolare
Esempio
Espressione regolare : a*bc*
Regular Grammar:
V = {S, A, C}
T = {a, b, c}
P = { S A
A aA
A bC
C cC
C c}
S = {S}
Grammatiche regolari - Automi a stati
finiti (FSA)
FSA(Q, T, o, q
0
, F)
G(V, T, P, S)
Algoritmo di costruzione
V = Q
S = q
0
q e Q, a e T se - una transizione etichettata con a da q a r e Q
allora esiste in P la produzione q a r
q e F, - una produzione q c
Dove Q = insieme degli stati
T insieme di simboli terminali
o insieme delle transizioni,
q
0
= stato iniziali,
F = insieme stati finali
21
Esempio
a
A
b
B C
c
b
d
Q = {A, B, C}
T = {a, b, c, d}
F = {B, C}
q
0
= A
A = o(A,a), B = o(A,b), C = o(B,c),
C = o(C,d), A = o(C,b)
V = {A, B, C}
T = {a, b, c, d}
B c, C c
A a A, A a B, B c C, C d C, C b A
S = A
Esempio
Linea di commento che inizia con
// a termina con eol
V = {S, A, C}
T = {/, c, e}
P = { S // A
A c A
A e}
e = eol
c = qualsiasi carattere
E = // c* e
P0 P1
P1
P2
-
-
e
c
22
Conversione di una espressione
regolare in un Automa a stati finiti
La conversione di una espressione regolare in un
NFA produce un NFA tale che ogni stato ho solo
uno o due successori ed ha un unico stato finale
Un espressione regolare pu essere convertito in
un NFA automaticamente utilizzando le regole di
Thomsons.
Queste regole sono semplici e sistematiche
Non detto che sia uil metodo pi efficente per
effettuare la conversione
Garantisceh che il risultante NFA abbia uno stato iniziale
e uno stato finale.
Forme base
Per c, si costruisce il seguente NFA
Per a in T, si costruisce il seguente NFA
i
f
c start
i
f
a start
23
Recursive Rules
Detti N(s) e N(t) gli NFA for s and t.
NFA N(s|t):
i f
start
N(s)
N(t)
c
c
c
c
Recursive Rules
NFA N(st):
i
f
start
N(s) N(t)
24
Recursive Rules
NFA N(s*)
NFA N((s)) = N(s)
i f
start
N(s)
c
c c
c
Thomsons Construction (Example -
(a|b)
*
a )
a:
a
b
b:
(a | b)
a
b
c
c
c
c
b
c
c
c
c
a
c
c
c
(a|b)
*
c
c
b
c
c
c
c
a
c
c
c
a
(a|b)
*
a
25
Chiusura
La c chiusura di uno stato linsieme degli stati che include:
Lo stato stesso,
Gli stati che possono essere raggiunti dallo stato attraverso una
serie di c mosse
Per calcolare la c -chiusura di un insieme s:
Aggiungere s alla c -chiusura
Se t appartiene alla c-chiusura(s) e esiste una c mossa da t a u,
aggiungere u alla chiusura e continuare fino a quando possibile
Funzione chiusura
void close(NFASet S) {
while (x in S and x

y and y notin S) {
S = S U {y}
}
}
26
Costruzione di un DSA da un NFA
Eliminazione delle epsilon mosse
N (Q, T, o, q
0
, F) automa con epsilon mosse
N (Q, T, o, q
0
, F) automa senza epsilon mosse
con F = F q
0
se c-chiusura(q
0
) contiene uno stato di F
F = F altrimenti
per ogni a in T esiste o(q,a) se esiste o(q,a) oppure esiste uno stato p
tale che o(p,a), p= o(q, c)
Costruzione di un DSA da un NFA
Eliminazione delle transizioni non deterministiche
N (Q, T, o, q
0
, F) automa non deterministico
senza epsilon mosse
M (Q, T, o, q
0
, F) automa deterministico
dove
Q = 2
Q
F = {p e Q | p contiene uno stato appartenente a F}
q
0
= [q
0
]
p e Q e a e T
o(p,a) = {s | s e o(q,a) F = C}
27
Esempio
a
a
a
a
b
b
2
3
4
5
c
1
Esempio
a
a
a
a
b
b
2
3
4
5
a
1
a
28
Esempio
a
a
a
a
b
b
2
3
4
5
a
1
a
Esempio
a
b
a
a
a
b
[2]
[4,5]
[2,4]
[5]
a
[1]
[2,3,4]
b
29
Conversione di un NFA in un DFA
Inserire c-closure({s
0
}) come stato non marcato in DS
while (c uno stato non marcato S
1
in DS) do {
marcare S
1
per ogni simbolo di ingresso a do {
S
2
c-closure(move(S
1
,a))
if (S
2
e DS)
aggiungere S
2
in DS come stato non marcato
transfunc[S
1
,a] S
2
}
}
Uno stato S finale (o accettante) nel DS se contiene uno stato
finale in NFA
Lo stato iniziale e c-closure({s0}
DFA MakeDeterministic(NFA N) {
DFA D; NFASet T
D.StartState = { N.StartState }
close(D.StartState)
D.States = { D.StartState }
while ( possibile aggiungere stati/transizioni){
S in D.States and c in E
T = {y in N.States : x
c
y per qualche x in S}
close(T);
if (T notin D.States) {
D.States = D.States U {T}
D.Trans = D.Trans U {S
c
T}
} }
D.AcceptingStates = { S in D.States : uno stato di
accettazione di N in S}
}
30
Esempio di conversione di un NFA in un
DFA
b
c
c
c
c
a
c
c
c
a 0 1
3
4 5
2
7 8 6
Esempio di conversione di un NFA in un
DFA
S
0
= c-closure({0}) = {0,1,2,4,7} S
0
in DS come stato non marcato
marcare S
0
c-closure(move(S
0
,a)) = c-closure({3,8}) = {1,2,3,4,6,7,8} = S
1
S
1
in DS
c-closure(move(S
0
,b)) = c-closure({5}) = {1,2,4,5,6,7} = S
2
S
2
in DS
transfunc[S
0
,a] S
1
transfunc[S
0
,b] S
2
marcare S
1
c-closure(move(S
1
,a)) = c-closure({3,8}) = {1,2,3,4,6,7,8} = S
1
c-closure(move(S
1
,b)) = c-closure({5}) = {1,2,4,5,6,7} = S
2
transfunc[S
1
,a] S
1
transfunc[S
1
,b] S
2
marcare S
2
c-closure(move(S
2
,a)) = c-closure({3,8}) = {1,2,3,4,6,7,8} = S
1
c-closure(move(S
2
,b)) = c-closure({5}) = {1,2,4,5,6,7} = S
2
transfunc[S
2
,a] S
1
transfunc[S
2
,b] S
2
31
Esempio di conversione di un NFA in un
DFA
S
0
lo stato iniziale dato che 0 membro di S
0
={0,1,2,4,7}
S
1
lo stato di accettazione (stato finale) del DFA dato che 8 appartiene a S
1
= {1,2,3,4,6,7,8}
b
a
a
b
b
a
S
1
S
2
S
0
Esempio
32
Conversione di una Espressione Regolare
direttamente in un DFAs
E possibile convertire direttamente una espressione regolare in
un DFA (senza creare prima un NFA).
1. Concatenare lespressione con un simbolo speciale #.
r (r)# espressione regolare aumentata
2. Creare un albero sintattico della espressione regolare
aumentata
3. In tale albero sintattico tutti gli elementi del vocabolario (pi #
e c) sono delle foglie dellalbero
4. Numerare con position number tutti gli elementi del
vocabolario (pi # e c)
Regular Expression DFA (cont.)
(a|b)
*
a (a|b)
*
a # espressione regolare aumentata
-
*
-
|
b
a
#
a
1
4
3
2
Albero sintattico di (a|b)
*
a #
Ogni simbolo e numerato (positions)
Ogni simbolo una foglia
inner nodes sono operatori
33
followpos
Definiamo la funzione followpos
followpos(i) -- linsime di posizioni che seguono una
posizione I nella stringa generata dallespressione regolare
aumentata
Esempio, ( a | b)
*
a #
1 2 3 4
followpos(1) = {1,2,3}
followpos(2) = {1,2,3}
followpos(3) = {4}
followpos(4) = {}
firstpos, lastpos, nullable
Per valutare followpos, noi abbiamo bisogno di tre
funzioni che sono definite per I nodi dellalbero
firstpos(n) -- linsieme di posizioni del first simbolo
della stringa generata dalla sub-expression di
radice n.
lastpos(n) -- linsieme di posizioni del last simbolo
della stringa generata dalla sub-expression di
radice n. nullable(n) -- true se la stringa vuota
appartine alla sub-expression di radice n, false
altrimenti
34
Come valutare firstpos, lastpos,
nullable
n nullable(n) firstpos(n) lastpos(n)
foglia c true u u
Foglia i false {i} {i}
|
c
1
c
2
nullable(c
1
) or
nullable(c
2
)
firstpos(c
1
)
firstpos(c
2
)
lastpos(c
1
)
lastpos(c
2
)
-
c
1
c
2
nullable(c
1
) and
nullable(c
2
)
if (nullable(c
1
))
firstpos(c
1
)firstpos(c
2
)
else firstpos(c
1
)
if (nullable(c
2
))
lastpos(c
1
)
lastpos(c
2
)
else lastpos(c
2
)
*
c
1
true firstpos(c
1
) lastpos(c
1
)
Come valutare followpos
Due regole per calcolare la funzione followpos:
1. Se n un concatenation-node (-)con figlio sinistro c
1
e figlio
destro c
2
, e i e lastpos(c
1
), allora firstpos(c
2
) _
followpos(i).
2. Se n un star-node (*), e i e lastpos(n), allora firstpos(n) _
followpos(i).
Se firstpos e lastpos sono stati calcolati per ogni nodo,
followpos pu essere calcolato con una visita depth-first
dellalbero sintattico.
35
Example -- ( a | b)
*
a #
-
*
-
|
b
a
#
a
1
4
3
2
{1} {1}
{1,2,3}
{3}
{1,2,3}
{1,2}
{1,2}
{2}
{4}
{4}
{4} {3}
{3}
{1,2}
{1,2}
{2}
green firstpos
blue lastpos
followpos(1) = {1,2,3}
followpos(2) = {1,2,3}
followpos(3) = {4}
followpos(4) = {}
Dopo aver calcolato followpos possiamo creare il DFA
per lespressione regolare.
Algoritmo (RE DFA)
Creare lalbero sintattico di (r) #
Calcolare le funzioni followpos, firstpos, lastpos, nullable
Porre firstpos(root) in S (S linsieme degli stati del DFA) come stato non marcato.
while (- s e S non marcato) {
s
for each simbolo a {
s

followpos(s
1
) ... followpos(s
n
)
let s
1
,...,s
n
posizioni in s e simboli per quelle posizioni sono a
move(s,a) s
if (s non e vuoto e non in S
put s into S come stato non marcato.
the start state of DFA is firstpos(root)
the accepting states of DFA are all states containing the position of #
36
Esempio -- ( a | b)
*
a #
followpos(1)={1,2,3} followpos(2)={1,2,3}
followpos(3)={4} followpos(4)={}
S
1
=firstpos(root)={1,2,3}
marcare S
1
a: followpos(1) followpos(3)={1,2,3,4}=S
2
move(S
1
,a)=S
2
b: followpos(2)={1,2,3}=S
1
move(S
1
,b)=S
1
marcare S
2
a: followpos(1) followpos(3)={1,2,3,4}=S
2
move(S
2
,a)=S
2
b: followpos(2)={1,2,3}=S
1
move(S
2
,b)=S
1
start state: S
1
accepting states: {S
2
}
S
1
S
2
a
b
b
a
Example -- ( a | c) b c
*
#
followpos(1)={2} followpos(2)={3,4} followpos(3)={3,4} followpos(4)={}
S
1
=firstpos(root)={1,2}
marcare S
1
a: followpos(1)={2}=S
2
move(S
1
,a)=S
2
b: followpos(2)={3,4}=S
3
move(S
1
,b)=S
3
marcare S
2
b: followpos(2)={3,4}=S
3
move(S
2
,b)=S
3
marcare S
3
c: followpos(3)={3,4}=S
3
move(S
3
,c)=S
3
start state: S
1
accepting states: {S
3
}
S
3
S
2
S
1
c
a
b
b
37
Minimizzare il numero di stati per
un DFA
Dividere gli stati in due insiemi:
G
1
: insiemi di stati finali
G
2
: insieme di stati non finali states
Per ogni nuovo gruppo G
Partizionare G in sottogruppo take che gli stati s
1
e s
2
sono nello
stesso gruppo iff
per tutti I simboli di input a, gli stati s
1
e s
2
hanno transizioni a stati
nello stesso gruppo.
Lo stato iniziale del DFA minimizzato il gruppo contenente lo
stato inziale del DFA originale.
GLi stati finiale del DFA minimizzato sono I gruppi contenente gli
stati finiali del DFA originale.
Esempio si minimizzazione
b a
a
a
b
b
3
2
1
G
1
= {2}
G
2
= {1,3}
G
2
cannot be partitioned because
move(1,a)=2 move(1,b)=3
move(3,a)=2 move(2,b)=3
So, the minimized DFA (with minimum states)
{1,3}
a
a
b
b
{2}
38
Minimizing DFA Esempio
b
b
b
a
a
a
a
b
4
3
2
1
Groups: {1,2,3} {4}
a b
1->2 1->3
2->2 2->3
3->4 3->3
{1,2} {3}
no more partitioning
So, the minimized DFA
{1,2}
{4}
{3}
b
a
a
a
b
b
Esempi di espressioni regolari
1. letter(letter|digit)*
2. digits = digit digit*
opt_frac = . digits | c
opt_exp = (E(+|-| c) digits | c
num = digits opt_frac opt_exp