Automatos

Gabriel Fernando
March 2024

Autômatos Finitos
Neste capı́tulo estudaremos um modelo simples de computação, os autômatos
finitos, e a classe das linguagens regulares.

1 Linguagens Regulares
Voltaremos nossa atenção um instante para conjuntos (classes) de linguagens,
ou seja, conjuntos de conjuntos de strings.

L = {A : A ⊆ Σ∗ } é o conjunto de todas as linguagens sobre Σ

∅ é a classe vazia.
{∅} é a classe que contém apenas a linguagem vazia.

{{ε}, ∅} é a classe que contém a linguagem vazia e a linguagem que possui

apenas a string vazia.

Podemos aplicar operações sobre linguagens. Como linguagens são conjuntos

de strings, podemos tomar a união de duas linguagens:

A ∪ B = {x ∈ Σ∗ : x ∈ A ou y ∈ B}

A = {p1 p2 , p1 , p2 p1 }
B = {p1 p1 , p3 , p1 }
A∪B = {p1 p2 , p1 , p2 p1 , p1 p1 , p3 }

Outra operação sobre linguagens é concatenação que consiste na concatenação

de cada combinação de strings da linguagem:

A ◦ B = {x · y ∈ Σ∗ : x ∈ A e x ∈ B}

1
 A = {p1 p2 , p1 }
B = {p1 p1 , p3 }
A◦B = {p1 p2 p1 p1 , p1 p2 p3 , p1 p1 p1 , p1 p3 }
B◦A = {p1 p1 p1 p2 , p1 p1 p1 , p3 p1 p2 , p3 p1 }
A◦A = {p1 p2 p1 p2 , p1 p2 p1 , p1 p1 p2 , p1 p1 }
Podemos, por fim, aplica a estrela de Kleene sobre uma linguagem para
produzir todas as possı́veis concatenações dos elementos:

A∗ = {x1 . . . xk ∈ Σ∗ : xi ∈ A}

A = {a, b}
∗
A = {ε, a, b, aa, ab, bb, ba, aaa, aab, aba, abb, . . .}
Repare que a notação Σ∗ é consistente com a definição de estrela de Kleene.
As operações de união, concatenação e estrela de Kleene sobre linguagens
são chamadas operações regulares.

A = {a}
B = {aa, b}
A◦B = {aaa, ab}
A ∪ (A ◦ B) = {a, aaa, ab}
∗
(A ∪ (A ◦ B)) = {ε, a, aaa, ab, aa, aaaa, aab, aaaaaa, aaaab, . . .}

Uma classe de linguagens L é fechada por união quando temos que:

se A, B ∈ L então A ∪ B ∈ L
Analogamente, uma classe de linguagens L é fechada por concatenação quando
temos que:
se A, B ∈ L então A ◦ B ∈ L
Por fim, L é fechada pela estrela de Kleene quando temos que:

se A ∈ L então A∗ ∈ L

L1 = {{a}, {b}}
L2 = {{a}, {b}, {a, b}}
L3 = {{a}, {aa}, {aaa}, {aaaa} . . .}
L4 = {{a}, {ε, a, aa, aaa, . . .}}

2
 L1 não é fechada por união, mas L2 é. L3 é fechada por concatenação e L4
é fechada pela estrela de Kleene.
A classe das linguagens regulares é a menor classe de linguagens fechada por
união, concatenação e estrela de Kleene que contém a seguinte linguagem:

{{a} : a ∈ Σ}

Uma foram alternativa de definir linguagens regulares é por meio de ex-

pressões regulares. Uma expressão regular pode ser definida da seguinte forma:
se r ∈ Σ então r é uma expressão regular,
ϵ é uma expressão regular,
ø é uma expressão regular,
se r1 e r2 são expressões regulares então r1 r2 é uma expressão regular,
se r1 e r2 são expressões regulares então r1 r2 é uma expressão regular e
se r é uma expressão regular então r⋆ é uma expressão regular.
São expressões regulares:
ø
01
01⋆ 1
ϵø
Denotaremos L(r) a linguagem expressa pela expressão regular r:

L(a) = {a} para todo a ∈ Σ

L(ϵ) = {ε}
L(ø) = ∅
L(r1 r2 ) = L(r1 ) ∪ L(r2 )
L(r1 r2 ) = L(r1 ) ◦ L(r2 )
L(r⋆ ) = L(r)∗

L(ø) = ∅
L(01) = L(0) ◦ L(1)
= {0} ◦ {1}
= {01}
⋆
L(01 1) = L(01⋆ ) ∪ L(1)
= L(0) ◦ L(1⋆ ) ∪ {1}

3
 = {0} ◦ {1}∗ ∪ {1}
= {1, 0, 01, 011, 0111 . . .}
L(ϵø) = L(ϵ) ∪ L(ø)
= {ε} ∪ ∅
= {ε}

Podemos definir a classe das linguagens regulares como a classe das lingua-
gens expressı́veis por meio de expressões regulares.

2 Autômatos Finitos Determinı́sticos

Um Autômato Finito Determinı́stico (AFD) é um modelo de computação, o mais
simples que estudaremos, adequado para representar sistemas computacionais
simples como portas automáticas, elevadores e termostatos.
Um AFD é definido formalmente como uma 5-upla M = ⟨Q, Σ, δ, q0 , F ⟩ em
que:
Q é um conjunto finito cujos elementos são chamados estados,

Σ é uma alfabeto,
δ : Q × Σ → Q é uma função de estados e sı́mbolos em estados chamada
função de transição,
q0 ∈ Q é um estado chamado inicial e

F ⊆ Q é um conjunto de estados chamados finais.

Representaremos um AFD pictoricamente por meio de um diagrama de es-
tados. Nesse tipo de diagrama, cada estado q ∈ Q é representado por uma
circunferência:

[node distance=2cm,auto] [state] (q) q;

Os estados finais q ∈ F são representados por uma circunferência dupla:

[node distance=2cm,auto,¿=latex] [state, accepting] (q) q;

O estado inicial é destacado com uma seta:

[node distance=2cm,auto,¿=latex] initial text= [state, initial] (q0) q0 ;

A função de transição é representada por uma seta entre os estado com uma
etiqueta:

[node distance=2cm,auto,¿=latex] [state] (q1) q1 ; [state] (q2) at (3,0) q2 ; [-¿,

bend left = 30] (q1) edge node a (q2);

4
 δ(q1 , a) = q2

Considere o seguinte AFD:

M = ⟨Q, Σ, δ, q0 , F ⟩
Q = {q0 , q1 , q2 }
Σ = {0, 1}
F = {q1 }

Para simplificar, normalmente escreveremos a função δ como uma tabela:

δ 0 1
q0 q0 q1
q1 q2 q1
q2 q1 q1

Essa tabela indica que:

δ(q0 , 0) = q0
δ(q0 , 1) = q1
δ(q1 , 0) = q2
δ(q1 , 1) = q1
δ(q2 , 0) = q1
δ(q2 , 1) = q1

O seguinte diagrama de estados representa esse AFD M :

[node distance=2cm,auto,¿=latex,initial text=] initial text= [state, initial]

(q0) q0 ; [state, accepting] (q1) at (3,0) q1 ; [state] (q2) at (6,0) q2 ; [-¿] (q0)
edge[loop above] node 0 (q0); [-¿] (q1) edge[loop above] node 1 (q1); [-¿] (q0)
edge node 1 (q1); [-¿, bend left = 30] (q1) edge node 0 (q2); [-¿, bend left =
30] (q2) edge node 0, 1 (q1);

Dizemos que um AFD M = ⟨Q, Σ, δ, qo , F ⟩ aceita, ou reconhece, uma string

ω = a0 a1 . . . an se existe uma sequência de estadps r0 , r1 , . . . , rm tal que:
1. r0 = q0
2. δ(ri , ai+1 ) = ri+1

3. rm ∈ F

5
 Dizemos que M consome a string conforme passa de um estado para outro.
Assim, começando pelo estado inicial, a cada passo a função de transição indica
qual o próximo estado conforme consome um sı́mbolo da string. Ao final do
processo, quando todos os sı́mbolos foram consumidos, a string é aceita se o
estado atual for final.
Escrevemos L(M ) para a linguagem das strings aceitas por M .

L(M ) = {ω ∈ Σ∗ : M aceita ω}

O AFD M do exemplo anterior aceita a string 1101.

