Teoria da Computação Primeiro Semestre, 2015

Aula 3: Autômatos Finitos

DAINF-UTFPR Prof. Ricardo Dutra da Silva

Um procedimento que determina se uma string de entrada pertence à uma linguagem é

um reconhecedor desta linguagem. Vamos definir uma classe de máquinas que determinam
se uma string deve ser aceita ou não. A entrada de uma máquina será uma string sobre
um alfabeto e a saı́da da computação seu aceite (reconhecimento) ou não dentro de uma
linguagem.
Em uma máquina bastante simples para venda de café, a entrada consiste em uma
sequência de moedas de 5, 10 e 25 centavos. Quando 30 centavos ou mais são inseridos,
a máquina chega ao estado de aceite e o café é entregue. Se mais de 30 centavos são inseri-
dos na máquina ela aceita de bom grado e não retorna troco.
A máquina tem conhecimento de quanto dinheiro foi inserido. Esse conhecimento é obtido
através dos estados internos da máquina. Quando uma entrada é recebida e processada,
a máquina atualiza o conhecimento, possivelmente, mudando de estado. Cada estado da
máquina representa um determinado estado da computação.
Na nossa máquina terı́amos 7 estados representado quantos centavos faltam para que o
café possa ser entregue. Cada estado, portanto, representaria uma das seguintes informações:

ˆ faltam 30 centavos para o café ser entregue;

ˆ faltam 25 centavos para o café ser entregue;

ˆ faltam 20 centavos para o café ser entregue;

ˆ faltam 15 centavos para o café ser entregue;

ˆ faltam 10 centavos para o café ser entregue;

ˆ faltam 5 centavos para o café ser entregue;

ˆ faltam 0 centavos para o café ser entregue.

1
2 Aula 3: Autômatos Finitos

Uma diagrama de estados é comumente usado para representar os estados e as transições

de uma máquina. O diagrama é um grafo em que cada nó representa um dos estados. As
arestas do grafo, rotuladas, representam a entrada processada e qual a transição entre estados
que ela produz. O diagrama de estados para a máquina de café é mostrado na Figura 3.1.

¢10 ¢10 ¢10 ¢10 ¢10

¢10

¢5 ¢5 ¢5 ¢5 ¢5 ¢5 ¢5, ¢10,
start 30 25 20 15 10 5 0
¢25 ¢25 ¢25
¢25 ¢25
¢25

¢25

Figura 3.1: Máquina de estados para uma máquina de vender café.

O estado “faltam 30 centavos” é chamado de estado inicial. O estado inicial deve ser
diferenciado no diagrama. Usaremos para esse propósito uma seta rotulada “start” (ver
Figura 3.1). O estado “faltam 0 centavos” é chamado de estado final, indicando que a
entrada fornecida para a máquina foi aceita, ou seja, que a sequência de moedas fornecida
compra um café. O estado final, ou estado de aceite, será indicado no diagrama por duas
circunferências (ver Figura 3.1).
A máquina de café aceita moedas de 5, 10 e 25 centavos. Seu alfabeto é, portanto,
Σ = {¢5, ¢10, ¢25}. As entradas para a máquina são strings do conjunto Σ∗ = {¢5, ¢10, ¢25}∗ .
As strings aceitas são aquelas que terminam no estado final.
Um autômato finito é uma máquina abstrata que pode ser usada para determinar se
strings fornecidas como entrada são aceitas. Cada sı́mbolo da string é processado em
sequência e o processamento determina as mudanças de estado que ocorrem na máquina.
Isso é feito percorrendo a aresta com rótulo igual ao do sı́mbolo processado.
A string ¢10¢10¢5¢5 é aceita pela máquina de café, pois o caminho induzido pela string
termina em um estado final. A Figura 3.1 mostra, em destaque, o caminho induzido pela
string ¢10¢10¢5¢5.
A string ¢10¢5¢5¢5 não é aceita pela máquina pois o caminho induzido pela string não
3.1. AUTÔMATOS FINITOS DETERMINÍSTICOS 3

