Automi - Informatica e Computazione

Automi a Stati Finiti
Automi nondeterministici
Automi a Pila
Informatica e Computazione
Automi
Marco Maratea
Corso di Laurea in Ingegneria Informatica

Dipartimento di Informatica, Bioingegneria, Robotica e Ingegneria dei Sistemi
Università degli Studi di Genova
logo.aiia.png
logoUnige.png
siteLogo.png
1/54
M. Maratea Automi
Automi a Pila
Perchè gli automi
Gli automi sono un modello di calcolo per alcuni dei linguaggi

presentati precedentemente.
Calcolo nel senso che, data una stringa, possiamo sempre dire
se è accettata o no. (invece, ad esempio non esistono alberi di
derivazione per stringhe non accettate da grammatiche.)
Addirittura, una alternativa sarebbe stata presentare i linguaggi

direttamente tramite automi, ad esempio i linguaggi regolari
tramite automi a stati finiti.
Vista la nostra scelta, invece, di definire i linguaggi tramite le

grammatiche che li generano, qui presentiamo alcune
corrispondenze tra classi di linguaggi e (classi di) automi.
logo.aiia.png
logoUnige.png
siteLogo.png
2/54
M. Maratea Automi
Automi a Pila
Outline
1 Automi a Stati Finiti
2 Automi nondeterministici
3 Automi a Pila
logo.aiia.png
logoUnige.png
siteLogo.png
3/54
M. Maratea Automi
Automi a Pila
Outline
3 Automi a Pila
logo.aiia.png
logoUnige.png
siteLogo.png
4/54
M. Maratea Automi
Automi a Pila
Automi a stati finiti (informale)

Un automa è una rappresentazione formale di un modello di
calcolo, ed è composto da:
• un insieme di stati, e
• un insieme di regole di transizioni.
A loro volta, gli stati possono essere di accettazione o non
accettazione.
Le regole di transizione, invece, intuitivamente permettono di
transitare da uno stato all’altro.
Quindi, un automa riceve un input (una stringa), lo elabora ed
eventualmente produce un output (accetta, o non accetta).
La computazione parte da un stato iniziale, leggendo l’input, e
si sposta attraverso stati dell’automa tramite le regole di
transizione. Se alla fine della lettura dell’input l’automa si trova
in uno stato di accettazione, allora la stringa è accettata;
logo.aiia.png
logoUnige.png
siteLogo.png
altrimenti, non lo è. 5/54
M. Maratea Automi
Automi a Pila
Automi a stati finiti (esempio informale) (I)

Example
Vogliamo rappresentare l’automa che modella una porta
automatica con porte scorrevoli che si aprono se una persona
si trova ad un certa distanza, o si chiudono se non vi è nessuno
entro un raggio prefissato, tramite sensori. Ci sono quindi:
• 4 input: {davanti, dietro, entrambi, nessuno},
• 2 stati: {aperta, chiusa},
con le seguenti regole:
• se la porta è chiusa e l’input è in
{davanti, dietro, entrambi} la porta si apre;
• se la porta è aperta e l’input è nessuno, allora la porta si
chiude;
• se la porta è chiusa e l’input è nessuno, alloralogo.aiia.png
la portalogoUnige.png
siteLogo.png
resta chiusa. 6/54
M. Maratea Automi
Automi a Pila
Automi a stati finiti (esempio informale) (II)
Example
Solitamente le regole di transizione si rappresentato tramite
una matrice di transizione:
(Stati/Input) davanti dietro entrambi nessuno

chiusa aperta aperta aperta chiusa
aperta aperta aperta aperta chiusa
Quindi, la matrice di transizione specifica come l’automa

cambia stato, ed è una funzione:
δ : Stati × Input → Stati.

logo.aiia.png
logoUnige.png
siteLogo.png
7/54
M. Maratea Automi
Automi a Pila
Automi a stati finiti

Automa a stati finiti: Definizione
Un automa a stati finiti A è una 5-upla hQ, Σ, δ, q0 , F i, dove:
• Q è l’insieme finito non vuoto degli stati;
• Σ è un alfabeto finito non vuoto;
• δ : Q × Σ → Q è la funzione di transizione;
• q0 ∈ Q è lo stato iniziale;
• F ⊆ Q è l’insieme degli stati di accettazione.
Il diagramma degli stati è una rappresentazione grafica dell’automa in

termini di un grafo dove:
• ogni nodo rappresenta uno stato, etichettato dalla stato stesso (i
nodi che rappresentano stati di accettazione hanno doppi bordi),
• gli archi sono definiti dalle transizioni, ed etichettati
logo.aiia.png
logoUnige.png
con l’input siteLogo.png
che le determinano. 8/54
M. Maratea Automi
Automi a Pila
Automi a stati finiti: Esempio (I)

