2015 Apostila Lfa PDF

Linguagens Formais e Autômatos
Ricardo Terra
rterrabh [at] gmail.com
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2015 1 / 423
CV
Nome: Ricardo Terra

Email: rterrabh [at] gmail.com
www: ricardoterra.com.br
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
1 Revisão 3
Conjuntos, relações e funções 4
Definições Recursivas 8
Indução Matemática 13
Linguagens Formais e Autômatos (LFA) 17
Lemas, Teoremas, Corolários, etc. 56
2 Introdução 59
3 Linguagens Regulares 74
Autômatos Finitos Determinísticos
Autômatos Finitos Não-Determinísticos
Autômatos Finitos Não-Determinísticos com Transições-λ
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-λ
4 Linguagens Livres de Contexto 171

Recursividade
Árvore de Derivação
Ambiguidade
Backus-Nahur Form (BNF)
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
Autômato com Pilha como Reconhecedor
Autômato com Pilha Descendente
Algoritmo de Cocke-Younger-Kasami (CYK)
Algoritmo de Early
Variantes
Critérios de Aceitação
Transformação de GLCs para APs
Transformação de APs para GLCs
5 Linguagens Sensíveis ao Contexto 350
6 Linguagens Irrestritas 367

Teoremas
Ricardo Terra (rterrabh [at] gmail.com)
Variantes Linguagens Formais e Autômatos (LFA) Outubro, 2015 3 / 423
Revisão
Conjuntos, relações e funções
Revisão – Conjuntos, relações e funções (1–34)
Revisão
Definiçõ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 ∈ N, então s(n) ∈ 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) ∈ fat, então

(n, n x k) ∈ 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 definido
recursivamente (Veja Sudkamp [?], 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 ∀x ∈ X0
Hipótese: P é válido ∀x ∈ X0 , X1 , ..., Xk
Passo indutivo: Mostrar que P também é válido ∀x ∈ Xk+1
Assim, P é válido ∀x ∈ X
Pn n(n+1)
Exemplo #1: Provar que i=1 i = 2
P1 1(1+1)
Base: P(1) é verdadeiro, i.e., i=1 i = 2 =1
Hipótese: P é verdadeira para 0, 1, 2, 3, . . . , k, ou seja,

k
X k(k + 1)
i=
2
i=1
PK +1 (K +1)((K +1)+1) (K +1)(K +2)

Passo indutivo: Provar que i=1 i= 2 = 2
PK +1
i=1 i
PK
= i=1 i + (k + 1) (definição somatório)
k(k+1)
= 2 + (k + 1) (uso da hipótese de indução)
k(k+1) + 2(k+1)
= 2 (matemática básica)
(k+1)(k+2)
= 2
Exemplo #2: Provar que n! > 2n , ∀n > 4

Base: P(5) é verdadeiro, i.e., (5! = 120) > (32 = 25 )
Hipótese: P é verdadeira para 5, 6, 7, . . . , k, ou seja,

k! > 2k , ∀k > 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 definida por
um conjunto regular
Um conjunto regular pode ser gerado a partir de Σ usando

operador de Kleene, união e concatenação
Definição recursiva:
Base: φ, {λ} e {a}(∀a ∈ Σ) 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}(∀a ∈ Σ) → a(∀a ∈ Σ)
{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 ∈ V )
Regras: µ → ν
µ∈V (i.e., µ é um elemento de V )
ν ∈ λ | Σ | Σ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
Definição de regra (→) 6= Aplicação de regra (⇒)
v ⇒∗ w w é derivável a partir de v (aplicando 0 ou mais regras)
v ⇒+ w w é derivável a partir de v (aplicando 1 ou mais regras)
v ⇒n w w é derivável a partir de v (aplicando n regras)
Portanto:
Uma palavra w ∈ (V ∪ Σ)∗ é uma forma sentencial se S ⇒∗ w
Uma palavra w ∈ Σ∗ é uma sentença se S ⇒∗ w
L(G) = {w ∈ Σ∗ | S ⇒∗ w}
Dada a seguinte GR(L):

S → aA
A → aA | bB
B → aB | bB | a
Pergunta-se: ababa ∈ 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 ∈ L(G)?
Autômato Finito
Máquina Aceitadora 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 ∈ ou 6∈ 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 ∈ Q = estado inicial
F ⊆ Q = conjunto de estados finais (aceitação)
Uma palavra w ∈ Σ∗ é 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 ∈ Σ∗ | δ̂(q0 , w) ∈ F}, onde δ̂ é a função
de transição estendida para M
Exemplo
AFD:
Exemplo
AFD:
a b a
a
a b
q0 q1 q2 q3
Exemplo
AFD:
a b a
a
a b
q0 q1 q2 q3
b
Sim, na verdade, é um AFD incompleto, por quê?
Exemplo
AFD:
a b a
a
a b
q0 q1 q2 q3
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 ∈ Σ∗ é dita ser aceita por um AFND se, e

somente se, existe uma computação que a consome e
para em um estado final
Para todo AFND, existe um AFD equivalente

i.e., não aumenta poder de expressão
Exemplo
AFND:
Exemplo
AFND:
a a,b
a b a
q0 q1 q2 q3
Exemplo
AFND:
a a,b
a b a
q0 q1 q2 q3
Sim, na verdade, é um AFND incompleto, por quê?
Exemplo
AFND:
a a,b
a b a
q0 q1 q2 q3
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-λ:
λ
a,b a,b
q0 q1 q3
Gramática Livre de Contexto (GLC)

Uma GLC é uma quádrupla (V , Σ, P, S):
Regras: µ → ν
µ∈V (i.e., um não-terminal)
ν ∈ (V ∪ Σ)∗ (i.e., palavra formada por elementos de V e Σ)
Exemplo Clássico
L(G) = {a i bi | i > 0}
GLC(L):
Toda LLC é aceita por um Autômato com Pilha (não-determinístico)
Exemplo Clássico
L(G) = {a i bi | i > 0}
GLC(L):
S → aSb | ab
Exemplo Clássico 2
L(G) = {w ∈ {a, b}∗ | w = w R }
GLC(L):
Exemplo Clássico 2
L(G) = {w ∈ {a, b}∗ | w = w R }
GLC(L):
S → aSa | bSb | a | b | λ
1 L = {a n bm a n |n > 0, m > 0}
2 L = {a n bm c m d 2n |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 , a 0 , b0 ) compatíveis:

(a = a 0 ou a = λ ou a 0 = λ) e (b = b0 ou b = λ ou b0 6= λ)
Uma palavra w ∈ Σ∗ é 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) = {a i bi | i > 0}
APD:
Exemplo Clássico
L(G) = {a i bi | i > 0}
APD:
a λ/X b X/λ
b X/λ
q0 q1
Autômato com Pilha Não-Determinístico (APND)

Um APND é uma sextupla (Q, Σ, Γ, δ, q0 , F):
δ : Q x (Σ ∪ λ) x (Γ ∪ λ) → P(Q x (Γ ∪ λ))
Permite transições δ(qi , a, b) e δ(qi , a 0 , b0 ) compatíveis:

δ(qi , a, b) = {[qj , B], [qk , C]}
Uma palavra w ∈ Σ∗ é dita ser aceita por um APND se, e

para em um estado final com pilha vazia
Exemplo Clássico 2
L(G) = {w ∈ {a, b}∗ | w = w R }
APND:
Toda LLC é aceita por um APND
Exemplo Clássico 2
L(G) = {w ∈ {a, b}∗ | w = w R }
APND:
a λ/A a A/λ
b λ/B a λ/λ b B/λ
b λ/λ
λ λ/λ
q0 q1
Toda LLC é aceita por um APND
Gramática Sensível ao Contexto (GSC)

