Apostila Linguagens Formais e Autômatos (LFA)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Derivação
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:
w
w
L(G) = {w 2 ⌃⇤
| S )⇤
w}
S ! aA
A ! aA | bB
B ! aB | bB | a
S ! aA
A ! aA | bB
B ! aB | bB | a
S ) aA
) abB
) abaB
) ababB
) ababa
S ! aA
A ! aA | bB
B ! aB | bB | a
S ) aA
) abB
) abaB
) ababB
) ababa
E abbabb 2 L(G)?

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Gramática Livre de Contexto
Linguagens Livres de Contexto – Gramática Livre de Contexto
Gramática Livre de Contexto (GLC)
Uma GLC é uma quádrupla (V, ⌃, P, S):
Regras: µ ! ⌫
µ 2 V (i.e., um não-terminal)
⌫ 2 (V [ ⌃)⇤
Regras
Mecânica: A ! w
o não-terminal A pode ser trocado por w
Exemplo: uAv ) uwv
Livre de contexto:
A sempre pode ser trocado por w (independentemente do
“contexto” u e v onde A ocorrer)
Característica Intrínseca
GLC permitem produzir duplo balanceamento
Em uma analogia com LPs
Permitem blocos balanceado, e.g., beginn
endn
ou {n
}n
Permitem parênteses balanceados (n
)n
Derivação
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 )i
w w é derivável a partir de v aplicando i regras
Portanto:
w
w
L(G) = {w 2 ⌃⇤
| S )⇤
w}

Exemplos
Deﬁnir GLCs para as seguintes linguagens:
1 Palíndromas sobre {a, b}, i.e., L = {w 2 {a, b}⇤
| w = wR
}
2 Palavras sobre {a, b} com tamanho ímpar, i.e.,
L = {w 2 {a, b}⇤
| |w| (mod 2) = 1}
Exemplos
| w = wR
}
S ! aSa | bSb | a | b |
L = {w 2 {a, b}⇤
| |w| (mod 2) = 1}
Exemplos
| w = wR
}
S ! aSa | bSb | a | b |
L = {w 2 {a, b}⇤
| |w| (mod 2) = 1}
S ! A | a | b
A ! aaS | abS | baS | bbS
Essa linguagem é, de fato, livre de contexto?
Exercícios
1 L = {an
bm
an
| m > 0 e n > 0}
2 L = {an
bm
cm
d2n
| m > 0 e n 0}
3 L = {an
bm
| 0  n  m  2n}

Recursividade
Recursividade
Uma regra A ! uAv é dita ser recursiva
Uma regra A ! Av é dita ser recursiva à esquerda
Uma regra A ! uA é dita ser recursiva à direita
Tipo de Derivações
Derivações mais à esquerda (usada por analisadores sintáticos descendentes)
Sempre trocam o V mais à esquerda da forma sentencial
Derivações mais à direita
Sempre trocam o V mais à direita da forma sentencial
Exemplo
Assuma a seguinte GLC:
S ! AA
A ! AAA | bA | Ab | a
Possíveis derivações para palavra ababaa:
S ) AA ) aA ) aAAA ) abAAA ) abaAA ) ababAA )
ababaA ) ababaa
S ) AA ) AAAA ) aAAA ) abAAA ) abaAA )
ababAA ) ababaA ) ababaa
S ) AA ) Aa ) AAAa ) AAbAa ) AAbaa ) AbAbaa )
Ababaa ) ababaa
S ) AA ) aA ) aAAA ) aAAa ) abAAa ) abAbAa )
ababAa ) ababaa
Exemplo
S ! AA
ababaA ) ababaa (derivação mais à esq.)
ababAA ) ababaA ) ababaa (derivação mais à esq.)
Ababaa ) ababaa (derivação mais à dir.)
ababAa ) ababaa (só derivação)

Exemplo
S ! AA
ababaA ) ababaa (derivação mais à esq.)
ababAA ) ababaA ) ababaa (derivação mais à esq.)
Ababaa ) ababaa
ababAa ) ababaa
Teorema
Seja G uma GLC. Uma palavra w pertence a L(G) sse existe
uma derivação mais à esquerda para w a partir de S
Prova pode ser encontrada em Sudkamp [6]
Derivação de palavras em uma árvore
Partindo do símbolo inicial como raíz
Terminando em símbolos terminais como folhas
Conveniente em muitas aplicações
Compiladores
Processadores de texto

Árvore de Derivação – Definição
Raíz: símbolo inicial
Vértices interiores: variáveis
Se A é um vértice interior e X1, X2, ..., Xn são “filhos” de A
A ! X1, X2, ..., Xn é uma produção da gramática
X1, X2, ..., Xn são ordenados da esquerda para a direita
Folha: terminal ou símbolo vazio
Se vazio: único filho de seu pai (A ! )
Exemplo #1
GLC: S ! aSb |
Palavra: aabb
S
a S b
a bS
Exemplo #2
GLC: E ! E + E | E ⇤ E | (E) | id
Palavra: id + id * id
E
E + E
id E ⇤ E
id id
Exemplo #2
GLC: E ! E + E | E ⇤ E | (E) | id
Palavra: id + id * id
E
E + E
id E ⇤ E
id id
Algum problema com a
GLC ou com a árvore?

Ambiguidade
Ambiguidade
Uma GLC G é ambígua se existir uma palavra w em L(G)
que possua duas derivações mais à esquerda diferentes
o que signiﬁca duas árvores de derivação diferentes
Exemplo: L(G) = a+
Exemplo de gramática ambígua para L(G):
S ! aS | Sa | a
Ambiguidade para aa:
Exemplo de gramática não-ambígua para L(G):
Ambiguidade
Exemplo: L(G) = a+
S ! aS | Sa | a
Ambiguidade para aa: S ) aS ) aa e S ) Sa ) aa
Ambiguidade
Exemplo: L(G) = a+
S ! aS | Sa | a
Ambiguidade para aa: S ) aS ) aa e S ) Sa ) aa
S ! aS | a (além de não-ambígua, é regular)

Assuma a seguinte GLC G usada reconhecer expressões
aritméticas em um analisador sintático
E ! E + E | E ⇤ E | (E) | id
Sim. Assuma w = id + id ⇤ id, logo:
E ) E + E ) id + E ) id + E ⇤ E ) id + id ⇤ E ) id + id ⇤ id
E ) E ⇤ E ) E + E ⇤ E ) id + E ⇤ E ) id + id ⇤ E ) id + id ⇤ id
Ambiguidade – Exemplo #2 – Árvores de Derivação
GLC: E ! E + E | E ⇤ E | (E) | id
Derivações:
E ) E + E ) id + E ) id + E ⇤ E ) id + id ⇤ E ) id + id ⇤ id
E ) E ⇤ E ) E + E ⇤ E ) id + E ⇤ E ) id + id ⇤ E ) id + id ⇤ id
E
E + E
id E ⇤ E
id id
E
E⇤E
idE+E
idid
Ambiguidade – Exemplo #2 – Gramática equivalentemente não
ambígua
Deve deﬁnir a prioridade de operadores:
E ! E + T | T
T ! T ⇤ F | F
F ! (E) | id
É possível duas derivações mais à esquerda para
id + id ⇤ id?
Ambiguidade – Indecibilidade
O problema de determinar se uma GLC arbitrária é
ambígua é indecidível
Portanto, isso signiﬁca que ...

Para refletir!
Seja a seguinte GLC que gere { } [ {ab}{ab}⇤{a}⇤:
S ! abSA |
A ! Aa |
Pergunta-se: Essa GLC gera uma LLC?
Para refletir!
S ! abSA |
A ! Aa |
Não
Para refletir!
S ! abSA |
A ! Aa |
Não
Então, ela gera, de fato, uma LR. No entanto, LR ⇢ LLC
Ambiguidade – Gramáticas Inerentemente ambíguas
Maioria das LLC podem ser geradas por uma GLC não
ambígua
No entanto...
Nem toda LLC pode ser gerada por uma GLC não ambígua
Tais LLC são inerentemente ambíguas

Exemplo clássico:
L= {an
bm
cm
dn
ou an
bn
cm
dm
| m 1 e n 1}
Crie uma GLC para L
Mostre a derivação de, e.g., aabbccdd
Exemplo clássico:
L= {an
bm
cm
dn
ou an
bn
cm
dm
| m 1 e n 1}
Crie uma GLC para L
Mostre a derivação de, e.g., aabbccdd
G(L):
S ! aNd | aXbcYd
N ! aNd | bMc
M ! bMc |
X ! aXb |
Y ! cYd |
Notação Backus-Nahur Form (BNF)
Proposta em ⇠1960
Notação normalmente utilizada para deﬁnir GLCs de LPs
Notação BNF:
“!” é substituído por “::=” (ou apenas “:”)
Terminais: negrito (ou começando com minúsculas)
Variáveis: < . . . > (ou começando com maiúsculas)
Não se usa
{A} denota zero ou mais repetições de A
[A] denota que A é opcional

BNF de Java
The Java Language Specification (http://java.sun.com/docs/books/jls/)
Fragmento de exemplo:
IfThenStatement:
if ( Expression ) Statement
IfThenElseStatement:
if ( Expression ) StatementNoShortIf else Statement
BasicForStatement:
for ( [ForInit] ; [Expression] ; [ForUpdate] ) Statement
BNF de DCL (não apenas LP)
1 S ::= ModDecl | DCDecl
3 ModDecl ::= module ModId : ModDef { , ModDef} ( ModDecl | DCDecl )
5 ModDef ::= ClassName | ClassName+ | Pkg* | Pkg** | RegExpr
7 DCDecl ::=
only RefMod can-Type { , can-Type} RefMod [ DCDecl ] |
9 RefMod cannot-Type {, cannot-Type} RefMod [DCDecl] |
RefMod can-Type-only {, can-Type-only} RefMod [DCDecl] |
11 RefMod must-MustType { , must-MustType } RefMod [ DCDecl ]
13 RefMod ::= ( ModDef | ModId ) { , RefMod}
15 MustType ::= extend | implement | derive | throw | useannotation
17 Type ::= access | declare | handle | create | depend | MustType
Formas Normais
Linguagens Livres de Contexto – Formas Normais
Problema
GLCs são muito flexíveis
Não existem restrições na forma do lado direito das regras
Isso facilita a construção das gramáticas
Embora dificulte a construção de analisadores sintáticos
Formas Normais (FN)
Impõem restrições no lado direito das regras de uma GLC
Mas não reduzem o poder de expressão de GLC
Geradas automaticamente (via algoritmo)
Serão abordadas:
FN de Chomsky
FN de Greibach

FN de Chomsky
Uma GLC G = (V, ⌃, P, S) está na FN de Chomsky se suas
regras têm uma das seguintes formas:
A ! BC onde B, C 2 V {S}
A ! a onde a 2 ⌃
S !
Propriedade: árvores de derivação são sempre binárias
Não é complexo converter uma GLC para a FN de
Chomsky quando a mesma:
Símbolo inicial não é recursivo (S 6! ↵S )
É essencialmente não-contrátil (só S ! )
Não possui regras de cadeia (A 6! B)
Não possui símbolos inúteis (8B | B ) ⌃+
e S ) ↵B )
FN de Chomsky
A ! a onde a 2 ⌃
S !
Símbolo inicial não é recursivo (S 6! ↵S ) ?
É essencialmente não-contrátil (só S ! ) ?
Não possui regras de cadeia (A 6! B) ?
e S ) ↵B ) ?
Forma normal não é minimização! (Parte 1)
Assuma a GLC clássica:
S ! aSb |
Símbolo inicial não recursivo: (S 6! ↵S )
S0
! S
S ! aSb |
Essencialmente não-contrátil: (só S ! )
S0
! S |
S ! aSb | ab
Sem regras de cadeia: (A 6! B)
S0
! aSb | ab |
S ! aSb | ab
Forma normal não é minimização! (Parte 1 ainda)
Sem regras de cadeia: (A 6! B)
S0
! aSb | ab |
S ! aSb | ab
Sem símbolos inúteis (que não geram terminais): (8B | B ) ⌃+
)
Todos geram terminais!
Sem símbolos inúteis (que não são alcançáveis): (8B | S ) ↵B )
Todos são alcançáveis!
Forma Normal de Chomsky (FNC):
S0
! AX | AB |
X ! SB
S ! AX | AB
A ! a
B ! b