1. r0 = q0
2. r1 = q1 pois δ(q0 , 1) = q1

3. r2 = q1 pois δ(q1 , 1) = q1
4. r3 = q2 pois δ(q1 , 0) = q2
5. r4 = q1 pois δ(q2 , 1) = q1
6. a string é aceita, pois r4 = q1 ∈ F

M1 = ⟨{q0 , q1 }, {0, 1}, δ, q0 , {q1 }⟩

δ 0 1
q0 q0 q1
q1 q0 q1

[node distance=2cm,auto,¿=latex,initial text=] initial text= [state, initial]

(q0) q0 ; [state, accepting] (q1) at (3,0) q1 ; [-¿] (q0) edge[loop above] node 0
(q0); [-¿] (q1) edge[loop above] node 1 (q1); [-¿, bend left = 30] (q0) edge node
1 (q1); [-¿, bend left = 30] (q1) edge node 0 (q0);

L(M1 ) = {ω ∈ {0, 1}∗ : ω termina com 1}

M2 = ⟨{q0 , q1 }, {0, 1}, δ, q0 , {q0 }⟩

δ 0 1
q0 q0 q1
q1 q0 q1

[node distance=2cm,auto,¿=latex,initial text=] initial text= [state, initial,

accepting] (q0) q0 ; [state] (q1) at (3,0) q1 ; [-¿] (q0) edge[loop above] node 0
(q0); [-¿] (q1) edge[loop above] node 1 (q1); [-¿, bend left = 30] (q0) edge node
1 (q1); [-¿, bend left = 30] (q1) edge node 0 (q0);

6
 L(M2 ) = {ω ∈ {0, 1}∗ : ω = ε ou ω termina com 0}

M3 = ⟨{s, q1 , q2 , r1 , r2 }, {a, b}, δ, s, {q1 , r1 }⟩

δ a b
s q1 r1
q1 q1 q2
q2 q1 q2
r1 r2 r1
r2 r2 r1

[node distance=2cm,auto,¿=latex,initial text=] initial text= [state, initial] (s)

s; [state, accepting] (q1) at (2,1.5) q1 ; [state] (q2) at (5,1.5) q2 ; [state,
accepting] (r1) at (2,-1.5) r1 ; [state] (r2) at (5,-1.5) r2 ; [-¿] (q1) edge[loop
above] node a (q1); [-¿] (q2) edge[loop above] node b (q2); [-¿] (r1) edge[loop
below] node b (r1); [-¿] (r2) edge[loop below] node a (r2); [-¿, bend left = 30]
(q1) edge node b (q2); [-¿, bend left = 30] (q2) edge node a (q1); [-¿, bend left
= 30] (r1) edge node a (r2); [-¿, bend left = 30] (r2) edge node b (r1); [-¿] (s)
edge node a (q1); [-¿] (s) edge node b (r1);

L(M3 ) = {ω ∈ {a, b}∗ : ω = começa e termina com o mesmo sı́mbolo}

M4 = ⟨{q0 , q1 , q2 , q3 }, {0, 1}, δ, q0 , {q3 }⟩

δ 0 1
q0 q1 q0
q1 q2 q0
q2 q2 q3
q3 q3 q3

[node distance=2cm,auto,¿=latex,initial text=] initial text= [state, initial]

(q0) q0 ; [state] (q1) at (3,0) q1 ; [state] (q2) at (6,0) q2 ; [state, accepting] (q3)
at (9,0) q3 ; [-¿] (q0) edge[loop above] node 1 (q0); [-¿] (q2) edge[loop above]
node 0 (q2); [-¿] (q3) edge[loop above] node 0, 1 (q3); [-¿, bend left = 30] (q0)
edge node 0 (q1); [-¿, bend left = 30] (q1) edge node 1 (q0); [-¿] (q1) edge
node 0 (q2); [-¿] (q2) edge node 1 (q3);

L(M4 ) = {ω ∈ {0, 1}∗ : ω contém a substring 001}

M5 = ⟨{q0 , q1 , q2 , q3 }, {a, b}, δ, q0 , {q2 }⟩

7
 δ a b
q0 q1 q0
q1 q2 q1
q2 q3 q2
q3 q3 q3

[node distance=2cm,auto,¿=latex,initial text=] initial text= [state, initial]

(q0) q0 ; [state] (q1) at (3,0) q1 ; [state, accepting] (q2) at (6,0) q2 ; [state] (q3)
at (9,0) q3 ; [-¿] (q0) edge[loop above] node b (q0); [-¿] (q1) edge[loop above]
node b (q1); [-¿] (q2) edge[loop above] node b (q2); [-¿] (q3) edge[loop above]
node a, b (q3); [-¿] (q0) edge node a (q1); [-¿] (q1) edge node a (q2); [-¿] (q2)
edge node a (q3);

L(M5 ) = {ω ∈ {a, b}∗ : ω contém exatamente dois a}

M6 = ⟨{q0 , q1 , q2 }, {a, b}, δ, q0 , {q2 }⟩

δ a b
q0 q0 q1
q1 q1 q2
q2 q2 q2

[node distance=2cm,auto,¿=latex,initial text=] initial text= [state, initial] (q0)

q0 ; [state] (q1) at (3,0) q1 ; [state, accepting] (q2) at (6,0) q2 ; [-¿] (q0) edge[loop
above] node a (q0); [-¿] (q1) edge[loop above] node a (q1); [-¿] (q2) edge[loop
above] node a, b (q2); [-¿] (q0) edge node b (q1); [-¿] (q1) edge node b (q2);

L(M6 ) = {ω ∈ {a, b}∗ : ω contém pelo menos dois b}

3 Autômatos Finitos Não-Determinı́sticos

Um AFD ao ler um sı́mbolo a em um estado q tem uma única possı́bilidade
de próximo estado (por isso determinı́stico). Na definição isso é garantido pelo
fato de δ ser uma função. No diagrama de estados isso se reflete no fato de que
de cada estado sai uma e uma única seta com cada sı́mbolo do alfabeto.
Os autômatos finitos não-determinı́sticos (AFN) extendem os determinı́sticos
em dois aspectos:
1. ao ler um sı́mbolo em um estado o AFN possui um conjunto (possivelmente
vazio) de possiblidades de próximos estados e
2. é possı́vel mudar de estado sem consumir nenhum sı́mbolo da entrada.

8
 Definimos formalmente um AFN é também definido como uma 5-upla N =
⟨Q, Σ, ∆, q0 , F ⟩, mas agora ∆ : Q × (Σ ∪ {ε}) → 2Q . Ou seja, a entrada da
função pode ser a string vazia ϵ e sua saı́da é um conjunto de estados.
Representamos o diagrama de estados da mesma forma que fizemos com os
AFDs, mas agora é possı́vel que de um mesmo estado partam mais de uma seta
com o mesmo sı́bolo, existem setas com ε e pode haver estados em que não haja
seta com determinado sı́mbolo.
Uma string é aceita por um AFN se existir alguma possibilidade de execução
do autômato que consuma toda string e termine em um estado final.
Formalmente, N = ⟨Q, Σ, ∆, q0 , F ⟩ aceita uma string ω = y1 . . . yn onde
yi ∈ Σ ∪ {ε} se existe uma sequência de estados r0 , . . . , rm tal que:

1. r0 = q0
2. ri+1 ∈ ∆(ri , yi+1 )
3. rm ∈ F

Novamente, escrevemos L(N ) para a linguagem formada pelas strings aceitas

por N .

N1 = ⟨{q0 , q1 , q2 , q3 }, {0, 1}, ∆, q0 , {q3 }⟩

∆ 0 1 ε
q0 {q0 } {q0 , q1 } ∅
q1 {q2 } ∅ {q2 }
q2 ∅ {q3 } ∅
q3 {q3 } {q3 } ∅

[node distance=2cm,auto,¿=latex,initial text=] initial text= [state, initial]

(q0) q0 ; [state] (q1) at (3,0) q1 ; [state] (q2) at (6,0) q2 ; [state, accepting] (q3)
at (9,0) q3 ; [-¿] (q0) edge[loop above] node 0, 1 (q0); [-¿] (q3) edge[loop above]
node 0, 1 (q3); [-¿] (q0) edge node 1 (q1); [-¿] (q1) edge node 0, ε (q2); [-¿] (q2)
edge node 1 (q3);

