Apostila Linguagens Formais e Autômatos (LFA)

Linguagens Formais e Autômatos
Ricardo Terra
rterrabh [at] gmail.com
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 1 / 468
CV
Nome: Ricardo Terra
Email: terra [at] dcc.ufla.br
www: dcc.ufla.br/⇠terra
Twitter: rterrabh
Lattes: lattes.cnpq.br/ 0162081093970868
Ph.D. (UFMG/UWaterloo),
Post-Ph.D. (INRIA/Université Lille 1)
Background
Acadêmico : UFLA (desde 2014), UFSJ (1 ano ), FUMEC (3 anos ), UNIPAC (1 ano ), FAMINAS (3 anos )
Profissional : DBA Eng. (1 ano ), Synos (2 anos ), Stefanini (1 ano )
1. Revisão – Conteúdo
Conjuntos, relações e funções 4
1 Revisão 3
Definições Recursivas 8
Indução Matemática 13
Linguagens Formais e Autômatos (LFA) 17
2 Introdução 59
Autômatos Finitos Determinísticos
Autômatos Finitos Não-Determinísticos
Autômatos Finitos Não-Determinísticos com Transições-
3 Linguagens Regulares 74
Máquina de Moore
Máquinas de Mealy
Algoritmos de Transformação
Transformação AFND- para AFD
Minimização de AFD
Transformação de ER para AFND-
Recursividade
Árvore de Derivação
Ambiguidade
Backus-Nahur Form (BNF)
4 Linguagens Livres de Contexto 172
Remoção de recursividade no símbolo inicial
Eliminação de regras
Eliminação de regras de cadeia
Remoção de símbolos inúteis
Variantes
Critérios de Aceitação
Autômato com Pilha como Reconhecedor
Autômato com Pilha Descendente
Algoritmo de Cocke-Younger-Kasami (CYK)
Algoritmo de Early
Transformação de GLCs para APs
Transformação de APs para GLCs
5 Linguagens Sensíveis ao Contexto 373
Teoremas
6 Linguagens Irrestritas 393
Variantes
7 Considerações Finais 459
Revisão
Conjuntos, relações e funções

Revisão – Conjuntos, relações e funções (1–34)
Revisão
Deﬁnições Recursivas

Revisão – Definições Recursivas
Conjuntos enumeráveis podem ser definidos por meio de
uma definição recursiva
Uma definição recursiva especifica como um conjunto
pode ser gerado a partir de um subconjunto do mesmo
aplicando-se operações um número finito de vezes
Uma definição recursiva de um conjunto A consta de três
partes:
(i) base: especificação de um conjunto base B ⇢ A
(ii) passo recursivo: especificação de um elenco de operações
que, se aplicadas a elementos de B, geram elementos de A
(iii) fechamento: afirmação que os únicos elementos de A são
aqueles que podem ser obtidos a partir dos elementos de B
aplicando-se um número finito de vezes as operações
especificadas em (ii)
Exemplo #1: Conjunto N
O conjunto N pode ser definido a partir de {0} usando-se a
operação s (sucessor)
(i) base: {0} ⇢ N
(ii) passo recursivo: se n 2 N, então s(n) 2 N
(iii) fechamento: só pertence a N, o número que pode ser
obtido de acordo com (i) e (ii)
Exemplo #2: Função Fatorial fat : N ! N
(i) base: fat(0) = 1
(ii) passo recursivo: fat(n) = n x fat(n 1), para n 1

Exemplo #2: Função Fatorial fat : N ! N
(i) base: fat(0) = 1
(ii) passo recursivo: fat(n) = n x fat(n 1), para n 1
Mais formalmente
(i) base: {(0, 1)} ⇢ fat
(ii) passo recursivo: se n 1 e (n 1, k) 2 fat, então
(n, n x k) 2 fat
(iii) fechamento: só pertence a fat, o par que pode ser obtido
conforme (i) e (ii)
Revisão
Indução Matemática
Revisão – Indução Matemática
Indução Matemática
Técnica usada para provar que uma propriedade é válida
para todos elementos de um conjunto deﬁnido
recursivamente (Veja Sudkamp [6], Seção 1.7)
Considere X um conjunto tendo como base X0
Seja X0, X1, . . . , Xn a sequência de conjuntos gerados por um
processo recursivo e P uma propriedade
Prova consiste em:
Base: Mostrar que P é válido 8x 2 X0
Hipótese: P é válido 8x 2 X0, X1, ..., Xk
Passo indutivo: Mostrar que P também é válido 8x 2 Xk+1
Assim, P é válido 8x 2 X
Exemplo #1: Provar que
Pn
i=1 i = n(n+1)
2
Base: P(1) é verdadeiro, i.e.,
P1
i=1 i = 1(1+1)
2 = 1
Hipótese: P é verdadeira para 0, 1, 2, 3, . . . , k, ou seja,
kX
i=1
i =
k(k + 1)
2
Passo indutivo: Provar que
PK+1
i=1 i = (K+1)((K+1)+1)
2 = (K+1)(K+2)
2
PK+1
i=1 i
=
PK
i=1 i + (k + 1) (deﬁnição somatório)
= k(k+1)
2 + (k + 1) (uso da hipótese de indução)
= k(k+1) + 2(k+1)
2 (matemática básica)
= (k+1)(k+2)
2

Exemplo #2: Provar que n! > 2n, 8n > 4
Base: P(5) é verdadeiro, i.e., (5! = 120) > (32 = 25)
Hipótese: P é verdadeira para 5, 6, 7, . . . , k, ou seja,
k! > 2k
, 8k > 4
Passo indutivo: Provar que (k + 1)! > 2(k+1)
(k + 1)!
= k! ⇥ (k + 1) (definição fatorial)
> 2k
⇥ (k + 1) (uso da hipótese de indução)
> 2k
⇥ 2 (pela certeza que k > 4)
= 2k+1
Revisão
Linguagens Formais e Autômatos (LFA)
Revisão – Linguagens Formais e Autômatos (LFA)
Hierarquia de Chomsky
Tipo Linguagem Gramática Máquina de aceitação
0 Rec. enumerável Irrestrita Máquina de Turing
1 Recursiva Sensível ao contexto Autômato linearmente limitado
2 Livre de contexto Livre de contexto Autômato com pilha
3 Regular Regular Autômato finito
Definições Básicas
Linguagem: conjunto de palavras sobre um alfabeto
Alfabeto (⌃): conjunto de símbolos de uma linguagem
Palavra: sequência finita de símbolos de um alfabeto ⌃
|w| = no
de símbolos da palavra w
= palavra vazia, constituída de zero símbolos
Fecho de Kleene (*)
{a}⇤
= { , a, aa, aaa, aaaa, ...}
⌃⇤
= conjunto de todas as palavras do alfabeto
Fecho Positivo de Kleene (+)
{a}+
= {a}{a}⇤
= {a, aa, aaa, aaaa, ...}
⌃+
= ⌃⇤
{ }

Linguagem Regular (LR)
Uma linguagem regular é aquela que pode ser deﬁnida por
um conjunto regular
Um conjunto regular pode ser gerado a partir de ⌃ usando
operador de Kleene, união e concatenação
Deﬁnição recursiva:
Base: , { } e {a}(8a 2 ⌃) são conjuntos regulares
Passo recursivo: se X e Y são conjuntos regulares, então
X [ Y, XY e X⇤
também são conjuntos regulares
Linguagem Regular (LR) – Exemplo
L = palavras sobre {a, b} que começam e terminam com a
e possuem pelo menos um b
Conjunto regular: {a}{a, b}⇤{b}{a, b}⇤{a}
Linguagem Regular (LR) – Exercício de Fixação
1 L = palavras sobre {a, b} que começam com a e tenham
número par de b
Expressão Regular (ER)
Alguns autores (e.g., Sudkamp) usam abreviações para denotar
conjunto regulares:
{ } !
{a}(8a 2 ⌃) ! a(8a 2 ⌃)
{a, b} ! (a [ b)
{ab} ! (ab)
{u}⇤
! u⇤
{xx⇤
} ! x+
Expressão Regular (ER) – Exemplo
Expressão regular:

Expressão regular: a(a [ b)⇤b(a [ b)⇤a
Expressão regular: a(a [ b)⇤b(a [ b)⇤a
Expressão Regular (LR) – Exercícios de Fixação
1 L = palavras sobre {a, b} que começam com b e tenham
número ímpar de a
2 L = palavras sobre {a, b, c} que todo a seja precedido de
um b
Gramática Regular (GR)
Uma GR é uma quádrupla (V, ⌃, P, S):
V = conjunto de símbolos não-terminais (variáveis)
⌃ = conjunto de símbolos terminais (⌃ V = )
P = conj. de regras (produções)
S = símbolo não-terminal inicial (S 2 V)
Regras: µ ! ⌫
µ 2 V (i.e., µ é um elemento de V)
⌫ 2 | ⌃ | ⌃V (i.e., palavra formada por elementos de V e ⌃)
Gramática Regular (GR) – Exemplo
GR(L):

GR(L):
S ! aA
A ! aA | bB
B ! aB | bB | a
GR(L):
S ! aA
A ! aA | bB
B ! aB | bB | a
Gramática Regular (GR) – Exercícios de Fixação
1 L = palavras sobre {a, b, c} que todo b seja seguido de a
2 L = palavras sobre {a, b} com número par de a
Derivação
Aplicação consecutiva de regras
Deﬁnição de regra (!) 6= Aplicação de regra ())
v )⇤ w w é derivável a partir de v (aplicando 0 ou mais regras)
v )+ w w é derivável a partir de v (aplicando 1 ou mais regras)
v )n w w é derivável a partir de v (aplicando n regras)
Portanto:
Uma palavra w 2 (V [ ⌃)⇤
é uma forma sentencial se S )⇤
w
Uma palavra w 2 ⌃⇤
é uma sentença se S )⇤
w
L(G) = {w 2 ⌃⇤
| S )⇤
w}
Dada a seguinte GR(L):
S ! aA
A ! aA | bB
B ! aB | bB | a
Pergunta-se: ababa 2 L(G)?