Example
Sia A1 = h{q1 , q2 , q3 }, {0, 1}, δ, q1 , {q2 }i, con δ:
0 1
q1 q1 q2
q2 q3 q2
q3 q2 q2
Se l’automa riceve, ad esempio, 1101 come input, le transizioni
all’interno dell’automa procedono come segue:
1. Inizia nello stato q1 .
2. Legge 1 ed esegue la transizione da q1 a q2 .
5. Legge 1 ed esegue la transizione da q3 a q2 . logo.aiia.png
logoUnige.png
siteLogo.png
Siccome q2 é stato di accettazione, allora A1 accetta 1101. 9/54
M. Maratea Automi
Automi a Pila
Automi a stati finiti: Esempio (I) - diagramma degli stati
0
1 0
q1 q2 q3
0, 1
logo.aiia.png
logoUnige.png
siteLogo.png
10/54
M. Maratea Automi
Automi a Pila
Automi a stati finiti: Definizioni

Se X è l’insieme delle stringhe accettate dall’automa A allora
diciamo che X è il linguaggio di A e scriviamo L(A) = X . In tal
caso diciamo che A accetta, o riconosce, X .
Se un automa non accetta alcuna stringa riconosce il
linguaggio ∅.
L’automa A1 di prima accetta tutte le stringhe che terminano
con 1, visto che appena legge un 1 va nello stato di
accettazione. Inoltre, accetta le stringhe che terminano con un
numero pari di 0 dopo l’ultimo 1, e rifiuta le altre (es. 0, 10, . . . ).
L’insieme delle stringhe accettate da A1 è:
X = {s ∈ Σ∗ |s = si 1(00)n , n ≥ 0, si ∈ Σ∗ } = L(A1 )
logo.aiia.png
logoUnige.png
siteLogo.png
ovvero A1 riconosce X . 11/54
M. Maratea Automi
Automi a Pila
Automi a stati finiti: Configurazione (I)
Configurazione
Sia A una automa a stati finiti, una configurazione di A è un
elemento (uqv ), dove q ∈ Q è uno stato, u ∈ Σ, e v ∈ Σ∗ .
Una configurazione è:
• Iniziale se q = q0 e u = .
• Intermedia se u 6= e v 6= .
• Di accettazione, o finale, se q ∈ F e v = .
logo.aiia.png
logoUnige.png
siteLogo.png
12/54
M. Maratea Automi
Automi a Pila
Automi a stati finiti: Configurazione (II)
Indichiamo con À la relazione tra due configurazioni: se

c1 = (u1 q1 v1 ) e c2 = (u2 q2 v2 ) sono due configurazioni, diciamo
che c1 À c2 (da c1 si raggiungere direttamente c2 in A) iff
δ(q1 , u2 ) = q2 e v1 = u2 v2 :
• la transizione ci dice che sono in q1 , leggo u2 e vado in q2
se questa transizione è definita da δ. In particolare:
• u2 è il simbolo letto, ovvero il primo simbolo di v1 (che è la
parte di stringa che rimane da leggere prima della
transizione);
• v2 è la parte di stringa di input che rimane da leggere dopo
la transizione tra configurazioni.
logo.aiia.png
logoUnige.png
siteLogo.png
13/54
M. Maratea Automi
Automi a Pila
Configurazioni: Esempio
Example
Si consideri l’automa precedente, e supponiamo che sia data in
ingresso la stringa 0101.
La relazione À1 fra coppie di configurazioni è la seguente:

• (q1 0101) À1 (0q1 101) À1 (1q2 01) À1 (0q3 1) À1
(1q2 ).
Raggiungiamo una configurazione finale, quindi la stringa è

accettata dall’automa.
L’esempio di sopra mostra una computazione, che è definita
nella prossima slide.
logo.aiia.png
logoUnige.png
siteLogo.png
14/54
M. Maratea Automi
Automi a Pila
Automi a stati finiti: Computazione