Vamos simular as possı́veis execuções desse autômato para a entrada 010110:

[level distance=2cm,sibling distance=.5cm, edge from parent path=() -¿ (),

¿=latex] [.q0 [-¿]node[auto=right]0; [.q0 [-¿]node[auto=right]1; [.q0
[-¿]node[auto=right]0; [.q0 [-¿]node[auto=right]1; [.q0 [-¿]node[auto=right]1;
[.q0 [-¿]node[auto=right]0; [.[red]q0 ; ] ] [-¿]node[auto=left]1; [.q1
[-¿]node[auto=right]0; [.[red]q2 ; ] [-¿]node[auto=left]ε; [.[red]q2 ; ] ] ]
[-¿]node[auto=left]1; [.q1 [-¿]node[auto=right]ε; [.q2 [-¿]node[auto=right]1; [.q3
[-¿]node[auto=right]0; [.[blue]q3 ; ] ] ] ] ] ] [-¿]node[auto=left]1; [.q1
[-¿]node[auto=right]0; [.q2 [-¿]node[auto=right]1; [.q3 [-¿]node[auto=right]1;
[.q3 [-¿]node[auto=right]0; [.[blue]q3 ; ] ] ] ] [-¿]node[auto=left]ε; [.[red]q2 ; ] ] ] ]

9
 Cada ramo dessa árvore representa uma possı́vel execução do autômato para
a entrada dada. O autômato para apenas quando toda a entrada foi consumida.
Note que nos três ramos mais a esquerda quando isso ocorre não estamos em
um estado final, mas nos dois ramos seguintes sim. Basta que exita um ramo,
uma possibilidade de execução, para que a string seja aceita. Assim, neste caso
a string de fato é aceita, basta escolher um caminha que termine em um estado
final. Por exemplo: q0 , q0 , q1 , q1 , q2 , q3 , q3 , q3 satisfaz a definição para a string
0101ε10 = 010110.

L(N1 ) = {ω ∈ {0, 1}∗ : ω contém 101 ou 11 como substring}

N2 = ⟨{q0 , q1 , q2 , q3 }, {0, 1}, ∆, q0 , {q3 }⟩

∆ 0 1 ε
q0 {q0 } {q0 , q1 } ∅
q1 {q2 } {q2 } ∅
q2 {q3 } {q3 } ∅
q3 ∅ ∅ ∅

[node distance=2cm,auto,¿=latex,initial text=] initial text= [state, initial]

(q0) q0 ; [state] (q1) at (3,0) q1 ; [state] (q2) at (6,0) q2 ; [state, accepting] (q3)
at (9,0) q3 ; [-¿] (q0) edge[loop above] node 0, 1 (q0); [-¿] (q0) edge node 1 (q1);
[-¿] (q1) edge node 0, 1 (q2); [-¿] (q2) edge node 0, 1 (q3);

L(N2 ) = {ω ∈ {0, 1}∗ : ω contém 1 na antepenúltima posição}

A partir daqui vamos apresentar os autômatos apenas por seu diagrama. O

seguinte é o diagrama de N3 :

[node distance=2cm,auto,¿=latex,initial text=] initial text= [state, initial]

(q0) q0 ; [state] (q1) at (3,0) q1 ; [state] (q2) at (6,0) q2 ; [state, accepting] (q3)
at (9,0) q3 ; [-¿] (q0) edge[loop above] node 0, 1 (q0); [-¿] (q0) edge node 0 (q1);
[-¿] (q1) edge node 1 (q2); [-¿] (q2) edge node 0 (q3);

L(N3 ) = {ω ∈ {0, 1}∗ : |ω| termina com 010}

O seguinte é o diagrama de N4 :

[node distance=2cm,auto,¿=latex,initial text=] initial text= [state, initial]

(q0) q0 ; [state, accepting] (q1) at (2,1) q1 ; [state] (q2) at (6,1) q2 ; [state,
accepting] (q3) at (2,-1) q3 ; [state] (q4) at (4,-3) q4 ; [state] (q5) at (6,-1) q5 ;
[-¿] (q0) edge node ε (q1); [-¿] (q0) edge node ε (q3); [-¿, bend left = 30] (q1)
edge node 0 (q2); [-¿, bend left = 30] (q2) edge node 0 (q1); [-¿] (q3) edge
node 0 (q4); [-¿] (q4) edge node 0 (q5); [-¿] (q5) edge node[above] 0 (q3);

10
 L(N4 ) = {ω ∈ {0}∗ : |ω| é múltiplo de 2 ou de 3}

O seguinte é o diagrama de N5 :

[node distance=2cm,auto,¿=latex,initial text=] initial text= [state, initial] (q1)

q1 ; [state] (q2) at (2,1.5) q2 ; [state, accepting] (q3) at (5,1.5) q3 ; [state] (q4) at
(2,-1.5) q4 ; [state, accepting] (q5) at (5,-1.5) q5 ; [-¿] (q2) edge[loop above] node
0, 1 (q2); [-¿] (q3) edge[loop above] node 0, 1 (q3); [-¿] (q4) edge[loop above]
node 1 (q4); [-¿] (q5) edge[loop above] node 1 (q5); [-¿] (q1) edge node ε (q2);
[-¿] (q1) edge node ε (q4); [-¿] (q2) edge node 1 (q3); [-¿, bend left = 30] (q4)
edge node 0 (q5); [-¿, bend left = 30] (q5) edge node 0 (q4);

L(N5 ) = {ω ∈ {0, 1}∗ : ω contém 1 ou um número ı́mpar de 0s}

O seguinte é o diagrama de N6 :

[node distance=2cm,auto,¿=latex,initial text=] initial text= [state, initial] (q0)

q0 ; [state] (q1) at (3,0) q1 ; [state, accepting] (q2) at (6,0) q2 ; [-¿] (q0) edge[loop
above] node 0 (q0); [-¿] (q1) edge[loop above] node 1 (q1); [-¿] (q2) edge[loop
above] node 0 (q2); [-¿] (q0) edge node 1 (q1); [-¿] (q1) edge node ε (q2);

L(N6 ) = L(0⋆ 11⋆ 0⋆ )

4 AFD ≡ AFN
Vimos nas últimas seções dois modelos computacionais. O primeiro é mais
próximo da descrição de dispositivos simples, mas sua descrição em termos de
diagramas possui diversas limitações. O segundo modelo é mais flexı́vel e mais
fácil de descrever pictoricamente.
A pergunta que procuraremos responder nessa seção é se algum desses mod-
elos é mais expressivo que o outro. Ou seja, será que algum deles é capaz
de resolver problemas, reconhecer linguagens, que o outro não consegue. A re-
sposta será negativa. De fato, ambos os modelos são equivalentes em um sentido
bastante preciso. Comecemos então com essa definição.
Dois autômatos M1 e M2 são ditos equivalentes (escrevemos M1 ∼ M2 ) se
reconhecem a mesma linguagem, ou seja, se L(M1 ) = L(M2 ).
Exemplo : 2
M1 = ⟨{q0 , q1 }, {a}, δ, q0 , {q0 , q1 }⟩

δ a
q0 q1
q1 q0

11
 [node distance=2cm,auto,¿=latex,initial text=] initial text= [state, initial,
accepting] (q0) q0 ; [state, accepting] (q1) at (3,0) q1 ; [-¿, bend left = 30] (q0)
edge node a (q1); [-¿, bend left = 30] (q1) edge node a (q0);

L(M1 ) = L(a⋆ )

M2 = ⟨{q0 }, {a}, δ, q0 , {q0 }⟩

δ a
q0 q0

[node distance=2cm,auto,¿=latex,initial text=] initial text= [state, initial,

accepting] (q0) q0 ; [-¿] (q0) edge[loop above] node a (q0);

L(M2 ) = L(a⋆ )

M1 ∼ M2