¢10 ¢10 ¢10 ¢10 ¢10

¢10

¢5 ¢5 ¢5 ¢5 ¢5 ¢5 ¢5, ¢10,
start 30 25 20 15 10 5 0
¢25 ¢25 ¢25
¢25 ¢25
¢25

¢25

Figura 3.2: Caminho induzido pela string ¢10¢10¢5¢5 na máquina de estados da máquina
de vender café.

termina em um estado final (Figura 3.3).

¢10 ¢10 ¢10 ¢10 ¢10

¢10

¢5 ¢5 ¢5 ¢5 ¢5 ¢5 ¢5, ¢10,
start 30 25 20 15 10 5 0
¢25 ¢25 ¢25
¢25 ¢25
¢25

¢25

Figura 3.3: Caminho induzido pela string ¢10¢5¢5¢5 na máquina de estados da máquina de
vender café.

Na sequência iremos formalizar as noções vistas nesta introdução. Com isso poderemos
estudar, em máquinas abstratas, capacidades e limitações de computação.

3.1 Autômatos Finitos Determinı́sticos

Definição 3.1. Um autômato finito determinı́stico (DFA, do inglês Finite Deterministic
Automata) é uma 5-tupla M = (Q, Σ, δ, q0 , F ), onde
4 Aula 3: Autômatos Finitos

ˆ Q é um conjunto finito de estados;

ˆ Σ é o alfabeto;

ˆ q0 ∈ Q é o estado inicial;

ˆ F é o subconjunto de estados finais de Q;

ˆ δ é uma função δ : Q × Σ → Q, chamada de função de transição.

Definição 3.2. O diagrama de estados de um DFA M = (Q, Σ, δ, q0 , F ) é um grafo G,

direcionado e rotulado, definido como:

ˆ os vértices de G são os elementos de Q;

ˆ os rótulos das arestas são elementos de Σ;

ˆ q0 é o estado inicial, indicado pela palavra “start”;

ˆ F é o subconjunto de nós finais, indicados por cı́rculos concêntricos;

ˆ existe um arco entre os nós qi e qj com o rótulo a se δ(qi , a) = qj ;

ˆ para cada nodo qi ∈ Q e sı́mbolo a ∈ Σ há exatamente uma aresta rotulada como a
partindo de qi .

Exemplo 3.1
Podemos descrever formalmente o autômato da máquina de café (Figura 3.1) como uma
5-tupla M = (Q, Σ, δ, q0 , F ), onde:

ˆ Q = {30, 25, 20, 15, 10, 5, 0};

ˆ Σ = {¢5, ¢10, ¢25};

ˆ q0 = 30;

ˆ F = {0};

ˆ δ é a função de transição que pode ser resumida pela tabela abaixo. Dado um
estado qi (linha l) e um sı́mbolo a ∈ Σ (coluna c), a posição (l, c) da tabela contém
3.1. AUTÔMATOS FINITOS DETERMINÍSTICOS 5

o estado qj resultante da transição δ(qi , a). Por exemplo, se qi = 30 e a = ¢10, a

posição respectiva da tabela corresponde à δ(30, ¢10) = 20.
δ ¢5 ¢10 ¢25
30 25 20 5
25 20 15 0
20 15 10 0
15 10 5 0
10 5 0 0
5 0 0 0
0 0 0 0

Exemplo 3.2
O diagrama de estados do DFA M = ({p, q, r}, {0, 1}, δ, p, {r}), com função de transição

δ(p, 0) = q
δ(p, 1) = p
δ(q, 0) = q
δ(q, 1) = r
δ(r, 0) = r
δ(r, 1) = r

é dado abaixo.

1 0 0, 1

p 0 q 1
start r

Um autômato pode ser visto como um máquina que contém cinco componentes.

ˆ Um registrador que armazena o estado atual em que a máquina se encontra.

ˆ Um conjunto de estados para o registrador, que é o conjunto de estados Q.

6 Aula 3: Autômatos Finitos

ˆ Uma fita seccionada que armazena sequencialmente, em posições contı́guas, sı́mbolos