S ! aA
A ! aA | bB
B ! aB | bB | a
S ) aA
) abB
) abaB
) ababB
) ababa
É uma sentença válida uma vez que S )⇤ ababa
S ! aA
A ! aA | bB
B ! aB | bB | a
S ) aA
) abB
) abaB
) ababB
) ababa
E abbabb 2 L(G)?
Autômato Finito
Máquina Reconhecedora de LR
Podem ser determinísticos (AFD)
Podem ser não-determinísticos (AFND)
Podem ser não-determinísticos com transições- (AFND- )
Verifica se uma palavra satisfaz condições (i.e., se 2 ou 62 L)
Entrada: palavra qualquer do alfabeto
Saída: sim (palavra válida) ou não (palavra inválida)
Autômato Finito Determinístico (AFD)
Um AFD é uma quíntupla (Q, ⌃, D, q0, F):
Q = conjunto finito de estados
⌃ = alfabeto
D : Q x ⌃ ! Q = função (total) de transições de estados
qo 2 Q = estado inicial
F ✓ Q = conjunto de estados finais (aceitação)
Uma palavra w 2 ⌃⇤ é dita ser aceita por um AFD quando,
partindo do estado inicial, forem lidos todos os símbolos
de w e efetuadas as correspondentes transições de modo
que, ao ler o último símbolo, o AFD para em um estado final
A linguagem aceita por um AFD M (Q, ⌃, D, q0, F) é o
conjunto L(M) = {w 2 ⌃⇤ | ˆ(q0, w) 2 F}, onde ˆ é a função
de transição estendida para M

Exemplo
AFD:
Exemplo
AFD:
q0 q1 q2 q3
a
a
b
b
a
a
b
Exemplo
AFD:
q0 q1 q2 q3
a
a
b
b
a
a
b
Sim, na verdade, é um AFD incompleto, por quê?
Exemplo
AFD:
q0 q1 q2 q3
a
a
b
b
a
a
b
Exercício de Fixação
1 L = palavras sobre {a, b} que contém aaa
2 L = palavras sobre {a, b} com número par de a e ímpar de b

Autômato Finito Não-Determinístico (AFND)
Um AFND é uma quíntupla (Q, ⌃, ND, q0, F):
⌃ = alfabeto
ND : Q x ⌃ ! P(Q) = função (total) de transições de estados
Uma palavra w 2 ⌃⇤ é dita ser aceita por um AFND se, e
somente se, existe uma computação que a consome e
para em um estado ﬁnal
Para todo AFND, existe um AFD equivalente
i.e., não aumenta poder de expressão
Exemplo
AFND:
Exemplo
AFND:
q0 q1 q2 q3
a b
a a,b
a
Exemplo
AFND:
q0 q1 q2 q3
a b
a a,b
a
Sim, na verdade, é um AFND incompleto, por quê?

