Sei sulla pagina 1di 69

Linguaggi Regolari

automi, espressioni regolari, grammatiche lineari destre

Nicola Fanizzi
Corso di Linguaggi di Programmazione

Dipartimento di Informatica
Università degli Studi di Bari

17 marzo 2014
Sommario

2 Espressioni Regolari
1 Automi a Stati Finiti Definizioni
Automi Deterministici Corrispondenza
Rappresentazione di DFA
Configurazioni e Transizioni
Linguaggi/Espressioni
Funzione di transizione per Regolari
stringhe Proprietà delle
Classe dei Linguaggi a Stati Espressioni Regolari
Finiti
Esercizi
Automi 3 Teorema di Kleene
Non-deterministici
Linguaggio accettato da NFA
L3 ⊆ Ldf
Classe dei Linguaggi Ldf ⊆ L3
Non-deterministici Ldf ⊆ Lreg
Equivalenza tra DFA e Lreg ⊆ L3
NFA L3 ⊆ Lreg
Esercizi Esercizi

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 2 / 69


Automi a Stati Finiti

Automi a Stati Finiti I

a b a a b a a b a a b a

Control
● Unit
q0 q1 q2 q3 q4 q5

schema di automa a stati finiti

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 3 / 69


Automi a Stati Finiti

Automi a Stati Finiti II

Definizione (Automa deterministico)


Dato un alfabeto Σ, un automa a stati finiti deterministico (DFA)
è una n-pla M = (Σ, Q, δ, q0 , F)
Σ è l’alfabeto d’ingresso
Q è un insieme finito e non vuoto di stati
δ è la funzione di transizione:

δ : Q × Σ −→ Q

q0 è lo stato iniziale
F ⊆ Q è l’insieme degli stati finali o d’accettazione

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 4 / 69


Automi a Stati Finiti Automi Deterministici

Rappresentazione I

Un DFA M = (Σ, Q, δ, q0 , F) è rappresentabile mediante:


. un grafo detto diagramma di transizione in cui:
uno stato q ∈ Q è rappresentato da un cerchio con etichetta q
lo stato iniziale q0 ha un arco entrante libero
ogni stato finale viene denotato da un cerchio doppio
per ogni q ∈ Q ed ogni a ∈ Σ, se ∃q0 = δ(q, a)
allora si descrive un arco da q in q0 etichettato con a

a0

a
q0 q q0

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 5 / 69


Automi a Stati Finiti Automi Deterministici

Rappresentazione II
. una matrice tavola di transizione con:
sulle righe
gli stati qi ∈ Q, i = 1, . . . , m
sulle colonne
i simboli dell’alfabeto d’ingresso aj ∈ Σ, j = 1, . . . , n
j
in ogni casella: qi = δ(qi , aj )

δ a1 a2 ··· an
→ q0 q10 q20 ··· qn0
∗q1 q11 q21 ··· qn1
.. .. .. .. ..
. . . . .
qm q1m q2m · · · qnm

Nota → stato iniziale; ∗ stati finali

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 6 / 69


Automi a Stati Finiti Automi Deterministici

Rappresentazione III

1 0

0 1
q0 q1 q2 0,1

M = ({0, 1}, {q0 , q1 , q2 }, δ, q0 , {q2 })

δ 0 1
→ q0 q1 q0
q1 q1 q2
∗q2 q2 q2

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 7 / 69


Automi a Stati Finiti Automi Deterministici

Rappresentazione IV

Osservazione δ potrebbe essere una funzione parziale:


i.e. indefinita per qualche coppia (q, a)
Per ottenere una funzione δ totale si considera uno stato
aggiuntivo (stato pozzo qP 6∈ F)
nel quale far confluire le transizioni mancanti e
dal quale non si possano raggiungere stati finali

M = (Σ, Q, δ, q0 , F) trasformato in M t = (Σ, Q ∪ {qp }, δ t , q0 , F)


con δ t : Q ∪ {qp } × Σ → Q ∪ {qp } totale equivalente:
∀(q, a) ∈ Q ∪ {qp } × Σ

q0 ∃q0 = δ(q, a) ∈ Q

t
δ (q, a) =
qp altrimenti

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 8 / 69


Automi a Stati Finiti Automi Deterministici

Configurazioni e Transizioni
Dato M = (Σ, Q, δ, q0 , F)
una configurazione di M è una coppia

(q, x) ∈ Q × Σ∗

(stato corrente, stringa da leggere)


(q, x) è detta:
iniziale se q = q0 ;
finale se x = ;
accettante se x =  e q ∈ F

δ associa ad ogni configurazione la successiva:


si definisce una (relazione di) transizione tra configurazioni di
M:
(q, x) `M (q0 , y) sse ∃a ∈ Σ : x = ay ∧ δ(q, a) = q0

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 9 / 69


Automi a Stati Finiti Automi Deterministici

Funzione di transizione estesa

La funzione di transizione estesa1 generalizza δ avendo in


ingresso uno stato ed una stringa su Σ

Definizione (funzione di transizione estesa)


Dato un automa a stati finiti M = (Σ, Q, δ, q0 , F)
Si definisce per induzione la funzione di transizione estesa

δ^ : Q × Σ∗ −→ Q

∀q ∈ Q, ∀w ∈ Σ∗ :
(
q  se w = 
δ̂(q, w) =
δ δ̂(q, z), a se w = za

1
Altrove indicata anche con δ ∗ o δ̄ [Linz(2012), Hopcroft et al.,(2009)].
N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 10 / 69
Automi a Stati Finiti Automi Deterministici

Linguaggi accettati da DFA


Una parola w ∈ Σ∗ si dice accettata (o riconosciuta) da M se,
partendo da q0 , M porta ad uno stato q finale
δ̂(q0 , w) = q ∈ F
ossia, dalla config. iniziale ad una di accettazione:

(q0 , w) `M (q, ) ∧ q ∈ F