a ∈ Σ da string de entrada;

ˆ Um leitor de fita que lê o sı́mbolo de uma secção da fita;

ˆ Um conjunto de instruções, relacionado com a função de transição, que informa a ação

da máquina. Dado o estado qi atual e o sı́mbolo a ∈ Σ lido, a máquina redefine o
estado do registrador para δ(qi , a) e move o leitor uma posição à frente.

O leitor é inicialmente posicionado na posição mais à esquerda da string na fita e o

registrador começa com o estado inicial. A máquina então computa a transição de estado
conforme a função δ. O processo é repetido até a cabeça de leitura encontrar uma posição
vazia. Uma string é aceita pela máquina se a computação termina em um estado final.
Exemplo 3.3
Dado o DFA M = ({p, q, r}, {0, 1}, δ, p, {r}), com

δ(p, 0) = q
δ(p, 1) = p
δ(q, 0) = q
δ(q, 1) = r
δ(r, 0) = r
δ(r, 1) = r

e a string 001. A computação da máquina é mostrada abaixo. O processo termina em

um estado final e a string é aceita.

0 0 1 ...
p

0 0 1 ...
q

0 0 1 ...
q
3.1. AUTÔMATOS FINITOS DETERMINÍSTICOS 7

0 0 1 ...
r

A string 100, por sua vez, não é aceita pela máquina, pois o processo termina em um
estado que não é final.

1 0 0 ...
p

1 0 0 ...
p

1 0 0 ...
q

1 0 0 ...
q

Pelo que vimos no exemplo anterior, podemos definir strings que são aceitas por um DFA.
Definição 3.3. Seja M = (Q, Σ, δ, q0 , F ) um DFA. Uma string w ∈ Σ∗ é aceita se o
processamento de w por M termina em um estado final.
Uma DFA M aceita um conjunto de strings e esse conjunto define a linguagem de M .
Definição 3.4. Seja M = (Q, Σ, δ, q0 , F ) um DFA. A linguagem de M , denotada L(M ), é
o conjunto de strings em Σ∗ aceitas por M .
Exemplo 3.4
O DFA M = ({p, q}, {0, 1}, δ, p, {q}), com função de transição

δ 0 1
p p q
q p q

e diagrama de estados
8 Aula 3: Autômatos Finitos

0 1
1
start p q
0

define a linguagem L(M ) = {w | w termina em 1} sobre o alfabeto Σ = {0, 1}.

Definição 3.5. A função de transição estendida δ̂ de um DFA com função de transição δ

é uma função δ̂ : Q × Σ∗ → Q definida recursivamente no tamanho da string de entrada:

i) Base: Se |w| = 0, então w = λ e δ̂(qi , λ) = qi . Se |w| = 1, então w = a, para a ∈ Σ, e

δ̂(qi , a) = δ(qi , a).

ii) Passo recursivo: Se w é uma string de tamanho n > 1, então w = ua e δ̂(qi , ua) =
δ(δ̂(qi , u), a).

A função de transição estendida representa a aplicação repetida da função de transição.

Exemplo 3.5
Seja DFA M = ({p, q}, {0, 1}, δ, p, {q}), com função de transição

δ 0 1
p p q
q p q

Dada a string 1001, então a computação da string pode ser vista como
3.1. AUTÔMATOS FINITOS DETERMINÍSTICOS 9

δ̂(p, 1001) = δ(δ̂(p, 100), 1)

= δ(δ(δ̂(p, 10), 0), 1)
= δ(δ(δ(δ̂(p, 1), 0), 0), 1)
= δ(δ(δ(δ(p, 1), 0), 0), 1)
= δ(δ(δ(q, 0), 0), 1)
= δ(δ(p, 0), 1)
= δ(p, 1)
= q.

Dada a string 0110, então a computação da string pode ser vista como

δ̂(p, 0110) = δ(δ̂(p, 011), 0)