Exemplo
AFND:
q0 q1 q2 q3
a b
a a,b
a
Sim, na verdade, é um AFND incompleto, por quê?
1 L = palavras sobre {a, b} que contém aa ou bb
2 L = (a [ b)⇤bb
Autômato Finito Não-Determinístico com Transições- (AFND- )
Um AFND- é uma quíntupla (Q, ⌃, ND , q0, F):
⌃ = alfabeto
ND : Q x (⌃ [ { }) ! P(Q) = f. de transições de estados
Para todo AFND- , existe um AFND e um AFD equivalentes
Exemplo
L = palavras sobre {a, b} com tamanho par
AFND- :
Exemplo
L = palavras sobre {a, b} com tamanho par
AFND- :
q0 q1 q3
a,b a,b

Gramática Livre de Contexto (GLC)
Uma GLC é uma quádrupla (V, ⌃, P, S):
Regras: µ ! ⌫
µ 2 V (i.e., um não-terminal)
⌫ 2 (V [ ⌃)⇤
(i.e., palavra formada por elementos de V e ⌃)
Exemplo Clássico
L(G) = {aibi | i > 0}
GLC(L):
Toda LLC é aceita por um Autômato com Pilha (não-determinístico)
Exemplo Clássico
L(G) = {aibi | i > 0}
GLC(L):
S ! aSb | ab

Exemplo Clássico 2
L(G) = {w 2 {a, b}⇤ | w = wR}
GLC(L):
Exemplo Clássico 2
L(G) = {w 2 {a, b}⇤ | w = wR}
GLC(L):
S ! aSa | bSb | a | b |
1 L = {anbman|n > 0, m > 0}
2 L = {anbmcmd2n|n 0, m > 0}
Autômato com Pilha
Máquina Aceitadora de LLC
Podem ser determinísticos (APD)
Aceita todas as LR e um sub-grupo de LLC
Se forem não-determinísticos (APND)
Aceita todas as LLC
i.e., aumenta o poder de expressão

Autômato com Pilha Determinístico (APD)
Um APD é uma sextupla (Q, ⌃, , , q0, F):
⌃ = alfabeto de entrada
= alfabeto da pilha
: Q x (⌃ [ ) x ( [ ) ! P(Q x ( [ ))
= função de transições de estados
Não permite transições (qi, a, b) e (qi, a0, b0) compatíveis:
(a = a0
ou a = ou a0
= ) e (b = b0
ou b = ou b0
6= )
Uma palavra w 2 ⌃⇤ é dita ser aceita por um APD quando
for totalmente consumida e que a máquina termine em um
estado final com pilha vazia (aceitação por parada em estado final e pilha vazia)
Exemplo Clássico
L(G) = {aibi | i > 0}
APD:
Exemplo Clássico
L(G) = {aibi | i > 0}
APD:
q0 q1
a /X
b X/
b X/
Autômato com Pilha Não-Determinístico (APND)
Um APND é uma sextupla (Q, ⌃, , , q0, F):
= alfabeto da pilha
: Q x (⌃ [ ) x ( [ ) ! P(Q x ( [ ))
= função de transições de estados
Permite transições (qi, a, b) e (qi, a0, b0) compatíveis:
(qi, a, b) = {[qj, B], [qk , C]}
Uma palavra w 2 ⌃⇤ é dita ser aceita por um APND se, e
para em um estado final com pilha vazia

Exemplo Clássico 2
L(G) = {w 2 {a, b}⇤ | w = wR}
APND:
Toda LLC é aceita por um APND
Exemplo Clássico 2
L(G) = {w 2 {a, b}⇤ | w = wR}
APND:
q0 q1
a /A
b /B a /
b /
/
a A/
b B/
Toda LLC é aceita por um APND
Gramática Sensível ao Contexto (GSC)
Uma GSC é uma quádrupla (V, ⌃, P, S):
Regras: µ ! ⌫
µ 2 (V [ ⌃)+
⌫ 2 (V [ ⌃)+
|µ|  |⌫| (i.e., regras não-contráteis)
nunca é uma palavra válida em uma LSC

Exemplo Clássico
L = {aibici | i > 0}
GSC(L):
S ! aAbc | abc
A ! aAbC | abC
Cb ! bC
Cc ! cc
Toda LSC é recursiva, logo:
existe uma ALL que aceita LSC
existe uma MT que decide LSC, i.e., sempre para para
qualquer entrada w 2 ⌃⇤
Autômato Linearmente Limitado (ALL)
Um ALL é uma óctupla (Q, ⌃, , , q0, <, >, F):
= alfabeto da fita
: Q ⇥ ! Q ⇥ ⇥ {E, D} = função de transições de estados
< e > = delimitadores da palavra de entrada
Autômato Linearmente Limitado (ALL)
Seja w uma palavra de entrada
Configuração inicial da fita: <w>
Delimitadores podem ser lidos, mas não apagados
Delimitadores não podem ser ultrapassados
Tamanho da fita = |w| + 2
Basicamente, um ALL é uma MT cuja quantidade de fita
disponível é limitada ao tamanho da palavra de entrada
Exemplo Clássico
L = {aibici | i > 0}
q0 q1 q2 q3 q4 q5
q6 q7
</<D a/X D
Y/Y D
b/Y D
Y/Y, D
a/a, D
c/Z D
Z/Z, D
b/b, D
> / > E
c/c D
X/X D
c/c, E
Z/Z, E
b/b, E
Y/Y, E
a/a, E
>/>E
Y/Y, D
Z/Z, D
Z/Z, E
Y/Y, E
X/X, E

Gramática Irrestrita (GI)
Todo o universo de linguagens é gerado por GI
Uma GI é uma quádrupla (V, ⌃, P, S):
Regras: µ ! ⌫
µ 2 (V [ ⌃)+
⌫ 2 (V [ ⌃)⇤
“Quase” nenhuma restrição é imposta (|µ| > 0)
Exemplo Clássico
L = {u[u] | u 2 {a, b}⇤}
GI(L):
S ! aT[a] | bT[b] | []
T[! aT[A | bT[B | [
Aa ! aA
Ab ! bA
Ba ! aB
Bb ! bB
A] ! a]
B] ! b]
Toda GI é recursivamente enumerável, logo:
existe uma MT que reconhece LI, mas não necessariamente
para para qualquer entrada w 2 ⌃⇤
Máquina de Turing (MT)
Um MT é uma séxtupla (Q, ⌃, , , q0, F):
= alfabeto da fita
: Q ⇥ ! Q ⇥ ⇥ {E, D} = função de transições de estados
Memória ilimitada
Seja w uma palavra de entrada
Configuração inicial da fita: BwBBBBBBBB...
A fita é infinita à direita

Exemplo Clássico
L = {u[u] | u 2 {a, b}⇤}
q0 q1
q2 q3
q4q5
q6 q7q8
q9 q10
B/B D
a
/X
D
b/Y
D
[/[ D
[/[ D
a/a D
b/b D
a
/X
E
X/X D
Y/Y D
[/[ E X/X E
Y/Y E
X/X D
Y/Y D
a/a E
b/b E
[/[ D
a/a D
b/b D
b/Y
E
X/X D
Y/Y D]/] D
X/X D
Y/Y D
B/B E
X/a E
Y/b E
[/[E
]/]E
Revisão
Lemas, Teoremas, Corolários, etc.
Revisão – Lemas, Teoremas, Corolários, etc.
Deﬁnições
Deﬁnem objetos e noções que são úteis em um
determinado estudo
Exemplo: Um AP é uma sextupla (Q, ⌃, , , q0, F)...
Lema e Teorema
Lema: É um pré-teorema, i.e., um resultado que leva a um
teorema ou que é usado na prova de um teorema
Teorema: É um resultado mais importante e interessante
Existem exceções, e.g., Pumping Lemma é um teorema
Revisão – Lemas, Teoremas, Corolários, etc.
Corolário
Consequência imediata de um teorema
Proposição
Uma observação que pode ser facilmente comprovada
não associada a um teorema em particular
Axioma (ou postulado)
Proposição que não precisa ser provada
por ser evidente, consensual, etc.
Exemplo: o sucessor de um natural é outro natural

2. Introdução – Conteúdo
1 Revisão 3
Hierarquia de Chomsky 60
Conceitos Básicos 63
2 Introdução 59
Máquina de Moore
Máquinas de Mealy
Recursividade
Ambiguidade
Variantes
Algoritmo de Early
Teoremas
Variantes
Introdução
Introdução – Hierarquia de Chomsky
Noam Chomsky (1927-presente): poeta, ﬁlósofo, linguista,
professor do MIT, e crítico do capitalismo e da política
externa americana
Noam Chomsky (1956) constitui uma classiﬁcação para
linguagens, gramáticas e autômatos
Introdução – Hierarquia de Chomsky
Toda categoria é um subconjunto próprio da categoria superior

Introdução
Conceitos Básicos
Introdução – Conceitos Básicos
Definições
Linguagem: conjunto de palavras sobre um alfabeto
Alfabeto (⌃): conjunto de símbolos de uma linguagem
Palavra (string): sequência de símbolos de um alfabeto
Convenções:
a, b, c, . . . representam elementos de um alfabeto
p, q, u, v, w, x, y, z representam palavras
Definições
⌃⇤ é o conjunto de todas as palavras geradas por ⌃
⇤ (estrela): operador de Kleene
Definição Recursiva Revisão
⌃⇤ é definido recursivamente da seguinte forma:
1 base: 2 ⌃* ( é a palavra vazia)
2 passo recursivo: se w 2 ⌃* e a 2 ⌃ então wa 2 ⌃*
3 fechamento: w 2 ⌃* sse puder ser obtida a partir de com
um número finito de aplicações de (2)
Exemplo
Se ⌃ = {a, b, c}, então ⌃⇤ inclui:
Tamanho zero:
Tamanho um: a b c
Tamanho dois: aa ab ac ba bb bc ca cb cc
etc.

Definições
Tamanho de uma palavra w: número de aplicações do
passo recursivo para se obter w
Linguagem (L): subconjunto do conjunto de todas as
possíveis palavras de um alfabeto (L ✓ ⌃⇤)
Palavras que interessam são as palavras válidas
e.g., se ⌃ = {Maria, fala, alto}, quais são as palavras válidas?
Concatenação
Seja u, v 2 ⌃⇤. A concatenação de u e v, escrita uv, é uma
operação binária em ⌃⇤ definida assim:
base: se tam(v) = 0, então v = e uv = u
passo recursivo: se tam(v) = n, onde n > 0 então:
v = wa, com tam(w) = n 1 e a 2 ⌃
Assim, uv = u(wa) = (uw)a
Concatenação não é comutativa
Prova: (por contra-exemplo)
Se u = ab e v = ca então uv = abca e vu = caab
Concatenação é associativa: (uv)w = u(vw)
Sim? Então prova! Revisão de Indução Matemática
Prova de Associatividade (por indução no comprimento da palavra w)
Teorema: Seja u, v, w 2 ⌃⇤, então (uv)w = u(vw)
Base: se tam(w) = 0, então w =
(uv)w = (uv) = uv e u(vw) = u(v ) = u(v) = uv
Logo, (uv)w = u(vw)
Hipótese: (uv)w = u(vw) 8w, tam(w)  k
Passo indutivo: provar (uv)w = u(vw) 8w, tam(w) = k + 1
Seja w = xa, tam(x) = k, a 2 ⌃
(uv)w = (uv)(xa) =
= ((uv)x)a (definição concatenação)
= (u(vx))a (uso da hipótese de indução)
= u((vx)a) (definição concatenação)
= u(v(xa)) (definição concatenação)
= u(vw)
Subpalavra, Prefixo, Sufixo, Reverso
x é uma subpalavra de y se 9x, v, z | y = zxv
x é dito prefixo de y se z = , ou seja, y = xv
x é dito sufixo de y se v = , ou seja, y = zx
Seja w 2 ⌃⇤. O reverso de w, ou wR, é definido por:
base: se tam(w) = 0, então w = e R
=
passo recursivo: se tam(w) = n, onde n 1 então:
w = ua, com tam(u) = n 1 e a 2 ⌃
Assim, wR
= (ua)R
= a(u)R
= auR

Prova de Reverso (por indução no comprimento da palavra v)
Teorema: seja u, v 2 ⌃⇤, então (uv)R = vRuR
Base: se tam(v) = 0, então v =
(uv)R
= (u )R
= uR
e vR
uR
= R
uR
= uR
Hipótese: (uv)R = vRuR 8w, tam(w)  k
Passo indutivo: provar (uv)R = vRuR 8v, tam(v) = k + 1
Seja v = wa, tam(w) = k, a 2 ⌃
(uv)R
= (u(wa))R
=
= ((uw)a)R
(associatividade concatenação)
= a(uw)R
(definição de reverso)
= a(wR
uR
) (uso da hipótese de indução)
= (awR
)uR
(associatividade)
= (wa)R
uR
(definição de reverso)
= vR
uR
Concatenação de Linguagens
Uma linguagem L é um subconjunto de ⌃* (L ✓ ⌃*)
Concatenação das linguagens X e Y, denotada XY, é a
linguagem: XY = {xy | x 2 X e y 2 Y}
Exemplo: X = {a, b, c} e Y = {abb, ba}
XY = {aabb, aba, babb, bba, cabb, cba}
Xn: concatenação de X com X mesmo n vezes
X0
= { }
X1
= {a, b, c}
X2
= {aa, ab, ac, ba, bb, bc, ca, cb, cc}
X⇤: todas as palavras construídas a partir de X
X⇤ (definição formal)
X⇤
=
1[
i=0
Xi
X+ (definição formal)
X+
=
1[
i=1
Xi
3. Linguagens Regulares – Conteúdo
1 Revisão 3
2 Introdução 59
Conjuntos Regulares 76
Expressões Regulares 80
Gramáticas Regulares 85
Autômatos Finitos 92
Autômatos com Saída 116
Máquina de Moore
Máquinas de Mealy
Algoritmos 134
Propriedades 156
Lema do Bombeamento 163
Recursividade
Ambiguidade
Variantes
Algoritmo de Early
Teoremas
Variantes

Linguagens Regulares – Hierarquia de Chomsky
Linguagens Regulares
Conjuntos Regulares
Linguagens Regulares – Conjuntos Regulares
Especificação Finita de Linguagens
Requer uma descrição não ambígua das palavras
Exemplo #1 (⌃ = {a, b})
Palavras com pelo menos uma ocorrência de bb:
L = {a, b}⇤
{bb}{a, b}⇤
Palavras que possuem prefixo aa ou sufixo bb
L = {aa}{a, b}⇤
[ {a, b}⇤
{bb}
Exemplo #2 (⌃ = {b})
L1 = {bb} e L2 = { , bb, bbbb}
Palavras com número par de b: L1
⇤
e L2
⇤
L1
⇤
= { , bb, bbbb, bbbbbb, ...}
L2
⇤
= { , bb, bbbb, bbbbbb, ...}
Conjuntos Regulares
Uma linguagem regular é aquela que pode ser definida por
um conjunto regular
Um conjunto é regular se pode ser gerado a partir de ⌃
usando operador de Kleene, união e concatenação

Um conjunto regular é definido recursivamente da seguinte
forma:
1 base: ;, { } e {a}8a 2 ⌃ são conjuntos regulares
2 passo recursivo: se X e Y são conjuntos regulares, então
X [ Y, XY e X⇤
também são conjuntos regulares
Exemplo
Palavras sobre {a, b} que começam e terminam com a e
contêm pelo menos um b
{a}{a, b}⇤
{b}{a, b}⇤
{a}
Expressões Regulares
Linguagens Regulares – Expressões Regulares
Expressões Regulares
Abreviação para conjuntos regulares
PS: x+
denota xx⇤
Uma expressão regular é definido recursivamente da
seguinte forma:
1 base: ;, e a(8a 2 ⌃), são expressões regulares
2 passo recursivo: se u e v são expressões regulares, então
u [ v, uv e u⇤
são expressões regulares
Exemplos
{a}{a, b}⇤{b}{a, b}⇤{a} = a(a [ b)⇤b(a [ b)⇤a
{a, b}⇤{bb}{a, b}⇤ = (a [ b)⇤bb(a [ b)⇤
Exercícios
1 Considerando ⌃ = {a, b}, crie expressões regulares para as
seguintes linguagens:
L1 = {bawab | w 2 {a, b}⇤
}
L2 = palavras contendo aa ou bb
L3 = palavras contendo aa e bb
L4 = palavras com número par de b
L5 = palavras que não contém aa
2 Considerando ⌃ = {a, b, c} e L = c⇤(b [ (ac⇤))⇤, verifique se
as seguintes palavras estão em L:
acabacc
bbaaacc

Identidades
1 ;w = w; = ;
2 w = w = w
3 ;⇤ =
4 ⇤ =
5 w [ u = u [ w
6 w [ ; = w
7 w [ w = w
8 w⇤w⇤ = w⇤
9 (w⇤)⇤ = w⇤
10 w⇤w = ww⇤ = w+
11 w(x [ y) = wx [ wy
12 (x [ y)w = xw [ yw
13 (wy)⇤w = w(yw)⇤
14 (w [ y)⇤ = (w⇤ [ y)⇤
= w⇤(w [ y)⇤
= (w [ yw⇤)⇤
= (w⇤y⇤)⇤
= w⇤(yw⇤)⇤
= (w⇤y)⇤w⇤
Exercícios
Mostre que:
b⇤
(ab+
)⇤
[ b⇤
(ab+
)⇤
a = (b [ ab)⇤
( [ a)
a⇤
(a⇤
ba⇤
ba⇤
)⇤
= a⇤
(ba⇤
ba⇤
)⇤
PS
ERs em Compiladores normalmente adotam | ao invés de [
i.e., a | b , a [ b
PS2
Existem linguagens que não podem deﬁnidas por
expressões regulares
Por exemplo, {an
bn
| n 0}
E aí, o que isso signiﬁca?
Gramáticas Regulares
Linguagens Regulares – Gramáticas Regulares
Gramática Regular (GR)
Uma GR é uma quádrupla (V, ⌃, P, S):
Regras: µ ! ⌫
µ 2 V (i.e., µ é um elemento de V)
⌫ 2 | ⌃ | ⌃V (i.e., palavra formada por elementos de V e ⌃)

GR(L):
GR(L):
S ! aA
A ! aA | bB
B ! aB | bB | a
GR(L):
S ! aA
A ! aA | bB
B ! aB | bB | a
Propriedade interessante de gramáticas regulares:
Uma forma sentencial possui no máximo uma variável
sempre o símbolo mais à direita
Toda aplicação de regra adiciona um terminal na palavra
que está sendo derivada
exceto regra da forma A !
Gramática Regular (GR) – Exercícios de Fixação
1 L = a+b⇤
2 L = { } [ {ab}{ab}⇤{a}⇤
3 L = palavras sobre {a, b, c} que todo b seja seguido de a

Derivação
Aplicação consecutiva de regras
Deﬁnição de regra (!) 6= Aplicação de regra ())
v )⇤ w w é derivável a partir de v (aplicando 0 ou mais regras)
v )+ w w é derivável a partir de v (aplicando 1 ou mais regras)
v )n w w é derivável a partir de v (aplicando n regras)
Portanto:
Uma palavra w 2 (V [ ⌃)⇤
é uma forma sentencial se S )⇤
w
Uma palavra w 2 ⌃⇤
é uma sentença se S )⇤
w
L(G) = {w 2 ⌃⇤
| S )⇤
w}
S ! aA
A ! aA | bB
B ! aB | bB | a
S ! aA
A ! aA | bB
B ! aB | bB | a
S ) aA
) abB
) abaB
) ababB
) ababa
S ! aA
A ! aA | bB
B ! aB | bB | a
S ) aA
) abB
) abaB
) ababB
) ababa
E abbabb 2 L(G)?

Enﬁm
Uma linguagem é regular se pode ser gerada por alguma
gramática regular (ou CR ou ER)
Autômatos Finitos
Linguagens Regulares – Autômatos Finitos
Autômato Finito
Máquina Reconhecedora de LR
Podem ser determinísticos (AFD)
Podem ser não-determinísticos (AFND)
Podem ser não-determinísticos com transições- (AFND- )
Veriﬁca se uma palavra satisfaz condições (i.e., se 2 ou 62 L)
Entrada: palavra qualquer do alfabeto
Saída: sim (palavra válida) ou não (palavra inválida)
Linguagem L é regular sse existe um AF que reconhece L
Autômatos Finitos

Linguagens Regulares – Autômatos Finitos – AFD
Autômato Finito Determinístico (AFD)
Um AFD é uma quíntupla (Q, ⌃, D, q0, F):
⌃ = alfabeto
Uma palavra w 2 ⌃⇤ é dita ser aceita por um AFD quando,
partindo do estado inicial, forem lidos todos os símbolos
de w e efetuadas as correspondentes transições de modo
que, ao ler o último símbolo, o AFD para em um estado ﬁnal
A linguagem aceita por um AFD M (Q, ⌃, D, q0, F) é o
conjunto L(M) = {w 2 ⌃⇤ | ˆD(q0, w) 2 F}, onde ˆD é a função
de transição estendida para M
Exemplo
AFD:
Exemplo
AFD:
q0 q1 q2 q3
a
a
b
b
a
a
b
D a b
q0 q1
q1 q1 q2
q2 q3 q2
q3 q3 q2
Exemplo
AFD:
q0 q1 q2 q3
a
a
b
b
a
a
b
D a b
q0 q1
q1 q1 q2
q2 q3 q2
q3 q3 q2

Exercícios de Fixação
1 L = palavras sobre {a, b} que contém aa ou bb
2 L = palavras sobre {a, b} que contém aaa
3 L = palavras sobre {a, b} com número par de a e ímpar de b
Função de Transição ( D)
D : Q x ⌃ ! Q
se total, então
em todos os estados (Q), existe transições para todos os
símbolos (⌃)
AFD é completo
AFD nunca trava
se parcial, então
em algum estado (Q), pode não existir transição para algum
símbolo (⌃)
AFD é incompleto
AFD pode travar
Como transformar uma função parcial em uma total?
1 Criar um estado não final qerro
2 8x 2 ⌃ =) (qerro, x) ! qerro
qerro tem um loop com todos os símbolos do alfabeto
3 (qi, x) # =) (qi, x) ! qerro
toda transição indefinida agora vai para qerro
q0 q1 q2 q3
a b
a b
a
Como transformar uma função parcial em uma total?
1 Criar um estado não final qerro
2 8x 2 ⌃ =) (qerro, x) ! qerro
qerro tem um loop com todos os símbolos do alfabeto
3 (qi, x) # =) (qi, x) ! qerro
toda transição indefinida agora vai para qerro
q0 q1 q2 q3
qerro
a
b
b
a b
a
a,b

Aceitação / Rejeição
Um AF aceita a entrada quando
após processar o último símbolo, assume um estado final (F)
Um AF rejeita a entrada quando
após processar o último símbolo, assume um estado não final
trava durante seu processamento
Função de Transição Estendida (ˆD)
É uma extensão da função de transição original que a partir
de um estado de origem (Q) e uma palavra (⌃⇤), retorna o
estado final do processamento (Q)
ˆD : Q x ⌃⇤ ! Q
ACEITA(M) = {w 2 ⌃⇤ | ˆD(q0, w) 2 F} = L(M)
REJEITA(M) = {w 2 ⌃⇤ | ˆD(q0, w) 62 F}
Pergunta-se: o que ocorre se D não for total?
Outros Exercícios
1 L = ⌃⇤
2 L = ;
Pergunta-se
Qual a principal diferença?
Logo, como modificar um AFD M que reconhece L para
reconhecer L?
Questões importantes
1 Pode um AF entrar em loop?
2 Dado dois AFs M1 e M2, pergunta-se:
Quando os dois AFs são equivalentes?
ACEITA(M) REJEITA(M) =
ACEITA(M) [ REJEITA(M) =
⇠ACEITA(M) =
⇠REJEITA(M) =

Questões importantes
1 Pode um AF entrar em loop?
2 Dado dois AFs M1 e M2, pergunta-se:
Quando os dois AFs são equivalentes? L(M1) = L(M2)
ACEITA(M) REJEITA(M) = ;
ACEITA(M) [ REJEITA(M) = ⌃⇤
= U
⇠ACEITA(M) = REJEITA(M)
⇠REJEITA(M) = ACEITA(M) = L(M)
Autômatos Finitos
Linguagens Regulares – Autômatos Finitos – AFND
Composição
A construção de sistemas é composicional, geralmente
É importante diferenciar três formas de composição:
Sequencial: A execução do próximo componente depende
do término do anterior
Concorrente: A execução dos componentes é irrelevante,
i.e., são componentes independentes
Não-determinista: A execução do próximo componente é
uma escolha entre diversos componentes alternativos
Exemplo: sistema bancário (atendimento em caixas)
Autômato Finito Não-Determinístico (AFND)
Um AFND é uma quíntupla (Q, ⌃, ND, q0, F):
⌃ = alfabeto
ND : Q x ⌃ ! P(Q) = função (total) de transições de estados
Uma palavra w 2 ⌃⇤ é dita ser aceita por um AFND se, e
para em um estado ﬁnal
Para todo AFND, existe um AFD equivalente

Exemplo
AFND:
Exemplo
AFND:
q0 q1 q2 q3
a b
a a,b
a
ND a b
q0 {q1} ;
q1 {q1} {q2}
q2 {q2, q3} {q2}
q3 ; ;
Exemplo
AFND:
q0 q1 q2 q3
a b
a a,b
a
Qual seria a árvore de computações para a palavra abaaa?
ND a b
q0 {q1} ;
q1 {q1} {q2}
q2 {q2, q3} {q2}
q3 ; ;
1 L1 = palavras sobre {a, b} que contém aa ou bb
2 L2 = (a [ b)⇤bb
3 L3 = palavras sobre {a, b} que terminam com aaa

Aceitação / Rejeição
Um AF aceita a entrada quando
após processar o último símbolo, em alguma das possíveis
computações, assume um estado final (F)
Um AF rejeita a entrada quando
(1) após processar o último símbolo, em todas as possíveis
computações, assume um estado não final
(2) trava durante seu processamento, em todas as possíveis
computações
(3) qualquer combinação de (1) ou (2)
e.g., das 10 possíveis computações, 7 assumem estado
não final e 3 travam
Função de Transição Estendida (ˆND)
É uma extensão da função de transição original que a partir
de um estado de origem (Q) e uma palavra (⌃⇤), retorna
todos os possível estados finais do processamento (P(Q))
ˆND : Q x ⌃⇤ ! P(Q)
ACEITA(M) = {w 2 ⌃⇤ | ˆND(q0, w) F 6= ;} = L(M)
REJEITA(M) = {w 2 ⌃⇤ | ˆND(q0, w) F = ;}
Pontos Importantes
Muitas vezes, é muito mais fácil desenvolver um AFND do
que um AFD
Por exemplo:
L = palavras sobre {a, b} cujo quinto último símbolo é a
Solução AFD: trabalhosa, 32 estados
Solução AFND: simples, 6 estados
Um estratégia bem conhecida:
Construir o AFND
Aplicar o algoritmo AFND ! AFD Algoritmo AFND ! AFD
Autômatos Finitos

Linguagens Regulares – Autômatos Finitos – AFND-
Autômato Finito Não-Determinístico com Transições- (AFND- )
Um AFND- é uma quíntupla (Q, ⌃, ND , q0, F):
⌃ = alfabeto
ND : Q x (⌃ [ { }) ! P(Q) = f. de transições de estados
Para todo AFND- , existe um AFND e um AFD equivalentes
É muito similar ao AFND
Tem como vantagem facilitar construções e demonstrações
Por exemplo, o algoritmo ER ! AFND- Algoritmo ER ! AFND-
Exemplo
L = {0k | k é múltiplo de 2 ou 3}
AFND- :
Exemplo
L = {0k | k é múltiplo de 2 ou 3}
AFND- :
q0
q1 q2
q3
q5
q4
0
0
0
00
ND 0
q0 ; {q1, q3}
q1 {q2} ;
q2 {q1} ;
q3 {q4} ;
q4 {q5} ;
q5 {q3} ;
1 L = (a [ b)⇤bb ou aa(a [ b)⇤
2 L = palavras sobre {a, b, c} que terminam com a ou bb ou
ccc

Autômatos com Saída
Máquina de Moore
Linguagens Regulares – Autômatos com Saída – Moore
Máquina de Moore
Uma máquina de Moore é uma sêxtupla (Q, ⌃, , D, , q0):
= alfabeto da saída
: Q ! = função (total) de saída
Uma máquina de Moore é um AFD com um símbolo de
saída associado a cada estado
Funcionamento da Máquina de Moore
Funcionamento semelhante aos AFDs
Ao invés de uma saída binária (aceita/rejeita), é uma
palavra
Na prática, é uma máquina de estados ﬁnitos transdutora
O primeiro símbolo da palavra de saída é sempre (q0)
Logo, o tamanho da saída é igual a w + 1
Sempre que se atingir um estado Q/Y, concatena-se o
simbolo Y = (Q) à direita da palavra de saída
No exemplo abaixo, ao se atingir o estado q3, concatena-se
“2” à direita da palavra de saída, i.e., (q3) = 2
q3/2

Exemplo #1
Máquina de Moore que determina o número de a
presentes nos dois últimos símbolos da palavra de entrada
bb/0 aa/2
ab/1
ba/1
b
a a
ba
b
a
b
O último símbolo da palavra de saída indica o resultado
Função de Saída Estendida (r)
Dados um estado (Q) e uma palavra de entrada (⌃⇤),
retorna a palavra de saída da máquina de Moore:
r : Q ⇥ ⌃⇤
! +
Formalização:
r(Q, ) = (Q)
r(Q, ay) = (Q) r( D(Q, a), y), 8a 2 ⌃ e y 2 ⌃⇤
Saída Computada:
A saída de uma máquina de Moore M = (Q, ⌃, , D, , q0)
para a palavra w 2 ⌃⇤
é r(q0, w)
Assim, retome o Exemplo #1 e compute r(bb, aaab)
Simulação de AFDs com Máquinas de Moore
Qualquer AFD M pode ser simulado utilizando-se uma
máquina de Moore
Uma possibilidade é fazer:
= {0, 1}
(Q) =
⇢
1, se Q 2 F
0, se Q 62 F
Logo, w 2 L(M) sse r(q0, w) termina em 1
Exemplo #2
Máquina de Moore que simula um AFD que reconhece as
palavras que terminam com aa
bb/0 aa/1
ab/0
ba/0
b
a a
ba
b
a
b

Linguagens Regulares – Autômatos com Saída – Exercícios
Exercício
1 Projetar uma AFD que cuja soma dos símbolos da palavra
seja divisível por 4, considerando ⌃ = {0, 1, 2, 3}
Dica1: A máquina deve aceitar “13”, “1111”, “202”, . . .
Dica2: Um estado para cada resto (e.g., 0%4, 1%4, . . . )
2 Projetar uma Máquina de Moore cujo último símbolo da
palavra de saída represente o resto da divisão por 4,
considerando ⌃ = {0, 1, 2, 3}
Dica: Pequena alteração em (1)
Máquinas de Mealy
Linguagens Regulares – Autômatos com Saída – Mealy
Máquina de Mealy
Uma máquina de Mealy é uma sêxtupla (Q, ⌃, , D, , q0):
= alfabeto da saída
: Q ⇥ ⌃ ! = função (total) de saída
Uma máquina de Mealy é um AFD com um símbolo de
saída associado a cada transição
Funcionamento da Máquina de Mealy
Funcionamento semelhante aos AFDs
Ao invés de uma saída binária (aceita ou rejeita), é uma
palavra
Na prática, é uma máquina de estados ﬁnitos transdutora
O tamanho da saída é igual ao tamanho da palavra
Sempre que, a partir de um estado Q, é efetuada uma
transição a/d , concatena-se o símbolo d = (Q, a) à
direita da palavra de saída
No exemplo abaixo, a partir do estado q2, ao se efetuar a
transição a/1, concatena-se “1” à direita da palavra de
saída, i.e., (q2, a) = 1
q2 q3
a/1

Exemplo #3
Máquina de Mealy que determina o quociente da divisão
de um número binário por 6
q0
q1
q2
q3
q4q5
0/0
1/0
1/0
0/0
1/0
0/0
1/1
0/1
1/10/1
1/1
0/1
Exemplo #4
Modiﬁcação 2 em 1
Mealy: quociente da divisão por 6 (transições)
Moore: resto da divisão por 6 (estados)
q0/0
q1/1
q2/2
q3/3
q4/4q5/5
0/0 1/0
1/0
0/0
1/0
0/0
1/1
0/1
1/10/1
1/1
0/1
Função de Saída Estendida (s)
Dados um estado (Q) e uma palavra de entrada (⌃⇤),
retorna a palavra de saída da máquina de Mealy:
s : Q ⇥ ⌃⇤
! ⇤
Formalização:
s(Q, ) =
s(Q, ay) = (Q, a) s( D(Q, a), y), 8a 2 ⌃ e y 2 ⌃⇤
Saída Computada:
A saída de uma máquina de Mealy M = (Q, ⌃, , D, , q0)
para a palavra w 2 ⌃⇤
é s(q0, w)
Assim, retome o Exemplo #3 e compute s(q0, 1000) e
s(q0, 1100)
Linguagens Regulares – Autômatos com Saída – Exercícios
Exercício
1 Projetar uma Máquina de Mealy que troque a por b e
vice-versa, considerando ⌃ = {a, b}
Dica: Não complique o que é simples

Existem algoritmos de transformação de uma Máquina de
Moore para uma Máquina de Mealy e vice-versa, com
certas ressalvas
No entanto, não serão abordados na disciplina
Os algoritmos podem ser encontrados em Vieira [8]
Algoritmos
Algoritmos

Linguagens Regulares – Algoritmos – AFND- para AFD
Transformação de um AFND- para AFD
1 AFND- ! AFND
i.e., ND ! ND
Importante: AFND pode ter mais de um estado inicial
2 AFND ! AFD
i.e., ND ! D
Importante: Dado um AFND com n estados, o AFD
correspondente pode ter até 2n
estados (e.g., 5 ! 32)
Por isso, abordaremos um algoritmo de construção de estados
sob demanda (para evitar estados inúteis)
Caso não haja transições , pular passo (1)
AFND-
q0 q1
q2
a
a
a
b
c
AFND-
q0 q1
q2
a
a
a
b
c
ND a b c fecho( )
q0 {q0, q1, q2} ; ; ; {q0}
q1 ; {q1} ; ; {q1}
q2 ; ; {q2} {q1} {q2, q1}
*fecho (qi ) = qi + estados acessíveis a partir de qi lendo
AFND-
q0 q1
q2
a
a
a
b
c
ND a b c fecho( )
q0 {q0, q1, q2} ; ; ; {q0}
q1 ; {q1} ; ; {q1}
q2 ; ; {q2} {q1} {q2, q1}
1 ND ! ND
i. São estados iniciais: fecho (q0)
Se um estado inicial alcança um
estado ﬁnal, tal inicial será ﬁnal
ND a b c

AFND-
q0 q1
q2
a
a
a
b
c
ND a b c fecho( )
q0 {q0, q1, q2} ; ; ; {q0}
q1 ; {q1} ; ; {q1}
q2 ; ; {q2} {q1} {q2, q1}
1 ND ! ND
ND a b c
q0 {q0, q1, q2} ; ;
q1 ; {q1} ;
q2 ;
AFND-
q0 q1
q2
a
a
a
b
c
ND a b c fecho( )
q0 {q0, q1, q2} ; ; ; {q0}
q1 ; {q1} ; ; {q1}
q2 ; ; {q2} {q1} {q2, q1}
1 ND ! ND
ii. Para os outros estados qi :
ND a b c
q0 {q0, q1, q2} ; ;
q1 ; {q1} ;
q2 ;
AFND-
q0 q1
q2
a
a
a
b
c
ND a b c fecho( )
q0 {q0, q1, q2} ; ; ; {q0}
q1 ; {q1} ; ; {q1}
q2 ; ; {q2} {q1} {q2, q1}
1 ND ! ND
considera todo estado em fecho (qi )
ND a b c
q0 {q0, q1, q2} ; ;
q1 ; {q1} ;
q2 ; {q1}
AFND-
q0 q1
q2
a
a
a
b
c
ND a b c fecho( )
q0 {q0, q1, q2} ; ; ; {q0}
q1 ; {q1} ; ; {q1}
q2 ; ; {q2} {q1} {q2, q1}
1 ND ! ND
considera todo estado em fecho (qi )
consome, para em um estado qj e então
adiciona fecho (qj )
ND a b c
q0 {q0, q1, q2} ; ;
q1 ; {q1} ;
q2 ; {q1} {q1, q2}

AFND (agora)
ND a b c
q0 {q0, q1, q2} ; ;
q1 ; {q1} ;
q2 ; {q1} {q1, q2}
AFND (agora)
q0 q1
q2
a
a
a
b
b,c
c
ND a b c
q0 {q0, q1, q2} ; ;
q1 ; {q1} ;
q2 ; {q1} {q1, q2}
AFND (agora)
q0 q1
q2
a
a
a
b
b,c
c
ND a b c
q0 {q0, q1, q2} ; ;
q1 ; {q1} ;
q2 ; {q1} {q1, q2}
2 ND ! D (construção de subconjuntos sob demanda)
i. É inicial: a união de todos
os estados iniciais: {q0} D a b c
q0 = hq0i hq0, q1, q2i
AFND (agora)
q0 q1
q2
a
a
a
b
b,c
c
ND a b c
q0 {q0, q1, q2} ; ;
q1 ; {q1} ;
q2 ; {q1} {q1, q2}
os estados iniciais: {q0}
ii. Cada novo Q obtém a
união das transições dos
seus estados integrantes
D a b c
hq0, q1, q2i hq0, q1, q2i hq1i hq1, q2i
hq1i hq1i
hq1, q2i hq1i hq1, q2i

AFND (agora)
q0 q1
q2
a
a
a
b
b,c
c
ND a b c
q0 {q0, q1, q2} ; ;
q1 ; {q1} ;
q2 ; {q1} {q1, q2}
os estados iniciais: {q0}
ii. Cada novo Q obtém a
união das transições dos
seus estados integrantes
iii. São finais: os estados que
contém pelo menos um
estado final
D a b c
F 3 hq0, q1, q2i hq0, q1, q2i hq1i hq1, q2i
F 3 hq1i hq1i
F 3 hq1, q2i hq1i hq1, q2i
AFD (enfim)
hq0i hq0, q1, q2i hq1, q2i
hq1i
a
b
c
a
b
c
b
D a b c
hq0i hq0, q1, q2i
hq0, q1, q2i hq0, q1, q2i hq1i hq1, q2i
hq1i hq1i
hq1, q2i hq1i hq1, q2i
Exercício de Fixação #1
q0
q1 q2
q3
a
b
a
q0 q1 q2 q3
0,1
1 0,1 0,1

q0 q1 q2
q3 q4
a b
a
a,b
Algoritmos
Linguagens Regulares – Algoritmos – Minimização de AFD
Minimização de um AFD
1 Todos os estados são equivalentes
2 Se um é estado ﬁnal e o outro não, logo não são
equivalentes
3 Conferir, estado por estado, se são "equivalentes"
Procedimento a ser detalhado
Toy Example (propósito ilustrativo apenas)
q0
q1
q2
q3
q4
q5
a
b
c
a
b
c
a
b
c
a,b
c
a,b,c
a,b,c
Algoritmo
Entrada: AFD M = (Q, ⌃, , q0, F)
1 Para todos os pares de estados qi e qj , i < j, faça:
1.1 D[i, j] = 0
1.2 S[i, j] = ;
2 Para cada par [i, j], i < j, se um é estado ﬁnal e o outro não, faça D[i, j] = 1
3 Para cada par [i, j], i < j e D[i, j] = 0, faça:
3.1 se existe um a 2 ⌃ tal que (qi , a) = qm e (qj , a) = qn e
(D[m, n] = 1 ou D[n, m] = 1) então:
DIST(i, j) //altera D[i, j] = 1 e propaga a distinção aos elementos de S[i, j]
3.2 para cada a 2 ⌃ tal que (qi , a) = qm e (qj , a) = qn
se m < n e [i, j] 6= [m, n], então adicione [i, j] à S[m, n]
se m > n e [i, j] 6= [n, m], então adicione [i, j] à S[n, m]
4 Para cada D[i, j] = 0, os estados i e j podem ser fundidos

Exemplo
q0 q1 q2 q3
q4 q5 q6
b
a
b
a
b
a
a,b
a,b a,b a,b
q0 q1 q2 q3
q4 q5 q6
b
a
b
a
b
a
a,b
a,b a,b a,b
1 Para todos os pares de estados qi e qj , i < j, faça:
1.1 D[i, j] = 0 (aqui, 0=X, 1=x)
1.2 S[i, j] = ;
Índice D[i, j] = S[i, j] = Motivo
[0, 1] X ;
[0, 2] X ;
[0, 3] X ;
[0, 4] X ;
[0, 5] X ;
[0, 6] X ;
[1, 2] X ;
[1, 3] X ;
[1, 4] X ;
[1, 5] X ;
[1, 6] X ;
[2, 3] X ;
[2, 4] X ;
[2, 5] X ;
[2, 6] X ;
[3, 4] X ;
[3, 5] X ;
[3, 6] X ;
[4, 5] X ;
[4, 6] X ;
[5, 6] X ;
q0 q1 q2 q3
q4 q5 q6
b
a
b
a
b
a
a,b
a,b a,b a,b
2 Para cada par [i, j], i < j, se um é estado ﬁnal e o outro não, faça D[i, j] = 1 (aqui, x)
[0, 1] X ;
[0, 2] X ;
[0, 3] X ;
[0, 4] x ;
[0, 5] x ;
[0, 6] x ;
[1, 2] X ;
[1, 3] X ;
[1, 4] x ;
[1, 5] x ;
[1, 6] x ;
[2, 3] X ;
[2, 4] x ;
[2, 5] x ;
[2, 6] x ;
[3, 4] x ;
[3, 5] x ;
[3, 6] x ;
[4, 5] X ;
[4, 6] X ;
[5, 6] X ;
q0 q1 q2 q3
q4 q5 q6
b
a
b
a
b
a
a,b
a,b a,b a,b
(D[m, n] = 1 ou D[n, m] = 1) então:
[0, 1] X { }
[0, 2] X { }
[0, 3] X { }
[1, 2] X { }
[1, 3] X { }
[2, 3] X { }
[4, 5] X { }
[4, 6] X { }
[5, 6] X { }

q0 q1 q2 q3
q4 q5 q6
b
a
b
a
b
a
a,b
a,b a,b a,b
(D[m, n] = 1 ou D[n, m] = 1) então:
⌅ [0, 1] X { }
[0, 2] X { }
[0, 3] X { }
[1, 2] X { [0, 1] }
[1, 3] X { }
[2, 3] X { }
[4, 5] X { [0, 1] }
[4, 6] X { }
[5, 6] X { }
q0 q1 q2 q3
q4 q5 q6
b
a
b
a
b
a
a,b
a,b a,b a,b
(D[m, n] = 1 ou D[n, m] = 1) então:
[0, 1] X { }
⌅ [0, 2] X { }
[0, 3] X { }
[1, 2] X { [0, 1] }
[1, 3] X { [0, 2] }
[2, 3] X { }
[4, 5] X { [0, 1] }
[4, 6] X { [0, 2] }
[5, 6] X { }
q0 q1 q2 q3
q4 q5 q6
b
a
b
a
b
a
a,b
a,b a,b a,b
(D[m, n] = 1 ou D[n, m] = 1) então:
[0, 1] X { }
[0, 2] X { }
⌅ [0, 3] X ! x { } a
[1, 2] X { [0, 1] }
[1, 3] X { [0, 2] }
[2, 3] X { }
[4, 5] X { [0, 1] }
[4, 6] X { [0, 2] }
[5, 6] X { }
q0 q1 q2 q3
q4 q5 q6
b
a
b
a
b
a
a,b
a,b a,b a,b
(D[m, n] = 1 ou D[n, m] = 1) então:
[0, 1] X { }
[0, 2] X { }
[0, 3] X ! x { } a
⌅ [1, 2] X { [0, 1] }
[1, 3] X { [0, 2] }
[2, 3] X { [1, 2] }
[4, 5] X { [0, 1] }
[4, 6] X { [0, 2] }
[5, 6] X { [1, 2] }

q0 q1 q2 q3
q4 q5 q6
b
a
b
a
b
a
a,b
a,b a,b a,b
(D[m, n] = 1 ou D[n, m] = 1) então:
[0, 1] X { }
[0, 2] X ! x { } [1, 3]
[0, 3] X ! x { } a
[1, 2] X { [0, 1] }
⌅ [1, 3] X ! x { [0, 2] } a
[2, 3] X { [1, 2] }
[4, 5] X { [0, 1] }
[4, 6] X { [0, 2] }
[5, 6] X { [1, 2] }
q0 q1 q2 q3
q4 q5 q6
b
a
b
a
b
a
a,b
a,b a,b a,b
(D[m, n] = 1 ou D[n, m] = 1) então:
[0, 1] X ! x { } [1, 2]
[0, 2] X ! x { } [1, 3]
[0, 3] X ! x { } a
[1, 2] X ! x { [0, 1] } [2, 3]
[1, 3] X ! x { [0, 2] } a
⌅ [2, 3] X ! x { [1, 2] } a
[4, 5] X { [0, 1] }
[4, 6] X { [0, 2] }
[5, 6] X { [1, 2] }
q0 q1 q2 q3
q4 q5 q6
b
a
b
a
b
a
a,b
a,b a,b a,b
(D[m, n] = 1 ou D[n, m] = 1) então:
[0, 1] X ! x { } [1, 2]
[0, 2] X ! x { } [1, 3]
[0, 3] X ! x { } a
[1, 2] X ! x { [0, 1] } [2, 3]
[1, 3] X ! x { [0, 2] } a
[2, 3] X ! x { [1, 2] } a
⌅ [4, 5] X { [0, 1] }
[4, 6] X { [0, 2] }
[5, 6] X { [1, 2] }
q0 q1 q2 q3
q4 q5 q6
b
a
b
a
b
a
a,b
a,b a,b a,b
(D[m, n] = 1 ou D[n, m] = 1) então:
[0, 1] X ! x { } [1, 2]
[0, 2] X ! x { } [1, 3]
[0, 3] X ! x { } a
[1, 2] X ! x { [0, 1] } [2, 3]
[1, 3] X ! x { [0, 2] } a
[2, 3] X ! x { [1, 2] } a
[4, 5] X { [0, 1] }
⌅ [4, 6] X { [0, 2] }
[5, 6] X { [1, 2] }

q0 q1 q2 q3
q4 q5 q6
b
a
b
a
b
a
a,b
a,b a,b a,b
(D[m, n] = 1 ou D[n, m] = 1) então:
[0, 1] X ! x { } [1, 2]
[0, 2] X ! x { } [1, 3]
[0, 3] X ! x { } a
[1, 2] X ! x { [0, 1] } [2, 3]
[1, 3] X ! x { [0, 2] } a
[2, 3] X ! x { [1, 2] } a
[4, 5] X { [0, 1] }
[4, 6] X { [0, 2] }
⌅ [5, 6] X { [1, 2] }
q0 q1 q2 q3
q4 q5 q6
b
a
b
a
b
a
a,b
a,b a,b a,b
4 Para cada D[i, j] = 0, os estados i e j podem ser fundidos
q0 q1 q2 q3
{q4, q5, q6}
b
a
b
a
b
a
a,b
a,b
Logo, um mesmo estado para q4, q5 e q6, já que D[4, 5] = 0, D[4, 6] = 0 e
D[5, 6] = 0
q0
q1
q2
q3
q4
q5
q6
q7
a
b
a
b
a,b
b
a
a
b
a,b
b
a a,b
Algoritmos

Linguagens Regulares – Algoritmos – ER para AFND-
Algoritmo de Thompson
a b
a b
ab
a b
a [ b (ou a | b)
a
b
a⇤
a
Exemplo: ((a [ b)c⇤)⇤
q2 q3
a
q2 q3
q4 q5
a
b

q1
q2 q3
q4 q5
q6
a
b
q1
q2 q3
q4 q5
q6 q7 q8
a
b
c
q1
q2 q3
q4 q5
q6q0
6
q7 q8 q9
a
b
c
q1
q2 q3
q4 q5
q6 q7 q8 q9
a
b
c

q0 q1
q2 q3
q4 q5
q6 q7 q8 q9 q10
a
b
c
Exercícios de Fixação
1 (a [ b [ c)⇤
2 (a [ b)⇤abb
3 (( [ a)b⇤)⇤
4 (a [ b)⇤abb(a [ b)⇤
5 letra (letra [ digito)⇤
Propriedades
Linguagens Regulares – Propriedades
Como provar que uma linguagem é regular?
1 Através de uma GR (formalismo gerador)
2 Através de um AFD, AFND ou AFND- (formalismo operacional)
3 Através de um CR ou ER (formalismo axiomático)
4 Ou através de propriedades de fechamento
Por isso, é importante conhecer as propriedades de LR

Propriedades de Fechamento
Se L1 e L2 são regulares, então também são regulares:
L1 [ L2
L1L2
L1
⇤
Se L1 é regular, então L1 também é regular
Se L1 e L2 são regulares, então L1 L2 também é regular
Objetivos:
Originar novas LRs a partir de existentes
Provar (ou refutar) que alguma linguagem é regular
Se L1 L2 = {ai
bi
| i > 0}, uma das linguagens não é regular
L1 [ L2
L1L2
L1
⇤
Prova: basta inverter os estados finais com não-finais
Objetivos:
Se L1 L2 = {ai
bi
L1 [ L2
L1L2
L1
⇤
Prova: basta inverter os estados finais com não-finais
Prova: Lei de Morgan: L1 L2 = (L1 [ L2)
Objetivos:
Se L1 L2 = {ai
bi
Prove que a linguagem formada por palavras sobre {a,b}
que tenham aa e não tenham bb é regular (Exemplo 6.4.1, Sudkamp [6])
L1 = palavras com aa = (a [ b)⇤
aa(a [ b)⇤
é regular
L2 = palavras com bb = (a [ b)⇤
bb(a [ b)⇤
é regular
L2 também é regular
Logo, L1 L2 é regular

Propriedades de Fechamento – Exemplo
Prove que L = {aibj | i, j 0 e i 6= j} não é regular
Suponha que L seja regular
Então, L também é regular
Mas, L = {ai
bj
| i, j 0 e i = j} não é regular
Logo, L não pode ser regular
Método utilizado: Prova por contradição
Supõe-se que o contrário do que se deseja provar é verdade
Então, demonstra-se que essa suposição leva a um absurdo
(contradição)
LR é Vazia, Finita ou Infinita?
Dada uma linguagem L reconhecida por um AFD M com
n estados, logo L é:
1 Infinita sse M aceita palavras z tal que |z| n
i.e., possui ciclo
2 Finita sse M aceita apenas palavras z tal que |z| < n
i.e., não possui ciclo
3 Vazia sse M não aceita qualquer palavras z
i.e., F = ; ou é inalcançável (ocorre apenas em autômatos
incompletos)
É possível garantir que duas LRs são iguais?
Sim, é possível verificar se L1 = L2
Prova
Suponha os AFs M1 e M2 onde L(M1) = L1 e L(M2) = L2
Pelas propriedades de fechamento, é possível construir um
AF M3 tal que:
L3 = (L1 L2) [ (L1 L2)
Portanto, L1 = L2 sse L3 for vazia
E, como vimos anteriormente, é possível determinar se uma
linguagem é vazia
Lema do Bombeamento

Linguagens Regulares – Lema do Bombeamento
Lema do Bombeamento (Pumping Lemma) (um teorema na verdade)
Técnica usada para provar que linguagem não é regular
e só para linguagens inﬁnitas (pq?)
Se um AFD tem k estados, então qualquer caminho de
aceitação de uma palavra z de tamanho |z| k contém
um ciclo
q0 q1
a
b b
a
Exemplo (k=2, pense em qualquer z tal que |z| k e z 2 L)
q0 q1
a
b b
a
Caminhos de aceitação
O caminho de aceitação de qualquer palavra z tal que
|z| k e z 2 L contém um ciclo
e.g., aa, baa, bb, . . .
Podem existir palavras de tamanho menor que 2
e.g. e b
Decomposição
Suponha uma palavra z 2 L tal que |z| k
Logo, z pode ser dividida em três subpalavras z = uvw tal
que |uv|  k, v 6= e v é parte de z reconhecida pelo ciclo
Claramente, o ciclo pode ser executado (“bombeado”)
várias vezes
uvi
w 2 L para todo i 0
q0 Q(s) qf
u
v
w
Exemplo
q0 q1
q2 q3
b
a a
ba
b
a, b
Decomponha as palavras z 2 L e |z| k em z = uvw
aabb
abaab
bababb

Enunciado do Lema do Bombeamento
“Seja L uma LR aceita pelo AFD M com k estados.
Seja z qualquer palavra de L tal que |z| k.
Então, z pode ser decomposta em z = uvw com
uv  k, v 6= e
uviw 2 L para todo i 0.”
Exemplo #1: L = {aibi | i 0}
Exemplo #1: L = {aibi | i 0}
Assuma que L é regular e seja k a constante especiﬁcada pelo Lema.
Seja z = ak
bk
. Qualquer decomposição de z = uvw satisfazendo as
precondições do lema terão a seguinte forma:
u v w
ai
aj
ak i j
bk
onde i + j  k e j > 0. Bombeando alguma subpalavra nesta forma produzirá
uv2
w = ai
aj
aj
ak i j
bk
= ak
aj
bk
que não pertence a L.
Como z 2 L não possui decomposições que satisfaçam as condições do
Lema do Bombeamento, conclui-se que L não é regular.
Exemplo #2: L = {an | n é um quadrado perfeito }

Exemplo #2: L = {an | n é um quadrado perfeito }
Assuma que L é regular e seja k a constante especiﬁcada pelo Lema.
Seja z = ak2
e, portanto, |z| = k2
. Qualquer decomposição de z = uvw conterá
apenas a. Assim, conduziremos a prova no tamanho da palavra bombeada:
|uv2
w| = |uvw| + |v|
= k2
+ |v| (0 < |v|  k)
 k2
+ k
< k2
+ 2k + 1
= (k + 1)2
Como k2
< |uv2
w| < (k + 1)2
, uv2
w 62 L.
Como z 2 L não possui decomposições que satisfaçam as condições do
Lema do Bombeamento, conclui-se que L não é regular.
1 L1 = {0m1n | m > n}
2 L2 = {0n12n | n > 0}
3 L3 = {aibmcn | 0 < i, 0 < m < n}
4 L4 = {0m1n2m+n | m > 0 e n > 0}
5 L5 = {0n | n é um número primo }
4. Linguagens Livres de Contexto – Conteúdo
1 Revisão 3
2 Introdução 59
Máquina de Moore
Máquinas de Mealy
Gramática Livre de Contexto 178
Recursividade
Ambiguidade
Formas Normais 207
Transformações de Gramática 214
Forma Normal de Chomsky 248
Remoção de recursividade à esquerda 256
Forma Normal de Greibach 264
Autômatos com Pilha 278
Variantes
Algoritmos de Reconhecimento 305
Algoritmo de Early
Algoritmos 337
Propriedades 356
Teoremas
Variantes
Linguagens Livres de Contexto

O que sabemos: LR, GR e AF (Tipo 3)
LR:
Ling. natural: Palavras sobre {a, b} que terminam com {a}
Conj. regular: {a, b}⇤
{a}
Abreviação: (a [ b)⇤
a
GR:
S ! bS | aA
A ! aA | bS |
AF:
S A
b
a
a
b
LR x LLC
LR descrevem linguagens simples
Geradas por GR
Reconhecidas por AF
No entanto, existem uma ampla gama de linguagens que
não podem ser descritas por LR
Exemplo Clássico: L = {ai
bi
| i 0}
Como já visto, o lema do bombeamento indica que a
linguagem L não é regular
Logo, devemos “subir” na Hierarquia de Chomsky!
De LR (tipo 3) para LLC (tipo 2)
LLC aumentam o poder de expressão da linguagem
(veremos o porquê)
GLC é o sistema formal para geração de LLC
Assim, descrever L= {aibi | i 0} é possível com uma GLC
S ! aSb |
(e, pelo jeito, bem simples também)
Aplicabilidade
Como já vimos, LR são fundamentais no projeto de um
analisador léxico
Padrões são descritos por ER
Diagramas de Transição (AF estendidos) são usados no
reconhecimento de tokens
Por outro lado, LLC são fundamentais no projeto de um
analisador sintático
A sequência de tokens segue a gramática da linguagem?
GLC especiﬁcam a gramática formal da LP

Apostila Linguagens Formais e Autômatos (LFA)

Apostila Linguagens Formais e Autômatos (LFA)

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Mais de Ricardo Terra

Mais de Ricardo Terra (20)

Último

Último (20)

Apostila Linguagens Formais e Autômatos (LFA)