Uma GSC é uma quádrupla (V , Σ, P, S):
Regras: µ → ν
µ ∈ (V ∪ Σ)+ (i.e., palavra formada por elementos de V e Σ)
ν ∈ (V ∪ Σ)+ (i.e., palavra formada por elementos de V e Σ)
|µ| ≤ |ν| (i.e., regras não-contráteis)
λ nunca é uma palavra válida em uma LSC
Exemplo Clássico
L = {a i bi c i | 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 ∈ Σ∗
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
L = {a i bi c i | i > 0}
c/c, E
Z /Z , E
b/b, E
Y /Y , D Z /Z , D Y /Y , E
a/a, D b/b, D c/c D a/a, E
</<D a/X D b/Y D c/Z D >/>E

q0 q1 q2 q3 q4 q5
Y/Y D X/X D
>/>E Z /Z , E
q6 q7 Y /Y , E
X /X , E
Y /Y , D
Z /Z , D
Gramática Irrestrita (GI)

Todo o universo de linguagens é gerado por GI
Uma GI é uma quádrupla (V , Σ, P, S):

Regras: µ → ν
“Quase” nenhuma restrição é imposta (|µ| > 0)
Exemplo Clássico
L = {u[u] | u ∈ {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 ∈ Σ∗
Máquina de Turing (MT)

Um MT é uma séxtupla (Q, Σ, Γ, δ, q0 , F):
Memória ilimitada
Configuração inicial da fita: BwBBBBBBBB...
A fita é infinita à direita
Exemplo Clássico
L = {u[u] | u ∈ {a, b}∗ }
a/a D X /X D
b/b D Y /Y D
[/[ D
q2 q3
D a
a/a E /X
/X b/b E E
a
X /X D
B/B D Y /Y D [/[ E X /X E
q0 q1 q5 q4
Y /Y E
[/[ D E
b/
Y
Y
b/
D
X /X D [/[ D
q8 q6 q7
Y /Y D
a/a D X /X D
]/] D b/b D Y /Y D
X /a E
B/B E Y /b E
q9 q10
[/[E
]/]E
Revisão
Lemas, Teoremas, Corolários, etc.
Revisão – Lemas, Teoremas, Corolários, etc.
Definições
Definem objetos e noções que são úteis em um
determinado estudo
Exemplo: Um AP é uma sextupla (Q, Σ, Γ, δ, q0 , F)...
Lema e Teorema
Lema: É um pré-teorema, i.e., um resultado que leva a um
teorema ou que é usado na prova de um teorema
Teorema: É um resultado mais importante e interessante

Existem exceções, e.g., Pumping Lemma é um teorema
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
2 Introdução 59
Hierarquia de Chomsky 60
Conceitos Básicos 63
Máquina de Moore
Máquinas de Mealy

Recursividade
Ambiguidade
Algoritmo de Early
Variantes

Teoremas
Variantes
Teoremas
Ricardo
7 Terra (rterrabh
Considerações Finais[at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2015 59
415/ 423
Introdução
Introdução – Hierarquia de Chomsky
Noam Chomsky (1927-presente): poeta, filósofo, linguista,
professor do MIT, e crítico do capitalismo e da política
externa americana
Noam Chomsky (1956) constitui uma classificação para

linguagens, gramáticas e autômatos
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: λ ∈ Σ* (λ é a palavra vazia)
2 passo recursivo: se w ∈ Σ* e a ∈ Σ então wa ∈ Σ*
3 fechamento: w ∈ Σ* sse puder ser obtido 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: abc
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 ∈ Σ. 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 ∈ Σ
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 ∈ Σ∗ , 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) ∀w, tam(w) ≤ k

Passo indutivo: provar (uv)w = u(vw) ∀w, tam(w) = k + 1
Seja w = xa, tam(x) = k, a ∈ Σ
(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 ∃x, 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 ∈ Σ∗ . O reverso de w, ou w R , é 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 ∈ Σ
Assim, w R = (ua)R = a(u)R = au R
Prova de Reverso (por indução no comprimento da palavra v)

Teorema: seja u, v ∈ Σ∗ , então (uv)R = v R u R
Base: se tam(v) = 0, então v = λ
(uv)R = (uλ)R = u R e v R u R = λR u R = u R
Hipótese: (uv)R = v R u R ∀w, tam(w) ≤ k

Passo indutivo: provar (uv)R = v R u R ∀v, tam(v) = k + 1
Seja v = wa, tam(w) = k, a ∈ Σ
(uv)R = (u(wa))R =
= ((uw)a)R (associatividade concatenação)
= a(uw)R (definição de reverso)
= a(w R u R ) (uso da hipótese de indução)
= (aw R )u R (associatividade)
= (wa)R u R (definição de reverso)
= v R 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 ∈ X e y ∈ Y }
Exemplo: X = {a, b, c} e Y = {abb, ba}
XY = {aabb, aba, babb, bba, cabb, cba}
X n : concatenação de X com X mesmo n vezes

X 0 = {λ}
X 1 = {a, b, c}
X 2 = {aa, ab, ac, ba, bb, bc, ca, cb, cc}
X ∗ : todas as palavras construídas a partir de X
X∗ (definição formal)
∞
[
X =∗
Xi
i=0
X+ (definição formal)
∞
[
X+ = Xi
i=1
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 115
Máquina de Moore
Máquinas de Mealy
Algoritmos 133
Propriedades 155
Lema do Bombeamento 162

Recursividade
Ambiguidade
Algoritmo de Early
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}∀a ∈ Σ 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(∀a ∈ Σ), 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 ∈ {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∅ = ∅ 10 w ∗ w = ww ∗ = w +
2 λw = wλ = w 11 w(x ∪ y) = wx ∪ wy
3 ∅∗ = λ 12 (x ∪ y)w = xw ∪ yw
4 λ∗ = λ 13 (wy)∗ w = w(yw)∗
5 w ∪u =u∪w 14 (w ∪ y)∗ = (w ∗ ∪ y ∗ )
= w ∗ (w ∪ y)∗
6 w ∪∅=w
= (w ∪ yw ∗ )∗
7 w ∪w =w = (w ∗ y ∗ )∗
= w ∗ (yw ∗ )∗
8 w ∗w ∗ = w ∗ = (w ∗ y)∗ w ∗
9 (w ∗ )∗ = w ∗
Exercícios
Mostre que:
b∗ (ab+ )∗ ∪ b∗ (ab+ )∗ a = (b ∪ ab)∗ (λ ∪ a)
a ∗ (a ∗ ba ∗ ba ∗ )∗ = a ∗ (ba ∗ ba ∗ )∗
PS
Existem linguagens que não podem definidas por
expressões regulares
Por exemplo, {a n bn | n ≥ 0}
E aí, o que isso significa?
Gramáticas Regulares
Linguagens Regulares – Gramáticas Regulares
Gramática Regular (GR)

Uma GR é uma quádrupla (V , Σ, P, S):
Regras: µ → ν
µ∈V (i.e., µ é um elemento de V )
ν ∈ λ | Σ | Σ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
até se aplicar uma regra da forma A → Σ ou 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:
L(G) = {w ∈ Σ∗ | 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 ∈ L(G)?
Enfim
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 Aceitadora 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 ∈ ou 6∈ 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 ∈ Σ∗ é 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 ∈ Σ∗ | δ̂D (q0 , w) ∈ F}, onde δ̂D é a função
de transição estendida para M
Exemplo
AFD:
Exemplo
AFD:
a b a
a
δD a b
a b
q0 q1 q2 q3 q0 q1 −
q1 q1 q2
b q2 q3 q2
q3 q3 q2
Exemplo
AFD:
a b a
a
δD a b
a b
q0 q1 q2 q3 q0 q1 −
q1 q1 q2
b q2 q3 q2
q3 q3 q2
Exercícios de Fixação
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
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 ∈ Σ∗ | δ̂D (q0 , w) ∈ F} = L(M)
REJEITA(M) = {w ∈ Σ∗ | δ̂D (q0 , w) 6∈ 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 ∈ Σ∗ é dita ser aceita por um AFND se, e

para em um estado final
Para todo AFND, existe um AFD equivalente

Exemplo
AFND:
Exemplo
AFND: δND a b
a a,b q0 {q1 } ∅
q1 {q1 } {q2 }
a b a q2 {q2 , q3 } {q2 }
q0 q1 q2 q3 q3 ∅ ∅
Exemplo
AFND: δND a b
a a,b q0 {q1 } ∅
q1 {q1 } {q2 }
a b a q2 {q2 , q3 } {q2 }
q0 q1 q2 q3 q3 ∅ ∅

Qual seria a árvore de computações para a palavra abaaa?
2 L = (a ∪ b)∗ bb
3 L = palavras 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 ∈ Σ∗ | δ̂ND (q0 , w) ∩ F 6= ∅} = L(M)
REJEITA(M) = {w ∈ Σ∗ | δ̂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-λ:
0 δND−λ 0 λ
q1 q2 q0 ∅ {q1 , q3 }
λ q1 {q2 } ∅
0 q2 {q1 } ∅
q0 q3 {q4 } ∅
q4 {q5 } ∅
λ
q5 {q3 } ∅
0
q3 q4
0 0
q5
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
Um AFD é 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 ou rejeita), é uma
palavra
Na prática, é uma máquina de estados finitos transdutora
O primeiro símbolo da palavra de saída é sempre σ(q0 )
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
ba/1
b a
a a
bb/0 a b aa/2
b b
ab/1
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), ∀a ∈ Σ e y ∈ Σ∗
Saída Computada:
A saída de uma máquina de Moore M = (Q, Σ, Γ, δD , σ, q0 )
para a palavra w ∈ Σ∗ é r(q0 , w)
Assim, retome o Exemplo #1 e compute r(00, 1110)
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}

1, se Q ∈ F
σ(Q) =
0, se Q 6∈ F
Logo, w ∈ 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
ba/0
b a
a a
bb/0 a b aa/1
b b
ab/0
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
Um AFD é 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 finitos transdutora
O primeiro símbolo da palavra de saída é sempre λ
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
a/1
q2 q3
Exemplo #3
Máquina de Mealy que determina o quociente da divisão
de um número binário por 6
0/0
1/1
1/0 0/1
q2 q5 q4
0/0 0/1 1/1
1/0
q1 q3
1/0 1/1
0/0
q0 0/1
Exemplo #4
Modificação 2 em 1
Mealy: quociente da divisão por 6 (transições)
Moore: resto da divisão por 6 (estados)
0/0
1/1
1/0 0/1
q2 /2 q5 /5 q4 /4
0/0 0/1 1/1

1/0
q1 /1 q3 /3
0/0 1/0 1/1
q0 /0 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) r( δD (Q, a), y), ∀a ∈ Σ e y ∈ Σ∗
Saída Computada:
A saída de uma máquina de Mealy M = (Q, Σ, Γ, δD , σ, q0 )
para a palavra w ∈ Σ∗ é 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 [?]
Algoritmos
Algoritmos
Linguagens Regulares – Algoritmos – AFND-λ para AFND
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-λ
a b
a
q0 q1
a λ
q2
AFND-λ
a b
q0
a
q1 δND−λ a b c λ
q0 {q0 , q1 , q2 } ∅ ∅ ∅
a λ
q1 ∅ {q1 } ∅ ∅
q2 q2 ∅ ∅ {q2 } {q1 }
AFND-λ
a b
q0
a
q0 {q0 , q1 , q2 } ∅ ∅ ∅
a λ
q1 ∅ {q1 } ∅ ∅
q2 q2 ∅ ∅ {q2 } {q1 }
1 δND−λ → δND
i. São estados iniciais: fecho−λ(q0 )
Se um estado inicial alcança um δND a b c
estado final, tal inicial será final
AFND-λ
a b
q0
a
q0 {q0 , q1 , q2 } ∅ ∅ ∅
a λ
q1 ∅ {q1 } ∅ ∅
q2 q2 ∅ ∅ {q2 } {q1 }
estado final, tal inicial será final q0 {q0 , q1 , q2 } ∅ ∅
q1 ∅ {q1 } ∅
q2 ∅
AFND-λ
a b
q0
a
q0 {q0 , q1 , q2 } ∅ ∅ ∅
a λ
q1 ∅ {q1 } ∅ ∅
q2 q2 ∅ ∅ {q2 } {q1 }
ii. Para os outros estados qi : q1 ∅ {q1 } ∅
q2 ∅
AFND-λ
a b
q0
a
q0 {q0 , q1 , q2 } ∅ ∅ ∅
a λ
q1 ∅ {q1 } ∅ ∅
q2 q2 ∅ ∅ {q2 } {q1 }
considera todo estado em fecho−λ(qi ) q2 ∅ {q 1 }
AFND-λ
a b
q0
a
q0 {q0 , q1 , q2 } ∅ ∅ ∅
a λ
q1 ∅ {q1 } ∅ ∅
q2 q2 ∅ ∅ {q2 } {q1 }
considera todo estado em fecho−λ(qi ) q2 ∅ {q 1 } {q 1 , q 2 }
consome, para em um estado qj e então
adiciona fecho−λ(qj )
AFND (agora)
δND a b c
q0 {q0 , q1 , q2 } ∅ ∅
q1 ∅ {q1 } ∅
q2 ∅ {q 1 } {q 1 , q 2 }
AFND (agora)
a b
q0
a
q1 δND a b c
q0 {q0 , q1 , q2 } ∅ ∅
a b,c
q1 ∅ {q1 } ∅
q2 q2 ∅ {q 1 } {q 1 , q 2 }
AFND (agora)
a b
q0
a
q1 δND a b c
q0 {q0 , q1 , q2 } ∅ ∅
a b,c
q1 ∅ {q1 } ∅
q2 q2 ∅ {q 1 } {q 1 , q 2 }
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 = hq0 i hq0 , q1 , q2 i ∅ ∅
AFND (agora)
a b
q0
a
q1 δND a b c
q0 {q0 , q1 , q2 } ∅ ∅
a b,c
q1 ∅ {q1 } ∅
q2 q2 ∅ {q 1 } {q 1 , q 2 }

ii. Cada novo Q obtém a q0 = hq0 i hq0 , q1 , q2 i ∅ ∅
união das transições dos
hq0 , q1 , q2 i hq0 , q1 , q2 i hq1 i hq1 , q2 i
seus estados integrantes
hq1 i ∅ hq1 i ∅
hq1 , q2 i ∅ hq1 i hq1 , q2 i
AFND (agora)
a b
q0
a
q1 δND a b c
q0 {q0 , q1 , q2 } ∅ ∅
a b,c
q1 ∅ {q1 } ∅
q2 q2 ∅ {q 1 } {q 1 , q 2 }

ii. Cada novo Q obtém a q0 = hq0 i hq0 , q1 , q2 i ∅ ∅
união das transições dos
F 3 hq0 , q1 , q2 i hq0 , q1 , q2 i hq1 i hq1 , q2 i
seus estados integrantes
F 3 hq1 i ∅ hq1 i ∅
iii. São finais: os estados que
contém pelo menos um F 3 hq1 , q2 i ∅ hq1 i hq1 , q2 i
estado final
AFD (enfim)
a
c
δD a b c
hq0 i
a
hq0 , q1 , q2 i
c
hq1 , q2 i hq0 i hq0 , q1 , q2 i ∅ ∅
hq0 , q1 , q2 i hq0 , q1 , q2 i hq1 i hq1 , q2 i
b b hq1 i ∅ hq1 i ∅
hq1 , q2 i ∅ hq1 i hq1 , q2 i
b hq1 i
Exercício de Fixação #1
a
q1 q2
λ b
q0
λ a
q3
0,1
1 0,1 0,1
q0 q1 q2 q3
a,b
a
q3 q4
λ
a b
q0 q1 q2
Algoritmos
Linguagens Regulares – Algoritmos – Minimização de AFD
Minimização de um AFD
1 Todos os estados são equivalentes
2 Se um é estado final e o outro não, logo não são
equivalentes
3 Conferir, estado por estado, se são "equivalentes"
Procedimento a ser detalhado
Toy Example (propósito ilustrativo apenas)

a a,b,c
c a
q1
c a,b q4
q0 b b q3
q2 q5
b c c
a 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 final e o outro não, faça D[i, j] = 1
3 Para cada par [i, j], i < j e D[i, j] = 0, faça:

3.1 se existe um a ∈ Σ 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 ∈ Σ 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
a,b
b b b
q0 q1 q2 q3
a a a
q4 q5 q6
a,b a,b a,b
a,b
b b b
q0 q1 q2 q3
a a a
q4 q5 q6
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 Índice D[i, j] = S[i, j] = Motivo

[0, 1] X ∅ [2, 3] X ∅
[0, 2] X ∅ [2, 4] X ∅
[0, 3] X ∅ [2, 5] X ∅
[0, 4] X ∅ [2, 6] X ∅
[0, 5] X ∅ [3, 4] X ∅
[0, 6] X ∅ [3, 5] X ∅
[1, 2] X ∅ [3, 6] X ∅
[1, 3] X ∅ [4, 5] X ∅
[1, 4] X ∅ [4, 6] X ∅
[1, 5] X ∅ [5, 6] X ∅
[1, 6] X ∅
a,b
b b b
q0 q1 q2 q3
a a a
q4 q5 q6
a,b a,b a,b
2 Para cada par [i, j], i < j, se um é estado final e o outro não, faça D[i, j] = 1 (aqui, x)

[0, 1] X ∅ [2, 3] X ∅
[0, 2] X ∅ [2, 4] x ∅
[0, 3] X ∅ [2, 5] x ∅
[0, 4] x ∅ [2, 6] x ∅
[0, 5] x ∅ [3, 4] x ∅
[0, 6] x ∅ [3, 5] x ∅
[1, 2] X ∅ [3, 6] x ∅
[1, 3] X ∅ [4, 5] X ∅
[1, 4] x ∅ [4, 6] X ∅
[1, 5] x ∅ [5, 6] X ∅
[1, 6] x ∅
a,b
b b b
q0 q1 q2 q3
a a a
q4 q5 q6
a,b a,b a,b

(D[m, n] = 1 ou D[n, m] = 1) então:

[0, 1] X { } [2, 3] X { }
[0, 2] X { } [4, 5] X { }
[0, 3] X { } [4, 6] X { }
[1, 2] X { } [5, 6] X { }
[1, 3] X { }
a,b
b b b
q0 q1 q2 q3
a a a
q4 q5 q6
a,b a,b a,b

(D[m, n] = 1 ou D[n, m] = 1) então:

[0, 1] X { } [2, 3] X { }
[0, 2] X { } [4, 5] X { [0, 1] }
[0, 3] X { } [4, 6] X { }
[1, 2] X { [0, 1] } [5, 6] X { }
[1, 3] X { }
a,b
b b b
q0 q1 q2 q3
a a a
q4 q5 q6
a,b a,b a,b

(D[m, n] = 1 ou D[n, m] = 1) então:

[0, 1] X { } [2, 3] X { }
[0, 2] X { } [4, 5] X { [0, 1] }
[0, 3] X { } [4, 6] X { [0, 2] }
[1, 2] X { [0, 1] } [5, 6] X { }
[1, 3] X { [0, 2] }
a,b
b b b
q0 q1 q2 q3
a a a
q4 q5 q6
a,b a,b a,b

(D[m, n] = 1 ou D[n, m] = 1) então:

[0, 1] X { } [2, 3] X { }
[0, 2] X { } [4, 5] X { [0, 1] }
[0, 3] X→x { } a [4, 6] X { [0, 2] }
[1, 2] X { [0, 1] } [5, 6] X { }
[1, 3] X { [0, 2] }
a,b
b b b
q0 q1 q2 q3
a a a
q4 q5 q6
a,b a,b a,b

(D[m, n] = 1 ou D[n, m] = 1) então:

[0, 1] X { } [2, 3] X { [1, 2] }
[0, 2] X { } [4, 5] X { [0, 1] }
[0, 3] X→x { } a [4, 6] X { [0, 2] }
[1, 2] X { [0, 1] } [5, 6] X { [1, 2] }
[1, 3] X { [0, 2] }
a,b
b b b
q0 q1 q2 q3
a a a
q4 q5 q6
a,b a,b a,b

(D[m, n] = 1 ou D[n, m] = 1) então:

[0, 1] X { } [2, 3] X { [1, 2] }
[0, 2] X→x { } [1, 3] [4, 5] X { [0, 1] }
[0, 3] X→x { } a [4, 6] X { [0, 2] }
[1, 2] X { [0, 1] } [5, 6] X { [1, 2] }
[1, 3] X→x { [0, 2] } a
a,b
b b b
q0 q1 q2 q3
a a a
q4 q5 q6
a,b a,b a,b

(D[m, n] = 1 ou D[n, m] = 1) então:

[0, 1] X→x { } [1, 2] [2, 3] X→x { [1, 2] } a
[0, 2] X→x { } [1, 3] [4, 5] X { [0, 1] }
[0, 3] X→x { } a [4, 6] X { [0, 2] }
[1, 2] X→x { [0, 1] } [2, 3] [5, 6] X { [1, 2] }
[1, 3] X→x { [0, 2] } a
a,b
b b b
q0 q1 q2 q3
a a a
q4 q5 q6
a,b a,b a,b

(D[m, n] = 1 ou D[n, m] = 1) então:

[0, 1] X→x { } [1, 2] [2, 3] X→x { [1, 2] } a
[0, 2] X→x { } [1, 3] [4, 5] X { [0, 1] }
[0, 3] X→x { } a [4, 6] X { [0, 2] }
[1, 2] X→x { [0, 1] } [2, 3] [5, 6] X { [1, 2] }
[1, 3] X→x { [0, 2] } a
a,b
b b b
q0 q1 q2 q3
a a a
q4 q5 q6
a,b a,b a,b

(D[m, n] = 1 ou D[n, m] = 1) então:

[0, 1] X→x { } [1, 2] [2, 3] X→x { [1, 2] } a
[0, 2] X→x { } [1, 3] [4, 5] X { [0, 1] }
[0, 3] X→x { } a [4, 6] X { [0, 2] }
[1, 2] X→x { [0, 1] } [2, 3] [5, 6] X { [1, 2] }
[1, 3] X→x { [0, 2] } a
a,b
b b b
q0 q1 q2 q3
a a a
q4 q5 q6
a,b a,b a,b

(D[m, n] = 1 ou D[n, m] = 1) então:

[0, 1] X→x { } [1, 2] [2, 3] X→x { [1, 2] } a
[0, 2] X→x { } [1, 3] [4, 5] X { [0, 1] }
[0, 3] X→x { } a [4, 6] X { [0, 2] }
[1, 2] X→x { [0, 1] } [2, 3] [5, 6] X { [1, 2] }
[1, 3] X→x { [0, 2] } a
a,b
b b b
q0 q1 q2 q3
a a a
q4 q5 q6
a,b a,b a,b
4 Para cada D[i, j] = 0, os estados i e j podem ser fundidos
a,b
b b b
q0 q1 q2 q3
a a
a
{q4 , q5 , q6 }
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
b
b
q1 q3
a
a a
q2 a,b
q0 q7
q5 a,b
b a a,b
a b
b
q4 q6
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 ∗ )∗
a
q2 q3
a
q2 q3
b
q4 q5
a
q2 q3
λ λ
q1 q6
λ b λ
q4 q5
a
q2 q3
λ λ
c
q1 q6 q7 q8
λ b λ
q4 q5
λ
a
q2 q3
λ λ
λ c λ
q1 qq660 q7 q8 q9
λ b λ
q4 q5
λ
a
q2 q3
λ λ
λ c λ
q1 q6 q7 q8 q9
λ b λ
q4 q5
λ
a
q2 q3
λ λ
λ λ c λ λ
q0 q1 q6 q7 q8 q9 q10
λ b λ
q4 q5
Exercícios de Fixação
1 (a ∪ b)∗
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
L1 L2
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
L1 ∪ L2
L1 L2
L1∗

Prova: basta inverter os estados finais com não-finais
Objetivos:
L1 ∪ L2
L1 L2
L1∗

Prova: basta inverter os estados finais com não-finais

Prova: Lei de Morgan: L1 ∩ L2 = (L1 ∪ L2 )
Objetivos:
Prove que a linguagem formada por palavras sobre {a,b}
que tenham aa e não tenham bb é regular (Exemplo 6.4.1, Sudkamp [?])
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 = {a i bj | i, j ≥ 0 e i 6= j} não é regular
Suponha que L seja regular
Então, L também é regular
Mas, L = {a i 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 = ∅
É 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 infinitas (pq?)
Se um AFD tem k estados, então qualquer caminho de

aceitação de uma palavra z de tamanho |z| ≥ k contém
um ciclo
b b
a
q0 q1
Exemplo (k=2, pense em qualquer z tal que |z| ≥ k e z ∈ L)

b b
a
q0 q1
Caminhos de aceitação
O caminho de aceitação de qualquer palavra z tal que
|z| ≥ k e z ∈ 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 ∈ 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
uv i w ∈ L para todo i ≥ 0
u w
q0 Q(s) qf
Exemplo
a a
a
q0 q1
b
a b
q2 q3
a, b
Decomponha as palavras z ∈ L e z > k em z = uvw

aaab
ababb
ababab
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
i
uv w ∈ L para todo i ≥ 0.”
Exemplo #1: L = {a i bi | i ≥ 0}
Exemplo #1: L = {a i bi | i ≥ 0}
Assuma que L é regular e seja k a constante especificada pelo Lema.
Seja z = a k bk . Qualquer decomposição de z = uvw satisfazendo as
precondições do lema terão a seguinte forma:
u v w
ai aj a k−i−j bk
onde i + j ≤ k e j > 0. Bombeando alguma subpalavra nesta forma produzirá

uv 2 w = a i a j a j a k−i−j bk = a k a j bk que não pertence a L.
Como z ∈ 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 = {a n | n é um quadrado perfeito }
Exemplo #2: L = {a n | n é um quadrado perfeito }

Assuma que L é regular e seja k a constante especificada pelo Lema.
2
Seja z = a k e, portanto, |z| = k 2 . Qualquer decomposição de z = uvw conterá
apenas a. Assim, conduziremos a prova no tamanho da palavra bombeada:
|uv 2 w| = |uvw| + |v|

= k 2 + |v| (0 < |v| ≤ k)
2
≤ k +k
2
< k +k +1
= (k + 1)2
Como k 2 < |uv 2 w| < (k + 1)2 , uv 2 w 6∈ L.
Como z ∈ 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 = {0m 1n | m > n}
2 L2 = {0n 12n | n > 0}
3 L3 = {a i bm c n | 0 < i, 0 < m < n}
4 L4 = {0m 1n 2m+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 177
Recursividade
Ambiguidade
Formas Normais 204
Transformações de Gramática 208
Forma Normal de Chomsky 238
Remoção de recursividade à esquerda 244
Forma Normal de Greibach 251
Propriedades 260
Algoritmos de Reconhecimento 277
Algoritmo de Early
Autômatos com Pilha 309
Variantes
Algoritmos 331
5
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:
b a
a
S A
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= {a i 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= {a i bi | 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 especificam 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: µ → ν
µ∈V (i.e., um não-terminal)
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 end n 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)
Portanto:
L(G) = {w ∈ Σ∗ | S ⇒∗ w}
Exemplos
Definir GLCs para as seguintes linguagens:
1 Palíndromas sobre {a, b}, i.e., L = {w ∈ {a, b}∗ | w = w R }
2 Palavras sobre {a, b} com tamanho ímpar, i.e.,

L = {w ∈ {a, b}∗ | |w| (mod 2) = 1}
Exemplos

L = {w ∈ {a, b}∗ | |w| (mod 2) = 1}
Exemplos

L = {w ∈ {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 = {a n bm a n | m > 0 e n > 0}
2 L = {a n bm c m d 2n | m > 0 e n ≥ 0}
3 L = {a n 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 ⇒ abava
Exemplo
S → AA

ababaA ⇒ ababaa (derivação mais à esq.)

ababAA ⇒ ababaA ⇒ ababaa (derivação mais à esq.)

Ababaa ⇒ ababaa (derivação mais à dir.)

ababAa ⇒ abava (só derivação)
Exemplo
S → AA

ababaA ⇒ ababaa (derivação mais à esq.)

ababAA ⇒ ababaA ⇒ ababaa (derivação mais à esq.)

Ababaa ⇒ ababaa

ababAa ⇒ abava
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 [?]
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
a S b
a S b
Exemplo #2
GLC: E → E + E | E ∗ E | (E) | id
Palavra: id + id * id
E + E
id E ∗ E
id id
Exemplo #2
GLC: E → E + E | E ∗ E | (E) | id
Palavra: id + id * id
E + E
Algum problema com a
GLC ou com a árvore?
id E ∗ E
id id
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 significa 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)
Ambiguidade – Exemplo #1
Assuma a seguinte GLC G:
S → aSb | aSbb | λ
Pergunta-se: Essa GLC é ambígua?

Sim. Assuma w = aabbb, logo:
S ⇒ aSb ⇒ aaSbbb ⇒ aabbb
S ⇒ aSbb ⇒ aaSbbb ⇒ aabbb

Sim. Assuma w = aabbb, logo:
S ⇒ aSb ⇒ aaSbbb ⇒ aabbb
S ⇒ aSbb ⇒ aaSbbb ⇒ aabbb
Gramática equivalentemente não ambígua:

S → aSb | A | λ
A → aAbb | abb
Assuma a seguinte GLC G usada reconhecer expressões
aritméticas em um analisador sintático
E → E + E | E ∗ E | (E) | id
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 + E E ∗ E
id E ∗ E E + E id
id id id id
Ambiguidade – Indecibilidade
O problema de determinar se uma GLC arbitrária é
ambígua é indecidível
Portanto, isso significa 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
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= {a n bm c m d n ou a n bn c m d m | m ≥ 1 e n ≥ 1}
Crie uma GLC para L
Mostre a derivação de, e.g., aabbccdd
Notação Backus-Nahur Form (BNF)

Proposta em ∼1960
Notação normalmente utilizada para definir 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 Greibach
FN de Chomsky
FN de Greibach
Uma GLC G = (V , Σ, P, S) está na FN de Greibach se suas
regras têm uma das seguintes formas:
A → aA1 A2 A3 . . . An onde a ∈ Σ e A1..n ∈ V − {S}
A→a
S→λ
1o passo:
Transformar GLC para FN de Chomsky
2o passo:
Em um futuro próximo...
FN de Greibach
A→a
S→λ
1o passo:
Transformar GLC para FN de Chomsky ?
2o passo:
Em um futuro próximo...
FN de Chomsky
Uma GLC G = (V , Σ, P, S) está na FN de Chomsky se suas
A → BC onde B, C ∈ V − {S}
A→a onde a ∈ Σ
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 (∀B | B ⇒ Σ+ e S ⇒ αBβ)
FN de Chomsky
A→a onde a ∈ Σ
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) ?
Não possui símbolos inúteis (∀B | B ⇒ Σ+ e S ⇒ α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, modificam 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, ∀B | B ⇒ Σ+ e REACH, ∀B | 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 ∪ {S 0 }, Σ, P ∪ {S 0 → S}, S 0 )
L(G0 ) = L(G)
Símbolo inicial S 0 de G0 não é mais recursivo

(V , Σ, P, S) =⇒ (V ∪ {S 0 }, Σ, P ∪ {S 0 → S}, S 0 )
Exemplo
S → aS | AB | AC
A → aA | λ
B → bB | bS
C → cC | λ
⇓

(V , Σ, P, S) =⇒ (V ∪ {S 0 }, Σ, P ∪ {S 0 → S}, S 0 )
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., ¬∃A ∈ 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 → λ} ∈ P}
repita
PREV = NULL
para cada A ∈ V fa ća
se A → w e w ∈ PREV ∗ fa ća
NULL = NULL ∪ {A}
até NULL == PREV
Exemplo
S → ACA NULL = {A | {A → λ} ∈ P}
repita
PREV = NULL
A → aAa | B | C para cada A ∈ V fa ća
B → bB | b NULL = NULL ∪ {A}
até NULL == PREV
C → cC | λ
NULLABLE
NULL PREV
Exemplo
S → ACA NULL = {A | {A → λ} ∈ P}
repita
PREV = NULL
até NULL == PREV
C → cC | λ
NULLABLE
NULL PREV
(0) {C} ∅
Exemplo
S → ACA NULL = {A | {A → λ} ∈ P}
repita
PREV = NULL
até NULL == PREV
C → cC | λ
NULLABLE
NULL PREV
(0) {C} ∅
(1) {C, A} {C}
Exemplo
S → ACA NULL = {A | {A → λ} ∈ P}
repita
PREV = NULL
até NULL == PREV
C → cC | λ
NULLABLE
NULL PREV
(0) {C} ∅
(1) {C, A} {C}
(2) {C, A, S} {C, A}
Exemplo
S → ACA NULL = {A | {A → λ} ∈ P}
repita
PREV = NULL
até NULL == PREV
C → cC | λ
NULLABLE
NULL PREV
(0) {C} ∅
(1) {C, A} {C}
(2) {C, A, S} {C, A}
(3) {C, A, S} {C, A, S}
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 λ ∈ 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: S, A e C
Exemplo #1
S → ACA
A → aAa | B | C
B → bB | b
C → cC | λ
⇓ variáveis anuláveis: S, A e 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: A, B e C
Exemplo #2
L(G) = a ∗ b∗ c ∗
G : S → ABC
A → aA | λ
B → bB | λ
C → cC | λ
⇓ variáveis anuláveis: A, B e C
S → ABC | AB | BC | AC | A | B | C | λ
A → aA | a
B → bB | b
C → cC | c

Uma regra na forma A → B
Não aumenta tamanho da forma sentencial
Não gera símbolos não 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 ∈ 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 ∈ NEW fa ća
para cada B → C fa ć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 | λ CHAIN(S) = {S, A, C, B}
CHAIN(B) = {B}
B → bB | b CHAIN(C) = {C}
C → cC | c
Novas Regras
A → w, onde B ∈ CHAIN(A), B → w ∈ P, w 6∈ V
Gramática Original
S → ACA | CA | AA | AC | A | C | λ CHAIN(S) = {S, A, C, B}
CHAIN(B) = {B}
B → bB | b CHAIN(C) = {C}
C → cC | c
Novas Regras
A → w, onde B ∈ CHAIN(A), B → w ∈ P, w 6∈ V
Nova Gramática sem Regras de Cadeia

S → ACA | CA | AA | AC | aAa | aa | bB | b | cC | c | λ
A → aAa | aa | bB | 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 ∈ (V ∪ Σ)∗ e |w| ≥ 2

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 D → aD | BD | C
A → aA | aF E → aA | BSA
B → CF | b F → bB | b
C → cC | D
Símbolos Inúteis
Um símbolo x ∈ (V ∪ Σ) é útil se:
S ⇒∗ uxv ⇒∗ w, onde u, v ∈ (V ∪ Σ)∗ e w ∈ Σ∗
Um terminal é útil quando ocorre em uma palavras w ∈ L(G)
Uma variável A é útil se existe: S ⇒∗ uAv ⇒∗ w, w ∈ L(G)
Algoritmo TERM
Saída: Conjunto de variáveis que geram terminais (TERM)
TERM = {A | e x i s t e uma regra A → w ∈ P , com w ∈ Σ∗ }

repita
PREV = TERM
para cada A ∈ V fa ća
se A → w ∈ P e w ∈ (PREV ∪ Σ)∗ então
TERM = TERM ∪ A
até PREV == TERM
Exemplo
S → AC | BS | B D → aD | BD | C
B → CF | b F → bB | b
C → cC | D
TERM
TERM PREV
Exemplo
S → AC | BS | B D → aD | BD | C
B → CF | b F → bB | b
C → cC | D
TERM
TERM PREV
(0) {B, F} ∅
Exemplo
S → AC | BS | B D → aD | BD | C
B → CF | b F → bB | b
C → cC | D
TERM
TERM PREV
(0) {B, F} ∅
(1) {B, F, A, S} {B, F}
Exemplo
S → AC | BS | B D → aD | BD | C
B → CF | b F → bB | b
C → cC | D
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 D → aD | BD | C
B → CF | b F → bB | b
C → cC | D
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 D → aD | BD | C
B → CF | b F → bB | b
C → cC | D
Gramática Original
S → AC | BS | B D → aD | BD | C
B → CF | b F → bB | b
C → cC | D
Variáveis que não geram terminal

V − {B, F, A, S, E} = {C, D}
Gramática Original
S → AC | BS | B D → aD | BD | C
B → CF | b F → bB | b
C → cC | D
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 E → aA | BSA
A → aA | aF F → bB | b
B→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 ∈ NEW fa ća
para cada A → w fa ća
adicione todas as v a r iáv e i s de w em REACH
até REACH == PREV
Exemplo
B→b
REACH
REACH PREV NEW
(0) {S} ∅
(1)
(2)
Exemplo
B→b
REACH
REACH PREV NEW
(0) {S} ∅ {S}
(1)
(2)
Exemplo
B→b
REACH
REACH PREV NEW
(0) {S} ∅ {S}
(1) {S, B} {S}
(2)
Exemplo
B→b
REACH
REACH PREV NEW
(0) {S} ∅ {S}
(1) {S, B} {S} {B}
(2)
Exemplo
B→b
REACH
REACH PREV NEW
(0) {S} ∅ {S}
(1) {S, B} {S} {B}
(2) {S, B} {S, B}
Exemplo
B→b
REACH
REACH PREV NEW
(0) {S} ∅ {S}
(1) {S, B} {S} {B}
(2) {S, B} {S, B} –
Gramática Original
B→b
Gramática Original
B→b
Variáveis inalcançáveis:
V − {S, B} = {A, E, F}
Gramática Original
B→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
Para remoção de variáveis inúteis: TERM e REACH (nesta ordem)

G : S → a | AB
A→b
TERM = {S, A}
GT : S → a
A→b
REACH = {S}
GU : S → a
Se algoritmos forem aplicados na ordem inversa, o

resultado seria incorreto!
Forma Normal de Chomsky
Linguagens Livres de Contexto – Forma Normal de Chomsky
FN de Chomsky
A→a onde a ∈ Σ
S→λ

Exemplo #1
A → bDcF
FN de Chomsky:
Exemplo #1
A → bDcF
FN de Chomsky:
Primeira transformação:
A → B 0 DC 0 F
B0 → b
C0 → c
Exemplo #1
A → bDcF
FN de Chomsky:
Primeira transformação:
A → B 0 DC 0 F
B0 → b
C0 → c
Segunda transformação:
A → B 0 T1
B0 → b
C0 → c
T1 → DT2
T2 → C 0 F
Exemplo #2
S → aABC | a
A → aA | a
B → bcB | bc
C → cC | c
FN de Chomsky:
Já satisfaz pré-condições:
Exemplo #2
S → aABC | a
A → aA | a
B → bcB | bc
C → cC | c
FN de Chomsky:
Exemplo #2
S → aABC | a
A → aA | a
B → bcB | bc
C → cC | c
FN de Chomsky:
S → A0 T1 | a B → B 0 T3 | B 0 C 0
A0 → a T3 → C 0 B
T1 → AT2 C → C0C | c
T2 → BC B0 → b
A → A0 A | a C0 → c
Exemplo #3
S → aXb | ab
X → aXb | ab
FN de Chomsky:
Exemplo #3
S → aXb | ab
X → aXb | ab
FN de Chomsky:
S → AT | AB
T → XB
X → AT | AB
A→a
B→b
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
infinitos” 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 | ν1 Z | ν2 Z | . . . | νn Z
Z → µ1 Z | µ2 Z | . . . | µm Z | µ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
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
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
B→b|c
Z → BZ | B
Exemplo #4
A → Aa | Aab | bb | b – gera (b ∪ bb)(a ∪ ab)∗
Exemplo #4
A → Aa | Aab | bb | b – gera (b ∪ bb)(a ∪ ab)∗
A → bb | b | bbZ | bZ – gera (b ∪ bb)(Z ∪ λ)

Z → aZ | abZ | a | ab – gera (a ∪ ab)+
Remoção de Recursão à Esquerda

Problema: recursão à esquerda indireta
A → Bu
B → Av
Recursão indireta também pode gerar “loops infinitos”
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 | ν1 Z | ν2 Z | . . . | νn Z
Z → µ1 Z | µ2 Z | . . . | µm Z | µ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 → ν1 Z | ν2 Z | . . . | νn Z
Z → µ1 Z | µ2 Z | . . . | µm Z | λ
Forma Normal de Greibach
Linguagens Livres de Contexto – Forma Normal de Greibach
FN de Greibach
A → aA1 A2 A3 . . . An onde a ∈ Σ e A1..n ∈ 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, . . .
3o passo: regras das seguintes formas

S→λ
A → aw
A → Bw onde w ∈ 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 – 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 → CBR1 B | aR1 B | CBB | aB | b – ok, C > B
C → CBR1 C | aR1 C | CBC | aC | c – recursiva esq.
R1 → BR1 | B
Removendo recursão à esquerda na regra C:

S → AB | λ – ok 3o passo
A → CBR1 | aR1 | CB | a – ok 3o passo
B → CBR1 B | aR1 B | CBB | aB | b – ok 3o passo
C → aR1 C | aC | c | aR1 CR2 | aCR2 | cR2 – ok 3o passo
R1 → BR1 | B
R2 → BR1 CR2 | BCR2 | BR1 C | 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 → aR1 B | aB | b |
aR1 CBR1 B | aCBR1 B | cBR1 B | aR1 CR2 BR1 B | aCR2 BR1 B | cR2 BR1 B |
aR1 CBB | aCBB | cBB | aR1 CR2 BB | aCR2 BB | cR2 BB
C → aR1 C | aC | c | aR1 CR2 | aCR2 | cR2
R1 → BR1 | B
R2 → BR1 CR2 | BCR2 | BR1 C | BC
PS
B agora também está na FN de Greibach
Repetir o procedimento para A, S, R1 e R2 (nesta ordem)

Comentários Finais
FN de Greibach:
Gramáticas grandes (i.e., diversas regras)
Gramáticas sem a simplicidade original
Transformação de GLCs para FN de Greibach pode ser

automatizada (via algoritmo descrito nos slides anteriores)
Propriedades importante de GLC na FN de Greibach:

Toda derivação adiciona um terminal no início da palavra
que está sendo derivada
Logo, não existe recursão à esquerda (direta ou indireta)
Palavras de tamanho n > 0 são derivadas aplicando-se
exatamente n regras
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 ∈ {a, b}∗ }
Analogia com compiladores:
declaração de uma variável antes do seu uso
Triplo balanceamento, e.g., L = {a n bn c n | 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 LLC
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 cujo estado inicial possui transições λ

para os estados iniciais de M1 e M2
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 = {a i bi c j | i, j ≥ 0} uma LC
Seja L2 = {a j bi c i | i, j ≥ 0} uma LC
No entanto, L1 ∩ L2 = {a i bi c i | i ≥ 0} não é LC
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 LC
Então L = L1 ∪ L2 também é LC
Mas, L = L1 ∩ L2
Já foi mostrado que L1 ∩ L2 não necessariamente é LC
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 ∈ 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 ∈ 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 M 0 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 = (V 0 , T 0 , P 0 , S) a GLC equivalente a G sem símbolos

inúteis
Se P 0 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 existir um clico 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 existir um clico no grafo de dependência, L é infinita
Caso contrário, L é finita
Exemplo (finita ou infinita?)

A
S → AB
A → aCb | a S C
B → bB | bb B
C → cBS
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 [?]
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, ineficientes
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
Classificaçã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

ineficiente para entradas mais longas
Exemplo
L = {a n bn | n ≥ 1}
G(L) = {V , T , P, S} = {{S}, {a, b}, {S → aSb, S → ab}, S}

Forma Normal de Greibach:
G(L) = {{S, B}, {a, b}, {S → aSB, S → aB, B → b}, S}
Exemplo
L = {a n bn | n ≥ 1}

Forma Normal de Greibach:
G(L) = {{S, B}, {a, b}, {S → aSB, S → aB, B → b}, S}
λ λ/S λ λ/λ
q0 q1 q2
a S/SB
a S/B
b B/λ

Forma alternativa de construir AP
Igualmente simples e com o mesmo nível de eficiê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 = {a n bn | n ≥ 1}
Exemplo
L = {a n bn | n ≥ 1}
λ λ/S λ λ/λ
q0 q1 q2
λ S/aSb
λ S/ab
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
S → AT | AB
T → XB
X → AT | AB
A→a
a a a b b b B→b
Para preencher a 1a
linha devemos verificar qual variável
gera a sequencia de 1 terminal
S → AT | AB
T → XB
X → AT | AB
A→a
1 A A A B B B B→b
a a a b b b
Para preencher a 2a
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 –
S → AT | AB
T → XB
X → AT | AB
A→a
B→b
2 -
1 A A A B B B
a a a b b b
O processo se repete
S → AT | AB
T → XB
2 - -
X → AT | AB
1 A A A B B B A→a
B→b
a a a b b b
Neste caso, existem duas regras que geram AB

Logo, ambas são colocadas na célula
S → AT | AB
T → XB
X → AT | AB
2 - - S,X
A→a
1 A A A B B B B→b
a a a b b b
O processo se repete até completar a 2a linha
S → AT | AB
T → XB
2 - - S,X - -
X → AT | AB
1 A A A B B B A→a
B→b
a a a b b b
Para preencher a 3a
gera a sequência de 3 terminais
as setas mostram quais pares de células devemos trabalhar a
fim de se obter a sequência de três terminais
S → AT | AB
T → XB
X → AT | AB
3 A→a
B→b
2
1
a a a b b b
1 + 2 = A + − = A−
Par inválido, logo marcamos a célula com um −
S → AT | AB
3 - T → XB
X → AT | AB
2 - - S,X - -
A→a
1 A A A B B B B→b
a a a b b b
2 + 1 = − + A = −A
Par inválido, logo marcamos a célula com um −
S → AT | AB
3 - T → XB
X → AT | AB
2 - - S,X - -
A→a
1 A A A B B B B→b
a a a b b b
O processo se repete até completar a 3a linha
3 - - T - S → AT | AB
T → XB
2 - - S,X - -
X → AT | AB
1 A A A B B B A→a
a a a b b b B→b
Para preencher a 4a
o processo se repete para as linhas superiores
S → AT | AB
4 - T → XB
3 - - T - X → AT | AB
A→a
2 - - S,X - -
B→b
1 A A A B B B
a a a b b b
Para preencher a 4a
S → AT | AB
4 - T → XB
3 - - T - X → AT | AB
A→a
2 - - S,X - -
B→b
1 A A A B B B
a a a b b b
Para preencher a 4a
S → AT | AB
4 - T → XB
3 - - T - X → AT | AB
A→a
2 - - S,X - -
B→b
1 A A A B B B
a a a b 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 ∈ L
Como S é a raiz então

6 S,X a palavra é reconhecida
5 - T
S → AT | AB
4 - S,X - T → XB
3 - - T - X → AT | AB
A→a
2 - - S,X - -
B→b
1 A A A B B B
a a a b 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 eficientes como o de Early serão abordados em

Compiladores!
Autômatos com Pilha
Linguagens Livres de Contexto – Autômatos com Pilha

AFDs são incapazes de reconhecer a i bi 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):
δ : Q x (Σ ∪ λ) x (Γ ∪ λ) → P(Q x (Γ ∪ λ))
Permite transições δ(qi , a, b) e δ(qi , a 0 , b0 ) compatíveis:
δ(qi , a, b) = {[qj , B], [qk , C]}
Uma palavra w ∈ Σ∗ é dita ser aceita por um APND se, e
para em um estado final com pilha vazia

Exemplo: δ(qi , a, A) = [qj , B]
a A/B
qi qj
q i : estado atual
a: símbolo a ser lido pela entrada
A: símbolo no topo da pilha (a ser desempilhado)
q j : novo estado
B: novo topo da pilha (a ser empilhado)
Se (estado== q i ) && (entrada== a) && (topo == A) então

Lê a da entrada
Muda o estado atual de q i para q j
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 , λ]
λ A/λ
qi qj
δ(qi , λ, λ) = [qj , B]
λ λ/B
qi qj
δ(qi , a, λ) = [qj , λ]
a λ/λ
qi qj
Autômatos com Pilha: Aceitação

Seja M = (Q, Σ, Γ, δ, q0 , F) um AP
Uma palavra w ∈ Σ∗ é aceita por M se existe uma

computação da forma:
∗
[q0 , w, λ] ` [qi , λ, λ], onde qi ∈ F
Ou seja:
A palavra de entrada deve ser toda lida
Deve-se terminar em um estado final
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) = {a i bi | i > 0}
Exemplo Clássico
L(G) = {a i bi | i > 0}
AP:
a λ/X b X/λ
b X/λ
q0 q1
Autômatos com Pilha: Exemplos

L1 = {wcw R | w = (a ∪ b)∗ }
L2 = {a i | i ≥ 0} ∪ {a i bi | i ≥ 0}
L3 = palíndromos de tamanho par sobre {a, b}
L4 = {a i b2i | 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: qj
/C
uA
δ(qi , u, A) = [qj , C]
qi
δ(qi , v, B) = [qk , D] v B/
D qk
Um AP é determinístico se não possui transições compatíveis

Essas duas transições são compatíveis se:
u=v eA=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 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)
a A/BCD
qi qj
APs Atômicos e Estendidos

Variantes de APs (i.e., Atômicos e Estendidos) não aumentam o
poder de expressão de APs
Exemplo Clássico:
AP atômico e estendido para L = {a i b2i | i ≥ 1}
Critério de Aceitação
Critério normal de aceitação: por estado final e pilha vazia
∗
[q0 , w, λ] ` [qi , λ, λ], qi ∈ F
Critério alternativo de aceitação: por estado final

∗
[q0 , w, λ] ` [qi , λ, α], qi ∈ F, α ∈ Γ∗
Basta processar toda a palavra e terminar em estado final
Critério alternativo de aceitação: por pilha vazia

+
[q0 , w, λ] ` [qi , λ, λ]
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: {a i | i ≥ 0} ∪ {a i bi | i ≥ 0}
No caso de aceitação por estado final, tais estados são

desnecessários
Aceitação por Estado Final

Lema: Seja L uma linguagem aceita por um AP M por
estado final, então existe um AP M 0 que aceita L por estado
final e pilha vazia
Basta acrescentar um novo estado final qf 0 e
δ’(qi , λ, λ) = [qf 0 , λ], para todo qi ∈ F
δ’(qf 0 , λ, X ) = [qf 0 , λ], para todo X ∈ Γ

∗ ∗
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 Pilha Vazia

Critério alternativo de aceitação: por pilha vazia
+
[q0 , w, λ] ` [qi , λ, λ]
Observe que não se exige mais que qi ∈ 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 M 0 que aceita L por estado final e
pilha vazia
Todo estado de M é um estado final em M 0
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 ∈ Q, x ∈ Σ ∪ {λ}, A ∈ Γ ∪ {λ}
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
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 final

estado final

pilha vazia
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→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 ∈ P }
δ(q1 , a, A) = { [q1 , w] | A → aw ∈ P e A ∈ V − {S} }
δ(q0 , λ, λ) = [q1 , λ], se S → λ ∈ 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 δ’ estende δ

com duas novas transições:
Se [qj , λ] ∈ δ(qi , u, λ) então
[qj , A] ∈ δ 0 (qi , u, A), para todo A ∈ Γ
Se [qj , B] ∈ δ(qi , u, λ) então
[qj , BA] ∈ δ 0 (qi , u, A), para todo A ∈ Γ
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 ∈ ΓM (qualquer que seja o topo)
Claramente, L(M) = L(M 0 )


Algoritmo para gerar uma GLC G a partir do AP M 0
Variáveis não vão ser mais maiúsculas, mas sim tuplas da

forma <qi , A, qj >
estou em q i ,
quero ir para q j e
existe A no topo da pilha

Regras de G:
#1 S → <q0 , λ, qj >, para todo qj ∈ F
#2 Se [qj , B] ∈ δ 0 (qi , x, A), então (A e B ∈ Γ ∪ {λ})
<qi , A, qk > → x<qj , B, qk >, para todo qk ∈ Q
#3 Se [qj , BA] ∈ δ 0 (qi , x, A), então (A e B ∈ Γ)
<qi , A, qk > → x<qj , B, qn >< qn , A, qk >, qk , qn ∈ Q
#4 Para todo qk ∈ 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) = a n cbn , n ≥ 0

a λ/A b A/λ
c λ/λ
q0 q1
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 , λ]

a λ/A
a A/AA b A/λ
c λ/λ
c A/A
q0 q1
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 ∈ F
Logo, primeira regra da GLC será: S → <q0 , λ, q1 >
Como [q0 , A] ∈ δ(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] ∈ δ 0 (qi , x, A), então (A e B ∈ Γ)
<qi , A, qk > → x<qj , B, qn >< qn , A, qk >, qk , qn ∈ Q
Como [q0 , AA] ∈ δ(q0 , a, A), então

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 , λ] ∈ δ(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] ∈ δ(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 , λ] ∈ δ(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 ∈ 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
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
Algoritmo de Early
Variantes

Gramática Sensível ao Contexto 352
Autômato Linearmente Limitado 357
Teoremas 362

Teoremas
Variantes
Teoremas
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: µ → ν
ν ∈ (V ∪ Σ)+ (i.e., palavra formada por elementos de V e Σ)
|µ| ≤ |ν| (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
L = {a i bi c i | i > 0}
GSC(L):

existe um ALL que aceita LSC
Exemplo Clássico
L = {a i bi c i | i > 0}
GSC(L):
S → aAbc | abc
A → aAbC | abC
Cb → bC
Cc → cc

existe um ALL que aceita LSC
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) = {a i b2i c i | i > 0}
Autômato Linearmente Limitado
Linguagens Sensíveis ao Contexto – Autômato Linearm. Limitado

Um ALL é uma óctupla (Q, Σ, Γ, δ, q0 , <, >, F):
< e > = delimitadores da palavra de entrada

Configuração inicial da fita: <w>
Delimitadores podem ser lidos, mas não apagados
Delimitadores não podem ser ultrapassados

Tamanho da fita = |w| + 2
Basicamente, um ALL é uma MT cuja quantidade de fita

disponível é limitada ao tamanho da palavra de entrada
Exemplo Clássico
L = {a i bi c i | i > 0}
Z /Z E
Y /Y E
c/c E
Y /Y D Z /Z D b/b E
a/a D b/b D c/c D a/a E
</< D a/X D b/Y D c/Z D >/> E

q0 q1 q2 q3 q4 q5
Y/Y D X/X D
>/> E Z /Z E
q6 q7 Y /Y E
X /X E
Y /Y D
Z /Z D
1 L = {ww | w ∈ {a, b}+ }
2 L = {wcw | w tem o mesmo número de a e b}
Teoremas
Linguagens Sensíveis ao Contexto – Teoremas
Prova do Teorema #1: Toda LSC L é 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
Prova do Teorema #2: Toda LSC L tem um ALL M tal que L(M) = L
Seja 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 fita) 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 infinita)
6. Linguagens Irrestritas – Conteúdo
1 Revisão 3
2 Introdução 59
Máquina de Moore
Máquinas de Mealy

Recursividade
Ambiguidade
Algoritmo de Early
Variantes

Gramática Irrestrita 369
Teoremas
Máquinas de Turing 378
Variantes
Teoremas
7 Considerações Finais 415/ 423

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2015 367
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: µ → ν
“Quase” nenhuma restrição é imposta (|µ| > 0)
Exemplo Clássico
L = {u[u] | u ∈ {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 ∈ Σ∗
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 a i A(bC)i−1 bc ⇒ a i (bC)i−1 bc
Exemplificando (i=3):
aaabCbCbc ⇒ aaabCbbCc ⇒ aaabCbbcc ⇒
aaabbCbcc ⇒ aaabbbCcc ⇒ aaabbbccc
Logo: L(GI) = a i bi c i , i ≥ 0
Exercício
L = {a i bj a i bj | i, j ≥ 0}
Exercício
L = {a i bj a i bj | i, j ≥ 0}
GI(L): Derivação Exemplo

S → X | Y | aPAbQb S ⇒ aPAbQb
X → aaX | λ ⇒ aaPAAbQb
Y → bbY | λ ⇒ aaAAbQb
P → aPA | λ ⇒ aaAAbEb
Q → bQb | E ⇒ aaAbAEb
Ab → bA ⇒ aabAAEb
AE → a ⇒ aabAab
Aa → aa ⇒ aabaab
Gramática Irrestrita
Teoremas
Prova do 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
Prova do 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: Toda LRE L tem uma GI G com 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 em Sudkamp [?]
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 ):
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)
x/y E x/y E
qi qj qi qj
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:
Ba n Ba m B... ⇒ Ba n Ba m Ba n+m B..., n, m ≥ 0
Ba n Ba m B... ⇒ Ba n Ba m Ba n−m B..., n ≥ m
Ba n Ba m B... ⇒ Ba n Ba m Ba n∗m B..., n, m ≥ 0

n
Ba n B... ⇒ Ba n Ba 2 B..., n ≥ 0
MT para Aceitação de Linguagens

Um MT é uma séxtupla (Q, Σ, Γ, δ, q0 , F):

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 ∈ Σ∗ é 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 = {a i bi c i | i ≥ 0}
L3 = {wcv | w e v tem o mesmo número de a e b}
L4 = {ww | w ∈ {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 (Σ∗ )
Reflexão
As linguagens L1...4 (anteriormente citadas) são:
a. recursivamente enumeráveis?
b. recursivas?
Máquinas de Turing
Variantes
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 ∈ {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ê?)
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
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ê?)
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 = {a i bi | i > 0}
L2 = {wdw | w ∈ {a, b, c}∗ }
L3 = {wcw r | w ∈ {a, b}∗ }
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 ∈ {a, b}∗ }
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 ∈ L e v ∈ Σ∗
ui é escrito na Fita 1 (entre #0 s) sse ui ∈ L
Definição não requer que a máquina pare (mesmo que a

linguagem seja finita)
Exemplo
MT para enumerar a linguagem L = {a i bi | i ≥ 0}
Exemplo
MT para enumerar a linguagem L = {a i bi | i ≥ 0}
[B/a D, X /X E]
[B/B D, B/B D] [B/# D, B/X D] [B/# D, B/B E]

q0 q1 q2 q3
[B/# D, B/X S] [B/B S, B/B D]
q4 [B/b D, X /X D]
Exemplo
Descrição do funcionamento da MT anterior:
Escreve ## na F1 (já que λ ∈ 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 = {a i bi c i | i ≥ 0}
Máquinas de Turing
Teoremas
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
Prova do Teorema #5: 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
Prova do Teorema #5
(volta) se L é enumerada por uma MT, então L é RE
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 ∈ L
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 6∈ L
Porém, definição de RE não exige parada em caso de

palavras não pertencentes à linguagem
Prova do Teorema #5
(ida) se L é RE, então L é enumerada por uma MT
Primeira tentativa (“gerar-e-testar via força bruta”):

Seja M a MT que reconhece palavras de L
Prova consiste em mostrar que pode-se construir uma MT E
que enumera L
Para cada palavra u ∈ Σ∗ (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
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(ai u) = 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(ab)= 5, lo(bb)= 8, lo(cb)= 11, lo(aab)=14,
lo(ac)= 6, lo(bc)= 9, lo(cc)= 12, lo(aac)=15
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 ∈ Σ∗ vai ser testada com 0, 1, 2, 3, ... passos
Se ui for válida, M vai parar para algum número k de passos

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 (Σ∗ )
Prova do Teorema #6: 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
Prova do Teorema #6
(ida) se L é recursiva, então L pode ser enumerada em
ordem lex.
Seja M a MT que decide L
Seja E ∗ uma MT que enumera Σ∗ em ordem lexicográfica

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
Prova do Teorema #6
(volta) Se L pode ser enumerada em ordem lexicográfica,
então L é recursiva
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
7. Considerações Finais – Conteúdo
1 Revisão 3
2 Introdução 59
Máquina de Moore
Máquinas de Mealy

Recursividade
Ambiguidade
Algoritmo de Early
Variantes

Teoremas
Variantes
Teoremas
7 Considerações Finais 415

Hierarquia de Chomsky 416
Ricardo Terra (rterrabh
Tese de [at] gmail.com)
Church-Turing Linguagens Formais e Autômatos (LFA) Outubro, 2015 415
418/ 423
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 fita,
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.

2015 Apostila Lfa PDF

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

2015 Apostila Lfa PDF

Enviado por

Direitos autorais:

Formatos disponíveis

Linguagens Formais e Autômatos

rterrabh [at] gmail.com

Nome: Ricardo Terra

4 Linguagens Livres de Contexto 171

5 Linguagens Sensíveis ao Contexto 350

6 Linguagens Irrestritas 367

Conjuntos, relações e funções

Uma definição recursiva especifica como um conjunto

(ii) passo recursivo: especificação de um elenco de operações

(iii) fechamento: afirmação que os únicos elementos de A são

Exemplo #1: Conjunto N

(ii) passo recursivo: se n ∈ N, então s(n) ∈ N

(iii) fechamento: só pertence a N, o número que pode ser

Exemplo #2: Função Fatorial fat : N → N

(ii) passo recursivo: fat(n) = n x fat(n − 1), para n ≥ 1

Exemplo #2: Função Fatorial fat : N → N

(ii) passo recursivo: fat(n) = n x fat(n − 1), para n ≥ 1

(ii) passo recursivo: se n ≥ 1 e (n − 1, k) ∈ fat, então

(iii) fechamento: só pertence a fat, o par que pode ser obtido

Considere X um conjunto tendo como base X0

Seja X0 , X1 , . . . , Xn a sequência de conjuntos gerados por um

Prova consiste em:

Hipótese: P é verdadeira para 0, 1, 2, 3, . . . , k, ou seja,

PK +1 (K +1)((K +1)+1) (K +1)(K +2)

Exemplo #2: Provar que n! > 2n , ∀n > 4

Hipótese: P é verdadeira para 5, 6, 7, . . . , k, ou seja,

Passo indutivo: Provar que (k + 1)! > 2(k+1)

Linguagens Formais e Autômatos (LFA)

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

λ = palavra vazia, constituída de zero símbolos

Σ∗ = conjunto de todas as palavras do alfabeto

Linguagem Regular (LR)

Um conjunto regular pode ser gerado a partir de Σ usando

Linguagem Regular (LR) – Exemplo

Linguagem Regular (LR) – Exercício de Fixação

Expressão Regular (ER)

Expressão Regular (ER) – Exemplo

Expressão Regular (ER) – Exemplo

Expressão Regular (ER) – Exemplo

Expressão Regular (LR) – Exercícios de Fixação

Gramática Regular (GR)

ν ∈ λ | Σ | ΣV (i.e., palavra formada por elementos de V e Σ)

Gramática Regular (GR) – Exemplo

Gramática Regular (GR) – Exemplo

Gramática Regular (GR) – Exemplo

Gramática Regular (GR) – Exercícios de Fixação

Definição de regra (→) 6= Aplicação de regra (⇒)

v ⇒∗ w w é derivável a partir de v (aplicando 0 ou mais regras)

v ⇒+ w w é derivável a partir de v (aplicando 1 ou mais regras)

v ⇒n w w é derivável a partir de v (aplicando n regras)

Uma palavra w ∈ Σ∗ é uma sentença se S ⇒∗ w

Dada a seguinte GR(L):

Pergunta-se: ababa ∈ L(G)?

Dada a seguinte GR(L):

Pergunta-se: ababa ∈ L(G)?

Dada a seguinte GR(L):

Pergunta-se: ababa ∈ L(G)?

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 ∈ ou 6∈ L)