= δ(δ(δ̂(p, 01), 1), 0)
= δ(δ(δ(δ̂(p, 0), 1), 1), 0)
= δ(δ(δ(δ(p, 0), 1), 1), 0)
= δ(δ(δ(p, 1), 1), 0)
= δ(δ(q, 1), 0)
= δ(q, 0)
= p.

A função de transição estendida δ̂(qi , w) computa qual o estado alcançado a partir de

qi . Podemos usar esse fato para definir (redefinir) as strings aceitas por um DFA (veja
Definition 3.3) bem como a linguagem de uma DFA M (veja Definição 3.4).

Definição 3.6. Seja M = (Q, Σ, δ, q0 , F ) um DFA. Uma string w ∈ Σ∗ é aceita se

δ̂(q0 , w) ∈ F .

Definição 3.7. Seja M = (Q, Σ, δ, q0 , F ) um DFA. A linguagem de M é o conjunto

10 Aula 3: Autômatos Finitos

L(M ) = {w | w ∈ Σ∗ , δ̂(q0 , w) ∈ F }.
Definição 3.8. Uma linguagem é chamada de linguagem regular se ela é aceita por um
autômato finito determinı́stico.
Exemplo 3.6
Vamos construir o autômato que aceita L = {w | w ∈ {0, 1}∗ e contém a substring 11}.
Não existe um método para construir autômatos para uma linguagem. A tarefa é ba-
sicamente criativa. Uma dica é tentar simular o que ocorre para cada entrada e tomar
decisões sobre o que o autômato precisa “lembrar”. Para a linguagem L, o autômato
pode aceitar uma string se ele lembra que processou dois 1’s justapostos. Lembrar tal
fato significa criar um estado como o significado “foi lida a string 11”. Tal estado deve
ser um estado final. Mas antes de lembrar que leu 11, o autômato precisa saber que leu
o primeiro 1. Para isso basta um estado que signifique a lembrança “acabei de ler um 1
e se eu ler mais um 1 eu posso aceitar a string”. O estado inicial do autômato seria o
estado “ainda não li a substring 11”. Poderı́amos então definir tais estados:

ˆ q0 : nenhuma substring 11 foi lida.

ˆ q1 : acabei de ler um 1, estou no meio do caminho.

ˆ q2 : já li a string 11 e portanto posso aceitar a string de entrada.

Nosso diagrama de estados parcial seria

start q0 q1 q2

Agora, para cada estado, precisamos saber qual transição realizar para cada um dos
sı́mbolos do alfabeto. Se estivermos no estado q0 e lermos um 0, nada ajuda no reco-
nhecimento de 11. Podemos simplesmente criar uma transição de q0 para ele mesmo e
continuar lendo a entrada. Se lermos um 1, no entanto, podemos mudar para o estado
q1 pois estamos no meio do caminho.

q0 1 q1 q2
start
3.2. OPERAÇÕES REGULARES 11

No estado q1 , ler um 0 significa que não há mais possibilidade de ler 11. Portanto
precisamos recomeçar, por exemplo, voltando ao estado inicial. Por outro lado, se lermos
um 1 significa que acabamos de ler a sequência 11 e podemos entrar o estado final q2 .

q0 1 q1 1 q2
start

Ainda não terminamos, em um DFA todo estado possui transições para todos os sı́mbolos
do alfabeto. Aqui basta criar transições de q2 para ele mesmo independentemente do
sı́mbolo do alfabeto. A string já foi aceita e tudo o que precisamo e lê-la até o final.

0 0, 1

q0 1 q1 1 q2
start

Formalmente, o DFA é descrito por M = ({q0 , q1 , q2 }, {0, 1}, δ, q0 , {q2 }), com função
de transição
δ 0 1
q0 q0 q1
q1 q0 q2
q2 q2 q2

3.2 Operações Regulares

Definimos que DFA’s aceitam linguagens regulares. Agora iremos estudar operações que
podem ser usada para construir linguagens regulares mais complexas a partir de linguagens
regulares mais simples. Tais operações são chamadas de operações regulares.
Definição 3.9. Dadas linguagens regulares L1 e L2 , as operações regulares união, conca-
tenação e estrela de Kleene são definidas como:
12 Aula 3: Autômatos Finitos