Primeiramente devemos mostrar que AFNs são uma extensão dos AFDs.
Essa parte coincide com nossa intuição uma vez que todo diagrama de um AFD
é também um diagrama para um AFN (o contrário não vale!). Vamos formalizar
essa ideia no seguinte teorema:
Se M é um AFD então existe um AFN N tal que M ∼ N Seja M =
⟨Q, Σ, δ, qo , F ⟩ um AFD qualquer. Considere o AFN N = ⟨Q, Σ, ∆, q0 , F ⟩ em
que:  ′
{q } se a ∈ Σ e δ(a, q) = q ′
∆(a, q) =
∅ se a = ε
Note que os diagramas de M e de N são idênticos e segue trivialmente que
M ∼N
A demonstração da outra equivalência exige mais cuidado e faremos em duas
partes. Primeiro vamos supor que não fosse permitido mudar de estado sem
consumir sı́mbolos em um AFN. Ou seja, suponhamos que não seja permitido
usar ε nas setas no diagrama de estados. Vamos mostrar que é possı́vel construir
um AFD equivalente a esse AFN. A ideia da construção é que cada estado no
AFD simula um conjunto de estados no AFN. Conforme consumimos a string
nesse AFD o estado atual representa o conjunto de todos os estados possı́veis
no AFN ao consumir os mesmos sı́mbolos.
Seja N um AFN em que não é permitido mudar de estados sem consumir
sı́mbolos, então existe um AFD M tal que N ∼ M . Não faremos a
demonstração completa, apenas apresentaremos a construção e posteriormente
mostraremos alguns exemplos.
Seja N = ⟨Q, Σ, ∆, q0 , F ⟩, construiremos M = ⟨Q′ , Σ′ , δ, q0′ , F ′ ⟩ da seguinte
forma:

12
 1. Q′ = 2Q
2. Σ′ = Σ
3. q0′ = {q0 }
4. F ′ = {R ∈ Q′ : R ∩ F ̸= ∅}
S
5. δ(R, a) = r∈R ∆(r, a)

N1 = ⟨{1, 2}, {a, b}, ∆, 1, {1}⟩

∆ a b
1 ∅ {2}
2 {1, 2} {1}

[node distance=2cm,auto,¿=latex,initial text=] initial text= [state, initial,

accepting] (1) 1; [state] (2) at (3,0) 2; [-¿, bend left = 30] (1) edge node b (2);
[-¿, bend left = 30] (2) edge node a, b (1); [-¿] (2) edge[loop above] node a (1);

Seguindo a construção que vimos no teorema anterior:

M1 = ⟨{∅, {1}, {2}, {1, 2}}, {a, b}, δ, {1}, {{1}, {1, 2}}⟩

δ a b
∅ ∅ ∅
{1} ∅ {2}
{2} {1, 2} {1}
{1, 2} {1, 2} {1, 2}

[node distance=2cm,auto,¿=latex,initial text=] initial text= [state, initial,

accepting] (1) {1}; [state] (2) at (3,0) {2}; [state, accepting] (12) at (3,
-2){1, 2}; [state] (0) at (0, -2)∅; [-¿] (1) edge node a (0); [-¿, bend left = 30] (1)
edge node b (2); [-¿] (2) edge node a (12); [-¿, bend left = 30] (2) edge node b
(1); [-¿] (0) edge[loop below] node a, b (0); [-¿] (12) edge[loop below] node a, b
(12);

Para terminar vamos simular nos dois a leitura da string baab:

2

[level distance=2cm,sibling distance=.5cm, edge from parent path=() -¿ (),

¿=latex] [.1 [-¿]node[auto=right]b; [.2 [-¿]node[auto=right]a; [.[red]1; ]
[-¿]node[auto=left]a; [.2 [-¿]node[auto=right]a; [.1 [-¿]node[auto=right]b;
[.[red]2; ] ] [-¿]node[auto=left]a; [.2 [-¿]node[auto=left]b; [.[blue]1; ] ] ] ] ]

[level distance=2cm,sibling distance=.5cm, edge from parent path=() -¿ (),

¿=latex] [.{1} [-¿]node[auto=right]b; [.{2} [-¿]node[auto=right]a; [.{1, 2}
[-¿]node[auto=right]a; [.{1, 2} [-¿]node[auto=right]b; [.[blue]{1, 2}; ] ] ] ] ]

13
 Para completar nossa prova precisamos lidar com as setas rotuladas por ε.
O que faremos nesse caso será incluir no estado atual todos os estados que
conseguimos alcançar sem precisar consumir sı́mbolos.
Para todo AFN N existe um AFD M tal que N ∼ M . Sejam N e M
como definidos na demonstração do lema anterior Considere a seguinte função
E : Q′ → Q′ :
E(R) = {q ∈ Q : ∃q ′ ∈ R(q ′ ε q)}
Ou seja, existe um caminho de algum q ′ ∈ R até q passando apenas por setas
com etiqueta ε.
Vamos agora atualizar a definição de M em dois pontos:

3’. q0 = E({q0 })
S
5’. δ(R, a) = r∈R E(∆(r, a))

Considere o AFN N2 representado pelo seguinte diagrama de estados:

[node distance=2cm,auto,¿=latex,initial text=] initial text= [state, initial]

(q0) q0 ; [state] (q1) at (3,0) q1 ; [state, accepting] (q2) at (6,0)q2 ; [-¿] (q0) edge
node 1 (q1); [-¿] (q1) edge node ε (q2); [-¿] (q0) edge[loop above] node 0 (q0);
[-¿] (q1) edge[loop above] node 1 (q1); [-¿] (q2) edge[loop above] node 0 (q2);

L(N2 ) = L(0⋆ 11⋆ 0⋆ )

Usando a construção dos teoremas anteriores produzimos o seguinte AFD

M2 :

[node distance=2cm,auto,¿=latex,initial text=] initial text= [state, initial] (1)

{q0 }; [state, accepting] (23) at (3,0) {q1 , q2 }; [state, accepting, red] (123) at
(6,0)Q; [state, red] (2) at (0,3) {q1 }; [state] (0) at (3,3) ∅; [state, accepting] (3)
at (6,3){q2 }; [state, red] (12) at (1,-3) {q0 , q1 }; [state, accepting, red] (13) at
(5,-3){q0 , q2 }; [-¿] (0) edge[loop above] node 0, 1 (0); [-¿] (1) edge[loop above]
node 0 (1); [-¿] (1) edge node 1 (23); [-¿] (2) edge node 0 (0); [-¿] (2) edge node
1 (23); [-¿] (3) edge[loop above] node 0 (3); [-¿] (3) edge node 1 (0); [-¿] (12)
edge node 0 (1); [-¿] (12) edge node 1 (23); [-¿] (13) edge[loop below] node 0
(13); [-¿] (13) edge node 1 (23); [-¿] (23) edge node 0 (3); [-¿] (23) edge[loop
above] node 1 (23); [-¿] (123) edge node 0 (13); [-¿] (123) edge node 1 (23);

A construção que vimos possui sempre uma quantidade exponencialmente

maior de estados, porém, alguns deles podem ser supérfluos. Note que os estados
em vermelho não são alcançáveis a partir do estado inicial, logo, podem ser omi-
tidos (formalmente, o autômato gerado ao se omitir esses estados é equivalente
a esse).

[node distance=2cm,auto,¿=latex,initial text=] initial text= [state, initial] (1)

{q0 }; [state, accepting] (23) at (3,0) {q1 , q2 }; [state, accepting] (3) at (6,0){q2 };

14
[state] (0) at (9,0)∅; [-¿] (1) edge node 1 (23); [-¿] (23) edge node 0 (3); [-¿] (3)
edge node 1 (0); [-¿] (1) edge[loop above] node 0 (1); [-¿] (23) edge[loop above]
node 1 (23); [-¿] (3) edge[loop above] node 0 (3); [-¿] (0) edge[loop above] node
0, 1 (0);
Removendo os estados supérfluos é fácil ver que:
L(M2 ) = L(N2 ) = L(0⋆ 11⋆ 0⋆ )
Portanto M2 ∼ N2 .

5 Linguagens Regulares são Reconhecı́veis por

AFNs
Na seção anterior vimos que AFDs e AFNs são capazes de reconhecer a mesma
classe de linguagens. Nesta seção começaremos a investigar que essa classe é
exatamente a classe das linguagens regulares.
Mostraremos nessa seção que toda linguagem regular é reconhecı́vel por al-
gum AFN e, consequentemente, por algum AFD. Para tanto, temos que mostrar
que a classe das linguagens reconhecı́veis por AFNs é fechada por ∗, ∪, ◦ e que
contém {{a} : a ∈ Σ}.
Se A, B ⊆ Σ∗ são reconhecı́veis por AFNs então A ∪ B também é. Ou seja, a
classe das linguagens reconhecı́veis por AFNs é fechada por união. A hipótese
garante que existem AFNs N1 e N2 tal que L(N1 ) = A e L(N2 ) = B. Vamos
construir a partir de N1 e N2 um AFN N tal que L(N ) = L(N1 ) ∪ L(N2 )
Sejam:

N1 = ⟨Q1 , Σ, ∆1 , q1 , F1 ⟩
N2 = ⟨Q2 , Σ, ∆2 , q1′ , F2 ⟩
Vamos construir N = ⟨Q, Σ, ∆, q0 , F ⟩:
Q = Q1 ∪ Q2 ∪ {q0 }
F = F1 ∪ F2


 ∆1 (q, a) se q ∈ Q1
∆2 (q, a) se q ∈ Q2

∆(q, a) =

 {q1 , q1′ } se q = q0 e a = ε
∅ se q = q0 e a ̸= ε


2 N1
[node distance=2cm,auto,¿=latex,initial text=,color=blue] coil/.style=
decorate, decoration= snake=coil , [state, initial] (1) q1 ; [state, accepting,
minimum size=0pt] (2) at (3,1); [state, accepting, minimum size=0pt] (3) at
(3,0); [state, accepting, minimum size=0pt] (4) at (3,-1); [-¿] (1) edge[coil] (2);
[-¿] (1) edge[coil] (3); [-¿] (1) edge[coil] (4);

15
N2
[node distance=2cm,auto,¿=latex,initial text=,color=red] coil/.style=
decorate, decoration= snake=coil , [state, initial] (1) q1′ ; [state, accepting,
minimum size=0pt] (2) at (3,1); [state, accepting, minimum size=0pt] (4) at
(3,-1); [-¿] (1) edge[coil] (2); [-¿] (1) edge[coil] (4);

N
[node distance=2cm,auto,¿=latex,initial text=] coil/.style= decorate,
decoration= snake=coil , [state, initial] (0) q0 ; [state, color=blue] (1) at (2,1)
q1 ; [state, color=red] (2) at (2,-1) q1′ ; [state, accepting, minimum size=0pt,
color=blue] (f1) at (5,2); [state, accepting, minimum size=0pt, color=blue]
(f2) at (5,1); [state, accepting, minimum size=0pt, color=blue] (f3) at (5,0);
[state, accepting, minimum size=0pt, color=red] (f4) at (5,-1); [state,
accepting, minimum size=0pt, color=red] (f5) at (5,-2); [-¿] (0) edge node ε
(1); [-¿] (0) edge node ε (2); [-¿, color=blue] (1) edge[coil] (f1); [-¿, color=blue]
(1) edge[coil] (f2); [-¿, color=blue] (1) edge[coil] (f3); [-¿, color=red] (2)
edge[coil] (f4); [-¿, color=red] (2) edge[coil] (f5);
2 N1
[node distance=2cm,auto,¿=latex,initial text=] [state, initial, accepting] (1)
q1 ; [-¿] (1) edge[loop above] node 0 (1);

L(N1 ) = L(0⋆ )

N2
[node distance=2cm,auto,¿=latex,initial text=] [state, initial] (2) q2 ; [state,
accepting] (3) at (3,0)q3 ; [-¿] (3) edge[loop above] node 0 (3); [-¿] (2) edge
node1 (3);

L(N2 ) = L(10⋆ )

N
[node distance=2cm,auto,¿=latex,initial text=] [state, initial] (0) q0 ; [state,
accepting] (1) at (2, 1)q1 ; [state] (2) at (2, -1)q2 ; [state, accepting] (3) at (5,
-1)q3 ; [-¿] (1) edge[loop above] node 0 (1); [-¿] (3) edge[loop above] node 0 (3);
[-¿] (2) edge node1 (3); [-¿] (0) edge nodeε (1); [-¿] (0) edge nodeε (2);

L(N ) = L(N1 ) ∪ L(N2 ) = L(0⋆ ) ∪ L(10⋆ ) = L(0⋆ 10⋆ )

Se A, B ⊆ Σ∗ são reconhecı́veis por AFNs então A ◦ B também é. Ou seja, a

classe das linguagens reconhecı́veis por AFNs é fechada por concatenação. A

16
hipótese garante que existem AFNs N1 e N2 tal que L(N1 ) = A e L(N2 ) = B.
Vamos construir a partir de N1 e N2 um AFN N tal que L(N ) = L(N1 ) ◦ L(N2 )
Sejam:

N1 = ⟨Q1 , Σ, ∆1 , q1 , F1 ⟩
N2 = ⟨Q2 , Σ, ∆2 , q1′ , F2 ⟩

Vamos construir N = ⟨Q, Σ, ∆, q0 , F ⟩:

Q = Q1 ∪ Q2
q0 = q1
F = F2


 ∆1 (q, a) se q ∈ Q1 e q ∈/ F1
∆1 (q, a) se q ∈ F1 e a ̸= ε

