Ricardo Terra apresenta um documento sobre linguagens formais e autômatos. O documento inclui seu currículo, experiência acadêmica e profissional, e um sumário do conteúdo abordado, incluindo revisões sobre conjuntos, definições recursivas, indução matemática e linguagens formais.
1. 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 )
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 2 / 468
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 3 / 468
Revisão
Conjuntos, relações e funções
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 4 / 468
2. Revisão – Conjuntos, relações e funções (1–34)
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 5 / 468
Revisão – Conjuntos, relações e funções (1–9)
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 6 / 468
Revisão – Conjuntos, relações e funções (1–7)
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 7 / 468
Revisão
Definições Recursivas
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 8 / 468
3. Revisão – Definições Recursivas
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 9 / 468
Revisão – Definições Recursivas
Definições Recursivas
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)
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 10 / 468
Revisão – Definições Recursivas
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)
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 11 / 468
Revisão – Definições Recursivas
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 12 / 468
4. Revisão – Definições Recursivas
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)
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 12 / 468
Revisão
Indução Matemática
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 13 / 468
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 definido
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 14 / 468
Revisão – Indução Matemática
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) (definiçã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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 15 / 468
5. Revisão – Indução Matemática
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 16 / 468
Revisão
Linguagens Formais e Autômatos (LFA)
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 17 / 468
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 18 / 468
Revisão – Linguagens Formais e Autômatos (LFA)
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, ...}
⌃+
= ⌃⇤
{ }
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 19 / 468
6. Revisão – Linguagens Formais e Autômatos (LFA)
Linguagem Regular (LR)
Uma linguagem regular é aquela que pode ser definida por
um conjunto regular
Um conjunto regular pode ser gerado a partir de ⌃ usando
operador de Kleene, união e concatenação
Definiçã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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 20 / 468
Revisão – Linguagens Formais e Autômatos (LFA)
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 21 / 468
Revisão – Linguagens Formais e Autômatos (LFA)
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+
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 22 / 468
Revisão – Linguagens Formais e Autômatos (LFA)
Expressão Regular (ER) – Exemplo
L = palavras sobre {a, b} que começam e terminam com a
e possuem pelo menos um b
Expressão regular:
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 23 / 468
7. Revisão – Linguagens Formais e Autômatos (LFA)
Expressão Regular (ER) – Exemplo
L = palavras sobre {a, b} que começam e terminam com a
e possuem pelo menos um b
Expressão regular: a(a [ b)⇤b(a [ b)⇤a
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 23 / 468
Revisão – Linguagens Formais e Autômatos (LFA)
Expressão Regular (ER) – Exemplo
L = palavras sobre {a, b} que começam e terminam com a
e possuem pelo menos um b
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 23 / 468
Revisão – Linguagens Formais e Autômatos (LFA)
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 ⌃)
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 24 / 468
Revisão – Linguagens Formais e Autômatos (LFA)
Gramática Regular (GR) – Exemplo
L = palavras sobre {a, b} que começam e terminam com a
e possuem pelo menos um b
GR(L):
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 25 / 468
8. Revisão – Linguagens Formais e Autômatos (LFA)
Gramática Regular (GR) – Exemplo
L = palavras sobre {a, b} que começam e terminam com a
e possuem pelo menos um b
GR(L):
S ! aA
A ! aA | bB
B ! aB | bB | a
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 25 / 468
Revisão – Linguagens Formais e Autômatos (LFA)
Gramática Regular (GR) – Exemplo
L = palavras sobre {a, b} que começam e terminam com a
e possuem pelo menos um b
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 25 / 468
Revisão – Linguagens Formais e Autômatos (LFA)
Derivação
Aplicação consecutiva de regras
Definiçã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}
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 26 / 468
Revisão – Linguagens Formais e Autômatos (LFA)
Dada a seguinte GR(L):
S ! aA
A ! aA | bB
B ! aB | bB | a
Pergunta-se: ababa 2 L(G)?
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 27 / 468
9. Revisão – Linguagens Formais e Autômatos (LFA)
Dada a seguinte GR(L):
S ! aA
A ! aA | bB
B ! aB | bB | a
Pergunta-se: ababa 2 L(G)?
S ) aA
) abB
) abaB
) ababB
) ababa
É uma sentença válida uma vez que S )⇤ ababa
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 27 / 468
Revisão – Linguagens Formais e Autômatos (LFA)
Dada a seguinte GR(L):
S ! aA
A ! aA | bB
B ! aB | bB | a
Pergunta-se: ababa 2 L(G)?
S ) aA
) abB
) abaB
) ababB
) ababa
É uma sentença válida uma vez que S )⇤ ababa
E abbabb 2 L(G)?
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 27 / 468
Revisão – Linguagens Formais e Autômatos (LFA)
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)
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 28 / 468
Revisão – Linguagens Formais e Autômatos (LFA)
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 29 / 468
10. Revisão – Linguagens Formais e Autômatos (LFA)
Exemplo
L = palavras sobre {a, b} que começam e terminam com a
e possuem pelo menos um b
AFD:
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 30 / 468
Revisão – Linguagens Formais e Autômatos (LFA)
Exemplo
L = palavras sobre {a, b} que começam e terminam com a
e possuem pelo menos um b
AFD:
q0 q1 q2 q3
a
a
b
b
a
a
b
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 30 / 468
Revisão – Linguagens Formais e Autômatos (LFA)
Exemplo
L = palavras sobre {a, b} que começam e terminam com a
e possuem pelo menos um b
AFD:
q0 q1 q2 q3
a
a
b
b
a
a
b
Sim, na verdade, é um AFD incompleto, por quê?
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 30 / 468
Revisão – Linguagens Formais e Autômatos (LFA)
Exemplo
L = palavras sobre {a, b} que começam e terminam com a
e possuem pelo menos um b
AFD:
q0 q1 q2 q3
a
a
b
b
a
a
b
Sim, na verdade, é um AFD incompleto, por quê?
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 30 / 468
11. Revisão – Linguagens Formais e Autômatos (LFA)
Autômato Finito Não-Determinístico (AFND)
Um AFND é uma quíntupla (Q, ⌃, ND, q0, F):
Q = conjunto finito de estados
⌃ = alfabeto
ND : Q x ⌃ ! P(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 AFND se, e
somente se, existe uma computação que a consome e
para em um estado final
Para todo AFND, existe um AFD equivalente
i.e., não aumenta poder de expressão
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 31 / 468
Revisão – Linguagens Formais e Autômatos (LFA)
Exemplo
L = palavras sobre {a, b} que começam e terminam com a
e possuem pelo menos um b
AFND:
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 32 / 468
Revisão – Linguagens Formais e Autômatos (LFA)
Exemplo
L = palavras sobre {a, b} que começam e terminam com a
e possuem pelo menos um b
AFND:
q0 q1 q2 q3
a b
a a,b
a
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 32 / 468
Revisão – Linguagens Formais e Autômatos (LFA)
Exemplo
L = palavras sobre {a, b} que começam e terminam com a
e possuem pelo menos um b
AFND:
q0 q1 q2 q3
a b
a a,b
a
Sim, na verdade, é um AFND incompleto, por quê?
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 32 / 468
12. Revisão – Linguagens Formais e Autômatos (LFA)
Exemplo
L = palavras sobre {a, b} que começam e terminam com a
e possuem pelo menos um b
AFND:
q0 q1 q2 q3
a b
a a,b
a
Sim, na verdade, é um AFND incompleto, por quê?
Exercício de Fixação
1 L = palavras sobre {a, b} que contém aa ou bb
2 L = (a [ b)⇤bb
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 32 / 468
Revisão – Linguagens Formais e Autômatos (LFA)
Autômato Finito Não-Determinístico com Transições- (AFND- )
Um AFND- é uma quíntupla (Q, ⌃, ND , q0, F):
Q = conjunto finito de estados
⌃ = alfabeto
ND : Q x (⌃ [ { }) ! P(Q) = f. de transições de estados
qo 2 Q = estado inicial
F ✓ Q = conjunto de estados finais (aceitação)
Para todo AFND- , existe um AFND e um AFD equivalentes
i.e., não aumenta poder de expressão
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 33 / 468
Revisão – Linguagens Formais e Autômatos (LFA)
Exemplo
L = palavras sobre {a, b} com tamanho par
AFND- :
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 34 / 468
Revisão – Linguagens Formais e Autômatos (LFA)
Exemplo
L = palavras sobre {a, b} com tamanho par
AFND- :
q0 q1 q3
a,b a,b
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 34 / 468
13. 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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 35 / 468
Revisão – Linguagens Formais e Autômatos (LFA)
Gramática Livre de Contexto (GLC)
Uma GLC é 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 não-terminal)
⌫ 2 (V [ ⌃)⇤
(i.e., palavra formada por elementos de V e ⌃)
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 36 / 468
Revisão – Linguagens Formais e Autômatos (LFA)
Exemplo Clássico
L(G) = {aibi | i > 0}
GLC(L):
Toda LLC é aceita por um Autômato com Pilha (não-determinístico)
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 37 / 468
Revisão – Linguagens Formais e Autômatos (LFA)
Exemplo Clássico
L(G) = {aibi | i > 0}
GLC(L):
S ! aSb | ab
Toda LLC é aceita por um Autômato com Pilha (não-determinístico)
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 37 / 468
14. Revisão – Linguagens Formais e Autômatos (LFA)
Exemplo Clássico 2
L(G) = {w 2 {a, b}⇤ | w = wR}
GLC(L):
Toda LLC é aceita por um Autômato com Pilha (não-determinístico)
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 38 / 468
Revisão – Linguagens Formais e Autômatos (LFA)
Exemplo Clássico 2
L(G) = {w 2 {a, b}⇤ | w = wR}
GLC(L):
S ! aSa | bSb | a | b |
Toda LLC é aceita por um Autômato com Pilha (não-determinístico)
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 38 / 468
Revisão – Linguagens Formais e Autômatos (LFA)
Exercício de Fixação
1 L = {anbman|n > 0, m > 0}
2 L = {anbmcmd2n|n 0, m > 0}
3 L = palavras sobre {a, b} com número par de a
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 39 / 468
Revisão – Linguagens Formais e Autômatos (LFA)
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 40 / 468
15. Revisão – Linguagens Formais e Autômatos (LFA)
Autômato com Pilha Determinístico (APD)
Um APD é uma sextupla (Q, ⌃, , , q0, F):
Q = conjunto finito de estados
⌃ = alfabeto de entrada
= alfabeto da pilha
: Q x (⌃ [ ) x ( [ ) ! P(Q x ( [ ))
= função de transições de estados
qo 2 Q = estado inicial
F ✓ Q = conjunto de estados finais (aceitação)
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)
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 41 / 468
Revisão – Linguagens Formais e Autômatos (LFA)
Exemplo Clássico
L(G) = {aibi | i > 0}
APD:
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 42 / 468
Revisão – Linguagens Formais e Autômatos (LFA)
Exemplo Clássico
L(G) = {aibi | i > 0}
APD:
q0 q1
a /X
b X/
b X/
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 42 / 468
Revisão – Linguagens Formais e Autômatos (LFA)
Autômato com Pilha Não-Determinístico (APND)
Um APND é uma sextupla (Q, ⌃, , , q0, F):
Q = conjunto finito de estados
⌃ = alfabeto de entrada
= alfabeto da pilha
: Q x (⌃ [ ) x ( [ ) ! P(Q x ( [ ))
= função de transições de estados
qo 2 Q = estado inicial
F ✓ Q = conjunto de estados finais (aceitação)
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
somente se, existe uma computação que a consome e
para em um estado final com pilha vazia
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 43 / 468
16. Revisão – Linguagens Formais e Autômatos (LFA)
Exemplo Clássico 2
L(G) = {w 2 {a, b}⇤ | w = wR}
APND:
Toda LLC é aceita por um APND
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 44 / 468
Revisão – Linguagens Formais e Autômatos (LFA)
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 44 / 468
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 45 / 468
Revisão – Linguagens Formais e Autômatos (LFA)
Gramática Sensível ao Contexto (GSC)
Uma GSC é 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., palavra formada por elementos de V e ⌃)
⌫ 2 (V [ ⌃)+
(i.e., palavra formada por elementos de V e ⌃)
|µ| |⌫| (i.e., regras não-contráteis)
nunca é uma palavra válida em uma LSC
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 46 / 468
17. Revisão – Linguagens Formais e Autômatos (LFA)
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 ⌃⇤
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 47 / 468
Revisão – Linguagens Formais e Autômatos (LFA)
Autômato Linearmente Limitado (ALL)
Um ALL é uma óctupla (Q, ⌃, , , q0, <, >, F):
Q = conjunto finito de estados
⌃ = alfabeto de entrada
= alfabeto da fita
: Q ⇥ ! Q ⇥ ⇥ {E, D} = função de transições de estados
qo 2 Q = estado inicial
F ✓ Q = conjunto de estados finais (aceitação)
< e > = delimitadores da palavra de entrada
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 48 / 468
Revisão – Linguagens Formais e Autômatos (LFA)
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 49 / 468
Revisão – Linguagens Formais e Autômatos (LFA)
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 50 / 468
18. 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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 51 / 468
Revisão – Linguagens Formais e Autômatos (LFA)
Gramática Irrestrita (GI)
Todo o universo de linguagens é gerado por GI
Uma GI é 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., palavra formada por elementos de V e ⌃)
⌫ 2 (V [ ⌃)⇤
(i.e., palavra formada por elementos de V e ⌃)
“Quase” nenhuma restrição é imposta (|µ| > 0)
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 52 / 468
Revisão – Linguagens Formais e Autômatos (LFA)
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 ⌃⇤
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 53 / 468
Revisão – Linguagens Formais e Autômatos (LFA)
Máquina de Turing (MT)
Um MT é uma séxtupla (Q, ⌃, , , q0, F):
Q = conjunto finito de estados
⌃ = alfabeto de entrada
= alfabeto da fita
: Q ⇥ ! Q ⇥ ⇥ {E, D} = função de transições de estados
qo 2 Q = estado inicial
F ✓ Q = conjunto de estados finais (aceitação)
Memória ilimitada
Seja w uma palavra de entrada
Configuração inicial da fita: BwBBBBBBBB...
A fita é infinita à direita
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 54 / 468
19. Revisão – Linguagens Formais e Autômatos (LFA)
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 55 / 468
Revisão
Lemas, Teoremas, Corolários, etc.
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 56 / 468
Revisão – Lemas, Teoremas, Corolários, etc.
Definições
Definem 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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 57 / 468
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 58 / 468
20. 2. Introdução – Conteúdo
1 Revisão 3
Hierarquia de Chomsky 60
Conceitos Básicos 63
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 59 / 468
Introdução
Hierarquia de Chomsky
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 60 / 468
Introdução – Hierarquia de Chomsky
Hierarquia de Chomsky
Noam Chomsky (1927-presente): poeta, filósofo, linguista,
professor do MIT, e crítico do capitalismo e da política
externa americana
Noam Chomsky (1956) constitui uma classificação para
linguagens, gramáticas e autômatos
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 61 / 468
Introdução – Hierarquia de Chomsky
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
Toda categoria é um subconjunto próprio da categoria superior
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 62 / 468
21. Introdução
Conceitos Básicos
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 63 / 468
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 64 / 468
Introdução – Conceitos Básicos
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)
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 65 / 468
Introdução – Conceitos Básicos
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.
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 66 / 468
22. Introdução – Conceitos Básicos
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?
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 67 / 468
Introdução – Conceitos Básicos
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 68 / 468
Introdução – Conceitos Básicos
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)
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 69 / 468
Introdução – Conceitos Básicos
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 70 / 468
23. Introdução – Conceitos Básicos
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 71 / 468
Introdução – Conceitos Básicos
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 72 / 468
Introdução – Conceitos Básicos
X⇤ (definição formal)
X⇤
=
1[
i=0
Xi
X+ (definição formal)
X+
=
1[
i=1
Xi
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 73 / 468
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 Finitos Determinísticos
Autômatos Finitos Não-Determinísticos
Autômatos Finitos Não-Determinísticos com Transições-
3 Linguagens Regulares 74
Autômatos com Saída 116
Máquina de Moore
Máquinas de Mealy
Algoritmos de Transformação
Algoritmos 134
Transformação AFND- para AFD
Minimização de AFD
Transformação de ER para AFND-
Propriedades 156
Lema do Bombeamento 163
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 74 / 468
24. Linguagens Regulares – Hierarquia de Chomsky
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 75 / 468
Linguagens Regulares
Conjuntos Regulares
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 76 / 468
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, ...}
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 77 / 468
Linguagens Regulares – Conjuntos Regulares
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 78 / 468
25. Linguagens Regulares – Conjuntos Regulares
Definição Recursiva Revisã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}
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 79 / 468
Linguagens Regulares
Expressões Regulares
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 80 / 468
Linguagens Regulares – Expressões Regulares
Expressões Regulares
Abreviação para conjuntos regulares
PS: x+
denota xx⇤
Definição Recursiva Revisão
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)⇤
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 81 / 468
Linguagens Regulares – Expressões Regulares
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 82 / 468
26. Linguagens Regulares – Expressões Regulares
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⇤
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 83 / 468
Linguagens Regulares – Expressões Regulares
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 definidas por
expressões regulares
Por exemplo, {an
bn
| n 0}
E aí, o que isso significa?
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 84 / 468
Linguagens Regulares
Gramáticas Regulares
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 85 / 468
Linguagens Regulares – Gramáticas Regulares
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 ⌃)
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 86 / 468
27. Linguagens Regulares – Gramáticas Regulares
Gramática Regular (GR) – Exemplo
L = palavras sobre {a, b} que começam e terminam com a
e possuem pelo menos um b
GR(L):
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 87 / 468
Linguagens Regulares – Gramáticas Regulares
Gramática Regular (GR) – Exemplo
L = palavras sobre {a, b} que começam e terminam com a
e possuem pelo menos um b
GR(L):
S ! aA
A ! aA | bB
B ! aB | bB | a
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 87 / 468
Linguagens Regulares – Gramáticas Regulares
Gramática Regular (GR) – Exemplo
L = palavras sobre {a, b} que começam e terminam com a
e possuem pelo menos um b
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 !
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 87 / 468
Linguagens Regulares – Gramáticas Regulares
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
4 L = palavras sobre {a, b} com número par de a
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 88 / 468
28. Linguagens Regulares – Gramáticas Regulares
Derivação
Aplicação consecutiva de regras
Definiçã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}
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 89 / 468
Linguagens Regulares – Gramáticas Regulares
Dada a seguinte GR(L):
S ! aA
A ! aA | bB
B ! aB | bB | a
Pergunta-se: ababa 2 L(G)?
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 90 / 468
Linguagens Regulares – Gramáticas Regulares
Dada a seguinte GR(L):
S ! aA
A ! aA | bB
B ! aB | bB | a
Pergunta-se: ababa 2 L(G)?
S ) aA
) abB
) abaB
) ababB
) ababa
É uma sentença válida uma vez que S )⇤ ababa
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 90 / 468
Linguagens Regulares – Gramáticas Regulares
Dada a seguinte GR(L):
S ! aA
A ! aA | bB
B ! aB | bB | a
Pergunta-se: ababa 2 L(G)?
S ) aA
) abB
) abaB
) ababB
) ababa
É uma sentença válida uma vez que S )⇤ ababa
E abbabb 2 L(G)?
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 90 / 468
29. Linguagens Regulares – Gramáticas Regulares
Enfim
Uma linguagem é regular se pode ser gerada por alguma
gramática regular (ou CR ou ER)
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 91 / 468
Linguagens Regulares
Autômatos Finitos
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 92 / 468
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- )
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)
Linguagem L é regular sse existe um AF que reconhece L
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 93 / 468
Linguagens Regulares
Autômatos Finitos
Autômatos Finitos Determinísticos
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 94 / 468
30. Linguagens Regulares – Autômatos Finitos – AFD
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 ⌃⇤ | ˆD(q0, w) 2 F}, onde ˆD é a função
de transição estendida para M
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 95 / 468
Linguagens Regulares – Autômatos Finitos – AFD
Exemplo
L = palavras sobre {a, b} que começam e terminam com a
e possuem pelo menos um b
AFD:
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 96 / 468
Linguagens Regulares – Autômatos Finitos – AFD
Exemplo
L = palavras sobre {a, b} que começam e terminam com a
e possuem pelo menos um b
AFD:
q0 q1 q2 q3
a
a
b
b
a
a
b
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 96 / 468
D a b
q0 q1
q1 q1 q2
q2 q3 q2
q3 q3 q2
Linguagens Regulares – Autômatos Finitos – AFD
Exemplo
L = palavras sobre {a, b} que começam e terminam com a
e possuem pelo menos um b
AFD:
q0 q1 q2 q3
a
a
b
b
a
a
b
Sim, na verdade, é um AFD incompleto, por quê?
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 96 / 468
D a b
q0 q1
q1 q1 q2
q2 q3 q2
q3 q3 q2
31. Linguagens Regulares – Autômatos Finitos – AFD
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 97 / 468
Linguagens Regulares – Autômatos Finitos – AFD
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 98 / 468
Linguagens Regulares – Autômatos Finitos – AFD
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 99 / 468
Linguagens Regulares – Autômatos Finitos – AFD
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 99 / 468
32. Linguagens Regulares – Autômatos Finitos – AFD
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 100 / 468
Linguagens Regulares – Autômatos Finitos – AFD
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?
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 101 / 468
Linguagens Regulares – Autômatos Finitos – AFD
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?
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 102 / 468
Linguagens Regulares – Autômatos Finitos – AFD
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) =
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 103 / 468
33. Linguagens Regulares – Autômatos Finitos – AFD
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)
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 103 / 468
Linguagens Regulares
Autômatos Finitos
Autômatos Finitos Não-Determinísticos
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 104 / 468
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)
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 105 / 468
Linguagens Regulares – Autômatos Finitos – AFND
Autômato Finito Não-Determinístico (AFND)
Um AFND é uma quíntupla (Q, ⌃, ND, q0, F):
Q = conjunto finito de estados
⌃ = alfabeto
ND : Q x ⌃ ! P(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 AFND se, e
somente se, existe uma computação que a consome e
para em um estado final
Para todo AFND, existe um AFD equivalente
i.e., não aumenta poder de expressão
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 106 / 468
34. Linguagens Regulares – Autômatos Finitos – AFND
Exemplo
L = palavras sobre {a, b} que começam e terminam com a
e possuem pelo menos um b
AFND:
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 107 / 468
Linguagens Regulares – Autômatos Finitos – AFND
Exemplo
L = palavras sobre {a, b} que começam e terminam com a
e possuem pelo menos um b
AFND:
q0 q1 q2 q3
a b
a a,b
a
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 107 / 468
ND a b
q0 {q1} ;
q1 {q1} {q2}
q2 {q2, q3} {q2}
q3 ; ;
Linguagens Regulares – Autômatos Finitos – AFND
Exemplo
L = palavras sobre {a, b} que começam e terminam com a
e possuem pelo menos um b
AFND:
q0 q1 q2 q3
a b
a a,b
a
Qual seria a árvore de computações para a palavra abaaa?
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 107 / 468
ND a b
q0 {q1} ;
q1 {q1} {q2}
q2 {q2, q3} {q2}
q3 ; ;
Linguagens Regulares – Autômatos Finitos – AFND
Exercício de Fixação
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 108 / 468
35. Linguagens Regulares – Autômatos Finitos – AFND
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 109 / 468
Linguagens Regulares – Autômatos Finitos – AFND
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 = ;}
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 110 / 468
Linguagens Regulares – Autômatos Finitos – AFND
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 111 / 468
Linguagens Regulares
Autômatos Finitos
Autômatos Finitos Não-Determinísticos com Transições-
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 112 / 468
36. 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):
Q = conjunto finito de estados
⌃ = alfabeto
ND : Q x (⌃ [ { }) ! P(Q) = f. de transições de estados
qo 2 Q = estado inicial
F ✓ Q = conjunto de estados finais (aceitação)
Para todo AFND- , existe um AFND e um AFD equivalentes
i.e., não aumenta poder de expressão
É muito similar ao AFND
Tem como vantagem facilitar construções e demonstrações
Por exemplo, o algoritmo ER ! AFND- Algoritmo ER ! AFND-
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 113 / 468
Linguagens Regulares – Autômatos Finitos – AFND-
Exemplo
L = {0k | k é múltiplo de 2 ou 3}
AFND- :
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 114 / 468
Linguagens Regulares – Autômatos Finitos – AFND-
Exemplo
L = {0k | k é múltiplo de 2 ou 3}
AFND- :
q0
q1 q2
q3
q5
q4
0
0
0
00
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 114 / 468
ND 0
q0 ; {q1, q3}
q1 {q2} ;
q2 {q1} ;
q3 {q4} ;
q4 {q5} ;
q5 {q3} ;
Linguagens Regulares – Autômatos Finitos – AFND-
Exercício de Fixação
1 L = (a [ b)⇤bb ou aa(a [ b)⇤
2 L = palavras sobre {a, b, c} que terminam com a ou bb ou
ccc
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 115 / 468
37. Linguagens Regulares
Autômatos com Saída
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 116 / 468
Linguagens Regulares
Autômatos com Saída
Máquina de Moore
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 117 / 468
Linguagens Regulares – Autômatos com Saída – Moore
Máquina de Moore
Uma máquina de Moore é uma sêxtupla (Q, ⌃, , D, , q0):
Q = conjunto finito de estados
⌃ = alfabeto de entrada
= alfabeto da saída
D : Q x ⌃ ! Q = função (total) de transições de estados
: Q ! = função (total) de saída
qo 2 Q = estado inicial
Uma máquina de Moore é um AFD com um símbolo de
saída associado a cada estado
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 118 / 468
Linguagens Regulares – Autômatos com Saída – Moore
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 finitos 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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 119 / 468
38. Linguagens Regulares – Autômatos com Saída – Moore
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 120 / 468
Linguagens Regulares – Autômatos com Saída – Moore
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)
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 121 / 468
Linguagens Regulares – Autômatos com Saída – Moore
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 122 / 468
Linguagens Regulares – Autômatos com Saída – Moore
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 123 / 468
39. 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)
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 124 / 468
Linguagens Regulares
Autômatos com Saída
Máquinas de Mealy
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 125 / 468
Linguagens Regulares – Autômatos com Saída – Mealy
Máquina de Mealy
Uma máquina de Mealy é uma sêxtupla (Q, ⌃, , D, , q0):
Q = conjunto finito de estados
⌃ = alfabeto de entrada
= alfabeto da saída
D : Q x ⌃ ! Q = função (total) de transições de estados
: Q ⇥ ⌃ ! = função (total) de saída
qo 2 Q = estado inicial
Uma máquina de Mealy é um AFD com um símbolo de
saída associado a cada transição
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 126 / 468
Linguagens Regulares – Autômatos com Saída – Mealy
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 finitos 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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 127 / 468
40. Linguagens Regulares – Autômatos com Saída – Mealy
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 128 / 468
Linguagens Regulares – Autômatos com Saída – Mealy
Exemplo #4
Modificaçã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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 129 / 468
Linguagens Regulares – Autômatos com Saída – Mealy
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)
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 130 / 468
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 131 / 468
41. Linguagens Regulares
Autômatos com Saída
Algoritmos de Transformação
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 132 / 468
Algoritmos de Transformação
Algoritmos de Transformação
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]
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 133 / 468
Linguagens Regulares
Algoritmos
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 134 / 468
Linguagens Regulares
Algoritmos
Transformação AFND- para AFD
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 135 / 468
42. 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)
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 136 / 468
Linguagens Regulares – Algoritmos – AFND- para AFD
AFND-
q0 q1
q2
a
a
a
b
c
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 137 / 468
Linguagens Regulares – Algoritmos – AFND- para AFD
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 137 / 468
Linguagens Regulares – Algoritmos – AFND- para AFD
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
1 ND ! ND
i. São estados iniciais: fecho (q0)
Se um estado inicial alcança um
estado final, tal inicial será final
ND a b c
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 137 / 468
43. Linguagens Regulares – Algoritmos – AFND- para AFD
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
1 ND ! ND
i. São estados iniciais: fecho (q0)
Se um estado inicial alcança um
estado final, tal inicial será final
ND a b c
q0 {q0, q1, q2} ; ;
q1 ; {q1} ;
q2 ;
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 137 / 468
Linguagens Regulares – Algoritmos – AFND- para AFD
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
1 ND ! ND
i. São estados iniciais: fecho (q0)
Se um estado inicial alcança um
estado final, tal inicial será final
ii. Para os outros estados qi :
ND a b c
q0 {q0, q1, q2} ; ;
q1 ; {q1} ;
q2 ;
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 137 / 468
Linguagens Regulares – Algoritmos – AFND- para AFD
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
1 ND ! ND
i. São estados iniciais: fecho (q0)
Se um estado inicial alcança um
estado final, tal inicial será final
ii. Para os outros estados qi :
considera todo estado em fecho (qi )
ND a b c
q0 {q0, q1, q2} ; ;
q1 ; {q1} ;
q2 ; {q1}
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 137 / 468
Linguagens Regulares – Algoritmos – AFND- para AFD
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
1 ND ! ND
i. São estados iniciais: fecho (q0)
Se um estado inicial alcança um
estado final, tal inicial será final
ii. Para os outros estados qi :
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}
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 137 / 468
44. Linguagens Regulares – Algoritmos – AFND- para AFD
AFND (agora)
ND a b c
q0 {q0, q1, q2} ; ;
q1 ; {q1} ;
q2 ; {q1} {q1, q2}
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 138 / 468
Linguagens Regulares – Algoritmos – AFND- para AFD
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}
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 138 / 468
Linguagens Regulares – Algoritmos – AFND- para AFD
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 138 / 468
Linguagens Regulares – Algoritmos – AFND- para AFD
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}
ii. Cada novo Q obtém a
união das transições dos
seus estados integrantes
D a b c
q0 = hq0i hq0, q1, q2i
hq0, q1, q2i hq0, q1, q2i hq1i hq1, q2i
hq1i hq1i
hq1, q2i hq1i hq1, q2i
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 138 / 468
45. Linguagens Regulares – Algoritmos – AFND- para AFD
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}
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
q0 = hq0i hq0, q1, q2i
F 3 hq0, q1, q2i hq0, q1, q2i hq1i hq1, q2i
F 3 hq1i hq1i
F 3 hq1, q2i hq1i hq1, q2i
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 138 / 468
Linguagens Regulares – Algoritmos – AFND- para AFD
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 139 / 468
Linguagens Regulares – Algoritmos – AFND- para AFD
Exercício de Fixação #1
q0
q1 q2
q3
a
b
a
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 140 / 468
Linguagens Regulares – Algoritmos – AFND- para AFD
Exercício de Fixação #2
q0 q1 q2 q3
0,1
1 0,1 0,1
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 141 / 468
46. Linguagens Regulares – Algoritmos – AFND- para AFD
Exercício de Fixação #3
q0 q1 q2
q3 q4
a b
a
a,b
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 142 / 468
Linguagens Regulares
Algoritmos
Minimização de AFD
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 143 / 468
Linguagens Regulares – Algoritmos – Minimização de AFD
Minimização de um AFD
1 Todos os estados são equivalentes
2 Se um é estado final 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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 144 / 468
Linguagens Regulares – Algoritmos – Minimização de AFD
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 final 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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 145 / 468
47. Linguagens Regulares – Algoritmos – Minimização de AFD
Exemplo
q0 q1 q2 q3
q4 q5 q6
b
a
b
a
b
a
a,b
a,b a,b a,b
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 146 / 468
Linguagens Regulares – Algoritmos – Minimização de AFD
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 ;
Índice D[i, j] = S[i, j] = Motivo
[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 ;
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 147 / 468
Linguagens Regulares – Algoritmos – Minimização de AFD
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 final e o outro não, faça D[i, j] = 1 (aqui, x)
Í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 ;
Índice D[i, j] = S[i, j] = Motivo
[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 ;
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 148 / 468
Linguagens Regulares – Algoritmos – Minimização de AFD
q0 q1 q2 q3
q4 q5 q6
b
a
b
a
b
a
a,b
a,b a,b a,b
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]
Índice D[i, j] = S[i, j] = Motivo
[0, 1] X { }
[0, 2] X { }
[0, 3] X { }
[1, 2] X { }
[1, 3] X { }
Índice D[i, j] = S[i, j] = Motivo
[2, 3] X { }
[4, 5] X { }
[4, 6] X { }
[5, 6] X { }
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 149 / 468
48. Linguagens Regulares – Algoritmos – Minimização de AFD
q0 q1 q2 q3
q4 q5 q6
b
a
b
a
b
a
a,b
a,b a,b a,b
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]
Índice D[i, j] = S[i, j] = Motivo
⌅ [0, 1] X { }
[0, 2] X { }
[0, 3] X { }
[1, 2] X { [0, 1] }
[1, 3] X { }
Índice D[i, j] = S[i, j] = Motivo
[2, 3] X { }
[4, 5] X { [0, 1] }
[4, 6] X { }
[5, 6] X { }
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 149 / 468
Linguagens Regulares – Algoritmos – Minimização de AFD
q0 q1 q2 q3
q4 q5 q6
b
a
b
a
b
a
a,b
a,b a,b a,b
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]
Índice D[i, j] = S[i, j] = Motivo
[0, 1] X { }
⌅ [0, 2] X { }
[0, 3] X { }
[1, 2] X { [0, 1] }
[1, 3] X { [0, 2] }
Índice D[i, j] = S[i, j] = Motivo
[2, 3] X { }
[4, 5] X { [0, 1] }
[4, 6] X { [0, 2] }
[5, 6] X { }
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 149 / 468
Linguagens Regulares – Algoritmos – Minimização de AFD
q0 q1 q2 q3
q4 q5 q6
b
a
b
a
b
a
a,b
a,b a,b a,b
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]
Índice D[i, j] = S[i, j] = Motivo
[0, 1] X { }
[0, 2] X { }
⌅ [0, 3] X ! x { } a
[1, 2] X { [0, 1] }
[1, 3] X { [0, 2] }
Índice D[i, j] = S[i, j] = Motivo
[2, 3] X { }
[4, 5] X { [0, 1] }
[4, 6] X { [0, 2] }
[5, 6] X { }
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 149 / 468
Linguagens Regulares – Algoritmos – Minimização de AFD
q0 q1 q2 q3
q4 q5 q6
b
a
b
a
b
a
a,b
a,b a,b a,b
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]
Índice D[i, j] = S[i, j] = Motivo
[0, 1] X { }
[0, 2] X { }
[0, 3] X ! x { } a
⌅ [1, 2] X { [0, 1] }
[1, 3] X { [0, 2] }
Índice D[i, j] = S[i, j] = Motivo
[2, 3] X { [1, 2] }
[4, 5] X { [0, 1] }
[4, 6] X { [0, 2] }
[5, 6] X { [1, 2] }
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 149 / 468
49. Linguagens Regulares – Algoritmos – Minimização de AFD
q0 q1 q2 q3
q4 q5 q6
b
a
b
a
b
a
a,b
a,b a,b a,b
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]
Índice D[i, j] = S[i, j] = Motivo
[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
Índice D[i, j] = S[i, j] = Motivo
[2, 3] X { [1, 2] }
[4, 5] X { [0, 1] }
[4, 6] X { [0, 2] }
[5, 6] X { [1, 2] }
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 149 / 468
Linguagens Regulares – Algoritmos – Minimização de AFD
q0 q1 q2 q3
q4 q5 q6
b
a
b
a
b
a
a,b
a,b a,b a,b
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]
Índice D[i, j] = S[i, j] = Motivo
[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
Índice D[i, j] = S[i, j] = Motivo
⌅ [2, 3] X ! x { [1, 2] } a
[4, 5] X { [0, 1] }
[4, 6] X { [0, 2] }
[5, 6] X { [1, 2] }
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 149 / 468
Linguagens Regulares – Algoritmos – Minimização de AFD
q0 q1 q2 q3
q4 q5 q6
b
a
b
a
b
a
a,b
a,b a,b a,b
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]
Índice D[i, j] = S[i, j] = Motivo
[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
Índice D[i, j] = S[i, j] = Motivo
[2, 3] X ! x { [1, 2] } a
⌅ [4, 5] X { [0, 1] }
[4, 6] X { [0, 2] }
[5, 6] X { [1, 2] }
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 149 / 468
Linguagens Regulares – Algoritmos – Minimização de AFD
q0 q1 q2 q3
q4 q5 q6
b
a
b
a
b
a
a,b
a,b a,b a,b
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]
Índice D[i, j] = S[i, j] = Motivo
[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
Índice D[i, j] = S[i, j] = Motivo
[2, 3] X ! x { [1, 2] } a
[4, 5] X { [0, 1] }
⌅ [4, 6] X { [0, 2] }
[5, 6] X { [1, 2] }
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 149 / 468
50. Linguagens Regulares – Algoritmos – Minimização de AFD
q0 q1 q2 q3
q4 q5 q6
b
a
b
a
b
a
a,b
a,b a,b a,b
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]
Índice D[i, j] = S[i, j] = Motivo
[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
Índice D[i, j] = S[i, j] = Motivo
[2, 3] X ! x { [1, 2] } a
[4, 5] X { [0, 1] }
[4, 6] X { [0, 2] }
⌅ [5, 6] X { [1, 2] }
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 149 / 468
Linguagens Regulares – Algoritmos – Minimização de AFD
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 150 / 468
Linguagens Regulares – Algoritmos – Minimização de AFD
Exercício de Fixação
q0
q1
q2
q3
q4
q5
q6
q7
a
b
a
b
a,b
b
a
a
b
a,b
b
a a,b
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 151 / 468
Linguagens Regulares
Algoritmos
Transformação de ER para AFND-
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 152 / 468
51. 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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 153 / 468
Linguagens Regulares – Algoritmos – ER para AFND-
Exemplo: ((a [ b)c⇤)⇤
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 154 / 468
Linguagens Regulares – Algoritmos – ER para AFND-
Exemplo: ((a [ b)c⇤)⇤
q2 q3
a
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 154 / 468
Linguagens Regulares – Algoritmos – ER para AFND-
Exemplo: ((a [ b)c⇤)⇤
q2 q3
q4 q5
a
b
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 154 / 468
52. Linguagens Regulares – Algoritmos – ER para AFND-
Exemplo: ((a [ b)c⇤)⇤
q1
q2 q3
q4 q5
q6
a
b
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 154 / 468
Linguagens Regulares – Algoritmos – ER para AFND-
Exemplo: ((a [ b)c⇤)⇤
q1
q2 q3
q4 q5
q6 q7 q8
a
b
c
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 154 / 468
Linguagens Regulares – Algoritmos – ER para AFND-
Exemplo: ((a [ b)c⇤)⇤
q1
q2 q3
q4 q5
q6q0
6
q7 q8 q9
a
b
c
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 154 / 468
Linguagens Regulares – Algoritmos – ER para AFND-
Exemplo: ((a [ b)c⇤)⇤
q1
q2 q3
q4 q5
q6 q7 q8 q9
a
b
c
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 154 / 468
53. Linguagens Regulares – Algoritmos – ER para AFND-
Exemplo: ((a [ b)c⇤)⇤
q0 q1
q2 q3
q4 q5
q6 q7 q8 q9 q10
a
b
c
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 154 / 468
Linguagens Regulares – Algoritmos – ER para AFND-
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)⇤
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 155 / 468
Linguagens Regulares
Propriedades
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 156 / 468
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 157 / 468
54. Linguagens Regulares – Propriedades
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 158 / 468
Linguagens Regulares – Propriedades
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
Prova: basta inverter os estados finais com não-finais
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 158 / 468
Linguagens Regulares – Propriedades
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
Prova: basta inverter os estados finais com não-finais
Se L1 e L2 são regulares, então L1 L2 também é regular
Prova: Lei de Morgan: L1 L2 = (L1 [ L2)
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 158 / 468
Linguagens Regulares – Propriedades
Propriedades de Fechamento
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 159 / 468
55. Linguagens Regulares – Propriedades
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)
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 160 / 468
Linguagens Regulares – Propriedades
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)
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 161 / 468
Linguagens Regulares – Propriedades
É 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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 162 / 468
Linguagens Regulares
Lema do Bombeamento
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 163 / 468
56. 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 infinitas (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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 164 / 468
Linguagens Regulares – Lema do Bombeamento
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 165 / 468
Linguagens Regulares – Lema do Bombeamento
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 166 / 468
Linguagens Regulares – Lema do Bombeamento
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 167 / 468
57. Linguagens Regulares – Lema do Bombeamento
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.”
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 168 / 468
Linguagens Regulares – Lema do Bombeamento
Exemplo #1: L = {aibi | i 0}
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 169 / 468
Linguagens Regulares – Lema do Bombeamento
Exemplo #1: L = {aibi | i 0}
Assuma que L é regular e seja k a constante especificada 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.
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 169 / 468
Linguagens Regulares – Lema do Bombeamento
Exemplo #2: L = {an | n é um quadrado perfeito }
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 170 / 468
58. Linguagens Regulares – Lema do Bombeamento
Exemplo #2: L = {an | n é um quadrado perfeito }
Assuma que L é regular e seja k a constante especificada 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.
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 170 / 468
Linguagens Regulares – Lema do Bombeamento
Exercício de Fixação
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 }
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 171 / 468
4. Linguagens Livres de Contexto – Conteúdo
1 Revisão 3
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-
Gramática Livre de Contexto 178
Recursividade
Árvore de Derivação
Ambiguidade
Backus-Nahur Form (BNF)
4 Linguagens Livres de Contexto 172
Formas Normais 207
Transformações de Gramática 214
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
Forma Normal de Chomsky 248
Remoção de recursividade à esquerda 256
Forma Normal de Greibach 264
Autômatos com Pilha 278
Variantes
Critérios de Aceitação
Algoritmos de Reconhecimento 305
Autômato com Pilha como Reconhecedor
Autômato com Pilha Descendente
Algoritmo de Cocke-Younger-Kasami (CYK)
Algoritmo de Early
Algoritmos 337
Transformação de GLCs para APs
Transformação de APs para GLCs
Propriedades 356
5 Linguagens Sensíveis ao Contexto 373
Teoremas
6 Linguagens Irrestritas 393
Variantes
7 Considerações Finais 459
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 172 / 468
Linguagens Livres de Contexto
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 173 / 468
59. 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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 174 / 468
Linguagens Livres de Contexto
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!
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 175 / 468
Linguagens Livres de Contexto
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)
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 176 / 468
Linguagens Livres de Contexto
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 especificam a gramática formal da LP
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 177 / 468