ˆ União: L1 ∪ L2 = {w | w ∈ L1 ou w ∈ L2 }

ˆ Concatenação: L1 L2 = {vw | v ∈ L1 e w ∈ L2 }

ˆ Estrela de Kleene: L∗1 = {w1 w2 w3 . . . wk | k ≥ 0 e wk ∈ L1 }

A concatenação de uma linguagem L com ela mesma k vezes será denotada por Lk .
Note que k = 0 na definição da estrela de Kleene significa que λ pertence à estrela de
Kleene de qualquer linguagem. Alternativamente, poderı́amos pensar na definição da estrela
de Kleene, para uma linguagem L, como:

L0 = {λ}

e para k ≥ 1
Lk = Lk−1 L.

Portanto, Lk é a concatenação de Lk−1 e L. A estrela de Kleene é, por sua vez:

∞
[
∗
L = Lk .
k=0

Uma variação da estrela que omite a string vazia é definida como

∞
[
+
L = Lk .
k=1

Exemplo 3.7
Sejam as linguagens L1 = {0, 01} e L2 = {1, 10}. Então

L1 ∪ L2 = {0, 01, 1, 10},

L1 L2 = {01, 010, 011, 0110}
L01 = {λ}
L11 = L10 L1 = {0, 01}
L21 = L11 L1 = {00, 010, 001, 0101}
L31 = L21 L1 = {000, 0100, 0010, 01010, 0001, 01001, 00101, 010101}
L∗1 = L01 ∪ L11 ∪ L21 . . . = {λ, 0, 01, 00, 010, 001, 0101, . . .}
L+ 1 2
1 = L1 ∪ L1 . . . = {0, 01, 00, 010, 001, 0101, . . .}.
3.2. OPERAÇÕES REGULARES 13

Essas operações podem ser usadas para produzir descrições não ambı́guas de linguagens.
Exemplo 3.8
A linguagem L = {w | w ∈ {0, 1}∗ e contém a substring 11}, vista anteriormente, pode
ser construı́da por operações regulares de linguagens mais simples. Vamos considerar as
linguagens L1 = {0} e L2 = {1}, que são regulares.

1. Concatenando L2 com ela mesma obtemos a linguagem {11}.

2. Realizando a união de L1 com L2 obtemos {0, 1}.

3. Aplicando a estrela de Kleene sobre a linguagem do passo dois obtemos {0, 1}∗ .

4. Concatenamos a linguagem do passo 3 com linguagem do passo 1 para obter

{0, 1}∗ 11.

5. Por fim, concatenamos a linguagem do passo 4 com linguagem do passo 3 para

obter {0, 1}∗ 11{0, 1}∗ .

A linguagem L pode então ser descrita como L = {0, 1}∗ 11{0, 1}∗ e consiste justamente
em strings sobre {0, 1} que contêm a substring 11. Essa é uma forma simplificada de
descrever linguagens.
A primeira parte da definição, {0, 1}∗ , informa que uma string pertencente a L pode
conter inicialmente qualquer quantidade de 0’s e 1’s, inclusive pode ser a string vazia. A
segunda parte, 11, obriga que exista a substring 11. A terceira parte funciona exatamente
como a primeira.
Podemos pensar na definição L = {0, 1}∗ 11{0, 1}∗ como: “Uma string que pertence a L
tem necessariamente a substring 11 e esta pode ter como prefixo e/ou sufixo qualquer
quantidade de 0’s e 1’s.”

Exemplo 3.9
Seja L a linguagem sobre {a, b} que consiste em todas as strings que iniciam com aa ou
terminam com bb. Podemos descrevê-la como L = aa{a, b}∗ ∪ {a, b}∗ bb.

As operações regulares definem linguagens regulares. Vimos anteriormente que linguagens

regulares são aquelas que são reconhecidas por um DFA. No entanto, construir DFA’s mais
14 Aula 3: Autômatos Finitos

complicados a partir de DFA’s mais simples nem sempre é uma tarefa tão fácil quanto a das
linguagens.