∆(q, a) =
 1 a) ∪ {q1′ }
 ∆ (q, se q ∈ F1 e a = ε
∆2 (q, a) se q ∈ Q2


2 N1
[node distance=2cm,auto,¿=latex,initial text=,color=blue] coil/.style=
decorate, decoration= snake=coil , [state, initial] (1) q1 ; [state, accepting,
minimum size=0pt] (2) at (3,1); [state, accepting, minimum size=0pt] (3) at
(3,0); [state, accepting, minimum size=0pt] (4) at (3,-1); [-¿] (1) edge[coil] (2);
[-¿] (1) edge[coil] (3); [-¿] (1) edge[coil] (4);
N2
[node distance=2cm,auto,¿=latex,initial text=,color=red] coil/.style=
decorate, decoration= snake=coil , [state, initial] (1) q2 ; [state, accepting,
minimum size=0pt] (2) at (3,1); [state, accepting, minimum size=0pt] (4) at
(3,-1); [-¿] (1) edge[coil] (2); [-¿] (1) edge[coil] (4);
N
[node distance=2cm,auto,¿=latex,initial text=] coil/.style= decorate,
decoration= snake=coil , [state, initial, color=blue] (1) q1 ; [state, minimum
size=0pt, color=blue] (f1) at (3,1); [state, minimum size=0pt, color=blue] (f2)
at (3,0); [state, minimum size=0pt, color=blue] (f3) at (3,-1); [state,
color=red] (2) at (5,0) q2 ; [state, accepting, minimum size=0pt, color=red]
(f4) at (8,1); [state, accepting, minimum size=0pt, color=red] (f5) at (8,-1);
[-¿] (f1) edge node ε (2); [-¿] (f2) edge node ε (2); [-¿] (f3) edge node ε (2); [-¿,
color=blue] (1) edge[coil] (f1); [-¿, color=blue] (1) edge[coil] (f2); [-¿,
color=blue] (1) edge[coil] (f3); [-¿, color=red] (2) edge[coil] (f4); [-¿, color=red]
(2) edge[coil] (f5);
2 N1

17
 [node distance=2cm,auto,¿=latex,initial text=] [state, initial, accepting] (1)
q1 ; [-¿] (1) edge[loop above] node 0 (1);

L(N1 ) = L(0⋆ )

N2

[node distance=2cm,auto,¿=latex,initial text=] [state, initial] (2) q2 ; [state,

accepting] (3) at (3,0)q3 ; [-¿] (3) edge[loop above] node 0 (3); [-¿] (2) edge
node1 (3);

L(N2 ) = L(10⋆ )

[node distance=2cm,auto,¿=latex,initial text=] [state, initial] (1) q1 ; [state] (2)

at (3, 0)q2 ; [state, accepting] (3) at (6, 0)q3 ; [-¿] (1) edge[loop above] node 0
(1); [-¿] (3) edge[loop above] node 0 (3); [-¿] (2) edge node1 (3); [-¿] (1) edge
nodeε (2);

L(N ) = L(N1 ) ◦ L(N2 ) = L(0⋆ ) ◦ L(10⋆ ) = L(0⋆ 10⋆ )

Se A ⊆ Σ∗ é reconhecı́vel por um AFN então A∗ também é. Ou seja, a classe

das linguagens reconhecı́veis por AFNs é fechada por estrela de Kleene. A
hipótese garante que existe AFNs N1 tal que L(N1 ) = A. Vamos construir a
partir de N1 um AFN N tal que L(N ) = L(N1 )∗
Seja:

N1 = ⟨Q1 , Σ, ∆1 , q1 , F1 ⟩

Vamos construir N = ⟨Q, Σ, ∆, q0 , F ⟩:

Q = Q1 ∪ {q0 }
F = F1 ∪ {q0 }


 ∆1 (q, a) se q ∈ Q1 e q ∈/ F1
∆1 (q, a) se q ∈ F1 e a ̸= ε



∆(q, a) = ∆1 (q, a) ∪ {q1 } se q ∈ F1 e a = ε
{q1 } se q = q0 e a = ε




∅ se q = q0 e a ̸= ε


N1

18
 [node distance=2cm,auto,¿=latex,initial text=,color=blue] coil/.style=
decorate, decoration= snake=coil , [state, initial] (1) q1 ; [state, accepting,
minimum size=0pt] (2) at (3,1); [state, accepting, minimum size=0pt] (3) at
(3,0); [state, accepting, minimum size=0pt] (4) at (3,-1); [-¿] (1) edge[coil] (2);
[-¿] (1) edge[coil] (3); [-¿] (1) edge[coil] (4);
N
[node distance=2cm,auto,¿=latex,initial text=] coil/.style= decorate,
decoration= snake=coil , [state, initial, accepting] (0) q0 ; [state, color=blue]
(1) at (2,0) q1 ; [state, accepting, minimum size=0pt, color=blue] (f1) at (5,2);
[state, accepting, minimum size=0pt, color=blue] (f2) at (5,0); [state,
accepting, minimum size=0pt, color=blue] (f3) at (5,-2); [-¿] (0) edge node ε
(1); [-¿, color=blue] (1) edge[coil] (f1); [-¿, color=blue] (1) edge[coil] (f2); [-¿,
color=blue] (1) edge[coil] (f3); [-¿, bend right = 30] (f1) edge node[above]ε (1);
[-¿, bend right = 30] (f2) edge node[above]ε (1); [-¿, bend left = 30] (f3) edge
node ε (1);
N1
[node distance=2cm,auto,¿=latex,initial text=] [state, initial] (1) q1 ; [state] (2)
at (3,1)q2 ; [state, accepting] (3) at (6,1)q3 ; [state] (4) at (3,-1)q4 ; [state,
accepting] (5) at (6,-1)q5 ; [-¿] (1) edge node0 (2); [-¿] (1) edge node1 (4); [-¿]
(2) edge node1 (3); [-¿] (4) edge node0 (5);

L(N1 ) = L(0110)

N
[node distance=2cm,auto,¿=latex,initial text=] [state,initial, accepting] (1) q1 ;
[state] (1) at (3,0) q1 ; [state] (2) at (6,1)q2 ; [state, accepting] (3) at (9,1)q3 ;
[state] (4) at (6,-1)q4 ; [state, accepting] (5) at (9,-1)q5 ; [-¿] (0) edge nodeε (1);
[-¿] (1) edge node0 (2); [-¿] (1) edge node1 (4); [-¿] (2) edge node1 (3); [-¿] (4)
edge node0 (5); [-¿, bend right = 45] (3) edge node[above]ε (1); [-¿, bend left
= 45] (5) edge node ε (1);

L(N ) = L(N1 )∗ = L((0110)⋆ )

Toda linguagem regular é reconhecı́vel por um AFN. Ou seja, a classe das

linguagens reconhecı́veis por AFNs contém a classe das linguagem regulares.
Pelos lemas anteriores sabemos que a classe das linguagens reconhecı́veis por
AFNs é fechada por união, concatenação e estrela de Kleene. Para completar a
prova mostraremos que a classe contém as linguagens {a} para todo a ∈ Σ, {ε}
e ∅. Os seguintes AFNs fazem exatamente isso:
Na

[node distance=2cm,auto,¿=latex,initial text=] [state,initial] (1) q1 ; [state,

accepting] (2) at (3,0) q2 ; [-¿] (1) edge nodea (2);

19
 Nε
[node distance=2cm,auto,¿=latex,initial text=] [state,initial,accepting] (1) q1 ;
N∅
[node distance=2cm,auto,¿=latex,initial text=] [state,initial] (1) q1 ;
Construiremos o autômato que reconhece L((aba)⋆ ) usando o método visto
neste capı́tulo:
a
[node distance=2cm,auto,¿=latex,initial text=] [state, initial, minimum
size=0pt] (1) ; [state, accepting, minimum size=0pt] (2) at (2,0) ; [-¿] (1) edge
nodea (2);
b
[node distance=2cm,auto,¿=latex,initial text=] [state, initial, minimum
size=0pt] (1) ; [state, accepting, minimum size=0pt] (2) at (2,0) ; [-¿] (1) edge
nodeb (2);
ab

[node distance=2cm,auto,¿=latex,initial text=] [state,initial, minimum

size=0pt] (1) ; [state, minimum size=0pt] (2) at (2,0) ; [state, minimum
size=0pt] (3) at (3,0) ; [state, accepting, minimum size=0pt] (4) at (5,0) ; [-¿]
(1) edge nodea (2); [-¿] (2) edge nodeε (3); [-¿] (3) edge nodeb (4);

aba

[node distance=2cm,auto,¿=latex,initial text=] [state, initial, minimum

size=0pt] (1) ; [state, minimum size=0pt] (2) at (1,0) ; [state, minimum
size=0pt] (3) at (3,0) ; [state, minimum size=0pt] (4) at (4,0) ; [state,
accepting,minimum size=0pt] (5) at (7,0) ; [state, minimum size=0pt] (6) at
(1,-1); [state, accepting, minimum size=0pt] (7) at (3,-1) ; [-¿] (1) edge nodeε
(2); [-¿] (1) edge node[below]ε (6); [-¿] (2) edge nodea (3); [-¿] (3) edge nodeε
(4); [-¿] (4) edge nodeb (5); [-¿] (6) edge nodea (7);

(aba)⋆
[node distance=2cm,auto,¿=latex,initial text=] [state, initial, accepting,
minimum size=0pt] (1) ; [state, minimum size=0pt] (2) at (1,0) ; [state,
minimum size=0pt] (3) at (2,0) ; [state, minimum size=0pt] (4) at (4,0) ;
[state, minimum size=0pt] (5) at (5,0) ; [state, accepting,minimum size=0pt]
(6) at (7,0) ; [state, minimum size=0pt] (7) at (2,-1); [state, accepting,
minimum size=0pt] (8) at (5,-1) ; [-¿] (1) edge nodeε (2); [-¿] (2) edge nodeε
(3); [-¿] (2) edge nodeε (7); [-¿] (3) edge nodea (4); [-¿] (4) edge nodeε (5); [-¿]
(5) edge nodeb (6); [-¿] (7) edge nodea (8); [-¿, bend left = 60] (8) edge nodeε
(2); [-¿, bend right = 45] (6) edge node[above]ε (2);

20
 Para concluir, construiremos o autômato que reconhece L((ab)⋆ aba) usando
o método visto neste capı́tulo:
ab

[node distance=2cm,auto,¿=latex,initial text=] [state, initial, minimum

size=0pt] (1) ; [state, minimum size=0pt] (2) at (1,1) ; [state, accepting,
minimum size=0pt] (3) at (3,1) ; [state, minimum size=0pt] (6) at (1,-1);
[state, accepting, minimum size=0pt] (7) at (3,-1) ; [-¿] (1) edge nodeε (2); [-¿]
(1) edge nodeε (6); [-¿] (2) edge nodea (3); [-¿] (6) edge nodeb (7);

(ab)⋆

[node distance=2cm,auto,¿=latex,initial text=] [state, initial, accepting,

minimum size=0pt] (1) ; [state, minimum size=0pt] (2) at (1,0); [state,
minimum size=0pt] (3) at (2,1) ; [state, accepting, minimum size=0pt] (4) at
(4,1) ; [state, minimum size=0pt] (7) at (2,-1); [state, accepting, minimum
size=0pt] (8) at (4,-1) ; [-¿] (1) edge nodeε (2); [-¿] (2) edge node[below]ε (3);
[-¿] (2) edge nodeε (7); [-¿] (3) edge nodea (4); [-¿] (7) edge nodeb (8); [-¿, bend
right = 60] (4) edge node[above]ε (2); [-¿, bend left = 60] (8) edge nodeε (2);

aba

[node distance=2cm,auto,¿=latex,initial text=] [state,initial, minimum

size=0pt] (1) ; [state, minimum size=0pt] (2) at (2,0) ; [state, minimum
size=0pt] (3) at (3,0) ; [state, minimum size=0pt] (4) at (5,0) ; [state,
minimum size=0pt] (5) at (6,0) ; [state, accepting, minimum size=0pt] (6) at
(8,0) ; [-¿] (1) edge nodea (2); [-¿] (2) edge nodeε (3); [-¿] (3) edge nodeb (4);
[-¿] (4) edge nodeε (5); [-¿] (5) edge nodea (6);

(ab)⋆ aba

[node distance=2cm,auto,¿=latex,initial text=] [state, initial, minimum

size=0pt] (1) ; [state, minimum size=0pt] (2) at (1,0); [state, minimum
size=0pt] (3) at (2,1) ; [state, minimum size=0pt] (4) at (4,1) ; [state,
minimum size=0pt] (5) at (2,-1); [state, minimum size=0pt] (6) at (4,-1) ;
[state, minimum size=0pt] (7) at (5,-3); [state, minimum size=0pt] (8) at
(6,-3) ; [state, minimum size=0pt] (9) at (7,-3) ; [state, minimum size=0pt]
(10) at (8,-3) ; [state, minimum size=0pt] (11) at (9,-3) ; [state, accepting,
minimum size=0pt] (12) at (10,-3) ;
[-¿] (1) edge nodeε (2); [-¿] (2) edge node[below]ε (3); [-¿] (2) edge nodeε (5);
[-¿] (3) edge nodea (4); [-¿] (5) edge nodeb (6); [-¿, bend right = 60] (4) edge
node[above]ε (2); [-¿, bend left = 60] (6) edge nodeε (2);
[-¿] (7) edge nodea (8); [-¿] (8) edge nodeε (9); [-¿] (9) edge nodeb (10); [-¿]
(10) edge nodeε (11); [-¿] (11) edge nodea (12);
[-¿, bend right = 45] (1) edge node[below]ε (7); [-¿, bend left = 30] (4) edge
nodeε (7); [-¿, bend left = 30] (6) edge nodeε (7);

21
6 Linguagens Reconhecı́veis por AFNs são Reg-
ulares
Na última seção vimos que toda linguagem regular pode ser reconhecida por
um autômato finito. Veremos agora a relação recı́proca, a saber, que toda
linguagem reconhecı́vel por um autômato é regular. Para isso comecemos com
a seguinte definição. Um Autômato Finito Generalizado (AFG) é uma 5-upla
⟨Q, Σ, δ, qi , qf ⟩ em que:

Q é um conjunto de estados,
Σ é um alfabeto,
qi ∈ Q é um estado chamado de inicial,

qf ∈ Q é um estado chamado final e

δ : (Q − {qf )) × (Q − {qi }) → R em que R é o conjunto das expressões
regulares sobre Σ.

Em outras palavas, um AFG é como um AFN com um único estado final

e aonde as transições são etiquetadas não com um sı́mbolo, mas com uma ex-
pressão regular. Um AFG aceita uma string ω ∈ Σ∗ se ω = ω1 · ω2 . . . ωk e existe
uma sequência de estados q0 , . . . , qk tal que:

1. q0 = qi
2. qk = qf
3. ωj ∈ L(Rj ) onde Rj = δ(qj−1 , qj ) para 0 < j ≤ k

G = ⟨{qi , q1 , q2 , qf }, {a, b}, δ, qi , qf ⟩

δ qi q1 q2 qf
qi × ø ab⋆ b
q1 × ab a⋆ b⋆
q2 × (aa)⋆ aa abba
qf × × × ×

[node distance=2cm,auto,¿=latex,initial text=] [state, initial] (1) qi ; [state] (2)

at (3,2)q2 ; [state] (3) at (3,0) q1 ; [state, accepting] (4) at (6,0) qf ;
[-¿] (2) edge[loop above] node aa (2); [-¿] (3) edge[loop below] node ab (3);
[-¿, bend left = 30] (1) edge nodeab⋆ (2); [-¿] (1) edge node[below]ø (3); [-¿,
bend left = 30] (2) edge nodeabba (4); [-¿] (3) edge node[below]b⋆ (4); [-¿, bend
right = 60] (1) edge node[below]b (4); [-¿, bend left = 45] (2) edge node(aa)⋆
(3); [-¿, bend left = 45] (3) edge nodea⋆ (2);

22
 aba, aab, abbbab, aaab, b ∈ L(G)

Omitiremos a partir de agora as setas com etiqueta ø.

Para todo AFD M existe um AFG G equivalente. Seja M = ⟨Q, Σ, δ, qo , F ⟩.
Construı́mos G = ⟨Q ∪ {qi , qf }, Σ, δ ′ , qi , qf ⟩ e para todo qj ∈ Q − {qf } e
qk ∈ Q − {qi } temos:


 ϵ se qj = qi e qk = q0
ϵ se qj ∈ F e qk = qf

δ ′ (qj , qk ) = S

 a i se δ(ai , qj ) = qk
ø se a ∈ Σ com δ(a, qj ) = qk


M = ⟨{1, 2}, {a, b}, δ, 1, {2}⟩

δ a b
1 1 2
2 2 2

[node distance=2cm,auto,¿=latex,initial text=] [state,initial] (1) 1; [state,

accepting] (2) at (3,0) 2;
[-¿] (1) edge[loop above] node a (1); [-¿] (2) edge[loop above] node a, b (2); [-¿]
(1) edge nodeb (2);

G = ⟨{1, 2, s, f }, {a, b}, δ ′ , s, f ⟩

δ′ s 1 2 f
s × ϵ ø ø
1 × a b ø
2 × ø ab ϵ
f × × × ×

[node distance=2cm,auto,¿=latex,initial text=] [state, initial] (s) s; [state] (1)

at (3,0)1; [state] (2) at (6,0) 2; [state, accepting] (f) at (9,0) f ;
[-¿] (1) edge[loop above] node a (1); [-¿] (2) edge[loop above] node ab (2); [-¿]
(1) edge nodeb (2); [-¿] (s) edge nodeϵ (1); [-¿] (2) edge nodeϵ (f);

Se G é um AFG com k > 2 estados, então existe um AFG G′ com k − 1

estados tal que G ∼ G′ . Seja G = ⟨Q, Σ, δ, qi , qf ⟩ um AFG e qr ∈ Q − {qi , qf },
Construiremos G′ = ⟨Q′ , Σ, δ ′ , qi , qf ⟩ da seguinte forma:

Q′ = Q − {qr }
δ ′ (qj , qk ) = R1 R2⋆ R3 R4 aonde:
R1 = δ(qj , qr )

23
 R2 = δ(qr , qr )
R3 = δ(qr , qk )
R4 = δ(qj , qk )

Diagramaticamente, partimos de um diagrama com o seguinte formato:

[node distance=2cm,auto,¿=latex,initial text=] [state] (qj) qj ; [state] (qr) at

(3,-3)qr ; [state] (qk) at (6,0) qk ;
[-¿] (qr) edge[loop below] node R2 (qr); [-¿] (qj) edge nodeR4 (qk); [-¿] (qj)
edge nodeR1 (qr); [-¿] (qr) edge nodeR3 (qk);

E depois de remover qr chegamos nos seguinte:

[node distance=2cm,auto,¿=latex,initial text=] [state] (qj) qj ; [state] (qk) at

(6,0) qk ;
[-¿] (qj) edge nodeR1 R2⋆ R3 R4 (qk);

Considere o AFG G do Exemplo 6. Vamos remover o estado 2 seguindo a

construção do lema anterior.

G′ = ⟨{s, 1, f }, {a, b}, δ ′ , s, f ⟩

δ′ s 1 f
s × ϵ ø
1 × a b(ab)⋆
f × × ×

[node distance=2cm,auto,¿=latex,initial text=] [state, initial] (s) s; [state] (1)

at (3,0)1; [state, accepting] (f) at (6,0) f ;
[-¿] (1) edge[loop above] node a (1); [-¿] (s) edge nodeϵ (1); [-¿] (1) edge
nodeb(ab)⋆ (f);

Toda linguagem reconhecı́vel por AFD é regular. Seja A uma linguagem

reconhecı́vel por um AFD M i.e. L(M ) = A. Pelo Lema 6 existe um AFG G
tal que M ∼ G. Além disso, examinando a construção do Lema 6 temos que se
o número de estados de M é k então o número de estado de G é k + 2.
Pelo lema 6 existe G1 com um estado a menos (k+1 estados) tal que G1 ∼ G.
Aplicando o lema k vezes obtemos Gk ∼ G com exatamente 2 estados: qi e qf .
É claro que L(Gk ) = L(R) aonde δGk (qi , qf ) = R. Como Gk ∼ G, temos
L(G) = L(H) = L(R).

L(M ) = L(G) = L(G1 ) = . . . = L(Gk ) = L(R)

Considere o AFD M do Exemplo 6. Mostramos que ele é equivalente a

um AFG e, em no Exemplo 6 mostramos um AFG equivalente com 3 estados.
Removendo mais um estado ficamos com o seguinte diagrama:

24
 [node distance=2cm,auto,¿=latex,initial text=] [state, initial] (s) s; [state,
accepting] (f) at (6,0) f ;
[-¿] (s) edge nodea⋆ b(ab)⋆ (f);

Portanto temos que:

L(M ) = L(a⋆ b(ab)⋆ )
Considere o seguinte AFD:
2 [node distance=2cm,auto,¿=latex,initial text=] [state, initial] (1) 1; [state,
accepting] (2) at (3,1.5)2; [state, accepting] (3) at (3,-1.5) 3;
[-¿] (2) edge[loop above] node b (2); [-¿, bend left = 15] (1) edge nodea
(2); [-¿, bend left = 15] (2) edge nodea (1); [-¿] (3) edge nodea (2); [-¿, bend
left = 15] (1) edge nodeb (3); [-¿, bend left = 15] (3) edge nodeb (1); [node
distance=2cm,auto,¿=latex,initial text=] [state, initial] (s) s; [state] (1) at (2,0)
1; [state] (2) at (5,1.5)2; [state] (3) at (5,-1.5) 3; [state, accepting] (f) at (7,0) f ;
[-¿] (2) edge[loop above] node b (2); [-¿, bend left = 15] (1) edge nodea (2);
[-¿, bend left = 15] (2) edge nodea (1); [-¿] (3) edge nodea (2); [-¿, bend left
= 15] (1) edge nodeb (3); [-¿, bend left = 15] (3) edge nodeb (1); [-¿] (s) edge
nodeϵ (1); [-¿] (2) edge nodeϵ (f); [-¿] (3) edge nodeϵ (f);
2 [node distance=2cm,auto,¿=latex,initial text=] [state, initial] (s) s; [state]
(2) at (3,1.5)2; [state] (3) at (3,-1.5) 3; [state, accepting] (f) at (5,0) f ;
[-¿] (s) edge nodea (2); [-¿] (s) edge node[below]b (3); [-¿] (2) edge[loop above]
node aab (2); [-¿] (3) edge[loop below] node bb (3); [-¿, bend left = 30] (2) edge
nodeab (3); [-¿, bend left = 30] (3) edge nodebaa (2); [-¿] (2) edge nodeϵ (f); [-¿]
(3) edge node[below]ϵ (f);
[node distance=2cm,auto,¿=latex,initial text=] [state, initial] (s) s; [state]
(3) at (5,0) 3; [state, accepting] (f) at (5,-4) f ;
[-¿] (s) edge nodea(aab)⋆ abb (3); [-¿] (3) edge[loop above] node (baa)(aab)⋆ abbb
(3); [-¿] (3) edge node(baa)(aab)⋆ ϵ (f); [-¿] (s) edge node[left]a(aab)⋆ (f);

[node distance=2cm,auto,¿=latex,initial text=] [state, initial] (s) s; [state,

accepting] (f) at (11,0) f ;
[-¿] (s) edge node(a(aab)⋆ abb)((baa)(aab)⋆ abbb)⋆ ((baa)(aab)⋆ ϵ)a(aab)⋆ (f);

7 Linguagens Não-Regulares
Neste capı́tulo vimos dois modelos computacionais: AFDs e AFNs. Ambos
reconhecem a mesma classe de linguagens, a saber, as linguagens regulares. Para
completar este capı́tulo veremos exemplos de linguagens que não são regulares.
[Lema do Bombeamento] Se A é uma linguagem regular então exite um
número p (chamado comprimento do bombeamento) tal que se ω ∈ A e |ω| ≥ p
então ω = x · y · z onde:
1. x · y i · z ∈ A para todo i ≤ 0,

2. |y| > 0 e

25
 3. |x · y| ≤ p
Como A é regular, existe AFD M = ⟨Q, Σ, δ, q0 , F ⟩ tal que L(M ) = A. Seja
p = |Q| − 1 e seja ω ∈ A uma string tal que |ω| ≥ p.
Como ω = a1 a2 . . . an ∈ A = L(M ) existe uma sequência de estados q0 , . . . , qn
onde qn ∈ F e qi+1 = δ(qi , ai+1 ). Como |ω| = n ≥ p, pelo princı́pio da casa dos
pombos1 existe pelo menos um estado que se repete na sequência.
Seja qi o primeiro estado que se repete na sequência. Temos então a seguinte
situação:

[node distance=2cm,auto,¿=latex,initial text=] coil/.style= decorate,

decoration= snake=coil , [state, initial] (1) q0 ; [state] (2) at (3,0)qi ; [state,
accepting] (3) at (6,0) qn ;
[-¿, dashed, in=120, out=60, distance=1.5cm] (2) edge[coil] node[above] y (2);
[-¿, dashed] (1) edge[coil] nodex (2); [-¿, dashed] (2) edge[coil] nodez (3);

Ou seja, a sequência q0 , . . . , qi reconhece a string x, a sequência qi , . . . , qi

reconhece y e a sequência qi , . . . , qn reconhece z.
Portanto, ω pode ser dividido em três partes ω = x · y · z em que |y| > 0.
Além disso, como qi é o primeiro estado que se repete, temos que |x · y| ≤ p. Por
fim, como ilustrado, o autômato reconhece y um número arbitrário de vezes.
Ou seja, x · y i · z ∈ A para todo i = 0, 1, 2, . . .
Vamos mostrar que A = {0n 1n : n ≥ 0} não é regular.
Seja p o comprimento do bombeamento e ω = 0p 1p ∈ A. Se A fosse regular,
pelo lema do bombeamento, ω poderia ser dividida em três partes ω = xyz e
para todo i = 0, 1, . . . terı́amos xy i z ∈ A.
Se y é formada só por 0s ou só por 1s então xyyz possuiria um número
diferente de 0s e 1s e, portanto, xyyz ∈ / A. Se y possuir 0s e 1s então xyyz
conterá pelo menos um 0 entre dois 1s e, portanto, xyyz ∈ / A.
Logo A não pode ser regular.
Mostraremos que A = {ω : ω tem o mesmo número de 0s e 1s} não é regular.
Seja p o comprimento do bombeamento e ω = 0p 1p ∈ A. Se A fosse regular
poderı́amos escrever ω = xyz com |xy| ≤ p e xy i z ∈ A para todo i ≥ 0.
Como |xy| ≤ p, por definição, xy contém apenas 0s. Neste caso, xyyz deve
conter mais 0 do que 1s. Logo xyyz ∈ / A.
Vamos mostrar que A = {ωω : ω ∈ {0, 1}∗ } não é regular.
Seja p o comprimento do bombeamento e ω = 0p 10p 1 ∈ A. Dividimos
ω = xyz com |xy| ≤ p então y contém apenas 0s e xyyz = 0p 0 . . . 010p 1 ∈ / A.
Por fim, vamos mostrar que A = {0i 1j : i > j} não é regular.
Seja p o comprimento do bombeamento e ω = 0p+1 1p ∈ A. Tomamos
ω = xyz com |xy| ≤ p e |y| > 0. Portanto, y contém apenas 0s e xy 0 z = xz ∈ / A.
Neste capı́tulo estudamos a classe das linguagens regulares e dois modelos
de computação, autômatos finitos determinı́sticos e não-determinı́sticos. Prova-
mos que esses dois modelos são equivalentes e que a classe das linguagens que
1 O princı́pio da casa dos pombos garante que se há n pombos e p casas com n > p então

com certeza pelo menos uma casa terá mais de um pombo.

26
eles reconhecem coincide com a classe das linguagens regulares. Terminamos o
capı́tulo vendo exemplos de linguagens que não são regulares.regulares.

27