FN de Greibach
Uma GLC G = (V, ⌃, P, S) está na FN de Greibach se suas
A ! aA1A2A3 . . . An onde a 2 ⌃ e A1..n 2 V {S}
A ! a
S !
1o passo:
Transformar GLC para FN de Chomsky
2o passo:
Em um futuro próximo...
Forma normal não é minimização! (Parte 2)
Forma Normal de Chomsky (FNC):
S0
! AX | AB |
X ! SB
S ! AX | AB
A ! a
B ! b
Forma Normal de Greibach (FNG):
S0
! aX | aB |
X ! aXB | aBB
S ! aX | aB
B ! b
Transformações de Gramática
Linguagens Livres de Contexto – Transformações de Gramática
Para alcançar uma FN, é importante que transformações
sejam realizadas na GLC
As quais adicionam, modiﬁcam ou eliminam regras
Veremos uma série de transformações em GLC:
Remoção de recursividade no símbolo inicial (S 6! ↵S )
Eliminação de regras (NULLABLE, só S ! )
Eliminação de regras de cadeia (CHAIN, A 6! B)
Remoção de símbolos inúteis [TERM, 8B | B )⇤
⌃+
e REACH, 8B | S )⇤
↵B )

Símbolo inicial (S) deve se limitar a iniciar derivações
i.e., S não deve ser uma variável recursiva
Não deve ser possível ter S )⇤
↵S
Assuma uma GLC G = (V, ⌃, P, S) onde S é recursivo, logo:
G0
= (V [ {S0
}, ⌃, P [ {S0
! S}, S0
)
L(G0
) = L(G)
Símbolo inicial S0
de G0
não é mais recursivo
(V, ⌃, P, S) =) (V [ {S0}, ⌃, P [ {S0 ! S}, S0)
Exemplo
S ! aS | AB | AC
A ! aA |
B ! bB | bS
C ! cC |
+
(V, ⌃, P, S) =) (V [ {S0}, ⌃, P [ {S0 ! S}, S0)
Exemplo
S ! aS | AB | AC
A ! aA |
B ! bB | bS
C ! cC |
+
S0 ! S
S ! aS | AB | AC
A ! aA |
B ! bB | bS
C ! cC |

Variável anulável: V que pode derivar
Se A é anulável, então: A )⇤
Gramática não-contrátil:
Não possui variáveis anuláveis, i.e., ¬9A 2 V (A ! )
Assim, não diminuem tamanho forma sentencial, i.e., |µ|  |⌫|
Gramática essencialmente não-contrátil:
Gramática não-contrátil, mas admite uma regra : S !
Todas as derivações são não-contráteis, exceto S )
Exemplo:
S ! aAb
A ! aA | B
B ! bB |
Exemplo:
S ! aAb
A ! aA | B Variáveis anuláveis?
B ! bB |
Exemplo:
S ! aAb
A ! aA | B Variáveis anuláveis? B e A
B ! bB |

Algoritmo NULLABLE (estratégia bottom-up)
Entrada: Uma GLC G = (V, ⌃, P, S)
Saída: Conjunto de variáveis anuláveis (NULLABLE)
NULL = {A | {A ! } 2 P}
repita
PREV = NULL
para cada A 2 V faça
se A ! w e w 2 PREV⇤
faça
NULL = NULL [ {A}
até NULL == PREV
Exemplo
S ! ACA
A ! aAa | B | C
B ! bB | b
C ! cC |
NULLABLE
NULL PREV
NULL = {A | {A ! } 2 P}
repita
PREV = NULL
faça
NULL = NULL [ {A}
até NULL == PREV
Exemplo
S ! ACA
A ! aAa | B | C
B ! bB | b
C ! cC |
NULLABLE
NULL PREV
(0) {C} ;
NULL = {A | {A ! } 2 P}
repita
PREV = NULL
faça
NULL = NULL [ {A}
até NULL == PREV
Exemplo
S ! ACA
A ! aAa | B | C
B ! bB | b
C ! cC |
NULLABLE
NULL PREV
(0) {C} ;
(1) {C, A} {C}
NULL = {A | {A ! } 2 P}
repita
PREV = NULL
faça
NULL = NULL [ {A}
até NULL == PREV

Exemplo
S ! ACA
A ! aAa | B | C
B ! bB | b
C ! cC |
NULLABLE
NULL PREV
(0) {C} ;
(1) {C, A} {C}
(2) {C, A, S} {C, A}
NULL = {A | {A ! } 2 P}
repita
PREV = NULL
faça
NULL = NULL [ {A}
até NULL == PREV
Exemplo
S ! ACA
A ! aAa | B | C
B ! bB | b
C ! cC |
NULLABLE
NULL PREV
(0) {C} ;
(1) {C, A} {C}
(2) {C, A, S} {C, A}
(3) {C, A, S} {C, A, S}
NULL = {A | {A ! } 2 P}
repita
PREV = NULL
faça
NULL = NULL [ {A}
até NULL == PREV
Técnica para eliminação de regras
Calcular conjunto de variáveis anuláveis
e eliminar regras que levam diretamente a
Adicionar regras na gramática onde a ocorrência de
variáveis anuláveis é omitida, por exemplo:
Assuma GLC com a seguinte regra: A ! BABa
Assuma que B é anulável
Logo, as seguintes regras devem ser adicionadas:
A ! ABa
A ! BAa
A ! Aa
Se 2 L(G), então regra S ! deve estar presente
Exemplo #1
S ! ACA
A ! aAa | B | C
B ! bB | b
C ! cC |
+ variáveis anuláveis:

Exemplo #1
S ! ACA
A ! aAa | B | C
B ! bB | b
C ! cC |
+ variáveis anuláveis: {S, A, C}
Exemplo #1
S ! ACA
A ! aAa | B | C
B ! bB | b
C ! cC |
+ variáveis anuláveis: {S, A, C}
S ! ACA | AC | AA | CA | A | C |
A ! aAa | B | C | aa
B ! bB | b
C ! cC | c
Exemplo #2
L(G) = a⇤b⇤c⇤
G : S ! ABC
A ! aA |
B ! bB |
C ! cC |
+ variáveis anuláveis:
Exemplo #2
L(G) = a⇤b⇤c⇤
G : S ! ABC
A ! aA |
B ! bB |
C ! cC |
+ variáveis anuláveis: {S, A, B, C}

Exemplo #2
L(G) = a⇤b⇤c⇤
G : S ! ABC
A ! aA |
B ! bB |
C ! cC |
+ variáveis anuláveis: {S, A, B, C}
S ! ABC | AB | BC | AC | A | B | C |
A ! aA | a
B ! bB | b
C ! cC | c
G : S ! aBC | Ba
A ! aA |
B ! AC
C ! cA | b | A
Uma regra na forma A ! B
Não aumenta tamanho da forma sentencial
Não gera símbolos terminais
Apenas renomeia uma variável
Tais regras são chamadas regras de cadeia (chain rules)

Eliminação de regras de cadeia – Exemplo
Suponha a seguinte gramática:
A ! aA | a | B
B ! bB | b | C
Eliminando a cadeia A ! B:
A ! aA | a | bB | b | C
B ! bB | b | C
Infelizmente, uma nova cadeia apareceu: A ! C
Portanto, o procedimento deve ser reaplicado
Até não mais restarem cadeias
Algoritmo CHAIN
Entrada: Uma GLC essencialmente não contrátil G = (V, ⌃, P, S) e
uma variável qualquer A 2 V
Saída: Conjunto de variáveis deriváveis a partir de A
aplicando-se apenas regras de cadeia
CHAIN(A) = {A}
PREV = ;
repita
NEW = CHAIN(A) PREV
PREV = CHAIN(A)
para cada B 2 NEW faça
para cada B ! C faça
CHAIN(A) = CHAIN(A) [ {C}
até CHAIN(A) == PREV
Exemplo
S ! ACA | CA | AA | AC | A | C |
A ! aAa | aa | B | C
B ! bB | b
C ! cC | c
CHAIN(S)
CHAIN(S) PREV NEW
(0) {S} ;
(1)
(2)
(3)
Exemplo
S ! ACA | CA | AA | AC | A | C |
B ! bB | b
C ! cC | c
CHAIN(S)
CHAIN(S) PREV NEW
(0) {S} ; {S}
(1)
(2)
(3)

Exemplo
S ! ACA | CA | AA | AC | A | C |
B ! bB | b
C ! cC | c
CHAIN(S)
CHAIN(S) PREV NEW
(0) {S} ; {S}
(1) {S, A, C} {S}
(2)
(3)
Exemplo
S ! ACA | CA | AA | AC | A | C |
B ! bB | b
C ! cC | c
CHAIN(S)
CHAIN(S) PREV NEW
(0) {S} ; {S}
(1) {S, A, C} {S} {A, C}
(2)
(3)
Exemplo
S ! ACA | CA | AA | AC | A | C |
B ! bB | b
C ! cC | c
CHAIN(S)
CHAIN(S) PREV NEW
(0) {S} ; {S}
(1) {S, A, C} {S} {A, C}
(2) {S, A, C, B} {S, A, C}
(3)
Exemplo
S ! ACA | CA | AA | AC | A | C |
B ! bB | b
C ! cC | c
CHAIN(S)
CHAIN(S) PREV NEW
(0) {S} ; {S}
(1) {S, A, C} {S} {A, C}
(2) {S, A, C, B} {S, A, C} {B}
(3)

Exemplo
S ! ACA | CA | AA | AC | A | C |
B ! bB | b
C ! cC | c
CHAIN(S)
CHAIN(S) PREV NEW
(0) {S} ; {S}
(1) {S, A, C} {S} {A, C}
(2) {S, A, C, B} {S, A, C} {B}
(3) {S, A, C, B} {S, A, C, B}
Exemplo
S ! ACA | CA | AA | AC | A | C |
B ! bB | b
C ! cC | c
CHAIN(S)
CHAIN(S) PREV NEW
(0) {S} ; {S}
(1) {S, A, C} {S} {A, C}
(2) {S, A, C, B} {S, A, C} {B}
(3) {S, A, C, B} {S, A, C, B} –
Gramática Original
S ! ACA | CA | AA | AC | A | C |
B ! bB | b
C ! cC | c
Resultado do algoritmo aplicado em todas as variáveis
CHAIN(S) = {S, A, C, B}
CHAIN(A) = {A, B, C}
CHAIN(B) = {B}
CHAIN(C) = {C}
Gramática Original
S ! ACA | CA | AA | AC | A | C |
B ! bB | b
C ! cC | c
CHAIN(S) = {S, A, B, C}
CHAIN(B) = {B}
CHAIN(C) = {C}
Novas Regras
A ! w onde B ! w 2 P, w 62 V e B 2 CHAIN(A)

Gramática Original
S ! ACA | CA | AA | AC | A | C |
B ! bB | b
C ! cC | c
CHAIN(B) = {B}
CHAIN(C) = {C}
Novas Regras
Nova Gramática sem Regras de Cadeia
S ! ACA | CA | AA | AC |
A ! aAa | aa
B ! bB | b
C ! cC | c
Gramática Original
S ! ACA | CA | AA | AC | A | C |
B ! bB | b
C ! cC | c
CHAIN(B) = {B}
CHAIN(C) = {C}
Novas Regras
S ! ACA | CA | AA | AC | | aAa | aa
A ! aAa | aa
B ! bB | b
C ! cC | c
Gramática Original
S ! ACA | CA | AA | AC | A | C |
B ! bB | b
C ! cC | c
CHAIN(B) = {B}
CHAIN(C) = {C}
Novas Regras
S ! ACA | CA | AA | AC | | aAa | aa | bB | b
A ! aAa | aa
B ! bB | b
C ! cC | c
Gramática Original
S ! ACA | CA | AA | AC | A | C |
B ! bB | b
C ! cC | c
CHAIN(B) = {B}
CHAIN(C) = {C}
Novas Regras
S ! ACA | CA | AA | AC | | aAa | aa | bB | b | cC | c
A ! aAa | aa
B ! bB | b
C ! cC | c

Gramática Original
S ! ACA | CA | AA | AC | A | C |
B ! bB | b
C ! cC | c
CHAIN(B) = {B}
CHAIN(C) = {C}
Novas Regras
A ! aAa | aa | bB | b
B ! bB | b
C ! cC | c
Gramática Original
S ! ACA | CA | AA | AC | A | C |
B ! bB | b
C ! cC | c
CHAIN(B) = {B}
CHAIN(C) = {C}
Novas Regras
A ! aAa | aa | bB | b | cC | c
B ! bB | b
C ! cC | c
Resumo
GLCs essencialmente não-contráteis e sem regras de
cadeia tem uma das seguintes formas:
S !
A ! a
A ! w onde w 2 (V [ ⌃)⇤
e |w| 2
G : S ! aS | b | A
A ! aA | a | C
B ! a | b
C ! c | B
D ! dD | B

Variável inútil
não aparece em derivações que geram palavras
não contribui para geração de palavras
Exemplo (Qual é a L(G)?)
S ! AC | BS | B
A ! aA | aF
B ! CF | b
C ! cC | D
D ! aD | BD | C
E ! aA | BSA
F ! bB | b
Símbolos Inúteis
Um símbolo x 2 (V [ ⌃) é útil se:
S )⇤
uxv )⇤
w, onde u, v 2 (V [ ⌃)⇤
e w 2 ⌃⇤
Um terminal é útil quando ocorre em uma palavras w 2 L(G)
Uma variável A é útil se existe: S )⇤ uAv )⇤ w, w 2 L(G)
Algoritmo TERM
Saída: Conjunto de variáveis que geram terminais (TERM)
TERM = {A | existe uma regra A ! w 2 P , com w 2 ⌃⇤
}
repita
PREV = TERM
se A ! w 2 P e w 2 (PREV [ ⌃)⇤
então
TERM = TERM [ A
até PREV == TERM

Exemplo
S ! AC | BS | B
A ! aA | aF
B ! CF | b
C ! cC | D
D ! aD | BD | C
E ! aA | BSA
F ! bB | b
TERM
TERM PREV
Exemplo
S ! AC | BS | B
A ! aA | aF
B ! CF | b
C ! cC | D
D ! aD | BD | C
E ! aA | BSA
F ! bB | b
TERM
TERM PREV
(0) {B, F} ;
Exemplo
S ! AC | BS | B
A ! aA | aF
B ! CF | b
C ! cC | D
D ! aD | BD | C
E ! aA | BSA
F ! bB | b
TERM
TERM PREV
(0) {B, F} ;
(1) {B, F, A, S} {B, F}
Exemplo
S ! AC | BS | B
A ! aA | aF
B ! CF | b
C ! cC | D
D ! aD | BD | C
E ! aA | BSA
F ! bB | b
TERM
TERM PREV
(0) {B, F} ;
(1) {B, F, A, S} {B, F}
(2) {B, F, A, S, E} {B, F, A, S}

Exemplo
S ! AC | BS | B
A ! aA | aF
B ! CF | b
C ! cC | D
D ! aD | BD | C
E ! aA | BSA
F ! bB | b
TERM
TERM PREV
(0) {B, F} ;
(1) {B, F, A, S} {B, F}
(2) {B, F, A, S, E} {B, F, A, S}
(3) {B, F, A, S, E} {B, F, A, S, E}
Gramática Original
S ! AC | BS | B
A ! aA | aF
B ! CF | b
C ! cC | D
D ! aD | BD | C
E ! aA | BSA
F ! bB | b
Gramática Original
S ! AC | BS | B
A ! aA | aF
B ! CF | b
C ! cC | D
D ! aD | BD | C
E ! aA | BSA
F ! bB | b
Variáveis que não geram terminal
V {B, F, A, S, E} = {C, D}
Gramática Original
S ! AC | BS | B
A ! aA | aF
B ! CF | b
C ! cC | D
D ! aD | BD | C
E ! aA | BSA
F ! bB | b
Variáveis que não geram terminal
V {B, F, A, S, E} = {C, D}
Nova Gramática sem variáveis que não geram terminal
S ! BS | B
A ! aA | aF
B ! b
E ! aA | BSA
F ! bB | b

Algoritmo REACH
Saída: Conjunto de variáveis alcançáveis a partir de S (REACH)
REACH = {S}
PREV = ;
repita
NEW = REACH PREV
PREV = REACH
para cada A 2 NEW faça
para cada A ! w faça
adicione todas as variáveis de w em REACH
até REACH == PREV
Exemplo
S ! BS | B
A ! aA | aF
B ! b
E ! aA | BSA
F ! bB | b
REACH
REACH PREV NEW
(0) {S} ;
(1)
(2)
Exemplo
S ! BS | B
A ! aA | aF
B ! b
E ! aA | BSA
F ! bB | b
REACH
REACH PREV NEW
(0) {S} ; {S}
(1)
(2)
Exemplo
S ! BS | B
A ! aA | aF
B ! b
E ! aA | BSA
F ! bB | b
REACH
REACH PREV NEW
(0) {S} ; {S}
(1) {S, B} {S}
(2)

Exemplo
S ! BS | B
A ! aA | aF
B ! b
E ! aA | BSA
F ! bB | b
REACH
REACH PREV NEW
(0) {S} ; {S}
(1) {S, B} {S} {B}
(2)
Exemplo
S ! BS | B
A ! aA | aF
B ! b
E ! aA | BSA
F ! bB | b
REACH
REACH PREV NEW
(0) {S} ; {S}
(1) {S, B} {S} {B}
(2) {S, B} {S, B}
Exemplo
S ! BS | B
A ! aA | aF
B ! b
E ! aA | BSA
F ! bB | b
REACH
REACH PREV NEW
(0) {S} ; {S}
(1) {S, B} {S} {B}
(2) {S, B} {S, B} –
Gramática Original
S ! BS | B
A ! aA | aF
B ! b
E ! aA | BSA
F ! bB | b

Gramática Original
S ! BS | B
A ! aA | aF
B ! b
E ! aA | BSA
F ! bB | b
Variáveis inalcançáveis:
V {S, B} = {A, E, F}
Gramática Original
S ! BS | B
A ! aA | aF
B ! b
E ! aA | BSA
F ! bB | b
Variáveis inalcançáveis:
V {S, B} = {A, E, F}
Nova Gramática sem variáveis inalcançáveis (Qual a L(G)?)
S ! BS | B
B ! b
Exercício de Fixação (TERM e REACH)
G : S ! aB | aA | bcC
A ! aA | ABA
B ! bB | b
C ! cC | BEA
D ! aE | bEc | d
E ! cD | cEb
Para remoção de variáveis inúteis: TERM e REACH (nesta ordem)
G : S ! a | AB
A ! b
B ! aB
TERM = {S, A}
GT : S ! a
A ! b
REACH = {S}
GR : S ! a
Se algoritmos forem aplicados na ordem inversa, o
resultado seria incorreto!

Se fosse na ordem errada:
G : S ! a | AB
A ! b
B ! aB
REACH = {S, A, B}
GR : S ! a | AB
A ! b
B ! aB
TERM = {S, A}
GT : S ! a
A ! b
Bem esquisito!
Forma Normal de Chomsky
Linguagens Livres de Contexto – Forma Normal de Chomsky
FN de Chomsky
A ! a onde a 2 ⌃
S !
e S ) ↵B )
Exemplo #1
A ! bDcF
FN de Chomsky:

Exemplo #1
A ! bDcF
FN de Chomsky:
Primeira transformação:
A ! B0DC0F
B0 ! b
C0 ! c
Exemplo #1
A ! bDcF
FN de Chomsky:
Primeira transformação:
A ! B0DC0F
B0 ! b
C0 ! c
Segunda transformação:
A ! B0T1
B0 ! b
C0 ! c
T1 ! DT2
T2 ! C0F
Exemplo #2
S ! aABC | a
A ! aA | a
B ! bcB | bc
C ! cC | c
FN de Chomsky:
Já satisfaz pré-condições:
e S ) ↵B )
Exemplo #2
S ! aABC | a
A ! aA | a
B ! bcB | bc
C ! cC | c
FN de Chomsky:

Exercício de Fixação (todos os passos para chegar à FNC)
G : S ! aAb | bAa | B | aS
A ! bB |
B ! cBc | Ba | aB | D
C ! a | b | c
D ! aDC
E ! BB | F
F ! FEB
Remoção de rec. à esquerda
Linguagens Livres de Contexto – Remoção de rec. à esquerda
Remoção de recursividade à esquerda
Recursividade direta à esquerda pode produzir “loops
inﬁnitos” em analisadores sintáticos descendentes (top-down)
Exemplo:
S ! Aa
A ! Aa | b
S ) Aa ) Aaa ) Aaaa ) . . .
Suponha a regra genérica diretamente recursiva à esq.:
A ! Aµ1 | Aµ2 | . . . | Aµm | ⌫1 | ⌫2 | . . . | ⌫n
Regra equivalente não-recursiva à esquerda:
A ! ⌫1 | ⌫2 | . . . | ⌫n | ⌫1Z | ⌫2Z | . . . | ⌫nZ
Z ! µ1Z | µ2Z | . . . | µmZ | µ1 | µ2 | . . . | µm
Exemplo #1
A ! Aa | b
+ remoção de recursividade à esq.
Exemplo #2
A ! Aa | Ab | b | c

Exemplo #1
A ! Aa | b
A ! bZ | b
Exemplo #2
A ! Aa | Ab | b | c
Exemplo #1
A ! Aa | b
A ! bZ | b
Z ! aZ | a
Exemplo #2
A ! Aa | Ab | b | c
Exemplo #1
A ! Aa | b
A ! bZ | b
Z ! aZ | a
Exemplo #2
A ! Aa | Ab | b | c
A ! bZ | cZ | b | c
Exemplo #1
A ! Aa | b
A ! bZ | b
Z ! aZ | a
Exemplo #2
A ! Aa | Ab | b | c
A ! bZ | cZ | b | c
Z ! aZ | bZ | a | b

Exemplo #3
A ! AB | BA | a
B ! b | c
Exemplo #3
A ! AB | BA | a
B ! b | c
A ! BAZ | aZ | BA | a
Exemplo #3
A ! AB | BA | a
B ! b | c
Z ! BZ | B
Exemplo #3
A ! AB | BA | a
B ! b | c
Z ! BZ | B
B ! b | c

Exemplo #4
A ! Aa | Aab | bb | b – gera (b [ bb)(a [ ab)⇤
Exemplo #4
A ! bbZ | bZ | bb | b – gera (b [ bb)(Z [ )
Exemplo #4
A ! bbZ | bZ | bb | b – gera (b [ bb)(Z [ )
Z ! aZ | abZ | a | ab – gera (a [ ab)+
G : A ! aA | ABc | ccA

Remoção de Recursão à Esquerda
Problema: recursão à esquerda indireta
A ! Bu
B ! Av
Recursão indireta também pode gerar “loops inﬁnitos”
Solução: Forma Normal de Greibach
Observação Relevante
Removemos recursividade como a seguir:
G:
A ! Aµ1 | Aµ2 | . . . | Aµm | ⌫1 | ⌫2 | . . . | ⌫n
G’ (sem rec. à esquerda):
A ! ⌫1 | ⌫2 | . . . | ⌫n | ⌫1Z | ⌫2Z | . . . | ⌫nZ
Z ! µ1Z | µ2Z | . . . | µmZ | µ1 | µ2 | . . . | µm
Outros autores (e.g., Aho) removem como a seguir:
G:
A ! Aµ1 | Aµ2 | . . . | Aµm | ⌫1 | ⌫2 | . . . | ⌫n
G’ (sem rec. à esquerda):
A ! ⌫1Z | ⌫2Z | . . . | ⌫nZ
Z ! µ1Z | µ2Z | . . . | µmZ |
Forma Normal de Greibach
Linguagens Livres de Contexto – Forma Normal de Greibach
FN de Greibach
Uma GLC G = (V, ⌃, P, S) está na FN de Greibach se suas
A ! aA1A2A3 . . . An onde a 2 ⌃ e A1..n 2 V {S}]
A ! a
S !

FN de Greibach
1o passo:
Transformar GLC para FN de Chomsky
2o passo:
Ordenar variáveis (i.e., cada variável ganha um número)
S = 1, A = 2, B = 3, . . .
Resolver, em ordem, as recursões
recursões diretas e indiretas
3o passo: regras das seguintes formas
S !
A ! aw
A ! Bw onde w 2 V⇤
e num(B) > num(A)
Exemplo
S ! AB |
A ! AB | CB | a
B ! AB | b
C ! AC | c
FN de Greibach[1] (S = 1; A = 2; B = 3; C = 4)
Eliminando recursão à esquerda em A:
S ! AB | – ok, A > S
A ! CBR1 | aR1 | CB | a Aantes ! AB | CB | a – ok, C > A
B ! AB | b – não ok
C ! AC | c – não ok
R1 ! BR1 | B
Movendo lado direito de A para regra B ! AB e C ! AC
S ! AB |
A ! CBR1 | aR1 | CB | a
B ! CBR1B | aR1B | CBB | aB | b Bantes ! AB | b – ok, C > B
C ! CBR1C | aR1C | CBC | aC | c Cantes ! AC | c – rec. esq.
R1 ! BR1 | B

Eliminando recursão à esquerda em C:
S ! AB | – ok 3opasso
A ! CBR1 | aR1 | CB | a – ok 3opasso
B ! CBR1B | aR1B | CBB | aB | b – ok 3opasso
C ! aR1C | aC | c | aR1CR2 | aCR2 | cR2 – ok 3opasso
Cantes ! CBR1C | aR1C | CBC | aC | c
R1 ! BR1 | B
R2 ! BR1CR2 | BCR2 | BR1C | BC
PS
C já está na FN de Greibach
Mas e B?
Movendo regra C para lado direito de B:
S ! AB |
A ! CBR1 | aR1 | CB | a
B ! aR1B | aB | b | Bantes ! CBR1B | aR1B | CBB | aB | b
aR1CBR1B | aCBR1B | cBR1B | aR1CR2BR1B | aCR2BR1B | cR2BR1B |
aR1CBB | aCBB | cBB | aR1CR2BB | aCR2BB | cR2BB
C ! aR1C | aC | c | aR1CR2 | aCR2 | cR2
R1 ! BR1 | B
PS
B agora também está na FN de Greibach
Repetir o procedimento para A, S, R1 e R2 (nesta ordem)
Movendo regra C para lado direito de A:
S ! AB | Aantes ! CBR1 | aR1 | CB | a
A ! aR1CBR1 | aCBR1 | cBR1 | aR1CR2BR1 | aCR2BR1 | cR2BR1 |
aR1 | aR1CB | aCB | cB | aR1CR2B | aCR2B | cR2B | a
B ! aR1B | aB | b |
R1 ! BR1 | B
PS
A agora também está na FN de Greibach
Repetir o procedimento para S, R1 e R2 (nesta ordem)
Movendo regra A para lado direito de S: Santes ! AB |
S ! aR1CBR1B | aCBR1B | cBR1B | aR1CR2BR1B | aCR2BR1B | cR2BR1B |
aR1B | aR1CBB | aCBB | cBB | aR1CR2BB | aCR2BB | cR2BB | aB |
A ! aR1CBR1 | aCBR1 | cBR1 | aR1CR2BR1 | aCR2BR1 | cR2BR1 |
aR1 | aR1CB | aCB | cB | aR1CR2B | aCR2B | cR2B | a
B ! aR1B | aB | b |
R1 ! BR1 | B
PS
S agora também está na FN de Greibach
Repetir o procedimento para R1 e R2 (nesta ordem)

Autômatos com Pilha
Linguagens Livres de Contexto – Autômatos com Pilha
AFDs são incapazes de reconhecer aibi porque possuem
uma “memória limitada”
Memória de um AFD: seus estados, os quais são finitos
Autômatos com Pilha (AP):
AFND- + Pilha de tamanho infinito
Autômato com Pilha Não-Determinístico (APND)
Um APND é uma sextupla (Q, ⌃, , , q0, F):
= alfabeto da pilha
: Q x (⌃ [ ) x ( [ ) ! P(Q x ( [ ))
Permite transições (qi, a, b) e (qi, a0, b0) compatíveis:
É ND, i.e., (qi, a, B) = {[qj, C], [qk, D]}
Uma palavra w 2 ⌃⇤ é dita ser aceita por um APND se, e
para em um estado final com pilha vazia
Exemplo: (qi, a, A) = [qj, B]
qi qj
a A/B
qi : estado atual
a: símbolo a ser lido pela entrada
A: símbolo no topo da pilha (a ser desempilhado)
qj : novo estado
B: novo topo da pilha (a ser empilhado)
Se (estado== qi) && (entrada== a) && (topo == A) então
Lê a da entrada
Muda o estado atual de qi para qj
Desempilha A do topo da pilha e empilha B

Autômatos com Pilha: Transições
Transições são permitidas
Exemplo: (qi, a, A) = [qj, B]
Se a = , não irá ler nada da entrada
Se A = , irá realizar a transição independente do símbolo
que estiver no topo da pilha
Se B = , não irá empilhar nada após a transição
Se A = e B = em todas as transições: o AP é um AFND-
Autômatos com Pilha: Transições
Exemplos:
(qi, , A) = [qj, ]
qi qj
A/
(qi, , ) = [qj, B]
qi qj
/B
(qi, a, ) = [qj, ]
qi qj
a /
Autômatos com Pilha: Aceitação
Seja M = (Q, ⌃, , , q0, F) um AP
Uma palavra w 2 ⌃⇤ é aceita por M se existe uma
computação da forma:
[q0, w, ] `
⇤
[qi, , ], onde qi 2 F
Ou seja:
A palavra de entrada deve ser toda lida
Deve-se terminar em um estado ﬁnal
A pilha deve começar e terminar vazia
A linguagem de M, denotada por L(M), é o conjunto das
palavras aceitas por M
Exemplo Clássico
L(G) = {aibi | i > 0}

Exemplo Clássico
L(G) = {aibi | i > 0}
AP:
q0 q1
a /X
b X/
b X/
Autômatos com Pilha: Exemplos
L1 = {wcwR | w = (a [ b)⇤}
L2 = {ai | i 0} [ {aibi | i 0}
L3 = palíndromos de tamanho par sobre {a, b}
L4 = {aib2i | i 1}
L5 = palavras sobre {a, b} com o mesmo número de a e b
Autômatos com Pilha Determinísticos (APD)
Assuma as transições:
(qi, u, A) = [qj, C]
(qi, v, B) = [qk , D]
qi
qj
qk
u A/C
v B/D
Um AP é determinístico se não possui transições compatíveis
Essas duas transições são compatíveis se:
u = v e A = B
u = v e (A = ou B = )
A = B e (u = ou v = )
(u = ou v = ) e (A = ou B = )
Poder computacional
AP sem uso da pilha
Semelhante ao AF e reconheceria a classe das LR
APD
Aceita um importante subconjunto próprio da classe de LLC
Aplicação: analisadores sintáticos (compiladores)
APND
Aceita a classe das LLC
AP com 2 (ou mais) pilhas
Mesmo poder computacional da MT (dispositivo mais geral
da computação)

Variantes
APs Atômicos
Transições são sempre de uma das formas:
(qi, a, ) = [qj, ] – apenas lê entrada
(qi, , A) = [qj, ] – apenas desempilha
(qi, , ) = [qj, A] – apenas empilha
Todo AP pode ser transformado em um AP atômico
APs Atômicos – Exemplo
AP atômico para L = {aibi | i > 0}
APs Atômicos – Exemplo
AP atômico para L = {aibi | i > 0}
q0
q1
q2 q3
q4
a / /A
b / A/
b / A/

APs Estendidos
Pode-se empilhar mais de uma letra, como resultado de
uma única transição
(qi, a, A) = [qj, BCD]
Leia a,
Desempilha A e
Empilha D, C e B (i.e., B é o novo topo)
qi qj
a A/BCD
APs Estendidos – Exemplo #1
AP estendido para L = {aib2i | i 1}
AP estendido para L = {aib2i | i 1}
q0 q1
a /XX
b X/
b X/
AP estendido para L = {ai(bc)i
| i 1}

AP estendido para L = {ai(bc)i
| i 1}
q0 q1
a /BC
b B/
b B/
c C/
APs Atômicos e Estendidos
Variantes de APs (i.e., Atômicos e Estendidos) não aumentam o
poder de expressão de APs
Critério de Aceitação
Critério normal de aceitação: por estado final e pilha vazia
[q0, w, ] `
⇤
[qi, , ], qi 2 F
Critério alternativo de aceitação: por estado final
[q0, w, ] `
⇤
[qi, , ↵], qi 2 F, ↵ 2 ⇤
Basta processar toda a palavra e terminar em estado final
Critério alternativo de aceitação: por pilha vazia
[q0, w, ] `
+
[qi, , ], qi 2 Q
Basta processar toda a palavra e terminar com a pilha vazia

Aceitação por Estado Final
Novo critério não aumenta o poder de expressão de APs
Quando a aceitação é por estado final e pilha vazia, às
vezes são acrescentados transições e/ou estados apenas
para esvaziar a pilha
Exemplo: {ai
| i > 0} [ {ai
bi
| i > 0}
No caso de aceitação por estado final, tais estados são
desnecessários
q0
q1
q2
a /X X/
b X/
X/
b X/
Aceitação por Estado Final
Lema: Seja L uma linguagem aceita por um AP M por
estado final, então existe um AP M0 que aceita L por estado
final e pilha vazia
Basta acrescentar um novo estado final qf
0
e
’(qi, , ) = [qf
0
, ], para todo qi 2 F
’(qf
0
, , X) = [qf
0
, ], para todo X 2
Aceitação: [q0, w, ] `
⇤
[qi, , ↵] ` [qf
0, , ↵] `
⇤
[qf
0, , ]
Resumindo:
Aceita por estado final ) aceita por estado final e pilha
vazia (pelo lema acima)
Aceita por estado final e pilha vazia ) aceita por estado final
Aceitação por Estado Final – Exemplo
L = {aibj | i j 0}
Estado Final (EF) Estado Final e Pilha Vazia (EF/PV)
L = {aibj | i j 0}
Estado Final (EF)
q0 q1
a /A
b A/
b A/
Estado Final e Pilha Vazia (EF/PV)

L = {aibj | i j 0}
Estado Final (EF)
q0 q1
a /A
b A/
b A/
q0 q1
q0
f
a /A
b A/
/
/
b A/
A/
Aceitação por Pilha Vazia
Critério alternativo de aceitação: por pilha vazia
[q0, w, ] `
+
[qi, , ], qi 2 Q
Observe que não se exige mais que qi 2 F
Basta que a palavra seja toda lida (sempre) e pilha vazia
Por que não [q0, w, ] `
⇤
[qi, , ] ?
Aceitação por Pilha Vazia
Lema: Seja L uma linguagem aceita por um AP M por pilha
vazia, então existe um AP M0 que aceita L por estado final e
pilha vazia
Todo estado de M é um estado final em M0
Novo estado inicial q0
0
0
(q0
0
, x, A) = (q0, x, A) e
0
(qi
0
, x, A) = (qi, x, A)
para todo qi 2 Q, x 2 ⌃ [ { }, A 2 [ { }
Resumindo:
Aceita por pilha vazia ) aceita por estado final e pilha vazia
(pelo lema acima)
Aceita por estado final e pilha vazia ) aceita por pilha vazia
Aceitação por Pilha Vazia – Exemplo
L = {aibi | i > 0}
Pilha Vazia (PV) Estado Final e Pilha Vazia (EF/PV)

L = {aibi | i > 0}
Pilha Vazia (PV)
q0 q1
a /A
/
b A/
L = {aibi | i > 0}
Pilha Vazia (PV)
q0 q1
a /A
/
b A/
q0 q1
q0
0
a /A
/
b A/
a /A
/
Critérios de Aceitação: Teorema
Assuma uma LLC L, logo
Existe um AP M1 que aceita L com critério de aceitação por
pilha vazia e estado ﬁnal
estado ﬁnal
pilha vazia
Algoritmos de Reconhecimento

Linguagens Livres de Contexto – Algoritmos de Reconhecimento
Alguns problemas não possuem solução computacional:
1 Certa LLC é ambígua?
2 Duas LLCs são iguais ou diferentes?
3 Uma palavra pertence a uma linguagem?
No entanto, o problema (3) possui solução em LLCs
Uma palavra pertence a uma LLC?
Algoritmos de reconhecimento
válidos para qualquer linguagem da classe
complexidade computacional (tempo e espaço)
Reconhecedores que utilizam AP
muito simples
em geral, ineﬁcientes
tempo de processamento é proporcional a k|w|
w: palavra de entrada
k: constante que depende do autômato
Reconhecedores que não utilizam AP
Tempo de processamento proporcional a |w|3
contudo limite não foi provado, pode ser até inferior
Algoritmos construídos a partir de uma GLC
Algoritmo de Early
Classiﬁcação
Top-Down (ou Preditivo)
constrói uma árvore de derivação
a partir da raiz (símbolo inicial da gramática)
com ramos em direção às folhas (terminais)
Bottom-up
oposto do Top-Down
parte das folhas
construindo a árvore de derivação em direção à raiz

Reconhecedores usando AP
Construção relativamente simples e imediata
Relação “direta” entre produções e as transições do AP
Algoritmos
Top-Down
Simula derivação mais à esquerda
Não determinista
É direta a conversão de qualquer GLC na FN de Greibach
para um AP
Cada produção gera exat. um terminal (FN de Greibach)
Logo, geração de w requer |w| etapas de derivação
No entanto, cada terminal pode ter diversas produções
associadas
AP testa as diversas alternativas
número de passos para reconhecer w é proporcional a k|w|
k = aprox. metade da média de produções das variáveis
Logo, o tempo de reconhecimento é pode ser muito
ineﬁciente para entradas mais longas
Exemplo
L = {anbn | n 1}
G(L) = {V, ⌃, P, S} = {{S}, {a, b}, {S ! aSb, S ! ab}, S}
Forma Normal de Greibach:
G0
(L) = {{S0
, S, B}, {a, b},
{S0
! aSB, S0
! aB, S ! aSB, S ! aB, B ! b}, S0
}

Exemplo
L = {anbn | n 1}
G(L) = {V, ⌃, P, S} = {{S}, {a, b}, {S ! aSb, S ! ab}, S}
Forma Normal de Greibach:
G0
(L) = {{S0
, S, B}, {a, b},
{S0
! aSB, S0
! aB, S ! aSB, S ! aB, B ! b}, S0
}
q0 q1
a /SB
a /B
a S/SB
a S/B
b B/
Forma alternativa de construir AP
não há necessidade de estar na FNG
Igualmente simples e com o mesmo nível de eﬁciência
a partir de uma GLC sem recursão à esquerda
simula a derivação mais à esquerda
Algoritmo
inicialmente, empilha o símbolo inicial
se topo == variável, então substitui (não determinismo) por todas
as produções da variável
se topo = terminal, então testa se é igual ao próximo símbolo
da entrada
Exemplo
L = {anbn | n 1}
G(L) = {V, ⌃, P, S} = {{S}, {a, b}, {S ! AX, S ! AB, X !
SB, A ! a, B ! b}, S}

Exemplo
L = {anbn | n 1}
G(L) = {V, ⌃, P, S} = {{S}, {a, b}, {S ! AX, S ! AB, X !
SB, A ! a, B ! b}, S}
q0 q1 q2
/S
S/AX
S/AB
X/SB
A/a
B/b
a a/
b b/
/
Proposto por J. Cocke, D. H. Younger e T. Kasami em 1965
GLC deve estar na FNC
Mecânica:
Estratégia bottom-up para criação de todas as possíveis
árvores de derivação da palavra de entrada w
Tempo de processamento proporcional a |w|3
(ruim)
Ideia básica:
Tabela triangular de derivação
Célula: raízes que podem gerar a correspondente subárvore
Exemplo (contribuição de Alberto Hokari)
Considere a seguinte GLC L:
S ! AT | AB
T ! XB
X ! AT | AB
A ! a
B ! b

L aceita a palavra aaabbb? (contribuição de Alberto Hokari)
Coloca-se a palavra a ser reconhecida na base da tabela
a a a b b b
S ! AT | AB
T ! XB
X ! AT | AB
A ! a
B ! b
Para preencher a 1a linha devemos veriﬁcar qual variável
gera a sequencia de 1 terminal
a a a b b b
A A A B B B1
S ! AT | AB
T ! XB
X ! AT | AB
A ! a
B ! b
gera a sequencia de 2 terminais
Por exemplo, existe alguma regra que produza AA?
A resposta é não, então marcamos a célula com um –
a a a b b b
A A A B B B1
2 -
S ! AT | AB
T ! XB
X ! AT | AB
A ! a
B ! b
O processo se repete
a a a b b b
A A A B B B1
2 - -
S ! AT | AB
T ! XB
X ! AT | AB
A ! a
B ! b

Neste caso, existem duas regras que geram AB
Logo, ambas são colocadas na célula
S,X
a a a b b b
A A A B B B1
2 - -
S ! AT | AB
T ! XB
X ! AT | AB
A ! a
B ! b
O processo se repete até completar a 2a linha
S,X
a a a b b b
A A A B B B1
2 - - - -
S ! AT | AB
T ! XB
X ! AT | AB
A ! a
B ! b
gera a sequência de 3 terminais
as setas mostram quais pares de células devemos trabalhar a
ﬁm de se obter a sequência de três terminais
a a a b b b
1
2
3
S ! AT | AB
T ! XB
X ! AT | AB
A ! a
B ! b
1 + 2 = A + = A
Par inválido, logo marcamos a célula com um
S,X
a a a b b b
A A A B B B1
2 - - - -
-3
S ! AT | AB
T ! XB
X ! AT | AB
A ! a
B ! b

2 + 1 = + A = A
Par inválido, logo marcamos a célula com um
S,X
a a a b b b
A A A B B B1
2 - - - -
-3
S ! AT | AB
T ! XB
X ! AT | AB
A ! a
B ! b
O processo se repete até completar a 3a linha
S,X
a a a b b b
A A A B B B1
2 - - - -
-3 - -T
S ! AT | AB
T ! XB
X ! AT | AB
A ! a
B ! b
o processo se repete para as linhas superiores
S,X
a a a b b b
A A A B B B1
2 - - - -
-3 - -T
4 -
S ! AT | AB
T ! XB
X ! AT | AB
A ! a
B ! b
S,X
a a a b b b
A A A B B B1
2 - - - -
-3 - -T
4 -
S ! AT | AB
T ! XB
X ! AT | AB
A ! a
B ! b

S,X
a a a b b b
A A A B B B1
2 - - - -
-3 - -T
4 -
S ! AT | AB
T ! XB
X ! AT | AB
A ! a
B ! b
Ao final do processo, se o símbolo inicial se encontra na
primeira célula, a palavra é reconhecida pela linguagem
Neste exemplo, aaabbb 2 L
Como S é a raiz então
a palavra é reconhecida
S,X
a a a b b b
A A A B B B1
2 - - - -
-3 - -T
4 - S,X -
5
6
T-
S,X
S ! AT | AB
T ! XB
X ! AT | AB
A ! a
B ! b
Verifique se a palavra abab é aceita na seguinte GLC:
S ! XY
T ! ZT | a
X ! TY
Y ! YT | b
Z ! TZ | b
Verifique se a palavra baaba é aceita na seguinte GLC:
S ! AB | BC
A ! BA | a
B ! CC | b
C ! AB | a

Algoritmo de Early
Algoritmo de Early
Possivelmente o mais rápido algoritmo para LLC
Proposto em 1968
Tempo de processamento:
qualquer GLC sem produções : |w|3
qualquer GLC não ambígua: |w|2
muitas gramáticas de interesse prático: |w|
Algoritmo de Early
Entrada: GLC sem produções vazias
Algoritmo Top-Down (a partir de S)
Executa sempre a derivação mais à esquerda
Cada iteração gera um terminal
comparado com o símbolo da entrada
continua se puder achar uma produção que gere o próximo
símbolo
Algoritmos eﬁcientes como o de Early serão abordados em
Compiladores!
Algoritmos

Algoritmos
Linguagens Livres de Contexto – Algoritmos
Transformação de GLCs para APs (veja Autômato com Pilha como Reconhecedor)
Teorema: Se L é uma LLC, então há um AP que aceita L
Seja L uma LLC e G = (V, ⌃, P, S) a GLC que gera L
Transforme G para a forma normal de Greibach:
A ! aA1A2A3 . . . An onde a 2 ⌃ e A1..n 2 V {S}
A ! a
S !
Crie um AP estendido M = (Q, ⌃, , , q0, F): (estado inicial q0)
QM = {q0, q1}, ⌃M = ⌃G, M = VG {S}, FM = {q1}
(q0, a, ) = { [q1, w] | S ! aw 2 P }
(q1, a, A) = { [q1, w] | A ! aw 2 P e A 2 V {S} }
(q0, , ) = [q1, ], se S ! 2 P
Transformação de GLCs para APs – Exemplo
S ! aAB | aB
A ! aAB | aB
B ! b
Intuitivamente, uma regra A ! aAB somente pode ser
aplicada quando o topo da pilha for A
Neste caso, aplicar a regra em questão implica em:
Desempilhar A
Ler a
Empilhar AB
Ou seja, a pilha armazena as variáveis que ainda devem ser
derivadas
Algoritmos

Toda linguagem aceita por um AP é uma LLC
Dado um AP, gerar um AP M’ estendido onde ’ herda todas
as transições de e acrescenta duas novas transições:
Se [qj, ] 2 (qi, u, ) então
[qj , A] 2 0
(qi , u, A), para todo A 2
Se [qj, B] 2 (qi, u, ) então
[qj , BA] 2 0
(qi , u, A), para todo A 2
Interpretação para novas transições:
Todas transições que não desempilham, passam agora a
empilhar e desempilhar o mesmo símbolo
Veja que é para todo A 2 M (qualquer que seja o topo)
Claramente, L(M) = L(M0)
Algoritmo para gerar uma GLC G a partir do AP M0
Variáveis não vão ser mais maiúsculas, mas sim tuplas da
forma <qi, A, qj>
estou em qi ,
quero ir para qj e
existe A no topo da pilha
Regras de G:
#1 S ! <q0, , qj>, para todo qj 2 F
#2 Se [qj, B] 2 0
(qi, x, A), então (A e B 2 [ { })
<qi , A, qk > ! x<qj , B, qk >, para todo qk 2 Q
#3 Se [qj, BA] 2 0
(qi, x, A), então (A e B 2 )
<qi , A, qk > ! x<qj , B, qn >< qn , A, qk >, qk , qn 2 Q
#4 Para todo qk 2 Q
<qk , , qk > !
Transformação de APs para GLCs – Exemplo
Construa uma gramática G para o seguinte AP M:
Q = {q0, q1}
⌃ = {a, b, c}, = {A}
F = {q1}
L(M) = an
cbn
, n 0

q0 q1
a /A
c /
b A/
Função de transição
(q0, a, ) = [q0, A] – não desempilha e empilha A
(q0, c, ) = [q1, ] – não desempilha, não empilha
(q1, b, A) = [q1, ]
q0 q1
a /A
a A/AA
c /
c A/A
b A/
Função de transição 0 é igual a mais duas regras:
0
(q0, a, A) = [q0, AA] – pois A é o único elemento de
0
(q0, c, A) = [q1, A]
#1 S ! <q0, , qj>, para todo qj 2 F
Logo, primeira regra da GLC será: S ! <q0, , q1>
#2 Se [qj, B] 2 0(qi, x, A), então (A e B 2 [ { })
<qi, A, qk > ! x<qj, B, qk >, para todo qk 2 Q
Como [q0, A] 2 (q0, a, ), então
<q0, , qk > ! a<q0, A, qk >
Novas regras:
<q0, , q0 > ! a<q0, A, q0 > – k = 0
<q0, , q1 > ! a<q0, A, q1 > – k = 1
#3 Se [qj, BA] 2 0(qi, x, A), então (A e B 2 )
<qi, A, qk > ! x<qj, B, qn >< qn , A, qk >, qk , qn 2 Q
Como [q0, AA] 2 (q0, a, A), então
<q0, A, qk > ! a<q0, A, qn>
Novas regras:
<q0, A, q0 > ! a<q0, A, q0 >< q0 , A, q0 > – k = 0 , n = 0
<q0, A, q1 > ! a<q0, A, q0 >< q0 , A, q1 > – k = 1 , n = 0
<q0, A, q0 > ! a<q0, A, q1 >< q1 , A, q0 > – k = 0 , n = 1
<q0, A, q1 > ! a<q0, A, q1 >< q1 , A, q1 > – k = 1 , n = 1

Como [q1, ] 2 (q0, c, ), então
<q0, , qk > ! c<q1, , qk >
Novas regras:
<q0, , q0 > ! c<q1, , q0 > – k = 0
<q0, , q1 > ! c<q1, , q1 > – k = 1
Como [q1, A] 2 (q0, c, A) então
<q0, A, qk > ! c<q1.A, qk >
Novas regras:
<q0, A, q0 > ! c<q1, A, q0 > – k = 0
<q0, A, q1 > ! c<q1, A, q1 > – k = 1
Como [q1, ] 2 (q1, b, A) então
<q1, A, qk > ! b<q1, , qk >
Novas regras:
<q1, A, q0 > ! b<q1, , q0 > – k = 0
<q1, A, q1 > ! b<q1, , q1 > – k = 1
#4 Para todo qk 2 Q
<qk , , qk > !
Novas regras:
<q0, , q0> ! – k = 0
<q1, , q1> ! – k = 1

Transformação de APs para GLCs – Exemplo – GLC resultante
S ! <q0, , q1>
<q0, , q0> ! a<q0, A, q0>
<q0, , q1> ! a<q0, A, q1>
<q0, A, q0> ! a<q0, A, q0><q0, A, q0>
<q0, A, q1> ! a<q0, A, q0><q0, A, q1>
<q0, A, q0> ! a<q0, A, q1><q1, A, q0>
<q0, A, q1> ! a<q0, A, q1><q1, A, q1>
<q0, , q0> ! c<q1, , q0>
<q0, , q1> ! c<q1, , q1>
<q0, A, q0> ! c<q1, A, q0>
<q0, A, q1> ! c<q1, A, q1>
<q1, A, q0> ! b<q1, , q0>
<q1, A, q1> ! b<q1, , q1>
<q0, , q0> !
<q1, , q1> !
Transformação de APs para GLCs – Exemplo – Derivação aacbb
S ) <q0, , q1>
) a<q0, A, q1>
) aa<q0, A, q1><q1, A, q1>
) aac<q1, A, q1><q1, A, q1>
) aacb<q1, , q1><q1, A, q1>
) aacb<q1, A, q1>
) aacbb<q1, , q1>
) aacbb
Propriedades
Linguagens Livres de Contexto – Propriedades
LLCs
Mais geral que LRs
Mas, ainda é relativamente restrita

Fácil definir linguagens que não são LLC
Palavra duplicada, e.g., L = {ww | w 2 {a, b}⇤}
Analogia com compiladores:
declaração de uma variável antes do seu uso
Triplo balanceamento, e.g., L = {anbncn | n 0}
Mais importante limitação das LLC
(propositalmente) incomum em LPs
Usando Autômato com Pilha
fácil intuir por que não são LLC
Linguagens de Programação
LPs normalmente são 99% LLC (e 1% safadão)
Mas, LPs são o quê então?
Mas, e a construção if then else?
Isso é encadeamento, não balanceamento
Não confunda!
Como verificar...
... se uma LLC é fechada para operações
união?
interseção?
concatenação?
complemento?
... se uma LLC é
infinita?
finita?
vazia?
Propriedades de fechamento
Fechamento é importante para
construir novas linguagens a partir de operações sobre
linguagens conhecidas
provar propriedades
construir algoritmos
O conjunto das LLC é fechado para:
União
Concatenação
Kleene
Mas não é fechado para:
Interseção
Complemento

O conjunto das LLC é fechado para União
Prova usando AP:
Seja M1 e M2 dois APs que reconhecem duas LLCs
Basta criar um novo AP com um novo estado inicial que
possui transições para os estados iniciais de M1 e M2
(que agora deixam de ser iniciais)
O conjunto das LLC é fechado para Concatenação
Prova usando AP:
Seja M1 e M2 dois APs que reconhecem duas LLCs com
critério de aceitação por estado final
Basta criar um novo AP em que o(s) estado(s) final(is) de M1
possui(em) transições para o estado inicial de M2
O conjunto das LLC é fechado para Kleene
Prova usando AP:
Seja M um AP que reconhece uma LLC com critério de
aceitação por estado final
Basta fazer transições do(s) estado(s) final(is) para o estado
inicial
O conjunto das LLC não é fechado para Interseção
Prova por Contradição:
Seja L1 = {ai
bi
cj
| i, j 0} uma LLC
Seja L2 = {aj
bi
ci
| i, j 0} uma LLC
No entanto, L1 L2 = {ai
bi
ci
| i 0} não é LLC

O conjunto das LLC não é fechado para complemento
Prova por Contradição:
Suponha que seja fechado para complemento
Suponha que L1 e L2 são LLC
Então L = L1 [ L2 também é LLC
Mas, L = L1 L2
Já foi mostrado que L1 L2 não necessariamente é LLC
Logo, revendo a hipótese, o conjunto das LLC não é
fechado para complemento
Prova por Intuição:
Suponha uma LLC L
Suponha um AP M que reconheça L (que pode ser APND)
Uma palavra w 2 L se alguma computação de M a aceitar
É possível um AP rejeitar o complemento de L, mas não
aceitar o complemento
Prova por Intuição:
Suponha uma LLC L
Suponha um AP M que reconheça L (que pode ser APND)
Uma palavra w 2 L se alguma computação de M a aceitar
É possível um AP rejeitar o complemento de L, mas não
aceitar o complemento
Propriedades de fechamento
Teorema: Seja R uma linguagem regular e L uma linguagem
livre de contexto, então R L é LC
Suponha um AFD N que reconheça R
Suponha um AP M que reconheça L
Basta criar um AP M0 que simule a operação de N e M
Os estados nessa máquina composta serão pares ordenados
[qNi
, qMj
], onde qNi
é um estado de N e qMj
é um estado de M

LLC é Vazia?
Prova: Suponha uma LLC L
Seja G = (V, ⌃, P, S) uma GLC que reconhece L
Seja G0 = (V0, ⌃0, P0, S) a GLC equivalente a G sem símbolos
inúteis
Se P0 for vazio, então L é vazia
LLC é Finita ou Infinita?
inúteis, regras de cadeia e regras
Crie um grafo de dependência das variáveis
Se existirem ciclos no grafo de dependência, L é infinita
Caso contrário, L é finita
LLC é Finita ou Infinita?
inúteis, regras de cadeia e regras
Crie um grafo de dependência das variáveis
Se existirem ciclos no grafo de dependência, L é infinita
Caso contrário, L é finita
Exemplo (finita ou infinita?)
S ! AB
A ! aCb | a
B ! bB | bb
C ! cBS
S
A
B
C
Investigação se é LLC
Para demonstrar que uma linguagem L é LC, basta:
Criar um GLC que gere L
Criar um AP que reconheça L
Para demostrar que uma linguagem L não é LC, deve-se:
Aplicar o Lema do Bombeamento para LLCs

Lema do Bombeamento para LLCs
Ideia similar ao Lema do Bombeamento para LRs
LRs
podem expressar bombeamentos sem qualquer
balanceamento
não podem expressar bombeamentos balanceados 2 a 2
LLCs
podem expressar bombeamentos balanceados 2 a 2
não podem expressar bombeamentos balanceados 3 a 3
Detalhes em Sudkamp [6]
5. Linguagens Sensíveis ao Contexto – Conteúdo
1 Revisão 3
2 Introdução 59
Máquina de Moore
Máquinas de Mealy
Recursividade
Ambiguidade
Variantes
Algoritmo de Early
Gramática Sensível ao Contexto 375
Autômato Linearmente Limitado 381
Teoremas 388
Teoremas
Variantes
Linguagens Sensíveis ao Contexto
Gramática Sensível ao Contexto

Linguagens Sensíveis ao Contexto – Gram. Sensível ao Contexto
Gramática Sensível ao Contexto (GSC)
Uma GSC é uma quádrupla (V, ⌃, P, S):
Regras: µ ! ⌫
µ 2 (V [ ⌃)+
⌫ 2 (V [ ⌃)+
|µ|  |⌫| (i.e., regras não-contráteis, o que indica que tamanho da forma
sentencial ou aumenta ou permanece constante)
nunca é uma palavra válida em uma LSC
Gramáticas Sensíveis ao Contexto
Se L1 é uma LR, então L1 é uma LLC
Se L2 é uma LLC, então L2–{ } é uma LSC
É uma GSC?
É uma GSC?
S ! aSCbc |
Cb ! bc
É uma GSC?
S ! aSCbc |
Cb ! bc
É uma GSC?

É uma GSC?
S ! aSCbc |
Cb ! bc
É uma GSC?
S ! aAc | bc
Ac ! b
Exemplo Clássico
GSC(L):
Derivação, por exemplo, de aabbcc:
S ) aAbc ) aabCbc ) aabbCc ) aabbcc
existe um ALL que reconhece uma LSC
Exemplo Clássico
GSC(L):
S ! aAbc | abc
A ! aAbC | abC
Cb ! bC
Cc ! cc
S ) aAbc ) aabCbc ) aabbCc ) aabbcc
existe um ALL que reconhece uma LSC
Por que não usamos apenas terminais
GSC(L):
S ! aAbc | abc
A ! aAbc | abc
cb ! bc
cc ! cc
S ) aAbc ) aabcbc ) aabbcc
Durante uma derivação:
Se w 2 ⌃⇤
, então w é uma palavra da linguagem
aabcbc 2 L?

Exercícios
1 Defina L(G) para a seguinte GSC:
S ! SBA | a
BA ! AB
aA ! aaB
B ! b
2 Desenvolva uma GSC G em que L(G) = {aib2ici | i > 0}
Autômato Linearmente Limitado
Linguagens Sensíveis ao Contexto – Autômato Linearm. Limitado
Um ALL é uma óctupla (Q, ⌃, , , q0, <, >, F):
= alfabeto da fita
< e > = delimitadores da palavra de entrada
Configuração inicial da fita: hwi
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

Por que sempre para?
Assuma um ALL a verificar a palavra aabb
Logo, configuração inicial da fita: haabbi
Como a fita é finita, o número máximo de combinações é
dado pela fórmula:
max_combinacoes = |Q| ⇥ |w| ⇥ | ||w|
onde Q é o conjunto de estados, w é a palavra e é o alfabeto da fita
Assuma, nesse exemplo, Q = {q0, q1} e = {h, i, a, b, X}.
Dessa forma, o número máximo de configurações seria:
max_combinacoes = 2 ⇥ 4 ⇥ 54
= 5.000
Se o ALL ultrapassa esse limite, a palavra é rejeitada, pois
certamente está repetindo configurações (loop)
Exemplo Clássico
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
Z/Z E
Y/Y E
c/c E
b/b E
a/a E
>/> E
Y/Y D
Z/Z D
Z/Z E
Y/Y E
X/X E
1 L1 = {wcw | w 2 {a, b}⇤ e tem o mesmo número de a e b}
2 L2 = {ww | w 2 {a, b}+}
L1 = {wcw | w 2 {a, b}⇤ e tem o mesmo número de a e b}
q0 q1
q2
q3
q4
q5
q6q7
q8
q9
q0
0
q0
1
q0
2
q0
3
q0
4
</< D
a/X D
b/Y D
c/c D
a/a D
b/b D
c/c D
a/a D
b/b D
a/X E
X/X D
Y/Y D
b/Y E
X/X D
Y/Y D
c/c E X/X E
Y/Y E
X/X D
Y/Y D
a/a E
b/b E
c/c D
>/> E
X/X D
Y/Y D
</< D
X/a E
Y/b E
c/c E
c/c D
a/X D
b/X D
X/X D
b/X E
X/X D
a/a D
a/X E
X/X D
b/b D
</< D a/a E
b/b E
X/X E

Teoremas
Linguagens Sensíveis ao Contexto – Teoremas
Teorema #1: Se G é GSC, então L(G) é recursiva
Mostrar que existe uma MT M que decide L(G)
Se p é derivável ou não por L(G), então p é decidido por M
M deve simular as derivações de G
M é uma MT não-determinística com 3 fitas
Fita #1: palavra de entrada p
Fita #2: regras de G
u ! v na fita fica ##u#v##
##: separador de regras e #: !
Fita #3: usada para registrar todas as formas sentenciais de
uma derivação
Ex.: S#aAbc#aabCbc#aabbCc#aabbcc
Funcionamento de M (máquina que decide L):
S# é gravado na posição 1 da Fita #3
Regras de G são escritas na Fita #2
loop
Escolher uma regra u#v na Fita #2
Seja q# a palavra mais recente gravada na Fita #3
Escolher uma instância de u em q (se existir). Senão, parar em
estado de rejeição
Sendo q = xuy#, gravar xvy# na Fita #3, logo após q#
Se xvy == p, parar em estado de aceitação
Se xvy ocorrer em outra forma sentencial na Fita #3 ou
tam(xvy) > tam(p), parar em estado de rejeição
Funcionamento de M (máquina que decide L)
Se xvy ocorrer em outra posição na Fita #3, parar em estado
de rejeição
Justificativa: derivações cíclicas S )+
w )+
w
Se tam(xvy) > tam(p), parar em estado de rejeição
Justificativa: em GSC, derivações são não-contráteis

Teorema #2: Se L é uma LSC, então tem uma GSC G tal que L(G) = L
Se L é uma LSC, então existe um ALL M cuja L(M) = L
Em uma LSC, nenhuma forma sentencial pode ser maior que
a palavra de entrada
É impossível uma derivação S )⇤
↵ )⇤
w, onde
tam(↵) > tam(w)
Logo, “memória” (ou quantidade de ﬁta) necessária para
realizar derivações pode ser limitada pelo tamanho da
palavra de entrada
Gramáticas irrestritas não são reconhecidas por ALL
É possível uma derivação S )⇤
↵ )⇤
w, onde
tam(↵) > tam(w)
ALLs são mais parecidos com computadores reais do que
uma MT (já que essas assumem memória inﬁnita)
6. Linguagens Irrestritas – Conteúdo
1 Revisão 3
2 Introdução 59
Máquina de Moore
Máquinas de Mealy
Recursividade
Ambiguidade
Variantes
Algoritmo de Early
Gramática Irrestrita 395
Teoremas
Máquinas de Turing 404
Variantes
Teoremas 444
Linguagens Irrestritas
Gramática Irrestrita

Linguagens Irrestritas – Gramática Irrestrita
Gramática Irrestrita (GI)
Todo o universo de linguagens é gerado por GIs
Uma GI é uma quádrupla (V, ⌃, P, S):
Regras: µ ! ⌫
µ 2 (V [ ⌃)+
⌫ 2 (V [ ⌃)⇤
“Quase” nenhuma restrição é imposta (|µ| > 0)
Exemplo Clássico
L = {u[u] | u 2 {a, b}⇤}
GI(L):
S ! aT[a] | bT[b] | []
T[! aT[A | bT[B | [
Aa ! aA
Ab ! bA
Ba ! aB
Bb ! bB
A] ! a]
B] ! b]
Toda GI é recursivamente enumerável, logo:
existe uma MT que reconhece LI, mas não necessariamente
para para qualquer entrada w 2 ⌃⇤
Exemplo Clássico
GI:
S ! aAbc |
A ! aAbC |
Cb ! bC (b’s podem ser passados para antes dos C’s)
CC ! Cc
Derivações:
S ) aAbc )i 1
ai
A(bC)i 1
bc ) ai
(bC)i 1
bc
Exempliﬁcando (i=3):
aaabCbCbc ) aaabCbbCc ) aaabCbbcc )
aaabbCbcc ) aaabbbCcc ) aaabbbccc
Logo: L(GI) = aibici, i 0
Exercício
L = {aibjaibj | i, j 0}

Exercício
L = {aibjaibj | i, j 0}
GI(L):
S ! X | Y | aPAbQb
X ! aaX |
Y ! bbY |
P ! aPA |
Q ! bQb | E
Ab ! bA
AE ! a
Aa ! aa
Derivação Exemplo
S ) aPAbQb
) aaPAAbQb
) aaAAbQb
) aaAAbEb
) aaAbAEb
) aabAAEb
) aabAab
) aabaab
Gramática Irrestrita
Teoremas
Teorema #3: Se G é GI, então L(G) é rec. enumerável
Mostrar que existe uma MT M que reconhece L(G)
Se p é derivável por L(G), então p é reconhecida por M
Ou seja, M deve simular as derivações de G
M é uma MT não-determinística com 3 fitas
Fita #1: palavra de entrada p
Fita #2: regras de G
u ! v na fita fica ##u#v##
##: separador de regras e #: !
Fita #3: usada para registrar todas as formas sentenciais de
uma derivação
Ex.: S#aAbc#aabCbc#aabbCc#aabbcc
Teorema #3: Se G é GI, então L(G) é rec. enumerável
Funcionamento de M:
S# é gravado na posição 1 da Fita #3
Regras de G são escritas na Fita #2
loop
Escolher uma regra u#v na Fita #2
Seja q# a palavra mais recente gravada na Fita #3
Escolher uma instância de u em q (se existir). Senão, parar em
estado de rejeição
Sendo q = xuy#, gravar xvy# na Fita #3, logo após q#
Se xvy == p, parar em estado de aceitação

Teorema #4: Se L é uma LRE, então tem uma GI G tal que L(G) = L
Dada uma MT M que reconhece L, prova consiste em
demonstrar como criar uma GI G, com L(G) = L
Prova completa pode ser encontrada no Teorema 10.1.3
em Sudkamp [6]
Máquinas de Turing
Linguagens Irrestritas – Máquinas de Turing
Máquinas de Turing
Modelo abstrato para os computadores modernos
Propostas por Alan Turing em 1936
Considerado um dos pais da Ciência da Computação
Prêmio Turing: “Prêmio Nobel” da área de Computação
Máquina de Turing (MT)
Uma MT Padrão é uma quíntupla (Q, ⌃, , , q0):
= alfabeto da fita
Memória ilimitada
Configuração inicial da fita: BwBBBBBBBB...
A fita é infinita à direita

Máquinas de Turing
Máquina de estados com uma fita e uma cabeça de
leitura/gravação
Cada posição da fita possui um símbolo de
Fita começa na posição zero
Fita possui infinitas posições para a direita
B (branco): simbolo especial de
Entrada é gravada na fita, começando na posição 1
Posição 0 é sempre um B
Posições depois da palavra de entrada são todas B
Cabeça começa posicionada na posição 0
Máquinas de Turing
Função de Transição ( )
MT padrão é determinística
Computação
Computação para quando encontra um estado/símbolo
para o qual não exista transição definida
Se a cabeça for deslocada para esquerda da posição 0,
então a computação termina anormalmente (“quebra”)
Exemplo: (qi, x) = [qj, y, E ou D]
Se (estado atual == qi) e (símbolo atual da fita == x) então
Novo estado = qj
Grave y na fita
Mova cabeça de leitura/gravação para esquerda (E) ou
direita (D)
qi qj qi qj
x/y E x/y D
Símbolo atual da fita: símbolo embaixo da cabeça de
leitura/gravação

MT para ler uma entrada formada por uma palavra sobre
{a, b} e trocar a por b e vice-versa. Ao final do
processamento, rebobinar a cabeça de leitura/gravação
para a posição zero da fita
MT para realizar a seguinte transformação na fita de
entrada:
BuB... ) BuBuB..., onde u = (a [ b)⇤
MT para somar 1 em um número binário gravado
inicialmente na fita de entrada
MT para realizar as seguintes transformações na fita de
entrada:
Ban
Bam
B... ) Ban
Bam
Ban+m
B..., n, m 0
Ban
Bam
B... ) Ban
Bam
Ban m
B..., n m
Ban
B... ) Ban
Ba2n
B..., n 0
Ban
Bam
B... ) Ban
Bam
Ban⇤m
B..., n, m 0
MT para Aceitação de Linguagens
Um MT é uma séxtupla (Q, ⌃, , , q0, F):
= alfabeto da fita
MTs que aceitam ou rejeitam uma palavra de entrada
Seja M = (Q, ⌃, , , q0, F) uma MT, onde F ✓ Q é o conjunto
de estados finais
Uma palavra u 2 ⌃⇤ é aceita por estado final se a
computação de M com entrada u para em um estado final
Isto é, MT não precisa ler toda a palavra para aceitá-la

Linguagem L(M): conjunto das palavras aceitas por M
Exemplos:
L1 = (a [ b)⇤
aa(a [ b)⇤
L2 = {ai
bi
ci
| i 0}
L3 = {wcv | w e v tem o mesmo número de a e b}
L4 = {ww | w 2 {a, b}+
}
Uma MT pode:
Parar e aceitar uma palavra de entrada
Parar e rejeitar uma palavra de entrada
Entrar em loop (isto é, não parar)
MT reconhece uma linguagem L, logo L é recursivamente
enumerável (LI)
Uma MT reconhece uma linguagem L se ela para para todas
as palavras de L, mas pode não parar para as palavras que
não estão em L
MT decide uma linguagem L, logo L é recursiva (LSC)
Uma MT decide uma linguagem L se ela para para todas as
possíveis palavras de entrada (⌃⇤
)
Reﬂexão
As linguagens L1...4 (anteriormente citadas) são:
a. recursivamente enumeráveis?
b. recursivas?
Máquinas de Turing
Variantes

MT com Fita Bidirecional
Fita se estende infinitamente para esquerda e para direita
Entrada pode ser inserida em qualquer ponto da fita
Cabeça de leitura/gravação é posicionada no branco
imediatamente à esquerda da palavra de entrada
Uma linguagem L é aceita por uma MT com fita bidirecional
sse é aceita por uma MT padrão (por quê?)
MT para somar 1 em um número binário
(ida) Se uma linguagem L é aceita por uma MT com fita
bidirecional, então é aceita por uma MT padrão
Uma fita infinita à direita tem o mesmo tamanho de uma fita
infinita à direita e à esquerda
basicamente: 1 = 1 + 1
Para não utilizar a fita “da esquerda”, basta realizar o shift
de toda a fita “da direita” antes de realizar uma transição
que utilizaria a fita “da esquerda”
(volta) Se uma linguagem L é aceita por uma MT padrão, então
é aceita por uma MT com fita bidirecional
Basta não utilizar a fita “da esquerda”
MT com Movimento Estático
Modificação da função de transição de estados:
: Q ⇥ ! Q ⇥ ⇥ {E, D, S}
Agora após uma leitura/gravação, é possível não mover a
cabeça de leitura/gravação (S)
Seu uso só faz sentido quando se tem mais fitas (por quê?)
Uma linguagem L é aceita por uma MT com movimento
estático sse é aceita por uma MT padrão (por quê?)
(ida) Se uma linguagem L é aceita por uma MT com movimento
estático, então é aceita por uma MT padrão
Basta substituir todas transições que possuem movimento
estático como a seguir:
qi qj qi qk qj
a/a S a/a D x/x E, 8x 2
é aceita por uma MT com movimento estático
Basta não utilizar o movimento estático

MT Multitrilhas
Fita é dividida em múltiplas trilhas, mantendo uma única
cabeça de leitura/gravação
Máquina com duas trilhas:
(qi, [x, y]) = [qj, [z, w], m], onde m 2 {E, D}
x = símbolo a ser lido da Fita 1
y = símbolo a ser lido da Fita 2
z = símbolo a ser gravado na Fita 1
w = símbolo a ser gravado na Fita 2
Uma linguagem L é aceita por uma MT com duas trilhas sse
é aceita por uma MT padrão (por quê?)
(ida) Se uma linguagem L é aceita por uma MT multitrilha, então
é aceita por uma MT padrão
Assuma uma MT com duas trilhas
Trilha 1: x0 x1 x2 x3 x4 x5 . . .
Trilha 2: y0 y1 y2 y3 y4 y5 . . .
1 Intercale as trilhas em uma única fita como a seguir:
Fita: x0 y0 x1 y1 x2 y2 x3 y3 x4 y4 x5 y5 . . .
2 Adapte as transições [x/y w/z M] como a seguir:
[x/y w/z M] =) [x/y D] e [w/z D]
Quando M = E, deve-se recuar o número de trilhas ⇥ 2
No nosso exemplo (2 trilhas), fazem-se 4 transições [ / E]
é aceita por uma MT multitrilha
Basta utilizar somente uma trilha
i.e., as demais terão sempre transições B/B
Dessa forma, uma transição [x/y D] em uma MT padrão
ficaria da seguinte forma em uma MT com n trilhas:
[x/y B2/B2 B3/B3 . . . Bn/Bn D]
MT Multifitas
Máquina com k fitas e k cabeças de leitura/gravação
Máquina lê as k fitas simultaneamente (de forma síncrona)
Transição consulta:
Estado atual (único)
Símbolos lidos por cada uma das cabeças
Uma transição pode:
Mudar o estado
Escrever um símbolo em cada uma das fitas
Reposicionar de forma independente cada uma das
cabeças de leitura/gravação
Uma linguagem L é aceita por uma MT Multifitas sse é
aceita por uma MT padrão (por quê?)

MT Multifitas
Entrada é escrita na Fita 1
Todas as outras fitas estão em branco (BBBBB...)
Todas as fitas começam com a cabeça de
leitura/gravação na posição 0
MT para reconhecer as seguintes linguagens:
L1 = {ai
bi
| i > 0}
L2 = {wdw | w 2 {a, b, c}⇤
}
L3 = {wcwr
| w 2 {a, b}⇤
}
(ida) Se uma linguagem L é aceita por uma MT multifita, então é
aceita por uma MT padrão
Assuma uma MT com duas fitas
#1: B a b c B . . .
#2: B x y z B . . .
Assuma também as seguintes configurações:
#1: B qi a b c B . . . (i.e., cabeça de leitura/gravação aponta para a)
#2: B x y qi z B . . . (i.e., cabeça de leitura/gravação aponta para z)
1 Concatene as fitas separadas por #
Fita: B a b c B # B x y z B . . .
2 Estenda o alfabeto da fita como a seguir:
8x 2 ! x 2 0
^ ˆx 2 0
(são adicionados ˆB, â, ˆb, ˆc, ˆx, ˆy e ˆz)
3 Dessa forma, os símbolos “acentuados” correspondem aos
símbolos que estão com a cabeça de leitura/gravação:
Fita: B â b c B # B x y ˆz B . . .
4 A cabeça de leitura/gravação sempre se inicia na Fita #1:
Fita: B qi0 â b c B # B x y ˆz B . . .
5 A computação para uma transição [a/x D z/c E] será
realizada como a seguir:
Substitua â por x na “Fita #1”
“Acentue” o próximo símbolo da “Fita #1” (b ! ˆb)
Passe para a “Fita #2” (após o símbolo #)
Procure por ˆz (caso não ache, pare)
Substitua ˆz por c
“Acentue” o símbolo anterior da “Fita #2” (y ! ˆy)
Retorne à “Fita #1” parando no símbolo “acentuado” e
compute a próxima transição

é aceita por uma MT multifita
Basta utilizar somente uma fita
i.e., as demais terão sempre transições B/B S
Dessa forma, uma transição [x/y D] em uma MT padrão
ficaria da seguinte forma em uma MT com n fitas:
[x/y D B2/B2 S B3/B3 S . . . Bn/Bn S]
MT Não-Determinísticas
Modificação da função de transição de estados:
: Q ⇥ ! P(Q ⇥ ⇥ {E, D})
P(X): conjunto potência de X (todos subconjuntos de X)
Exemplo de transição:
(q1, c) = {[q1, c, D], [q2, c, D], [q3, C, E]}
ND não aumenta o poder de expressão de MTs
Uma linguagem L é aceita por uma MT Não-Determinística
sse é aceita por uma MT padrão (por quê?)
MT para reconhecer as seguintes linguagens:
Palavras contendo um c precedido ou sucedido por ab
L = {ww | w 2 {a, b}⇤
}
(ida) Se uma linguagem L é aceita por uma MT
Não-Determinística, então é aceita por uma MT padrão
Prova é feita assumindo uma MT multifita
uma vez já provamos ter o mesmo poder computacional

Assuma 3 fitas:
#1: B a b b B . . . (palavra de entrada)
#2: q0B a b b B # . . . (configurações iniciando com a 1a
)
#3: B B B B B . . . (configuração em execução)
Loop
1 Mova a 1a configuração da Fita #2 para Fita #3
2 Execute a MTND sobre a configuração presente na Fita #3
Caso não haja transições, verifique se é igual a palavra de entrada. Se
for, pare e aceite. Se não for, pule para o passo (3)
Caso haja uma transição possível, execute e concatene a
configuração resultante + “#” na Fita #2
Caso hajam várias transições possíveis (ND), concatene todas as
configurações resultantes + “#” na Fita #2
3 Apague Fita #3
Exemplificando:
Assuma Lexemplo = {w 2 {a, b}⇤
| w termina com b}
Assuma a seguinte MTND M em que L(M) = Lexemplo
q0 q1 q2 q3
B/B D
a/a D
b/b D
b/b D B/B D
Simule a execução da MTND em uma MT padrão com a
palavra abb
Antes, construa a árvore de computações possíveis para o
melhor entendimento
q0 q1 q2 q3
B/B D
a/a D
b/b D
b/b D B/B D
#2: q0B a b b B # . . . (configurações iniciando com a 1a
)
#3: B B B B B . . . (configuração em execução)
q0 q1 q2 q3
B/B D
a/a D
b/b D
b/b D B/B D
#2: B B B B B . . . (mover 1a
)
#3: q0B a b b B . . . (executar)

q0 q1 q2 q3
B/B D
a/a D
b/b D
b/b D B/B D
#2: B q1a b b B # . . . (transição resultante)
#3: B B B B B . . .
q0 q1 q2 q3
B/B D
a/a D
b/b D
b/b D B/B D
#2: B B B B B . . . (mover 1a
)
#3: B q1a b b B . . . (executar)
q0 q1 q2 q3
B/B D
a/a D
b/b D
b/b D B/B D
#2: B a q1b b B # . . . (transição resultante)
#3: B B B B B . . .
q0 q1 q2 q3
B/B D
a/a D
b/b D
b/b D B/B D
#2: B B B B B . . . (mover 1a
)
#3: B a q1b b B # . . . (executar, ND)

q0 q1 q2 q3
B/B D
a/a D
b/b D
b/b D B/B D
#2: B a b q1b B # B a b q2b B # . . . (transições resultantes)
#3: B B B B B . . .
q0 q1 q2 q3
B/B D
a/a D
b/b D
b/b D B/B D
#2: B a b q2b B # . . . (mover 1a
)
#3: B a b q1b B # (executar, ND)
q0 q1 q2 q3
B/B D
a/a D
b/b D
b/b D B/B D
#2: B a b q2b B # B a b b q1B # B a b b q2B # . . . (transições res.)
#3: B B B B B . . .
q0 q1 q2 q3
B/B D
a/a D
b/b D
b/b D B/B D
#2: B a b b q1B # B a b b q2B # . . . (mover 1a
)
#3: B a b q2b B # (executar, para e rejeita)

q0 q1 q2 q3
B/B D
a/a D
b/b D
b/b D B/B D
#2: B a b b q1B # B a b b q2B # . . . (antigas transições resultantes)
#3: B B B B B . . .
q0 q1 q2 q3
B/B D
a/a D
b/b D
b/b D B/B D
#2: B a b b q2B # . . . (mover 1a
)
#3: B a b b q1B # (executar, para e rejeita)
q0 q1 q2 q3
B/B D
a/a D
b/b D
b/b D B/B D
#2: B a b b q2B # . . . (antiga transição resultante)
#3: B B B B B . . .
q0 q1 q2 q3
B/B D
a/a D
b/b D
b/b D B/B D
#2: B B B B B . . . (mover 1a
)
#3: B a b b q2B # . . . (executar)

q0 q1 q2 q3
B/B D
a/a D
b/b D
b/b D B/B D
#2: B a b b B q3 . . . (transição resultante)
#3: B B B B B . . .
q0 q1 q2 q3
B/B D
a/a D
b/b D
b/b D B/B D
#2: B B B B B . . . (mover 1a
)
#3: B a b b B q3 . . . (executar, para e aceita)
é aceita por uma MT Não-Determinística
Basta não utilizar transições não-determinísticas
MT Enumeradoras de Linguagens
MT vistas até o momento são aceitadoras de linguagens:
Entrada: palavra de acordo com um alfabeto
Saída: palavra válida (parada em estado final) ou inválida
Máquina com k-fitas (multi-fita)
Não possui entrada
Saída: grava (ou enumera) todas as palavras de uma
linguagem em uma de suas fitas (chamada fita de saída)
Se linguagem for infinita, MT enumeradora não para

Uma MT com k-fitas E = (Q, ⌃, , , q0) enumera uma
linguagem L se:
Sua computação começa com todas fitas vazias
Fita 1 é chamada de fita de saída
A cada transição, cabeça da Fita 1 permanece parada (S)
ou se move para a direita (D)
Parte “não-branca” da Fita 1 tem uma das formas:
B#u1#u2#...#uk # ou
B#u1#u2#...#uk #v onde ui 2 L e v 2 ⌃⇤
ui é escrito na Fita 1 (entre #0s) sse ui 2 L
Definição não requer que a máquina pare (mesmo que a
linguagem seja finita)
Exemplo
MT para enumerar a linguagem L = {aibi | i > 0}
Exemplo
MT para enumerar a linguagem L = {aibi | i > 0}
q0 q2 q3
q4
[B/B D, B/B D] [B/# D, B/X S]
[B/B S, B/B D]
[B/a D, X/X E]
[B/# D, B/X S]
[B/b D, X/X D]
Exemplo
Descrição do funcionamento da MT anterior:
Escreve ## na F1 (já que 2 L)
Escreve “X” na posição 1 da F2
Loop:
q3: volta na F2: para cada X, escreve a na F1
q4: avança na F2: para cada X, escreve b na F1
q4 para q3: escreve X no final da F2 e escreve # na F1

MT para enumerar a linguagem L = {aibici | i 0}
Teoremas
Linguagens Irrestritas – Teoremas
Linguagem Recursiva
MT decide uma linguagem L, logo L é recursiva (LSC)
Uma MT decide uma linguagem L se ela para para todas as
possíveis palavras de entrada (⌃⇤
)
Teorema #5: L é recursiva se, e somente se, L pode ser
enumerada em ordem lexicográfica
Deve-se provar que:
(ida) se L é recursiva, então L pode ser enumerada em
ordem lexicográfica
(volta) Se L pode ser enumerada em ordem lexicográfica,
então L é recursiva
Teorema #5
Seja M a MT que decide L
Seja E⇤
uma MT que enumera ⌃⇤
em ordem lexicográfica
Prova consiste em mostrar que pode-se construir uma MT E
que enumera L em ordem lex. como a seguir:
loop:
Rode E⇤
e produza uma palavra u (em ordem lex.)
Rode M com u
Se M aceita u, escreva u na fita de saída de E

Teorema #5 (explicação gráfica)
Teorema #5
Se L for finita, então L é imediatamente recursiva
Se L for infinita e puder ser enumerada em ordem lex.:
Seja E a MT que enumera L em ordem lex.
Prova consiste em mostrar que pode-se construir uma
máquina M que decide L como a seguir:
Rode E, sendo que toda vez que E escrever uma palavra w na
fita de saída, M deve verificar se:
lo(w) == lo(u): M para e aceita u
lo(w) < lo(u): execução de E prossegue
lo(w) > lo(u): M para e rejeita u

Linguagem Recursivamente Enumerável
MT reconhece uma linguagem L, logo L é recursivamente
enumerável (LI)
Uma MT reconhece uma linguagem L se ela para para todas
as palavras de L, mas pode não parar para as palavras que
não estão em L
Teorema #6: Uma linguagem é rec. enumerável se, e somente
se, ela puder ser enumerada por uma MT
Deve-se provar que:
(ida) se L é RE, então L é enumerada por uma MT
(volta) se L é enumerada por uma MT, então L é RE
Teorema #6
Seja E a MT que enumera L
Prova consiste em mostrar que pode-se construir uma
máquina M que reconhece L
M recebe como entrada uma palavra u 2 ⌃⇤
Sempre que E escrever uma palavra w na fita de saída, M
verifica se w == u. Se for, M para em um estado final
Veja que M não vai parar se u 62 L
Porém, definição de RE não exige parada em caso de
palavras não pertencentes à linguagem

Teorema #6
Primeira tentativa (“gerar-e-testar via força bruta”):
Seja M a MT que reconhece palavras de L
que enumera L
Para cada palavra u 2 ⌃⇤
(i.e., gerar todas palavras de ⌃)
Se M aceitar u, escrever u na fita de saída de E
Essa tentativa não funciona, pois:
Requer que todas palavras de u sejam geradas (ok)
Porém, ao se gerar uma palavra inválida, M pode não parar
ao analisar u
Com isso, próximas palavras de u não serão geradas e
testadas
Teorema #6 (explicação gráfica do porquê força bruta falha)
Ordem Lexicográfica
Ordem lexicográfica de ⌃: função que mapeia palavras de
⌃ para números naturais
Seja ⌃ = {a1, ..., an} um alfabeto. A ordem lexicográfica lo
de ⌃ é definida recursivamente como:
Base: lo( ) = 0, lo(ai) = i
Passo recursivo: lo(aiu) = lo(u) + i ⇤ ntam(u)
Exemplo: ⌃ = {a, b, c} e a1 = a, a2 = b, a3 = c
lo( )= 0, lo(a)= 1, lo(b)= 2, lo(c)= 3,
lo(aa)= 4, lo(ba)= 7, lo(ca)= 10, lo(aaa)=13, lo(aba)=16,
lo(ab)= 5, lo(bb)= 8, lo(cb)= 11, lo(aab)=14, lo(abb)=17,
lo(ac)= 6, lo(bc)= 9, lo(cc)= 12, lo(aac)=15, lo(abc)=18,

Preparando a Prova
Suponha as palavras de ⌃ em ordem lexicográfica
, u1, u2, u3, ...
Seja a seguinte tabela:
Os pares dessa tabela podem ser enumerados “pelas
diagonais”:
[ , 0], [ , 1], [u1, 0], [ , 2], [u1, 1], [u2, 0], [ , 3], [u1, 2], ...
Voltando à Prova
Significado de par [i,j]: rode M com entrada ui por j passos
Finalmente, a prova que ficou pendente
"Ida": se L é RE, então L é enumerada por uma MT
Seja M a MT que reconhece L
que enumera L
Para cada par ordenado [i, j]
Rode M com entrada ui por j passos (ou até M parar)
Se M aceitar ui , escrever ui na fita de saída de E
Cada palavra ui 2 ⌃⇤ vai ser testada com 0, 1, 2, 3, ... passos
Se ui for válida, M vai parar para algum número k de passos
7. Considerações Finais – Conteúdo
1 Revisão 3
2 Introdução 59
Máquina de Moore
Máquinas de Mealy
Recursividade
Ambiguidade
Variantes
Algoritmo de Early
Teoremas
Variantes
Hierarquia de Chomsky 460
Tese de Church-Turing 462

Considerações Finais
Considerações Finais – Hierarquia de Chomsky
Toda categoria é um subconjunto próprio da categoria superior
Considerações Finais
Tese de Church-Turing
Considerações Finais – Tese de Church-Turing
“Toda ‘função naturalmente computável’ pode ser computada
por uma Máquina de Turing.”
A tese não pode ser formalmente provada
O que é uma função naturalmente computável?
No entanto, pode ser refutada
Basta a descoberta de uma máquina mais poderosa que
uma Máquina de Turing

Considerações Finais – Tese de Church-Turing
Linguagens de Programação
Se uma LP é capaz de manipular uma MT de uma única ﬁta,
essa LP é capaz de expressar qualquer algoritmo
Normalmente, LPs provêem abstrações mais elaboradas
O poder de computação, contudo, é o mesmo de uma MT
Agradecimentos
Agradecimentos
Kleber Marchetti Antunes
Gostaria de agradecer ao aluno pela tarefa de conversão
inicial da apostila em formato ppt para LaTeX
Alberto Hokari
Gostaria de agradecer ao aluno pelos desenhos das máquinas
em formato TikZ e ao desenvolvimento do material de CYK
Referências I
P. F. Blauth Menezes.
Linguagens formais e autômatos, volume 3.
Bookman, 6 edition, 2011.
S. L. G. de Oliveira.
Algoritmos e seus fundamentos.
Editora UFLA, 2011.
J. E. Hopcroft and J. D. Ullman.
Formal languages and their relation to automata.
Addison-Wesley, 1969.
J. E. Hopcroft and J. D. Ullman.
Introduction to Automata Theory, Languages, and Computation.
Addison-Wesley, 1979.
M. Sipser.
Introdução à Teoria da Computação.
Thompson, 2007.

Referências II
T. A. Sudkamp.
Languages and machines: an introduction to the theory of Computer
Science.
Addison-Wesley, 2 edition, 2005.
M. T. Valente.
Notas de aula da disciplina Fundamentos Teóricos da Computação.
Programa de Pós-graduação em Informática, PUC Minas, 2007.
N. J. Vieira.
Introdução aos Fundamentos da Computação: Linguagens e máquinas.
Thomson, 2006.
N. J. Vieira.
Notas de aula da disciplina fundamentos da teoria da computação.
Bacharelado em Ciência da Computação, UFMG, 2009.

Apostila Linguagens Formais e Autômatos (LFA)

Mais conteúdo relacionado

Mais procurados

Semelhante a Apostila Linguagens Formais e Autômatos (LFA)

Mais de Ricardo Terra

Último

Apostila Linguagens Formais e Autômatos (LFA)