Il linguaggio accettato2 (o riconosciuto) da M è dato da:


L(M) = {w ∈ Σ∗ | δ̂(q0 , w) ∈ F}

Due DFA M1 e M2 si dicono equivalenti quando:


L(M1 ) = L(M2 )

2
denotato spesso anche con T(·)
N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 11 / 69
Automi a Stati Finiti Automi Deterministici

Esempio
DFA che riconosce parole con un numero pari di a o di b

a
q0 q1
a

b b b b

a
q2 q3
a

aab è accettata: δ̂(q0 , aab) = δ(δ̂(q0 , aa), b) =


δ(δ(δ̂(q0 , a), a), b) = δ(δ(δ(δ̂(q0 , ), a), a), b) =
δ(δ(δ(q0 , a), a), b) = δ(δ(q1 , a), b) = δ(q0 , b) = q2 ∈ F
ovvero: (q0 , aab) ` (q1 , ab) ` (q0 , b) ` (q2 , )
N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 12 / 69
Automi a Stati Finiti Automi Deterministici

Classe dei Linguaggi a Stati Finiti

Definizione (linguaggio a stati finiti deterministico)


Un linguaggio L su un alfabeto Σ è un linguaggio a stati finiti
deterministico sse esiste un automa deterministico M,
con alfabeto di ingresso Σ, tale che L = L(M)

Risulta così definita la

Classe dei Linguaggi a Stati Finiti deterministici:

Ldf = {L ∈ ℘(Σ∗ ) | ∃M L = L(M)}

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 13 / 69


Automi a Stati Finiti Automi Deterministici

Esempi I

L(M) = {u01v | u, v ∈ {0, 1}∗ }

1 0

0 1
q0 q1 q2 0,1

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 14 / 69


Automi a Stati Finiti Automi Deterministici

Esempi II

0,3,6,9
Σ =
{0,1,2,3,4,5,6,7,8,9} start q0
M = (Σ, Q, δ, q0 , F) ∈ DFA

2,
Q = {q0 , q1 , q2 }

5,

5,
2,

8
7 1,
q0 : classe resto 0 4, 4,
7
1,
q1 : classe resto 1 1,4,7

q2 : classe resto 2 q1 q2
F = {q0 } 2,5,8

0,3,6,9 0,3,6,9

δ̂(q0 , 1234) = q1 ∈
6 F 1234 = 3 × 137 + 1
δ̂(q0 , 7290) = q0 ∈ F 7290 = 3 × 810 + 0

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 15 / 69


Automi a Stati Finiti Automi Non-deterministici

Automi Non-deterministici

Definizione (automa non-deterministico)


Un automa a stati finiti non-deterministico (NFA) è una tupla
M = (Σ, Q, δ, q0 , F)
dove:
Σ alfabeto di ingresso
Q è un insieme finito e non vuoto di stati
q0 è lo stato iniziale
F ⊆ Q è l’insieme degli stati finali o d’accettazione
δ è la funzione di transizione

δ : Q × Σ −→ ℘(Q)

Per ogni (q, a) si ha un insieme di stati in cui è possibile transitare


N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 16 / 69
Automi a Stati Finiti Automi Non-deterministici

Esempio NFA

q2
a a
a,b

b a,b
q0 q1 q3

δ a b
→ q0 {q0 } {q0 , q1 }
q1 {q2 , q3 } {q3 }
q2 {q3 } ∅
∗q3 ∅ ∅

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 17 / 69


Automi a Stati Finiti Automi Non-deterministici

Funzione di transizione estesa per NFA

Nel corso della computazione non-deterministica per ogni simbolo


letto, l’automa assume un insieme di stati attuali e transita, ad
ogni nuovo simbolo, da un insieme di stati ad un insieme di stati

La funzione δ̂ estesa alle stringhe si definisce:

δ^ : Q × Σ∗ → ℘(Q)

∀(q, w) ∈ Q × Σ∗ :

[{q} se w = 


δ̂(q, w) = δ(q̂, a) se w = za, a ∈ Σ

q̂∈δ̂(q,z)

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 18 / 69


Automi a Stati Finiti Automi Non-deterministici

NFA – Accettazione di stringhe I

Una stringa si dice accettata (o riconosciuta) dal NFA M se,


partendo da q0 con una stringa in ingresso w,
M raggiunge uno stato finale in almeno un cammino

δ̂(q0 , w) ∩ F 6= ∅

ovvero (computazione non-deterministica)



({q0 }, w) ` (Q̄, ) ∧ Q̄ ∩ F 6= ∅

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 19 / 69


Automi a Stati Finiti Automi Non-deterministici

NFA – Accettazione di stringhe II


a,b a,b