Sia dato un automa a stati finiti A.
Passo di computazione
Un passo di computazione di s = s1 . . . sm ∈ Σ∗ è una
transizione fra due configurazioni ci e cj , tale che ci À cj .
Computazione
Una computazione di s in A è una sequenza di passi di
computazione (`∗ ) tra configurazioni c1 . . . cm (con c1
configurazione iniziale e cm configurazione finale), tale che
esiste un q ∈ F e c1 = (q0 s) `∗A (sm q) = cm , e per ogni j,
1 < j ≤ m, cj−1 À cj .
`∗A è la chiusura riflessiva e transitiva di À . logo.aiia.png

logoUnige.png
siteLogo.png
15/54
M. Maratea Automi
Automi a Pila
Linguaggio accettato da un automa a stati finiti

Linguaggio accettato
Sia A = (Q, Σ, δ, q0 , F ) un automa a stati finiti, e sia
s = s1 s2 . . . sn ∈ Σ∗ .
s è accettata da A se esiste una computazione di s in A,
ovvero esiste un q ∈ F tale che (q0 s) `∗A (sn q), ovvero
partendo da configurazione iniziale se ne raggiunge una finale
attraverso una serie di passi di computazione.
Il linguaggio accettato da A è l’insieme delle stringhe accettate
da A:
L(A) = {s ∈ Σ∗ |∃q ∈ F tale che (q0 s) `∗A (sn q)}
La classe dei linguaggi accettati dagli automi a stati finitilogoUnige.png

logo.aiia.png siteLogo.png
deterministici è la classe dei linguaggi regolari. 16/54
M. Maratea Automi
Automi a Pila
Linguaggio accettato: Esempio (I)

Vediamo un esempio di come di possa associare ad un automa
a stati finiti un linguaggio mediante una grammatica lineare.
Example
Consideriamo ancora l’esempio precedente, e la grammatica
GA1 associata all’automa A1 , con GA1 = hΣ, Q, q1 , Pi, dove Σ è
l’alfabeto, Q è il vocabolario dei simboli nonterminali, q1 è lo
stato iniziale (corrispondente al simbolo S), e P sono le regole
di produzione.
1. q1 → 0q1 | 1q2 | 1
2. q2 → 1q2 | 0q3 | 1
3. q3 → 0q2 | 1q2 | 1 | 0
Le regole ricalcano le transizioni dell’automa, più le transizioni

logo.aiia.png
logoUnige.png
siteLogo.png
verso lo stato finale. 17/54
M. Maratea Automi
Automi a Pila
Linguaggio accettato: Esempio (II)
Example
Consideriamo la stringa 1101 e verifichiamo che appartiene al
linguaggio L(GA1 ) = L(A1 ).
Verifichiamolo con l’analisi sintattica (parsing).
1101 ← 110q3 (da 3.) ← 11q2 (da 2.) ← 1q2 (da 2.) ← q1
(da 1.)
Abbiamo raggiunto il simbolo iniziale, quindi la stringa è

accettata.
logo.aiia.png
logoUnige.png
siteLogo.png
18/54
M. Maratea Automi
Automi a Pila
Outline
3 Automi a Pila
logo.aiia.png
logoUnige.png
siteLogo.png
19/54
M. Maratea Automi
Automi a Pila
Automi nondeterministici: Intuizione (I)
Negli automi a stati finiti deterministici, che abbiamo visto fino

ad ora, ogni passo della computazione segue
deterministicamente dal precedente, ovvero dato lo stato q in
cui si è, e l’input, esiste una unica transizione possibile che è
definita tramite la funzione δ.
Se invece la transizione ad uno nuovo stato coinvolge più di

una possibilità, allora l’automa è nondeterministico. Visto che
la proprietà di nondeterminismo è più generale della proprietà
di determinismo, allora qualunque automa deterministico è
anche nondeterministico (con unica possibilità).
logo.aiia.png
logoUnige.png
siteLogo.png
20/54
M. Maratea Automi
Automi a Pila
Automi nondeterministici: Intuizione (II)
In pratica, nella loro rappresentazione grafica, in un automa a

stati finiti nondeterministico (AFN) ci può essere più di un arco
uscente da uno stato con la stessa etichetta. Inoltre, negli AFN
un arco può essere etichettato dalla stringa vuota.
Dal punto di vista della computazione, nel caso che l’AFN sia in
uno stato dal quale partono due archi etichettati dallo stesso
simbolo, che corrisponde alla parte di stringa letta attualmente,
l’automa segue entrambi i passi di computazione in parallelo.
Se durante la computazione si incontra uno stato cha ha un
arco uscente etichettato con , allora l’automa transita senza
leggere l’input.
logo.aiia.png
logoUnige.png
siteLogo.png
21/54
M. Maratea Automi
Automi a Pila
AFN: Definizione
Definizione
Un AFN è una 5-upla hQ, Σ, δ, q0 , F i dove
• Q è l’insieme finito non vuoto degli stati;
• Σ è un alfabeto finito non vuoto;
• δ : Q × (Σ ∪ {}) → Q p è la funzione di transizione;
con Q p l’insieme potenza, o delle parti, di Q, ovvero,

Q p = {Q 0 |Q 0 ⊆ Q}.
Es: {q1 , q2 , q3 }p =
{∅, {q1 }, {q2 }, {q3 }, {q1 , q3 }, {q1 , q2 }, {q2 , q3 }, {q1logo.aiia.png}}. siteLogo.png
, q2 , q3logoUnige.png
22/54
M. Maratea Automi
Automi a Pila
AFN: Esempio (I)
Example
Sia N1 = hQ, Σ, δ, q0 , F i un AFN con:
• Q = {q1 , q2 , q3 , q4 };
• Σ = {0, 1};
• δ è definita tramite la seguente matrice di transizione:
0 1
q1 {q1 } {q1 , q2 } ∅
q2 {q3 } ∅ {q3 }
q3 ∅ {q4 } ∅
q4 {q4 } {q4 } ∅
• F = {q4 }. logo.aiia.png
logoUnige.png
siteLogo.png
23/54
M. Maratea Automi
Automi a Pila
AFN Esempio (II): Rappresentazione grafica
0, 1
0, 1
1 0, 1
q1 q2 q3 q4
logo.aiia.png
logoUnige.png
siteLogo.png
24/54
M. Maratea Automi
Automi a Pila
AFN Esempio (III): Computazione

La computazione in un AFN può essere vista come un
processo che si ramifica come un albero. Vediamolo sulla
stringa 010110.
logo.aiia.png
logoUnige.png
siteLogo.png
25/54
M. Maratea Automi
Automi a Pila
AFN: Configurazione
Configurazioni in AFN
Sia N un AFN. Similmente agli automi a stati finiti
deterministici, una configurazione di N è un elemento (uqv )
come definito in precedenza per gli automi deterministici.
Indichiamo con `N la relazione tra due configurazioni, definita

in maniera analoga agli automi deterministici: se c1 = (u1 q1 v1 )
e c2 = (u2 q2 v2 ) sono due configurazioni, diciamo che c1 `N c2
iff
• q2 ∈ δ(q1 , u2 ), e
• v1 = u2 v2 .
∈ δ(qlogoUnige.png
Ciò che cambia è che ora la prima condizione è q2logo.aiia.png 1 , u2 ) siteLogo.png
invece che q2 = δ(q1 , u2 ), dato che δ(q1 , u2 ) è un insieme. 26/54
M. Maratea Automi
Automi a Pila
AFN: Esempio di computazione
Example
Si consideri l’AFN N1 precedente, e supponiamo che sia data
in ingresso la stringa 0101. Alcune delle configurazione di N1
sono {(q1 0101), (0q1 101), (1q2 01), (0q3 1), (1q4 )}.
La relazione `N fra configurazioni è la seguente:

• (q1 0101) `N (0q1 101) `N {(1q2 01)∗ , (1q1 01)} `N
{(0q3 1)∗ , (q3 01)} `N (1q4 ).
L’esempio dato adesso segue un solo ramo dell’albero di prima,

in particolare quello nel quale è sviluppata la configurazione
marcata con ∗ : se si arriva in uno stato di accettazione, come in
questo caso, allora la stringa è accettata. Altrimenti, bisogna
logo.aiia.png
logoUnige.png
siteLogo.png
seguire anche gli altri rami.
27/54
M. Maratea Automi
Automi a Pila
AFN: Computazione
Sia data una AFN N che accetta una stringa s = s1 . . . sn .

Un passo di computazione di s è una transizione fra due
configurazioni ci e cj .
Computazione
Una computazione di s in N è una sequenza di passi di
computazione tra configurazioni c1 (iniziale) . . . cm (finale), tale
che esiste un q ∈ F e c1 = (q0 s) `∗N (uq) = cm , e per ogni j,
1 < j ≤ m, cj−1 `N cj , u ∈ sn ∪ {}.
`∗N è la chiusura riflessiva e transitiva di `N . logo.aiia.png

logoUnige.png
siteLogo.png
28/54
M. Maratea Automi
Automi a Pila
AFN: Linguaggio accettato da una AFN
Sia N = (Q, Σ, δ, q0 , F ) un AFN a stati finiti nondeterministico,
e sia s = s1 s2 . . . sn ∈ Σ∗ .
s è accettata da N se esiste una computazione di s in N ,

ovvero esiste un q ∈ F tale che (q0 s) `∗N (uq) .
Il linguaggio accettato da N è l’insieme delle stringhe accettate

da N :
L(N ) = {s ∈ Σ∗ |∃q ∈ F tale che (q0 s) `∗N (uq)}
logo.aiia.png
logoUnige.png
siteLogo.png
29/54
M. Maratea Automi
Automi a Pila
Corrispondenza tra automi a stati finiti
Equivalenza tra automi

Dati due automi, essi si dicono equivalenti se riconoscono lo
stesso linguaggio.
Teorema
Per ogni automa nondeterministico esiste un automa
deterministico ad esso equivalente.
In conclusione, nonostante gli automi nondeterministici

possano sembrare più “potenti”, automi deterministici e
nondeterministici riconoscono gli stessi linguaggi, ovvero i
linguaggi regolari. logo.aiia.png
logoUnige.png
siteLogo.png
30/54
M. Maratea Automi
Automi a Pila
Automi e linguaggi di programmazione (I)

Nella parte dedicata a grammatiche e linguaggi avevamo
mostrato che, dato un insieme di simboli terminali, una
espressione regolare che definisce il linguaggio degli
identificatori (variabili) di linguaggi di programmazione:
Example
Sia VT = L ∪ D, con
• L = {a, . . . , z, A, . . . , Z }, e
• D = {0, 1, . . . , 9, −, +, . . . }.
L’espressione regolare l + d ∗ , l ∈ L, d ∈ VT , definisce il
linguaggio degli identificatori di linguaggi di programmazione
come C o Pascal. logo.aiia.png
logoUnige.png
siteLogo.png
31/54
M. Maratea Automi
Automi a Pila
Automi e linguaggi di programmazione (II)

Mostriamo ora un automa a stati finiti, deterministico,
A2 = h{q0 , q1 , q2 }, VT , δ, q0 , {q1 , q2 }i (con δ definito
implicitamente tramite il diagrammi degli stati), che riconosce
tali identificatori:
Example
logo.aiia.png
logoUnige.png
siteLogo.png
32/54
M. Maratea Automi
Automi a Pila
Outline
3 Automi a Pila
logo.aiia.png
logoUnige.png
siteLogo.png
33/54
M. Maratea Automi
Automi a Pila
Automi a Pila (informale)
Rispetto ad un automa a stati finiti (non=deterministico,

l’automa a pila ha una nuova componente, ovvero la pila
(stack).
Intuitivamente, un automa a pila svolge le seguenti operazioni

sulla pila (oltre a quelle degli automi a stati finiti):
• scrive un simbolo e lo inserisce nella pila, o
• legge un simbolo estraendolo dalla pila.
Siccome queste operazioni possono farsi solo sull’ultimo

elemento “sopra” la pila, l’automa a pila è anche detto LIFO
(last-in first-out).
logo.aiia.png
logoUnige.png
siteLogo.png
34/54
M. Maratea Automi
Automi a Pila
Automi a Pila (vantaggi)
La pila è utile perchè può mantenere una quantità non limitata

di informazione, a differenza degli automi a stati finiti, che
hanno memoria limitata (ovvero, l’insieme finito di stati).
Data questa proprietà, essi possono riconoscere linguaggi che

gli automi a stati finiti non possono riconoscere, ad esempio il
linguaggio:
Ln = {0n 1n | n > 0}
non può essere riconosciuto da un automa a stati finiti, ma può
essere riconosciuto da un automa a pila, perchè può
memorizzare nella pila il numero di volte che ha letto il simbolo
0 prima di iniziare a leggere i simboli 1. logo.aiia.png
logoUnige.png
siteLogo.png
35/54
M. Maratea Automi
Automi a Pila
Automi a Pila (computazione informale)

Vediamo come lavora un automa a pila per riconoscere Ln :
• Legge i simboli in input;

• appena legge uno 0 lo mette nella pila, e ciò viene fatto per
ciascun 0 che legge;
• appena legge un 1, estrae uno 0 dalla pila, e ciò viene fatto
per ciascun 1 che legge;
• se termina la lettura esattamente quando la pila è vuota,
allora accetta l’input;
• negli altri casi, ovvero se la pila si svuota ma ci sono
ancora 1 da leggere, oppure se gli 1 sono terminati mentre
la pila ancora contiene degli 0, oppure se uno 0 appare a
seguito di un 1, allora rifiuta l’input. logo.aiia.png
logoUnige.png
siteLogo.png
36/54
M. Maratea Automi
Automi a Pila
Automi a pila
Automi a pila: Definizione

Un automa a pila è una 6-upla hQ, Σ, Γ, δ, q0 , F i, dove
• Q è l’insieme degli stati;

• Σ è l’alfabeto;
• Γ è l’alfabeto della pila;
• δ : Q × (Σ ∪ {}) × (Γ ∪ {}) → (Q × (Γ ∪ {}))p ;
Come si può notare, la definizione dell’automa a pila è

direttamente nondeterministica. Tale definizione include anche
logo.aiia.png
logoUnige.png
siteLogo.png
la definizione deterministica.
37/54
M. Maratea Automi
Automi a Pila
Automi a pila: caratteristiche della funzione δ (I)

Come si nota, il dominio di δ è ora Q × (Σ ∪ {}) × (Γ ∪ {}),
quindi è formato da:
• lo stato corrente,
• il prossimo simbolo da leggere, ed
• il simbolo sulla pila.
Se il simbolo in input letto è , allora la macchina può transitare

di stato senza leggere dall’input.
Per quanto riguarda il codominio di δ, l’automa può
• entrare in un nuovo stato, e
• possibilmente, scrivere un simbolo sulla pila.
Siccome sono possibili diverse mosse, allora scriviamo
logo.aiia.png
logoUnige.png
siteLogo.png
(Q × (Γ ∪ {}))p .
38/54
M. Maratea Automi
Automi a Pila
Automi a pila: caratteristiche della funzione δ (II)
Le transizioni di un automa a pila sono della forma
(q2 , c) ∈ δ(q1 , a, b)
cioè:
• se un automa è nello stato q1 con input a, e b è in cima
alla pila, allora l’automa
• si muove nello stato q2 leggendo a e sostituendo b con c
sulla pila.
Per riflettere questo comportamento, nel diagramma avremo un

arco da q1 e q2 etichettato con “a, b → c”.
logo.aiia.png
logoUnige.png
siteLogo.png
39/54
M. Maratea Automi
Automi a Pila
Automi a pila: caratteristiche della funzione δ (III)
Casi particolari
Sia a, che b, che c possono assumere il valore .
Vediamo quale è il significato dei tre casi precedenti:

• se a = , allora l’automa può transitare nel nuovo stato
senza leggere dall’input (come per automi a stati finiti non
deterministici);1
• se b = , allora l’automa può transitare di stato senza
leggere ed estrarre elementi dalla pila;
• se c = , allora l’automa può transitare di stato senza
inserire elementi nella pila.
1
Si veda più avanti per un caso particolare di questa applicazione
logo.aiia.png nelle siteLogo.png
logoUnige.png
slides successive. 40/54
M. Maratea Automi
Automi a Pila
Automi a pila: Verifica della pila vuota

Bisogna trovare un modo per riuscire a verificare quando la pila
è vuota.
Vi sono diverse soluzioni a questa problematica. Quella che
utilizzeremo noi è la seguente: si inserisce, come prima
transizione, una che nondeterministicamente aggiunge un
simbolo particolare, $, alla pila, con il significato che tale
simbolo indica che la pila è vuota.
Corrispondentemente, vi sarà una transizione che
(nondeterministicamente) va nello stato finale se vi è il simbolo
$ in cima alla pila, ovvero se la pila è vuota.
Tramite una computazione sull’esempio successivo vedremo
che questa soluzione, che come vantaggio ha la semplicità, ci
crea qualche problema nell’interpretazione dell’ultima
logo.aiia.png
logoUnige.png
siteLogo.png
transizione e del risultato (si veda spiegazione tra tre slides). 41/54
M. Maratea Automi
Automi a Pila
Automi a pila: Esempio (I)

Example
Sia AP1 = h{q1 , q2 , q3 , q4 }, {0, 1}, {0, $}, δ, q1 , {q4 }i, con δ
definita tramite la seguente matrice di transizione:
Input 0 1
Pila 0 $ 0 $ 0 $
q1 (q2 , $)
q2 (q2 , 0) (q3 , )
q3 (q3 , ) (q4 , )
q4
$ è un simbolo particolare della pila per indicare che la pila è

vuota. Esso è necessario perchè, dalla definizione, non
logo.aiia.png
riusciamo a discriminare questo stato. AP1 riconosce LnlogoUnige.png
. siteLogo.png
42/54
M. Maratea Automi
Automi a Pila
Automi a pila: Esempio (II)
Il diagramma degli stati corrispondente è:
0, → 0 1, 0 →
, → $ 1, 0 → , $ →
q1 q2 q3 q4
logo.aiia.png
logoUnige.png
siteLogo.png
43/54
M. Maratea Automi
Automi a Pila
Interpretazione dell’ultima transizione

Come detto utilzzare $ per indicare la pila vuota da una parte è
una soluzione semplice, ma dall’altra porta a dover assumere
delle interpretazioni particolari per alcune transizioni.
Vedremo più avanti il concetto di computazione legato agli
automi a pila, ma si consideri un input 00111. Seguendo
l’automa AP1 , dopo aver letto la prima parte 0011 della stringa
ci troviamo nello stato q3 con $ come simbolo sulla pila. Quindi,
secondo le interpretazioni che ci siamo dati, potremmo
transitare (nondeterministicamente) in q4 ed accettare,
erroreamente, la stringa 00111.
Invece, nell’ultima transizione, che come la prima è una
transizione "particolare" che non si lega al particolare
linguaggio che stiamo riconoscendo, dobbiamo interpretare
logo.aiia.png
il siteLogo.png
logoUnige.png
simbolo in corrispondenza dell’input come "non vi sono più 44/54
elementi in input da leggere".

M. Maratea Automi
Automi a Pila
Automi a pila: Configurazione
Configurazioni in Automi a pila

Sia AP un automa a pila. Sia s = s1 . . . sk ∈ Σ∗ . Una
configurazione ci dell’automa a pila nondeterministico AP è
indicata da (sr qsr +1 . . . sk , bx), dove sj ∈ Σ, r ≤ j ≤ k ,
b ∈ Γ ∪ {}, e x ∈ Γ∗ . b è il simbolo affiorante nella pila.
Indichiamo con ÀP la relazione tra due configurazioni: se

ci = (sr qsr +1 . . . sk , bx) e cj = (sr +1 q 0 sr +2 . . . sk , ax) sono due
configurazioni, diciamo che ci ÀP cj iff
• (q 0 , a) ∈ δ(q, sr +1 , b)
logo.aiia.png
logoUnige.png
siteLogo.png
45/54
M. Maratea Automi
Automi a Pila
AP: Computazione
Sia dato una automa a pila AP che accetta una stringa
s = s1 . . . sn .
Un passo di computazione di s è una transizione fra due
configurazioni ci e cj dell’automa.
Computazione
Una computazione di s in AP è una sequenza di passi di
computazione tale che da una configurazione iniziale si
raggiunge una configurazione finale, ovvero esiste un q ∈ F e
(q0 s, ) `∗AP (uq, ), u ∈ sn ∪ {}.
logo.aiia.png
logoUnige.png
siteLogo.png
`∗AP è la chiusura riflessiva e transitiva di ÀP .
46/54
M. Maratea Automi
Automi a Pila
AP: Esempio di computazione (I)
Example
Si consideri AP1 , e supponiamo che sia data in ingresso la
stringa 0011.
Un esempio di computazione è il seguente:

(q1 0011, ) ÀP (q2 0011, $) ÀP (0q2 011, 0$) ÀP
(0q2 11, 00$) ÀP (1q3 1, 0$) ÀP (1q3 , $) ÀP (q4 , )
logo.aiia.png
logoUnige.png
siteLogo.png
47/54
M. Maratea Automi
Automi a Pila
AP: Esempio di computazione (II)
Example
Si consideri AP1 , e supponiamo che sia data in ingresso la
stringa 00111, che non dovrebbe essere riconosciuta.
Un esempio di computazione è il seguente:

(q1 00111, ) ÀP (q2 00111, $) ÀP (0q2 0111, 0$) ÀP
(0q2 111, 00$) ÀP (1q3 11, 0$) ÀP (1q3 1, $)
A questo punto (ma anche al passo precedente) la transizione

da q3 a q3 non si può applicare per il carattere sulla pila, però,
data la definizione si può applicare la transizione
nondeterministica verso lo stato finale, che porterebbe a dire
che 00111 è accettata. logo.aiia.png
logoUnige.png
siteLogo.png
48/54
M. Maratea Automi
Automi a Pila
AP: Esempio di computazione (II)
Come anticipavamo prima, la soluzione adottata per verificare

la pila vuota ci porta a problemi, ovvero quello mostrato ora.
Il punto è che questa non è una "vera" transizione, ma una
transizione "ad hoc" per fare una verifica specifica.
Il problema qui è d’interpretazione: qui non dobbiamo valutare
il caso a = come per gli automi nondeterministico ma come
"la parte di stringa rimanente v̀uota". In questo caso, la
transizione non è effettuabile.
Vediamo ad ogni modo che, svolgendo la transizione, ci
porteremmo in una configurazione (1q4 1, $) che non ha la
struttura di una configurazione finale.
logo.aiia.png
logoUnige.png
siteLogo.png
49/54
M. Maratea Automi
Automi a Pila
Automi a pila: Linguaggio accettato
Sia AP un automa a pila, e sia s = s1 s2 . . . sn ∈ Σ∗ .
s è accettata da AP quando AP è nella configurazione finale e

la pila è vuota.
Il linguaggio accettato da AP è l’insieme delle stringhe

accettate da AP:
L(AP) = {s ∈ Σ∗ |∃q ∈ F e (q0 s, ) `∗AP (uq, )}
u ∈ sn ∪ {}.
L’automa a pila AP1 di prima accetta il linguaggio

Ln = {0n 1n | n > 0}. logo.aiia.png
logoUnige.png
siteLogo.png
50/54
M. Maratea Automi
Automi a Pila
Automi a pila e linguaggi noncontestuali

Di seguito si trovano alcuni risultati che mostrano che gli automi
a pila riconoscono linguaggi noncontestuali.
Teorema
Un linguaggio è noncontestuale iff esiste un automa a pila che
lo riconosce.
Questo risultato si basa su due sotto-risultati (Lemmi), che si
focalizzano ogniuno su una delle “direzioni” dell’iff.
Lemma 1.
Se un linguaggio è noncontestuale, allora esiste un automa a
pila che lo riconosce.
Lemma 2.
Se un automa a pila riconosce un linguaggio, allora questo
logo.aiia.png è siteLogo.png
logoUnige.png
noncontestuale. 51/54
M. Maratea Automi
Automi a Pila
Automi a pila e linguaggi di programmazione (I)

Vogliamo ora definire un automa a pila che descriva
correttamente l’idea dell’annidamento in linguaggi di
programmazione. Consideriamo:
• istruzioni condizionali if . . . fi,
• cicli do . . . od, e
• parentesi “(“ e “)”.
Quando un automa legge in ingresso if, do o “(“, aggiunge alla
pila un simbolo I, D o P.
Quando un automa legge in ingresso fi, od o “)“, per avere un
annidamento esatto allora dovrà essere presente sulla pila un I,
D, o P corrispondente: se ciò è vero, allora il simbolo viene
rimosso dalla pila.
Questo non è possibile con automi a stati finiti, visto che
abbiamo bisogno di una memoria (la pila) non limitata perchè
logo.aiia.png asiteLogo.png
logoUnige.png
priori non sappiamo quanti annidamenti avremo. 52/54
M. Maratea Automi
Automi a Pila
Automi a pila e linguaggi di programmazione (II)

Formalmente possiamo definire l’automa
AP3 = h{q0 , q1 , q2 }, {if, fi, do, od, (, )}, {I, D, P, $}, δ, q0 , {q2 }i
Vediamo la proiezione di δ sui soli ingressi do, od, e simboli della pila
D e $:
Input do od
Pila D $ D $ D $
q0 (q1 , $ )
q1 (q1 , D) (q1 , ) (q2 , )
q2
Se in input abbiamo un inizio ciclo, aggiunge una D; se legge un fine

ciclo, toglie una D (che dovrebbe essere in cima alla lista). Se input è
, allora va in q2 , che è lo stato finale, cancellando l’eventuale simbolo
$ . Se questo è vero vuole dire che apertura e chiusura dei cicli erano
correttamente “bilanciate”. logo.aiia.png
logoUnige.png
siteLogo.png
Per gli altri input {if, fi, (, )} il comportamente è simile. 53/54
M. Maratea Automi
Automi a Pila
Automi a pila e linguaggi di programmazione (II)

Vediamo come si svolge una computazione su un programma
con la seguente struttura.
do
if
...
fi
od
Es 1: (q0 do if fi od, ) ÀP 3 (q1 do if fi od, $) ÀP 3
(do q1 if fi od, D$) ÀP 3 (if q1 fi od, ID$) ÀP 3
(fi q1 od, D$) ÀP 3 (od q1 , $) ÀP 3 (q2 , )
Es 2: Se provassimo invece con la configurazione iniziale

(q0 do if od fi, ), allora la computazione di fermerebbe
alla configurazione (if q1 od if, ID$), che non logo.aiia.png
è finale. logoUnige.png
siteLogo.png
54/54
M. Maratea Automi

Automi - Informatica e Computazione

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

Automi - Informatica e Computazione

Caricato da

Copyright:

Formati disponibili

Automi a Stati Finiti

Corso di Laurea in Ingegneria Informatica

Perchè gli automi

Gli automi sono un modello di calcolo per alcuni dei linguaggi

Addirittura, una alternativa sarebbe stata presentare i linguaggi

Vista la nostra scelta, invece, di definire i linguaggi tramite le

1 Automi a Stati Finiti

1 Automi a Stati Finiti

Automi a stati finiti (informale)

altrimenti, non lo è. 5/54

Automi a stati finiti (esempio informale) (I)

resta chiusa. 6/54

Automi a stati finiti (esempio informale) (II)

(Stati/Input) davanti dietro entrambi nessuno

Quindi, la matrice di transizione specifica come l’automa

δ : Stati × Input → Stati.

Automi a stati finiti

Il diagramma degli stati è una rappresentazione grafica dell’automa in

che le determinano. 8/54

Automi a stati finiti: Esempio (I)

Siccome q2 é stato di accettazione, allora A1 accetta 1101. 9/54

Automi a stati finiti: Esempio (I) - diagramma degli stati

Automi a stati finiti: Definizioni

Automi a stati finiti: Configurazione (I)

Automi a stati finiti: Configurazione (II)

Indichiamo con `A la relazione tra due configurazioni: se

La relazione `A1 fra coppie di configurazioni è la seguente:

Raggiungiamo una configurazione finale, quindi la stringa è

Automi a stati finiti: Computazione

`∗A è la chiusura riflessiva e transitiva di `A . logo.aiia.png

Linguaggio accettato da un automa a stati finiti

L(A) = {s ∈ Σ∗ |∃q ∈ F tale che (q0 s) `∗A (sn q)}

La classe dei linguaggi accettati dagli automi a stati finitilogoUnige.png

Linguaggio accettato: Esempio (I)

Le regole ricalcano le transizioni dell’automa, più le transizioni

verso lo stato finale. 17/54

Linguaggio accettato: Esempio (II)

Verifichiamolo con l’analisi sintattica (parsing).

Abbiamo raggiunto il simbolo iniziale, quindi la stringa è

1 Automi a Stati Finiti

Automi nondeterministici: Intuizione (I)

Negli automi a stati finiti deterministici, che abbiamo visto fino

Se invece la transizione ad uno nuovo stato coinvolge più di

Automi nondeterministici: Intuizione (II)

In pratica, nella loro rappresentazione grafica, in un automa a

con Q p l’insieme potenza, o delle parti, di Q, ovvero,

AFN: Esempio (I)

AFN Esempio (II): Rappresentazione grafica

AFN Esempio (III): Computazione

Indichiamo con `N la relazione tra due configurazioni, definita

AFN: Esempio di computazione

La relazione `N fra configurazioni è la seguente:

L’esempio dato adesso segue un solo ramo dell’albero di prima,

Sia data una AFN N che accetta una stringa s = s1 . . . sn .

`∗N è la chiusura riflessiva e transitiva di `N . logo.aiia.png

AFN: Linguaggio accettato da una AFN

s è accettata da N se esiste una computazione di s in N ,

Il linguaggio accettato da N è l’insieme delle stringhe accettate

L(N ) = {s ∈ Σ∗ |∃q ∈ F tale che (q0 s) `∗N (uq)}

Corrispondenza tra automi a stati finiti

Equivalenza tra automi

In conclusione, nonostante gli automi nondeterministici

Automi e linguaggi di programmazione (I)

L(A) = {s ∈ Σ∗ |∃q ∈ F tale che (q0 s) `∗A (sn q)}

L(N ) = {s ∈ Σ∗ |∃q ∈ F tale che (q0 s) `∗N (uq)}

Se il simbolo in input letto è , allora la macchina può transitare

L(AP) = {s ∈ Σ∗ |∃q ∈ F e (q0 s, ) `∗AP (uq, )}