b a a
q0 q1 q2 q3
Esempio
w = bba ∈ L(M) ?
({q0 }, bba) ` ({q0 , q1 }, ba) ` ({q0 , q1 , q3 }, a) ` ({q0 , q2 , q3 }, )
e {q0 , q2 , q3 } ∩ F = {q3 } 6= ∅ quindi M accetta w

(q2 , ) NO

(q1 , a)

(q0 , ba) (q3 , ) OK

(q0 , bba) (q0 , a) (q0 , ) NO

(q1 , ba) (q3 , a) bloccato

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 20 / 69


Automi a Stati Finiti Automi Non-deterministici

Linguaggi Non-deterministici

Il linguaggio accettato (o riconosciuto) da M è dato da:

L(M) = {w ∈ Σ∗ | δ̂(q0 , w) ∩ F 6= ∅}

Due NFA sono equivalenti se accettano lo stesso linguaggio

Risulta così definita la

Classe dei linguaggi a stati finiti non deterministici:

Lnf = {L ∈ ℘(Σ∗ ) | ∃M ∈ NFA : L = L(M)}

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 21 / 69


Automi a Stati Finiti Equivalenza tra DFA e NFA

Equivalenza tra DFA e NFA I

Teorema (Equivalenza)
Le classi di linguaggi Ldf e Lnf coincidono

Dim.

Ldf ≡ Lnf ⇔ Ldf ⊆ Lnf ∧ Lnf ⊆ Ldf

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 22 / 69


Automi a Stati Finiti Equivalenza tra DFA e NFA

Equivalenza tra DFA e NFA II

Tesi Ldf ⊆ Lnf

Si consideri un DFA M = (Σ, Q1 , δ, q0 , F)


quindi L(M) ∈ Ldf
Definiamo l’NFA M 0 = (Σ, Q, δ 0 , q0 , F), dove:

δ 0 : Q × Σ −→ ℘(Q)

∀(q, a) ∈ Q × Σ δ 0 (q, a)={δ(q, a)}

Per induzione sulla lunghezza delle parole si dimostra facilmente


che: L(M 0 ) = L(M)

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 23 / 69


Automi a Stati Finiti Equivalenza tra DFA e NFA

Equivalenza tra DFA e NFA III


Tesi Lnf ⊆ Ldf

Sia MN = (Σ, QN , δN , qN
0 , FN ) un NFA

Algoritmo di costruzione dell’DFA equivalente


MD = (Σ, QD , δD , qD
0 , FD ):
1 QD = ℘(QN )
2 qD N
0 = {q0 }
3 FD = {Q0 ⊆ QN | Q0 ∩ FN 6= ∅}
4 δD : QD × Σ −→ QD

∀Q0 = {q1 , q2 , . . . , qk } ∈ QD ∀a ∈ Σ
δD (Q0 , a) = δD ({q1 , q2 , . . . , qk }, a) =
k
[ [
= δN (qj , a) = δN (q, a) (1)
j=1 q∈Q0

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 24 / 69


Automi a Stati Finiti Equivalenza tra DFA e NFA

Equivalenza tra DFA e NFA IV


Dim. Per L(MN ) = L(MD ) si dimostra che
∀w δ̂D (qD N
0 , w) = δ̂N (q0 , w) per induzione su |w|
base w = . Allora δ̂D (qD D N N
0 , ) = q0 = {q0 } = δ̂N (q0 , )
passo w = va.
Ipotesi di induzione: δ̂D (qD N
0 , v) = δ̂N (q0 , v) (H)

δ̂D (qD
0 , w) = δ̂D (qD
0 , va) =
def. δ̂D
= δD (δ̂D (qD
0 , v), a) =
(H)
= δD (δ̂N (qN
0 , v), a) =
(1) [
= δN (q, a) =
q∈δ̂N (qN
0 ,v)

def. δ̂N
= δ̂N (qN N
0 , va) = δ̂N (q0 , w)

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 25 / 69


Automi a Stati Finiti Equivalenza tra DFA e NFA

Trasformazione NFA → DFA I

Nel caso peggiore: 2|QN | stati necessari


Esempio
Ln = {w ∈ {0, 1}∗ | w ha n-esimo bit dalla fine acceso}

0,1

1 0,1 0,1 0,1 0,1


q0 q1 q2 ··· qn−1 qn

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 26 / 69


Automi a Stati Finiti Equivalenza tra DFA e NFA

Trasformazione NFA → DFA II


Nella pratica
1 QD := {q0 };
2 elaborato[{q0 }] := false;
3 while ∃Q ∈ QD : ¬elaborato[Q] do
4 begin { lavora su Q }
5 for each a ∈ Σ
6 begin
7 Qa := ∪q∈Q δN (q, a);
8 if Qa ∈ / QD then
9 begin
10 QD := QD ∪ {Qa };
11 elaborato[Qa ] := false
12 end
13 δD (Q, a) := Qa
14 end
15 elaborato[Q] := true
16 end

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 27 / 69


Automi a Stati Finiti Equivalenza tra DFA e NFA

Esempio Trasformazione NFA → DFA

q2
a a
a,b

b a,b
q0 q1 q3

b b
{q0 } {q0 , q1 } {q0 , q1 , q3 }

b
a b a
a
b
a
{q0 , q3 } {q0 , q2 , q3 }

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 28 / 69


Automi a Stati Finiti Esercizi

Esercizi I

1 Costruire un DFA che accetti il linguaggio:


L = {w ∈ {a, b}∗ | w ha un numero pari di b e dispari di a}
2 Costruire un DFA che accetti il linguaggio:
L = {w ∈ {a, b}∗ | w 6= uaav, u, v ∈ {a, b}∗ }
3 Trasformare in DFA questo NFA:
0 1
0,1

q0 q1
1

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 29 / 69


Automi a Stati Finiti Esercizi

Esercizi II
4 Determinare L(M) e trasformare in DFA questo NFA:
a,b

b a
q0 q1 q2

5 determinare un automa per i seguenti linguaggi:


ling. L1 su {a, b} delle stringhe che finiscono con aa:
w ∈ L1 sse w = zaa, con z ∈ {a, b}∗
ling. L2 su {0, 1} delle stringhe con tre 0 consecutivi:
w ∈ L2 sse w = u000v, con u, v ∈ {0, 1}∗
ling. su {0, 1} delle stringhe con 011 come sottostringa
ling. L4 su {a, b} delle stringhe che cominciano o finiscono con
ab:
w ∈ L4 sse w = aby ∨ w = yab, con y ∈ {a, b}∗

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 30 / 69


Automi a Stati Finiti Esercizi

Esercizio 1. Costruire un DFA che accetti il linguaggio:


L = {w ∈ {a, b}∗ | w ha un numero dispari di a e pari di b}
Soluzione: Sia M = (Σ, Q, δ, q0 , F) ∈ DFA
Q = {q0 , q1 , q2 , q3 } dove
q0 stato per un numero pari di a e di b
q1 stato per un numero dispari di a e pari di b
q2 stato per un numero pari di a e dispari di b
q3 stato per un numero dispari di a e di b
funzione di transizione δ definita:
δ(q0 , a) = δ(q3 , b) = q1
δ(q0 , b) = δ(q3 , a) = q2
δ(q1 , a) = δ(q2 , b) = q0
δ(q1 , b) = δ(q2 , a) = q3
q0 stato iniziale
F = {q1 }

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 31 / 69


Automi a Stati Finiti Esercizi

a
q0 q1
a

b b b b

a
q2 q3
a

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 32 / 69


Automi a Stati Finiti Esercizi

Esercizio 2. Costruire un DFA che accetti questo linguaggio:


L = {w ∈ {a, b}∗ | w 6= uaav, u, v ∈ {a, b}∗ }
Soluzione: Sia M = (Σ, Q, δ, q0 , F) ∈ DFA
Q = {q0 , q1 , q2 } dove
q0 stato per parole non contenenti due o più a consecutive e
terminanti con b
q1 stato per parole non contenenti due o più a consecutive e
terminanti con a
q2 stato pozzo per parole contenenti due o più a consecutive
q0 stato iniziale
F = {q0 , q1 }

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 33 / 69


Automi a Stati Finiti Esercizi

funzione di transizione δ definita:

δ a b
→ ∗q0 q1 q0
∗q1 q2 q0
q2 q2 q2

b
a
a
q0 q1 q2 a.b

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 34 / 69


Automi a Stati Finiti Esercizi

Esercizio 3. Trasformare in DFA questo NFA:

0 1
0,1

q0 q1
1

Soluzione: Sia M 0 = (Σ, Q0 , δ 0 , q00 , F 0 ) ∈ DFA


Q0 = {∅, {q0 }, {q1 }, Q}
{q0 } stato iniziale
F 0 = {{q1 }, Q}
funzione di transizione δ 0 definita:

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 35 / 69


Automi a Stati Finiti Esercizi

0 0,1

1 1
{q0 } {q1 } Q ∅

0
0,1

∅ stato pozzo per definire δ 0 totale

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 36 / 69


Espressioni Regolari Definizioni

Linguaggi Regolari

Definizione (linguaggio regolare)


Dato un alfabeto finito Σ
un linguaggio L su Σ è un linguaggio regolare sse:
L è finito
oppure
L può essere ottenuto induttivamente mediante le
operazioni:
1 L = L1 ∪ L2 con L1 , L2 regolari
2 L = L1 · L2 con L1 , L2 regolari
3 L = L∗1 con L1 regolare

Definiamo l’insieme di tali linguaggi, denotato con Lreg ,


la classe dei linguaggi regolari
Osservazione ∅ ∈ Lreg e {} ∈ Lreg

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 37 / 69


Espressioni Regolari Definizioni

Espressioni Regolari

Definizione (espressione regolare)


Dato un alfabeto finito Σ, una stringa R sull’alfabeto ampliato
Σ ∪ {, +, ∗, ·, ∅, (, )} è una espressione regolare (ER) di alfabeto
Σ sse vale una delle seguenti condizioni:
R=∅
R=
R=a con a ∈ Σ
R = (R1 +R2 ) con R1 , R2 espressioni regolari di alfabeto Σ
R = (R1 · R2 ) con R1 , R2 espressioni regolari di alfabeto Σ
R = (R1 )∗ con R1 espressione regolare di alfabeto Σ
L’insieme delle espressioni regolari di alfabeto Σ
verrà denotato con RΣ o semplicemente R

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 38 / 69


Espressioni Regolari Corrispondenza Linguaggi/Espressioni Regolari

Linguaggi ed Espressioni Regolari


Ad ogni espr. regolare R corrisponde un ling. regolare L(R):
espressione regolare linguaggio regolare
∅ ∅
 {}
a {a}
(R1 + R2 ) L(R1 ) ∪ L(R2 )
(R1 · R2 ) L(R1 ) · L(R2 )
(R)∗ (L(R))∗

Risulta così definita la funzione3 L : R −→ ℘(Σ∗ ).


Osservazioni
 non strettamente necessaria perché {} = L(∅∗ )
Data l’associatività e assumendo che ∗ preceda · e questo
preceda + , si possono eliminare le parentesi
3
Denotata, su alcuni testi, anche con S
N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 39 / 69
Espressioni Regolari Corrispondenza Linguaggi/Espressioni Regolari

Proprietà
Proposizione
Un linguaggio su Σ è regolare sse esso corrisponde ad una
espressione regolare di alfabeto Σ

Si definisce la classe dei linguaggi regolari


Lreg = {L ∈ ℘(Σ∗ ) | ∃R ∈ R : L = L(R)}

Osservazioni
Un linguaggio regolare può essere descritto da più di una
espressione:
la funzione L non è iniettiva
Due espressioni regolari R1 e R2 si dicono equivalenti,
e si scrive R1 = R2 , sse
L(R1 ) = L(R2 )
N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 40 / 69
Espressioni Regolari Corrispondenza Linguaggi/Espressioni Regolari

Esempi
data R = (a∗ (a + b)):
L(R) = L(a∗ (a + b)) = L(a∗ ) · L(a + b) =
(L(a))∗ · (L(a) ∪ L(b)) = {, a, aa, aaa, . . .} · {a, b} =
{a, aa, aaa, aaaa, . . . , b, ab, aab, aaab, . . .}
espressione regolare per il ling. delle stringhe d’ogni
lunghezza su Σ = {0, 1} con 0 e 1 alternati (in qualsiasi
ordine):

R = (01)∗ + (10)∗ + 0(10)∗ + 1(01)∗

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 41 / 69


Espressioni Regolari Corrispondenza Linguaggi/Espressioni Regolari

espressione regolare per L = {a2i b2j+1 | i ≥ 0 ∧ j ≥ 0}:


R1 = (aa)∗ b(bb)∗
Ma considerando anche R2 = (aa)∗ (bb)∗ b si ha

L(R1 ) = L(R2 ) = L

espressione regolare per


L = {w ∈ {0, 1} | w non ha coppie di 0 consecutivi}
Si osservi che
dopo uno 0 può seguire solo un 1
le sottostringhe possono essere precedute o seguite da un
numero di 1 arbitrario:
si possono denotare con: (1∗ 011∗ )∗
la stringhe possono essere composte di soli 1
la stringhe possono terminare anche con uno 0

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 42 / 69


Espressioni Regolari Corrispondenza Linguaggi/Espressioni Regolari

Una soluzione è R = (1∗ 011∗ )∗ (0 + ) + 1∗ (0 + )


Oppure, osservando che le stringhe
si ottengono concatenando 1 o 01
terminano eventualmente anche con uno 0
si ottiene R0 = (1 + 01)∗ ( + 0) che è equivalente

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 43 / 69


Espressioni Regolari Proprietà delle Espressioni Regolari

Proprietà dei Linguaggi Regolari I

1. (R1 + R2 ) + R3 = R1 + (R2 + R3 ) prop. associativa di +


2. R1 + R2 = R2 + R1 prop. commutativa di +
3. R+∅=∅+R=R ∅ elem. neutro per +
4. R+R=R prop. di idempotenza
5. (R1 · R2 ) · R3 = R1 · (R2 · R3 ) prop. associativa di ·
6. R1 · R2 6= R2 · R1 non commutatività di ·
7. R·=·R=R  elem. neutro per ·
8. R·∅=∅·R=∅ ∅ elem. assorbente per ·
9. R1 · (R2 + R3 ) = (R1 · R2 ) + (R1 · R3 ) prop. distributiva di · risp. a +
10. (R1 + R2 ) · R3 = (R1 · R3 ) + (R2 · R3 ) prop. distributiva di · risp. a +

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 44 / 69


Espressioni Regolari Proprietà delle Espressioni Regolari

Proprietà dei Linguaggi Regolari II

11. (R)∗ = (R)∗ · (R)∗ = ((R)∗ )∗ = ( + R)∗


12. (∅)∗ = ()∗ = 
13. (R) =  + R + . . . + Rn + (Rn+1 · R∗ )

14. (R1 + R2 )∗ = (R∗1 + R∗2 )∗ = (R∗1 · R∗2 )∗ =


= (R∗1 · R∗2 )∗ · R∗1 = R∗1 · (R∗1 · R∗2 )∗
15. (R1 + R2 )∗ 6= R∗1 + R∗2 in generale
∗ ∗
16. R·R =R ·R
17. R1 · (R2 · R1 )∗ = (R1 · R2 )∗ · R1
18. (R∗1 · R2 )∗ =  + (R1 + R2 )∗ · R2
19. (R1 · R∗2 )∗ =  + R1 · (R1 + R2 )∗
20. R1 = R2 · R1 + R3 sse R1 = R∗2 · R3 con R2 6= 
R1 = R1 · R2 + R3 sse R1 = R3 · R∗2

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 45 / 69


Espressioni Regolari Esercizi

Esercizi – Espressioni regolari

1 Quali linguaggi sono denotati da (∅∗ )∗ e a∅ ?


2 Elencare le stringhe di L ((a + b)∗ b(a + ab)∗ ) di lunghezza
minore di 6
3 Scrivere un’espressione regolare per i seguenti linguaggi
a) L = {uwu ∈ {a, b}∗ | |u| = 2}
b) L = {w01 | w ∈ {0, 1}∗ }
c) L = {z 6= wab | z, w ∈ {a, b}∗ }
d) delle stringhe su {a, b, c} tali che contengano almeno una a ed
almeno una b;
e) delle stringhe binarie che abbiano come quinto simbolo da
destra un 1
f) delle stringhe binarie con al più una coppia di 1 consecutivi
g) delle stringhe su {a, b} che contengano un numero di a
divisibile per 3

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 46 / 69


Teorema di Kleene

Teorema di Kleene

Teorema (Kleene)
Vale l’equivalenza:
L3 ≡ Ldf ≡ Lreg

Dim. [schema]
Tesi da provare
1 L3 ⊆ Ldf (ed anche Ldf ⊆ L3 )
2 Ldf ⊆ Lreg
3 Lreg ⊆ L3 (ed anche L3 ⊆ Lreg )

come pronunciare ”Kleene”: Kleene pronounced his last name: /’kleini/ as in ”clay-knee”. /’kli:ni/ and /’kli:n/
are common mispronunciations. (His son, Ken Kleene, wrote: ”As far as I am aware this pronunciation is incorrect in all
known languages. I believe that this novel pronunciation was invented by my father.”)

da http://en.wikipedia.org/wiki/Stephen_Cole_Kleene

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 47 / 69


Teorema di Kleene L3 ⊆ Ldf

Tesi L3 ⊆ Ldf / I
Dim. Sia L ∈ L3 cioè ∃G = (Σ, V, S, P), G di tipo 3: L(G) = L
Si deve costruire un DFA M = (Σ, Q, δ, q0 , F) tale che
L(M) = L(G)

Algoritmo (dalle grammatiche agli automi)


Input: G = (Σ, V , S, P), G di tipo 3
Output: M = (Σ, Q, δ, q0 , F) ∈ DFA
1 Σ alfabeto di ingresso per M
2 Q = V ∪ {q}, q 6∈ V
3 q0 = S
4 F = {q} ∪ {B | B −→  ∈ P}
5 δ : Q × Σ −→ ℘(Q) B
a
C

1 ∀B −→ aC ∈ P : C ∈ δ(B, a) a
q
2 ∀B −→ a ∈ P : q ∈ δ(B, a) B

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 48 / 69


Teorema di Kleene L3 ⊆ Ldf

Tesi L3 ⊆ Ldf / II

Osservazione l’algoritmo può generare NFA (passi 5.1 e 5.2)

Occorre dimostrare anche la correttezza dell’automa:


L(G) = L(M)
L(G) ⊆ L(M): sia w = a1 a2 · · · ak ∈ L(G)
w può essere generata con una derivazione:
S =⇒ a1 X2 =⇒ a1 a2 X3 =⇒ · · · =⇒ a1 a2 · · · Xk =⇒
a1 a2 · · · ak
Per sua def., M, prendendo in input w, compie una serie di
transizioni che portano da S a X1 , X2 , . . . , Xk fino a q
L(M) ⊆ L(G): analogamente

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 49 / 69


Teorema di Kleene Ldf ⊆ L3

Tesi (alt.) Ldf ⊆ L3

Dim. dato M si deve costruire G di tipo 3 tale che L(G) = L(M)

Algoritmo (dagli automi alle grammatiche)


Input: M = (Σ, Q, δ, q0 , F) ∈ NFA
Output: G = (Σ, V, S, P) lineare

1 Σ alfabeto di ingresso per M


2 V = {A0 , . . . , A|Q|−1 } |V| = |Q|
3 S = A0
4 P = {Ai −→ aAj | qj ∈ δ(qi , a)} ∪
{Ai −→ a | δ(qi , a) ∈ F}

L(G) = L(M) per esercizio

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 50 / 69


Teorema di Kleene Ldf ⊆ Lreg

Tesi Ldf ⊆ Lreg / I

Dim. Sia L ∈ Ldf .


Per def. ∃M = (Σ, Q, δ, q0 , F) ∈ DFA tale che: L(M) = L
Supponiamo Q = {q0 , q1 , . . . , qn }

Si definiscono (∀i, j ∈ {0, . . . , n}) i linguaggi:

Rij = {w ∈ Σ∗ | δ̂(qi , w) = qj }

contenenti le stringhe che fanno transitare M da qi a qj

Per def. di linguaggio accettato da DFA, risulta:


[
L(M) = R0j
qj ∈F

quindi si deve dimostrare che ogni linguaggio Rij sia regolare

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 51 / 69


Teorema di Kleene Ldf ⊆ Lreg

Tesi Ldf ⊆ Lreg / II


Si definiscono:

Rkij = {w ∈ Σ∗ | δ̂(qi , w) = qj senza transitare in qk , qk+1 , . . . , qn }

n+1
Osservato che: Rij = Rij , si dimostra per induzione su k che

Rkij ∈ Lreg ∀i, j ∈ {0, . . . , n}

(k = 0) R0ij = {w ∈ Σ∗ | δ(qi , w) = qj } ∈ Lreg perché finito


(k > 0) Per ipotesi induttiva: Rkij ∈ Lreg ∀i, j ∈ {0, . . . , n}
Dimostriamo che Rk+1
ij ∈ Lreg
Sia w ∈ Rk+1
ij .
Per definizione di Rk+1
ij , la lettura di w non fa transitare
M in nessuno degli stati qk+1 , qk+2 , . . . , qn
N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 52 / 69
Teorema di Kleene Ldf ⊆ Lreg

Tesi Ldf ⊆ Lreg / III

w1 qk wm

wk
qi qj
transito per stati da q0 a qk−1
I casi sono due:
1 w non fa transitare M nemmeno attraverso qk ,
quindi w ∈ Rkij (e Rkij è regolare per ipotesi ind.)
2 w fa transitare M in qk e risulta concatenazione di
m > 1 sottostringhe:

w = w1 w2 · · · wm−1 wm

con:
w1 ∈ Rkik wt ∈ Rkkk 1<t<m wm ∈ Rkkj
N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 53 / 69
Teorema di Kleene Ldf ⊆ Lreg

Tesi Ldf ⊆ Lreg / IV


Si può scrivere: w ∈ Rkik · (Rkkk )m−2 · Rkkj (m > 1)
per cui: w ∈ Rkik · (Rkkk )∗ · Rkkj
Ne consegue allora che: Rk+1
ij ⊆ Rkij ∪ Rkik · (Rkkk )∗ · Rkkj
k+1
ma ovviamente vale anche: Rkij ∪ Rkik · (Rkkk )∗ · Rkkj ⊆ Rij

Da Rk+1
ij = Rkij ∪ Rkik · (Rkkk )∗ · Rkkj segue Rk+1
ij ∈ Lreg
in quanto espresso attraverso unione, prodotto e iterazione di
linguaggi che sono regolari (per ipotesi induttiva)
Risulta dimostrato che ∀k ∈ {0, . . . , n} : Rkij ∈ Lreg perciò

Rn+1
[ [
L(M) = R0j = 0j
qj ∈F qj ∈F

è regolare perché unione di linguaggi regolari

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 54 / 69


Teorema di Kleene Ldf ⊆ Lreg

Algoritmo alternativo per Ldf ⊆ Lreg


[Hopcroft et al.,(2009), Linz(2012)]
eliminando uno stato alla volta, occorre preservare i
cammini che portano dallo stato iniziale a stati finali
si considerano gli (immediati) predecessori q1 , . . . , qk e
successori p1 , . . . , pm dello stato s da eliminare
archi etichettati con espr. regolari anziché con simboli:
infinite parole possono portare da uno stato ad un altro

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 55 / 69


Teorema di Kleene Ldf ⊆ Lreg

R11

q1 p1

Q1 P1
R1m

S s

Qk Rk1
Pm

qk pm

Rkm

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 56 / 69


Teorema di Kleene Ldf ⊆ Lreg

eliminando s, per ogni (qi , pj ), si etichetta l’arco con:

Rij + Qi S∗ Pj

(un arco assente nel DFA originario sarebbe etichettato con ∅)

R11 + Q1 S∗ P1
q1 p1
R1
m +Q
1S ∗
Pm

S P1

+ Q k
R k1

qk pm
Rkm + Qk S∗ Pm

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 57 / 69


Teorema di Kleene Ldf ⊆ Lreg

Algoritmo (dagli automi alle espressioni regolari)


per ogni stato finale q ∈ F
si eliminano tutti gli stati tranne q0 e q:
applicando l’algoritmo si produce un automa con archi
etichettati da espr. regolari
if q 6= q0 allora risulta un automa a due stati
⇒ soluzione: (R∗ + SU ∗ T)∗ SU ∗
else risulta un automa ad un stato
⇒ soluzione: R∗
return somma di tutte le espr. regolari ottenute, al variare di q

R U R
S

q0 q q0
T

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 58 / 69


Teorema di Kleene Ldf ⊆ Lreg

Esempio
0,1
1 0,1 0,1
A B C D

0+1
1 0+1 0+1
A B C D

0+1
1(0 + 1) 0+1
A C D

0+1
1(0 + 1)(0 + 1)
A D RAD = (0 + 1)∗ 1(0 + 1)(0 + 1)

0+1
1(0 + 1)
A C RAC = (0 + 1)∗ 1(0 + 1)

R = RAC + RAD = (0 + 1)∗ 1(0 + 1)(0 + 1) + (0 + 1)∗ 1(0 + 1)

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 59 / 69


Teorema di Kleene Ldf ⊆ Lreg

Esempio
b
q0 q1 q0

a a b + bb
a b ab a
b a
//////

q2 b q3 q2 b q3

///
///
q0 ab∗ ab (R∗ + SU ∗ T)∗ SU ∗

b + bb R = ab∗ ab S=a
T = b + bb U =∅
a

q3 R03 = ((ab∗ ab)∗ + a(b + bb))∗ a

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 60 / 69


Teorema di Kleene Lreg ⊆ L3

Tesi Lreg ⊆ L3 / I

Sia L ∈ Lreg quindi vale una delle seguenti condizioni:


L è finito
L = L1 ∪ L2 con L1 , L2 regolari
L = L1 · L2 con L1 , L2 regolari
L = (L1 )∗ con L1 regolare

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 61 / 69


Teorema di Kleene Lreg ⊆ L3

Tesi Lreg ⊆ L3 / II

Dim. per induzione sulla costruzione di L


base L finito L = {w1 , w2 , . . . , wn } allora si può scrivere come
unione di linguaggi lineari Li che generano ognuno una
stringa di wi e la classe L3 è chiusa rispetto all’unione:
n
[
L= Li
i=0

Si può facilmente dimostrare che ∀i ∈ {0, . . . , n} : Li ∈ L3


passo In tutti i tre casi i linguaggi L1 e L2 sono lineari per ipotesi
di induzione
Anche la loro unione/concatenazione/iterazione è in L3 per
la chiusura di L3 rispetto a queste operazioni
Quindi L ∈ L3

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 62 / 69


Teorema di Kleene L3 ⊆ Lreg

Tesi (alt.) L3 ⊆ Lreg / I

Sia L ∈ L3 e sia G tale che L(G) = L.


Supponiamo4 per semplicità che  6∈ L
si trasforma ogni produzione in una equazione lineare destra:
A −→ a1 B1 | · · · |an Bn |b1 | · · · |bm
diventa
A = a1 B1 + · · · + an Bn + b1 + · · · + bm
si risolve il sistema usando le regole:
sostituzione
eliminazione della ricorsione:
A = α1 A + · · · + αn A + β 1 + · · · + β m
diventa
A = (α1 + · · · + αn )∗ (β1 + · · · + βm )
l’espressione regolare sarà quella corrispondente ad S

4
Se  ∈ L allora calcolare R0 per L \ {} e poi R = R0 +  per L.
N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 63 / 69
Teorema di Kleene L3 ⊆ Lreg

Esempio
S −→ aS|bA|
A −→ aA|bS|
eliminando subito la produzione A −→ :
S −→ aS|bA|b|
A −→ aA|bS|a
Si costruisce il sistema:

S = aS + bA + b + 
A = aA + bS + a
eliminando
 la ricorsione su A:
S = aS + bA + b + 
A = a∗ (bS + a)
sostituendo A nella def. di S, si ha:
 S = aS + b(a∗ (bS + a)) + b + 

= aS + ba∗ bS + ba∗ a + b + 



 = (a + ba∗ b)S + ba∗ a + b + 
A = a∗ (bS + a)

eliminando la ricorsione su S:
S = (a + ba∗ b)∗ (ba∗ a + b + )


A = ···
Quindi la soluzione è RS = (a + ba∗ b)∗ (ba∗ a + b + )
N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 64 / 69
Teorema di Kleene Esercizi

Esercizi I

1 Data la grammatica lineare G = (Σ, V, S, P) con


Σ = {a,b,c}, V = {S, A, B} e
P = {S −→ bA|aS|b,
A −→ aB|cS|a,
B −→ bA|cB|c}
determinare una espressione regolare per L(G)
2 Sia L = L(R) ove R = (aa + aaa)∗
costruire un automa che riconosce L
trasformare l’NFA del punto 1. in DFA
3 Sia L = L(R) ove R = ab(bb)∗ c
trovare un automa (NFA) per riconoscere L
trasformare l’automa NFA nell’DFA equivalente

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 65 / 69


Teorema di Kleene Esercizi

Esercizi II

4 Data la grammatica lineare G = (Σ, V, S, P) con


Σ = {a,b}, V = {S, B} e
P = {S −→ aB, B −→ aB|bS|a}
determinare un automa DFA M tale che: L(M) = L(G)

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 66 / 69


Teorema di Kleene Esercizi

Esercizi III

Esercizio 2. Sia L = L(R) ove R = (aa + aaa)∗


1. costruire un automa che riconosce L
2. trasformare l’NFA del punto 1. in DFA
1. Dato Σ = {a}, determiniamo le grammatiche G1 per
L1 = {aa} e G2 per L2 = {aaa}:
G1 = (Σ, V1 , S1 , P1 ) con V1 = {S1 , A} e
P1 = {S1 −→ aA, A −→ a}
G2 = (Σ, V2 , S2 , P2 ) con V2 = {S2 , B, C} e
P2 = {S2 −→ aB, B −→ aC, C −→ a}
Sia G3 = (Σ, V3 , S3 , P3 ) la grammatica per L3 = L1 ∪ L2 :
con V3 = V1 ∪ V2 ∪ {S3 } = {S3 , S1 , S2 , A, B, C} e
P3 ={S3 −→ w | S1 −→ w ∈ P1 }∪
{S3 −→ w | S2 −→ w ∈ P2 } ∪ P1 ∪ P2
={S3 −→ aA | aB} ∪ P1 ∪ P2
(contiene produzioni inutili e quindi NT superflui: S1 ,S2 )

N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 67 / 69


Teorema di Kleene Esercizi

Esercizi IV
2. L’automa a stati finiti si ottiene mediante l’algoritmo dato nella
dimostrazione del teorema di Kleene:
Q = V ∪ {q} = {S, A, B, C, q}
q0 = S
F = {q, S}
δ definita da:
a
a A q
δ a
a
→ ∗S {A, B}
a A {S, q}
S a
B {C}
C {S, q}
a
a ∗q ∅
B C

Per esercizio: trasformare l’NFA in un DFA


N. Fanizzi Linguaggi di prog.+Lab Linguaggi Regolari 17 marzo 2014 68 / 69
Riferimenti
Ausiello G.; D’Amore F.; Gambosi G. 2003.
Linguaggi, Modelli, Complessità.
FrancoAngeli.
Cohen D. I. 1996.
Introduction to Computer Theory.
Wiley.
Hopcroft J. E.; Motwani R.; Ullman J. D. 2009.
Automi, Linguaggi e Calcolabilità.
Pearson Italia, 3a edizione.
Linz P. 2012.
An Introduction to Formal Languages and Automata.
Jones & Bartlett, 5a edizione.
Moll R. N.; Arbib M. A.; Kfoury A. J. 1988.
An introduction to formal language theory.
Springer.
Sipser 2005.
Introduction to the theory of computation.
Thomson, 2a edizione.
Sudkamp 2006.
Languages and Machines.
Addison-Wesley, 3a edizione.