Você está na página 1de 158

CV

Nome: Ricardo Terra


Email: terra [at] dcc.ufla.br
www: dcc.ufla.br/∼terra
Linguagens Formais e Autômatos
Twitter: rterrabh
Lattes: lattes.cnpq.br/ 0162081093970868
Ricardo Terra

rterrabh [at] gmail.com Ph.D. (UFMG/UWaterloo),


Post-Ph.D. (INRIA/Université Lille 1)

Background
Acadêmico : UFLA (desde 2014), UFSJ (1 ano ), FUMEC (3 anos ), UNIPAC (1 ano ), FAMINAS (3 anos )
Profissional : DBA Eng. (1 ano ), Synos (2 anos ), Stefanini (1 ano )

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 1 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 2 / 471

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

Revisão
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

4
Transformação de ER para AFND-λ

Linguagens Livres de Contexto 172


Conjuntos, relações e funções
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
Variantes
Critérios de Aceitação
Autômato com Pilha como Reconhecedor
Autômato com Pilha Descendente
Algoritmo de Cocke-Younger-Kasami (CYK)
Algoritmo de Early
Transformação de GLCs para APs
Transformação de APs para GLCs

5 Linguagens Sensíveis ao Contexto 376

6 Linguagens Irrestritas 396


Teoremas
Variantes

7 Considerações Finais 462

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 3 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 4 / 471
Revisão – Conjuntos, relações e funções (1–34) Revisão – Conjuntos, relações e funções (1–9)

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 5 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 6 / 471

Revisão – Conjuntos, relações e funções (1–7)

Revisão

Definições Recursivas

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 7 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 8 / 471
Revisão – Definições Recursivas Revisão – Definições Recursivas

Definições Recursivas Definições Recursivas


Conjuntos enumeráveis podem ser definidos por meio de Uma definição recursiva de um conjunto A consta de três
uma definição recursiva partes:
(i) base: especificação de um conjunto base B ⊂ A
Uma definição recursiva especifica como um conjunto
pode ser gerado a partir de um subconjunto do mesmo (ii) passo recursivo: especificação de um elenco de operações
aplicando-se operações um número finito de vezes que, se aplicadas a elementos de B, geram elementos de A

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


aqueles que podem ser obtidos a partir dos elementos de B
aplicando-se um número finito de vezes as operações
especificadas em (ii)

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 9 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 10 / 471

Revisão – Definições Recursivas Revisão – Definições Recursivas

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


O conjunto N pode ser definido a partir de {0} usando-se a (i) base: fat(0) = 1
operação s (sucessor)
(ii) passo recursivo: fat(n) = n x fat(n − 1), para n ≥ 1
(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)

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 11 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 12 / 471
Revisão – Definições Recursivas

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


(i) base: fat(0) = 1

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


Revisão

Mais formalmente Indução Matemática


(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)

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 12 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 13 / 471

Revisão – Indução Matemática Revisão – Indução Matemática

Pn n(n+1)
Indução Matemática Exemplo #1: Provar que i=1 i = 2
Técnica usada para provar que uma propriedade é válida Base: P(1) é verdadeiro, i.e.,
P1 1(1+1)
i=1 i = 2 =1
para todos elementos de um conjunto definido
recursivamente (Veja Sudkamp [6], Seção 1.7) Hipótese: P é verdadeira para 0, 1, 2, 3, . . . , k, ou seja,
k
Considere X um conjunto tendo como base X0 X k(k + 1)
i=
2
Seja X0 , X1 , . . . , Xn a sequência de conjuntos gerados por um i=1
processo recursivo e P uma propriedade PK +1 (K +1)((K +1)+1) (K +1)(K +2)
Passo indutivo: Provar que i=1 i= 2 = 2
Prova consiste em: PK +1
i=1 i
Base: Mostrar que P é válido ∀x ∈ X0 PK
= i=1 i + (k + 1) (definição somatório)
Hipótese: P é válido ∀x ∈ X0 , X1 , ..., Xk k(k+1)
= + (k + 1) (uso da hipótese de indução)
Passo indutivo: Mostrar que P também é válido ∀x ∈ Xk+1 2
k(k+1) + 2(k+1)
= 2 (matemática básica)
Assim, P é válido ∀x ∈ X (k+1)(k+2)
= 2
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 14 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 15 / 471
Revisão – Indução Matemática

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,


Revisão
k! > 2k , ∀k > 4

Passo indutivo: Provar que (k + 1)! > 2(k+1) Linguagens Formais e Autômatos (LFA)
(k + 1)!
= k! × (k + 1) (definição fatorial)
> 2k × (k + 1) (uso da hipótese de indução)
> 2k × 2 (pela certeza que k > 4)
= 2k+1

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 16 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 17 / 471

Revisão – Linguagens Formais e Autômatos (LFA) Revisão – Linguagens Formais e Autômatos (LFA)

Hierarquia de Chomsky Definições Básicas


Tipo Linguagem Gramática Máquina de aceitação Linguagem: conjunto de palavras sobre um alfabeto
0 Rec. enumerável Irrestrita Máquina de Turing Alfabeto (Σ): conjunto de símbolos de uma linguagem
1 Recursiva Sensível ao contexto Autômato linearmente limitado Palavra: sequência finita de símbolos de um alfabeto Σ
2 Livre de contexto Livre de contexto Autômato com pilha
|w| = no de símbolos da palavra w
3 Regular Regular Autômato finito
λ = palavra vazia, constituída de zero símbolos
Fecho de Kleene (*)
{a}∗ = {λ, a, aa, aaa, aaaa, ...}

Σ∗ = conjunto de todas as palavras do alfabeto


Fecho Positivo de Kleene (+)
{a}+ = {a}{a}∗ = {a, aa, aaa, aaaa, ...}

Σ+ = Σ∗ − {λ}

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 18 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 19 / 471
Revisão – Linguagens Formais e Autômatos (LFA) Revisão – Linguagens Formais e Autômatos (LFA)

Linguagem Regular (LR) Linguagem Regular (LR) – Exemplo


Uma linguagem regular é aquela que pode ser definida por L = palavras sobre {a, b} que começam e terminam com a
um conjunto regular e possuem pelo menos um b
Conjunto regular: {a}{a, b}∗ {b}{a, b}∗ {a}
Um conjunto regular pode ser gerado a partir de Σ usando
operador de Kleene, união e concatenação
Linguagem Regular (LR) – Exercício de Fixação
Definição recursiva:
Base: φ, {λ} e {a}(∀a ∈ Σ) são conjuntos regulares
1 L = palavras sobre {a, b} que começam com a e tenham
Passo recursivo: se X e Y são conjuntos regulares, então
número par de b
X ∪ Y , XY e X ∗ também são conjuntos regulares

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 20 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 21 / 471

Revisão – Linguagens Formais e Autômatos (LFA) Revisão – Linguagens Formais e Autômatos (LFA)

Expressão Regular (ER) Expressão Regular (ER) – Exemplo


Alguns autores (e.g., Sudkamp) usam abreviações para denotar L = palavras sobre {a, b} que começam e terminam com a
conjunto regulares: e possuem pelo menos um b
{λ} → λ Expressão regular:
{a}(∀a ∈ Σ) → a(∀a ∈ Σ)
{a, b} → (a ∪ b)
{ab} → (ab)
{u}∗ → u ∗
{xx ∗ } → x +

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 22 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 23 / 471
Revisão – Linguagens Formais e Autômatos (LFA) Revisão – Linguagens Formais e Autômatos (LFA)

Expressão Regular (ER) – Exemplo Expressão Regular (ER) – Exemplo


L = palavras sobre {a, b} que começam e terminam com a L = palavras sobre {a, b} que começam e terminam com a
e possuem pelo menos um b e possuem pelo menos um b
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

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 23 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 23 / 471

Revisão – Linguagens Formais e Autômatos (LFA) Revisão – Linguagens Formais e Autômatos (LFA)

Gramática Regular (GR) Gramática Regular (GR) – Exemplo


Uma GR é uma quádrupla (V , Σ, P, S): L = palavras sobre {a, b} que começam e terminam com a
V = conjunto de símbolos não-terminais (variáveis) e possuem pelo menos um b
Σ = conjunto de símbolos terminais (Σ ∩ V = φ) GR(L):
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 Σ)

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 24 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 25 / 471
Revisão – Linguagens Formais e Autômatos (LFA) Revisão – Linguagens Formais e Autômatos (LFA)

Gramática Regular (GR) – Exemplo Gramática Regular (GR) – Exemplo


L = palavras sobre {a, b} que começam e terminam com a L = palavras sobre {a, b} que começam e terminam com a
e possuem pelo menos um b e possuem pelo menos um b

GR(L): GR(L):
S → aA S → aA
A → aA | bB A → aA | bB
B → aB | bB | a B → aB | bB | a

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


1 L = palavras sobre {a, b, c} que todo b seja seguido de a
2 L = palavras sobre {a, b} com número par de a

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 25 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 25 / 471

Revisão – Linguagens Formais e Autômatos (LFA) Revisão – Linguagens Formais e Autômatos (LFA)

Derivação Dada a seguinte GR(L):


Aplicação consecutiva de regras S → aA
A → aA | bB
Definição de regra (→) 6= Aplicação de regra (⇒)
B → aB | bB | a
v ⇒∗ w w é derivável a partir de v (aplicando 0 ou mais regras)
Pergunta-se: ababa ∈ L(G)?
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}

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 26 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 27 / 471
Revisão – Linguagens Formais e Autômatos (LFA) Revisão – Linguagens Formais e Autômatos (LFA)

Dada a seguinte GR(L): Dada a seguinte GR(L):


S → aA S → aA
A → aA | bB A → aA | bB
B → aB | bB | a B → aB | bB | a

Pergunta-se: ababa ∈ L(G)? Pergunta-se: ababa ∈ L(G)?


S ⇒ aA S ⇒ aA
⇒ abB ⇒ abB
⇒ abaB ⇒ abaB
⇒ ababB ⇒ ababB
⇒ ababa ⇒ ababa
É uma sentença válida uma vez que S ⇒∗ ababa É uma sentença válida uma vez que S ⇒∗ ababa

E abbabb ∈ L(G)?

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 27 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 27 / 471

Revisão – Linguagens Formais e Autômatos (LFA) Revisão – Linguagens Formais e Autômatos (LFA)

Autômato Finito Autômato Finito Determinístico (AFD)


Máquina Reconhecedora de LR Um AFD é uma quíntupla (Q, Σ, δD , q0 , F):
Podem ser determinísticos (AFD) Q = conjunto finito de estados
Σ = alfabeto
Podem ser não-determinísticos (AFND)
δD : Q x Σ → Q = função (total) de transições de estados
Podem ser não-determinísticos com transições-λ (AFND-λ) qo ∈ Q = estado inicial
F ⊆ Q = conjunto de estados finais (aceitação)
Verifica se uma palavra satisfaz condições (i.e., se ∈ ou 6∈ L)
Uma palavra w ∈ Σ∗ é dita ser aceita por um AFD quando,
Entrada: palavra qualquer do alfabeto partindo do estado inicial, forem lidos todos os símbolos
Saída: sim (palavra válida) ou não (palavra inválida) 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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 28 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 29 / 471
Revisão – Linguagens Formais e Autômatos (LFA) Revisão – Linguagens Formais e Autômatos (LFA)

Exemplo Exemplo
L = palavras sobre {a, b} que começam e terminam com a L = palavras sobre {a, b} que começam e terminam com a
e possuem pelo menos um b e possuem pelo menos um b

AFD: AFD:
a b a
a
a b
q0 q1 q2 q3

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 30 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 30 / 471

Revisão – Linguagens Formais e Autômatos (LFA) Revisão – Linguagens Formais e Autômatos (LFA)

Exemplo Exemplo
L = palavras sobre {a, b} que começam e terminam com a L = palavras sobre {a, b} que começam e terminam com a
e possuem pelo menos um b e possuem pelo menos um b

AFD: AFD:
a b a a b a
a a
a b a b
q0 q1 q2 q3 q0 q1 q2 q3

b b
Sim, na verdade, é um AFD incompleto, por quê? Sim, na verdade, é um AFD incompleto, por quê?

Exercício de Fixação
1 L = palavras sobre {a, b} que contém aaa
2 L = palavras sobre {a, b} com número par de a e ímpar de b
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 30 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 30 / 471
Revisão – Linguagens Formais e Autômatos (LFA) Revisão – Linguagens Formais e Autômatos (LFA)

Autômato Finito Não-Determinístico (AFND) Exemplo


Um AFND é uma quíntupla (Q, Σ, δND , q0 , F): L = palavras sobre {a, b} que começam e terminam com a
Q = conjunto finito de estados e possuem pelo menos um b
Σ = alfabeto AFND:
δND : Q x Σ → P(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 AFND se, e


somente se, existe uma computação que a consome e
para em um estado final

Para todo AFND, existe um AFD equivalente


i.e., não aumenta poder de expressão

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 31 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 32 / 471

Revisão – Linguagens Formais e Autômatos (LFA) Revisão – Linguagens Formais e Autômatos (LFA)

Exemplo Exemplo
L = palavras sobre {a, b} que começam e terminam com a L = palavras sobre {a, b} que começam e terminam com a
e possuem pelo menos um b e possuem pelo menos um b

AFND: AFND:
a a,b a a,b

a b a a b a
q0 q1 q2 q3 q0 q1 q2 q3

Sim, na verdade, é um AFND incompleto, por quê?

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 32 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 32 / 471
Revisão – Linguagens Formais e Autômatos (LFA) Revisão – Linguagens Formais e Autômatos (LFA)

Exemplo Autômato Finito Não-Determinístico com Transições-λ (AFND-λ)


L = palavras sobre {a, b} que começam e terminam com a Um AFND-λ é uma quíntupla (Q, Σ, δND−λ , q0 , F):
e possuem pelo menos um b
Q = conjunto finito de estados
AFND: Σ = alfabeto
a a,b δND−λ : Q x (Σ ∪ {λ}) → P(Q) = f. de transições de estados
qo ∈ Q = estado inicial
a b a
q0 q1 q2 q3 F ⊆ Q = conjunto de estados finais (aceitação)
Sim, na verdade, é um AFND incompleto, por quê? Para todo AFND-λ, existe um AFND e um AFD equivalentes
i.e., não aumenta poder de expressão
Exercício de Fixação
1 L = palavras sobre {a, b} que contém aa ou bb
2 L = (a ∪ b)∗ bb

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 32 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 33 / 471

Revisão – Linguagens Formais e Autômatos (LFA) Revisão – Linguagens Formais e Autômatos (LFA)

Exemplo Exemplo
L = palavras sobre {a, b} com tamanho par L = palavras sobre {a, b} com tamanho par

AFND-λ: AFND-λ:
λ

a,b a,b
q0 q1 q3

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 34 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 34 / 471
Revisão – Linguagens Formais e Autômatos (LFA) Revisão – Linguagens Formais e Autômatos (LFA)

Hierarquia de Chomsky Gramática Livre de Contexto (GLC)


Tipo Linguagem Gramática Máquina de aceitação Uma GLC é uma quádrupla (V , Σ, P, S):
0 Rec. enumerável Irrestrita Máquina de Turing V = conjunto de símbolos não-terminais (variáveis)
1 Recursiva Sensível ao contexto Autômato linearmente limitado Σ = conjunto de símbolos terminais (Σ ∩ V = φ)
2 Livre de contexto Livre de contexto Autômato com pilha
P = conj. de regras (produções)
S = símbolo não-terminal inicial (S ∈ V )
3 Regular Regular Autômato finito

Regras: µ → ν
µ∈V (i.e., um não-terminal)

ν ∈ (V ∪ Σ)∗ (i.e., palavra formada por elementos de V e Σ)

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 35 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 36 / 471

Revisão – Linguagens Formais e Autômatos (LFA) Revisão – Linguagens Formais e Autômatos (LFA)

Exemplo Clássico Exemplo Clássico


L(G) = {a i bi | i > 0} L(G) = {a i bi | i > 0}

GLC(L): GLC(L):
S → aSb | ab

Toda LLC é aceita por um Autômato com Pilha (não-determinístico) Toda LLC é aceita por um Autômato com Pilha (não-determinístico)

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 37 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 37 / 471
Revisão – Linguagens Formais e Autômatos (LFA) Revisão – Linguagens Formais e Autômatos (LFA)

Exemplo Clássico 2 Exemplo Clássico 2


L(G) = {w ∈ {a, b}∗ | w = w R } L(G) = {w ∈ {a, b}∗ | w = w R }

GLC(L): GLC(L):
S → aSa | bSb | a | b | λ

Toda LLC é aceita por um Autômato com Pilha (não-determinístico) Toda LLC é aceita por um Autômato com Pilha (não-determinístico)

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 38 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 38 / 471

Revisão – Linguagens Formais e Autômatos (LFA) Revisão – Linguagens Formais e Autômatos (LFA)

Exercício de Fixação Autômato com Pilha


1 L = {a n bm a n |n > 0, m > 0} Máquina Aceitadora de LLC
Podem ser determinísticos (APD)
2 L = {a n bm c m d 2n |n ≥ 0, m > 0}
Aceita todas as LR e um sub-grupo de LLC
3 L = palavras sobre {a, b} com número par de a Se forem não-determinísticos (APND)
Aceita todas as LLC
i.e., aumenta o poder de expressão

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 39 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 40 / 471
Revisão – Linguagens Formais e Autômatos (LFA) Revisão – Linguagens Formais e Autômatos (LFA)

Autômato com Pilha Determinístico (APD) Exemplo Clássico


Um APD é uma sextupla (Q, Σ, Γ, δ, q0 , F): L(G) = {a i bi | i > 0}
Q = conjunto finito de estados
APD:
Σ = alfabeto de entrada
Γ = alfabeto da pilha
δ : Q x (Σ ∪ λ) x (Γ ∪ λ) → P(Q x (Γ ∪ λ))
= função de transições de estados
qo ∈ Q = estado inicial
F ⊆ Q = conjunto de estados finais (aceitação)

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)
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 41 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 42 / 471

Revisão – Linguagens Formais e Autômatos (LFA) Revisão – Linguagens Formais e Autômatos (LFA)

Exemplo Clássico Autômato com Pilha Não-Determinístico (APND)


L(G) = {a i bi | i > 0} Um APND é uma sextupla (Q, Σ, Γ, δ, q0 , F):
Q = conjunto finito de estados
APD:
Σ = alfabeto de entrada
a λ/X b X/λ Γ = alfabeto da pilha
δ : Q x (Σ ∪ λ) x (Γ ∪ λ) → P(Q x (Γ ∪ λ))
b X/λ = função de transições de estados
q0 q1
qo ∈ Q = estado inicial
F ⊆ Q = conjunto de estados finais (aceitação)

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


somente se, existe uma computação que a consome e
para em um estado final com pilha vazia
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 42 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 43 / 471
Revisão – Linguagens Formais e Autômatos (LFA) Revisão – Linguagens Formais e Autômatos (LFA)

Exemplo Clássico 2 Exemplo Clássico 2


L(G) = {w ∈ {a, b}∗ | w = w R } L(G) = {w ∈ {a, b}∗ | w = w R }

APND: APND:
a λ/A a A/λ
b λ/B a λ/λ b B/λ
b λ/λ
λ λ/λ
q0 q1

Toda LLC é aceita por um APND Toda LLC é aceita por um APND

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 44 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 44 / 471

Revisão – Linguagens Formais e Autômatos (LFA) Revisão – Linguagens Formais e Autômatos (LFA)

Hierarquia de Chomsky Gramática Sensível ao Contexto (GSC)


Tipo Linguagem Gramática Máquina de aceitação Uma GSC é uma quádrupla (V , Σ, P, S):
0 Rec. enumerável Irrestrita Máquina de Turing V = conjunto de símbolos não-terminais (variáveis)
1 Recursiva Sensível ao contexto Autômato linearmente limitado Σ = conjunto de símbolos terminais (Σ ∩ V = φ)
2 Livre de contexto Livre de contexto Autômato com pilha
P = conj. de regras (produções)
S = símbolo não-terminal inicial (S ∈ V )
3 Regular Regular Autômato finito

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

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 45 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 46 / 471
Revisão – Linguagens Formais e Autômatos (LFA) Revisão – Linguagens Formais e Autômatos (LFA)

Exemplo Clássico Autômato Linearmente Limitado (ALL)


L = {a i bi c i | i > 0} Um ALL é uma óctupla (Q, Σ, Γ, δ, q0 , <, >, F):
Q = conjunto finito de estados
GSC(L):
Σ = alfabeto de entrada
S → aAbc | abc Γ = alfabeto da fita
A → aAbC | abC δ : Q × Γ → Q × Γ × {E, D} = função de transições de estados
Cb → bC qo ∈ Q = estado inicial
Cc → cc F ⊆ Q = conjunto de estados finais (aceitação)
< e > = delimitadores da palavra de entrada
Toda LSC é recursiva, logo:
existe uma ALL que aceita LSC
existe uma MT que decide LSC, i.e., sempre para para
qualquer entrada w ∈ Σ∗

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 47 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 48 / 471

Revisão – Linguagens Formais e Autômatos (LFA) Revisão – Linguagens Formais e Autômatos (LFA)

Autômato Linearmente Limitado (ALL) Exemplo Clássico


Seja w uma palavra de entrada L = {a i bi c i | i > 0}
Configuração inicial da fita: <w> c/c, E
Z /Z , E
b/b, E
Delimitadores podem ser lidos, mas não apagados Y /Y , D Z /Z , D Y /Y , E
a/a, D b/b, D c/c D a/a, E

Delimitadores não podem ser ultrapassados </<D a/X D b/Y D c/Z D >/>E
q0 q1 q2 q3 q4 q5
Tamanho da fita = |w| + 2
Y/Y D
Basicamente, um ALL é uma MT cuja quantidade de fita X/X D

disponível é limitada ao tamanho da palavra de entrada >/>E Z /Z , E


q6 q7 Y /Y , E
X /X , E

Y /Y , D
Z /Z , D

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 49 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 50 / 471
Revisão – Linguagens Formais e Autômatos (LFA) Revisão – Linguagens Formais e Autômatos (LFA)

Hierarquia de Chomsky Gramática Irrestrita (GI)


Tipo Linguagem Gramática Máquina de aceitação Todo o universo de linguagens é gerado por GI
0 Rec. enumerável Irrestrita Máquina de Turing Uma GI é uma quádrupla (V , Σ, P, S):
1 Recursiva Sensível ao contexto Autômato linearmente limitado V = conjunto de símbolos não-terminais (variáveis)
2 Livre de contexto Livre de contexto Autômato com pilha Σ = conjunto de símbolos terminais (Σ ∩ V = φ)
3 Regular Regular Autômato finito P = conj. de regras (produções)
S = símbolo não-terminal inicial (S ∈ V )

Regras: µ → ν
µ ∈ (V ∪ Σ)+ (i.e., palavra formada por elementos de V e Σ)

ν ∈ (V ∪ Σ)∗ (i.e., palavra formada por elementos de V e Σ)

“Quase” nenhuma restrição é imposta (|µ| > 0)

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 51 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 52 / 471

Revisão – Linguagens Formais e Autômatos (LFA) Revisão – Linguagens Formais e Autômatos (LFA)

Exemplo Clássico Máquina de Turing (MT)


L = {u[u] | u ∈ {a, b}∗ } Um MT é uma séxtupla (Q, Σ, Γ, δ, q0 , F):
GI(L): Q = conjunto finito de estados
S → aT [a] | bT [b] | [] Σ = alfabeto de entrada
T [→ aT [A | bT [B | [ Γ = alfabeto da fita
Aa → aA δ : Q × Γ → Q × Γ × {E, D} = função de transições de estados
Ab → bA qo ∈ Q = estado inicial
Ba → aB F ⊆ Q = conjunto de estados finais (aceitação)
Bb → bB
A] → a] Memória ilimitada
B] → b] Seja w uma palavra de entrada
Toda GI é recursivamente enumerável, logo: Configuração inicial da fita: BwBBBBBBBB...
existe uma MT que reconhece LI, mas não necessariamente A fita é infinita à direita
para para qualquer entrada w ∈ Σ∗
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 53 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 54 / 471
Revisão – Linguagens Formais e Autômatos (LFA)

Exemplo Clássico
L = {u[u] | u ∈ {a, b}∗ }
a/a D X /X D
b/b D Y /Y D

[/[ D
Revisão
q2 q3

D a
a/a E /X
/X E
a
X /X D
b/b E
Lemas, Teoremas, Corolários, etc.
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

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 55 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 56 / 471

Revisão – Lemas, Teoremas, Corolários, etc. Revisão – Lemas, Teoremas, Corolários, etc.

Definições Corolário
Definem objetos e noções que são úteis em um Consequência imediata de um teorema
determinado estudo
Proposição
Exemplo: Um AP é uma sextupla (Q, Σ, Γ, δ, q0 , F)...
Uma observação que pode ser facilmente comprovada
Lema e Teorema não associada a um teorema em particular

Lema: É um pré-teorema, i.e., um resultado que leva a um


teorema ou que é usado na prova de um teorema Axioma (ou postulado)
Proposição que não precisa ser provada
Teorema: É um resultado mais importante e interessante
por ser evidente, consensual, etc.
Existem exceções, e.g., Pumping Lemma é um teorema
Exemplo: o sucessor de um natural é outro natural

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 57 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 58 / 471
2. Introdução – Conteúdo

1 Revisão 3

2 Introdução 59
Hierarquia de Chomsky 60
Conceitos Básicos 63

3 Linguagens Regulares 74

Introdução
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


Recursividade
Árvore de Derivação
172
Hierarquia de Chomsky
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
Variantes
Critérios de Aceitação
Autômato com Pilha como Reconhecedor
Autômato com Pilha Descendente
Algoritmo de Cocke-Younger-Kasami (CYK)
Algoritmo de Early
Transformação de GLCs para APs
Transformação de APs para GLCs

5 Linguagens Sensíveis ao Contexto 376

6 Linguagens Irrestritas 396


Teoremas
Variantes

7 Considerações Finais 462

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 59 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 60 / 471

Introdução – Hierarquia de Chomsky Introdução – Hierarquia de Chomsky

Hierarquia de Chomsky Hierarquia de Chomsky


Noam Chomsky (1927-presente): poeta, filósofo, linguista, Tipo Linguagem Gramática Máquina de aceitação
professor do MIT, e crítico do capitalismo e da política
0 Rec. enumerável Irrestrita Máquina de Turing
externa americana
1 Recursiva Sensível ao contexto Autômato linearmente limitado
Noam Chomsky (1956) constitui uma classificação para 2 Livre de contexto Livre de contexto Autômato com pilha
linguagens, gramáticas e autômatos 3 Regular Regular Autômato finito

Toda categoria é um subconjunto próprio da categoria superior

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 61 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 62 / 471
Introdução – Conceitos Básicos

Definições
Linguagem: conjunto de palavras sobre um alfabeto

Alfabeto (Σ): conjunto de símbolos de uma linguagem


Introdução
Palavra (string): sequência de símbolos de um alfabeto

Conceitos Básicos Convenções:


a, b, c, . . . representam elementos de um alfabeto

p, q, u, v, w, x, y, z representam palavras

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 63 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 64 / 471

Introdução – Conceitos Básicos Introdução – Conceitos Básicos

Definições Exemplo
Σ∗ é o conjunto de todas as palavras geradas por Σ Se Σ = {a, b, c}, então Σ∗ inclui:
∗ Tamanho zero: λ
(estrela): operador de Kleene
Tamanho um: a b c
Definição Recursiva Revisão
Tamanho dois: aa ab ac ba bb bc ca cb cc
Σ∗ é definido recursivamente da seguinte forma:
etc.
1 base: λ ∈ Σ* (λ é a palavra vazia)
2 passo recursivo: se w ∈ Σ* e a ∈ Σ então wa ∈ Σ*
3 fechamento: w ∈ Σ* sse puder ser obtida a partir de λ com
um número finito de aplicações de (2)

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 65 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 66 / 471
Introdução – Conceitos Básicos Introdução – Conceitos Básicos

Definições Concatenação
Tamanho de uma palavra w: número de aplicações do Seja u, v ∈ Σ∗ . A concatenação de u e v, escrita uv, é uma
passo recursivo para se obter w operação binária em Σ∗ definida assim:
base: se tam(v) = 0, então v = λ e uv = u
Linguagem (L): subconjunto do conjunto de todas as
possíveis palavras de um alfabeto (L ⊆ Σ∗ ) passo recursivo: se tam(v) = n, onde n > 0 então:
v = wa, com tam(w) = n − 1 e a ∈ Σ
Palavras que interessam são as palavras válidas
e.g., se Σ = {Maria, fala, alto}, quais são as palavras válidas? Assim, uv = u(wa) = (uw)a

Concatenação não é comutativa


Prova: (por contra-exemplo)
Se u = ab e v = ca então uv = abca e vu = caab

Concatenação é associativa: (uv)w = u(vw)

Sim? Então prova! Revisão de Indução Matemática

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 67 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 68 / 471

Introdução – Conceitos Básicos Introdução – Conceitos Básicos

Prova de Associatividade (por indução no comprimento da palavra w) Subpalavra, Prefixo, Sufixo, Reverso
Teorema: Seja u, v, w ∈ Σ∗ , então (uv)w = u(vw) x é uma subpalavra de y se ∃x, v, z | y = zxv
Base: se tam(w) = 0, então w = λ x é dito prefixo de y se z = λ, ou seja, y = xv
(uv)w = (uv)λ = uv e u(vw) = u(vλ) = u(v) = uv
x é dito sufixo de y se v = λ, ou seja, y = zx
Logo, (uv)w = u(vw)
Seja w ∈ Σ∗ . O reverso de w, ou w R , é definido por:
Hipótese: (uv)w = u(vw) ∀w, tam(w) ≤ k
base: se tam(w) = 0, então w = λ e λR = λ
Passo indutivo: provar (uv)w = u(vw) ∀w, tam(w) = k + 1
passo recursivo: se tam(w) = n, onde n ≥ 1 então:
Seja w = xa, tam(x) = k, a ∈ Σ
w = ua, com tam(u) = n − 1 e a ∈ Σ
(uv)w = (uv)(xa) =
= ((uv)x)a (definição concatenação) Assim, w R = (ua)R = a(u)R = au R
= (u(vx))a (uso da hipótese de indução)
= u((vx)a) (definição concatenação)
= u(v(xa)) (definição concatenação)
= u(vw)
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 69 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 70 / 471
Introdução – Conceitos Básicos Introdução – Conceitos Básicos

Prova de Reverso (por indução no comprimento da palavra v) Concatenação de Linguagens


Teorema: seja u, v ∈ Σ∗ , então (uv)R = v R uR Uma linguagem L é um subconjunto de Σ* (L ⊆ Σ*)
Base: se tam(v) = 0, então v = λ Concatenação das linguagens X e Y, denotada XY, é a
R
(uv) = (uλ) = u R R
e R R
v u =λ u =u R R R linguagem: XY = {xy | x ∈ X e y ∈ Y }

Hipótese: (uv)R = v R u R ∀w, tam(w) ≤ k Exemplo: X = {a, b, c} e Y = {abb, ba}


XY = {aabb, aba, babb, bba, cabb, cba}
Passo indutivo: provar (uv)R = v R u R ∀v, tam(v) = k + 1
Seja v = wa, tam(w) = k, a ∈ Σ X n : concatenação de X com X mesmo n vezes
(uv)R = (u(wa))R = X 0 = {λ}
= ((uw)a)R (associatividade concatenação)
X 1 = {a, b, c}
= a(uw)R (definição de reverso)
= a(w R u R ) (uso da hipótese de indução)
X 2 = {aa, ab, ac, ba, bb, bc, ca, cb, cc}
= (aw R )u R (associatividade)
X ∗ : todas as palavras construídas a partir de X
= (wa)R u R (definição de reverso)
= v R uR

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 71 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 72 / 471

Introdução – Conceitos Básicos 3. Linguagens Regulares – Conteúdo

X∗ (definição formal) 1 Revisão 3

2 Introdução 59

[ 3 Linguagens Regulares 74

X∗ = Xi
Conjuntos Regulares 76
Expressões Regulares 80
Gramáticas Regulares 85
Autômatos Finitos 92
i=0 Autômatos Finitos Determinísticos
Autômatos Finitos Não-Determinísticos
Autômatos Finitos Não-Determinísticos com Transições-λ
Autômatos com Saída 116
Máquina de Moore
Máquinas de Mealy
Algoritmos de Transformação

X+
Algoritmos 134
(definição formal) Transformação AFND-λ para AFD
Minimização de AFD
Transformação de ER para AFND-λ


[
Propriedades
Lema do Bombeamento
156
163

X+ = Xi 4 Linguagens Livres de Contexto


Recursividade
Árvore de Derivação
172

Ambiguidade

i=1 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
Variantes
Critérios de Aceitação
Autômato com Pilha como Reconhecedor
Autômato com Pilha Descendente
Algoritmo de Cocke-Younger-Kasami (CYK)
Algoritmo de Early
Transformação de GLCs para APs
Transformação de APs para GLCs

5 Linguagens Sensíveis ao Contexto 376

6 Linguagens Irrestritas 396


Teoremas
Variantes

7 Considerações Finais 462

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 73 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 74 / 471
Linguagens Regulares – Hierarquia de Chomsky

Hierarquia de Chomsky
Tipo Linguagem Gramática Máquina de aceitação

0 Rec. enumerável Irrestrita Máquina de Turing

1 Recursiva Sensível ao contexto Autômato linearmente limitado


Linguagens Regulares
2 Livre de contexto Livre de contexto Autômato com pilha

3 Regular Regular Autômato finito Conjuntos Regulares

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 75 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 76 / 471

Linguagens Regulares – Conjuntos Regulares Linguagens Regulares – Conjuntos Regulares

Especificação Finita de Linguagens Conjuntos Regulares


Requer uma descrição não ambígua das palavras Uma linguagem regular é aquela que pode ser definida por
um conjunto regular
Exemplo #1 (Σ = {a, b})
Um conjunto é regular se pode ser gerado a partir de Σ
Palavras com pelo menos uma ocorrência de bb:
usando operador de Kleene, união e concatenação
L = {a, b}∗ {bb}{a, b}∗

Palavras que possuem prefixo aa ou sufixo bb


L = {aa}{a, b}∗ ∪ {a, b}∗ {bb}

Exemplo #2 (Σ = {b})
L1 = {bb} e L2 = {λ, bb, bbbb}
Palavras com número par de b: L1 ∗ e L2 ∗
L1 ∗ = {λ, bb, bbbb, bbbbbb, ...}
L2 ∗ = {λ, bb, bbbb, bbbbbb, ...}
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 77 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 78 / 471
Linguagens Regulares – Conjuntos Regulares

Definição Recursiva Revisão

Um conjunto regular é definido recursivamente da seguinte


forma:
1 base: ∅, {λ} e {a}∀a ∈ Σ são conjuntos regulares Linguagens 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 Expressões Regulares

Exemplo
Palavras sobre {a, b} que começam e terminam com a e
contêm pelo menos um b
{a}{a, b}∗ {b}{a, b}∗ {a}

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 79 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 80 / 471

Linguagens Regulares – Expressões Regulares Linguagens Regulares – Expressões Regulares

Expressões Regulares Exercícios


Abreviação para conjuntos regulares 1 Considerando Σ = {a, b}, crie expressões regulares para as
+ ∗
PS: x denota xx seguintes linguagens:
L1 = {bawab | w ∈ {a, b}∗ }
Definição Recursiva Revisão

Uma expressão regular é definido recursivamente da L2 = palavras contendo aa ou bb


seguinte forma: L3 = palavras contendo aa e bb
1 base: ∅, λ e a(∀a ∈ Σ), são expressões regulares
L4 = palavras com número par de b
2 passo recursivo: se u e v são expressões regulares, então
L5 = palavras que não contém aa
u ∪ v, uv e u ∗ são expressões regulares
2 Considerando Σ = {a, b, c} e L = c ∗ (b ∪ (ac ∗ ))∗ , verifique se
Exemplos as seguintes palavras estão em L:
{a}{a, b}∗ {b}{a, b}∗ {a} = a(a ∪ b)∗ b(a ∪ b)∗ a acabacc
{a, b}∗ {bb}{a, b}∗ = (a ∪ b)∗ bb(a ∪ b)∗ bbaaacc
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 81 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 82 / 471
Linguagens Regulares – Expressões Regulares Linguagens Regulares – Expressões Regulares

Identidades Exercícios
1 ∅w = w∅ = ∅ 10 w ∗ w = ww ∗ = w + Mostre que:
b∗ (ab+ )∗ ∪ b∗ (ab+ )∗ a = (b ∪ ab)∗ (λ ∪ a)
2 λw = wλ = w 11 w(x ∪ y) = wx ∪ wy
a ∗ (a ∗ ba ∗ ba ∗ )∗ = a ∗ (ba ∗ ba ∗ )∗
3 ∅∗ = λ 12 (x ∪ y)w = xw ∪ yw
PS
4 λ∗ = λ 13 (wy)∗ w = w(yw)∗
ERs em Compiladores normalmente adotam | ao invés de ∪
5 w ∪u =u∪w 14 (w ∪ y)∗
= ∪ (w ∗ y)∗ i.e., a | b ⇔ a ∪ b
= w ∗ (w ∪ y)∗
6 w ∪∅=w
= (w ∪ yw ∗ )∗ PS2
7 w ∪w =w = (w ∗ y ∗ )∗ Existem linguagens que não podem definidas por
= w ∗ (yw ∗ )∗ expressões regulares
8 w ∗w ∗ = w ∗ = (w ∗ y)∗ w ∗ Por exemplo, {a n bn | n ≥ 0}
9 (w ∗ )∗ = w ∗
E aí, o que isso significa?
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 83 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 84 / 471

Linguagens Regulares – Gramáticas Regulares

Gramática Regular (GR)


Uma GR é uma quádrupla (V , Σ, P, S):
V = conjunto de símbolos não-terminais (variáveis)
Linguagens Regulares Σ = conjunto de símbolos terminais (Σ ∩ V = φ)
P = conj. de regras (produções)
Gramáticas Regulares 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 Σ)

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 85 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 86 / 471
Linguagens Regulares – Gramáticas Regulares Linguagens Regulares – Gramáticas Regulares

Gramática Regular (GR) – Exemplo Gramática Regular (GR) – Exemplo


L = palavras sobre {a, b} que começam e terminam com a L = palavras sobre {a, b} que começam e terminam com a
e possuem pelo menos um b e possuem pelo menos um b

GR(L): GR(L):
S → aA
A → aA | bB
B → aB | bB | a

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 87 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 87 / 471

Linguagens Regulares – Gramáticas Regulares Linguagens Regulares – Gramáticas Regulares

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


L = palavras sobre {a, b} que começam e terminam com a 1 L = a + b∗
e possuem pelo menos um b
2 L = {λ} ∪ {ab}{ab}∗ {a}∗
GR(L):
S → aA
3 L = palavras sobre {a, b, c} que todo b seja seguido de a
A → aA | bB 4 L = palavras sobre {a, b} com número par de a
B → aB | bB | a

Propriedade interessante de gramáticas regulares:


Uma forma sentencial possui no máximo uma variável
sempre o símbolo mais à direita

Toda aplicação de regra adiciona um terminal na palavra


que está sendo derivada
exceto regra da forma A → λ
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 87 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 88 / 471
Linguagens Regulares – Gramáticas Regulares Linguagens Regulares – Gramáticas Regulares

Derivação Dada a seguinte GR(L):


Aplicação consecutiva de regras S → aA
A → aA | bB
Definição de regra (→) 6= Aplicação de regra (⇒)
B → aB | bB | a
v ⇒∗ w w é derivável a partir de v (aplicando 0 ou mais regras)
Pergunta-se: ababa ∈ L(G)?
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}

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 89 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 90 / 471

Linguagens Regulares – Gramáticas Regulares Linguagens Regulares – Gramáticas Regulares

Dada a seguinte GR(L): Dada a seguinte GR(L):


S → aA S → aA
A → aA | bB A → aA | bB
B → aB | bB | a B → aB | bB | a

Pergunta-se: ababa ∈ L(G)? Pergunta-se: ababa ∈ L(G)?


S ⇒ aA S ⇒ aA
⇒ abB ⇒ abB
⇒ abaB ⇒ abaB
⇒ ababB ⇒ ababB
⇒ ababa ⇒ ababa
É uma sentença válida uma vez que S ⇒∗ ababa É uma sentença válida uma vez que S ⇒∗ ababa

E abbabb ∈ L(G)?

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 90 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 90 / 471
Linguagens Regulares – Gramáticas Regulares

Enfim
Uma linguagem é regular se pode ser gerada por alguma
gramática regular (ou CR ou ER)
Linguagens Regulares

Autômatos Finitos

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 91 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 92 / 471

Linguagens Regulares – Autômatos Finitos

Autômato Finito
Máquina Reconhecedora de LR
Podem ser determinísticos (AFD) Linguagens Regulares
Podem ser não-determinísticos (AFND)

Podem ser não-determinísticos com transições-λ (AFND-λ) Autômatos Finitos

Verifica se uma palavra satisfaz condições (i.e., se ∈ ou 6∈ L) Autômatos Finitos Determinísticos


Entrada: palavra qualquer do alfabeto

Saída: sim (palavra válida) ou não (palavra inválida)

Linguagem L é regular sse existe um AF que reconhece L

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 93 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 94 / 471
Linguagens Regulares – Autômatos Finitos – AFD Linguagens Regulares – Autômatos Finitos – AFD

Autômato Finito Determinístico (AFD) Exemplo


Um AFD é uma quíntupla (Q, Σ, δD , q0 , F): L = palavras sobre {a, b} que começam e terminam com a
Q = conjunto finito de estados e possuem pelo menos um b
Σ = alfabeto AFD:
δ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 ∈ Σ∗ | δ̂D (q0 , w) ∈ F}, onde δ̂D é a função
de transição estendida para M
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 95 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 96 / 471

Linguagens Regulares – Autômatos Finitos – AFD Linguagens Regulares – Autômatos Finitos – AFD

Exemplo Exemplo
L = palavras sobre {a, b} que começam e terminam com a L = palavras sobre {a, b} que começam e terminam com a
e possuem pelo menos um b e possuem pelo menos um b

AFD: AFD:
a b a δD a b a b a δD a b
a q0 q1 − a q0 q1 −
a b q1 q1 q2 a b q1 q1 q2
q0 q1 q2 q3 q0 q1 q2 q3
q2 q3 q2 q2 q3 q2
q3 q3 q2 q3 q3 q2
b b
Sim, na verdade, é um AFD incompleto, por quê?

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 96 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 96 / 471
Linguagens Regulares – Autômatos Finitos – AFD Linguagens Regulares – Autômatos Finitos – AFD

Exercícios de Fixação Função de Transição (δD )


1 L = palavras sobre {a, b} que contém aa ou bb δD : Q x Σ → Q

2 L = palavras sobre {a, b} que contém aaa se total, então


em todos os estados (Q), existe transições para todos os
3 L = palavras sobre {a, b} com número par de a e ímpar de b símbolos (Σ)
AFD é completo
AFD nunca trava

se parcial, então
em algum estado (Q), pode não existir transição para algum
símbolo (Σ)
AFD é incompleto
AFD pode travar

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 97 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 98 / 471

Linguagens Regulares – Autômatos Finitos – AFD Linguagens Regulares – Autômatos Finitos – AFD

Como transformar uma função parcial em uma total? Como transformar uma função parcial em uma total?
1 Criar um estado não final qerro 1 Criar um estado não final qerro

2 ∀x ∈ Σ =⇒ δ(qerro , x) → qerro 2 ∀x ∈ Σ =⇒ δ(qerro , x) → qerro


qerro tem um loop com todos os símbolos do alfabeto qerro tem um loop com todos os símbolos do alfabeto

3 δ(qi , x) ↓ =⇒ δ(qi , x) → qerro 3 δ(qi , x) ↓ =⇒ δ(qi , x) → qerro


toda transição indefinida agora vai para qerro toda transição indefinida agora vai para qerro
a b a b

a b a a b a
q0 q1 q2 q3 q0 q1 q2 q3

b a,b
qerro

a,b
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 99 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 99 / 471
Linguagens Regulares – Autômatos Finitos – AFD Linguagens Regulares – Autômatos Finitos – AFD

Aceitação / Rejeição Função de Transição Estendida (δ̂D )


Um AF aceita a entrada quando É uma extensão da função de transição original que a partir
após processar o último símbolo, assume um estado final (F) de um estado de origem (Q) e uma palavra (Σ∗ ), retorna o
estado final do processamento (Q)

Um AF rejeita a entrada quando δ̂D : Q x Σ∗ → Q


após processar o último símbolo, assume um estado não final ACEITA(M) = {w ∈ Σ∗ | δ̂D (q0 , w) ∈ F} = L(M)
trava durante seu processamento REJEITA(M) = {w ∈ Σ∗ | δ̂D (q0 , w) 6∈ F}

Pergunta-se: o que ocorre se δD não for total?

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 100 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 101 / 471

Linguagens Regulares – Autômatos Finitos – AFD Linguagens Regulares – Autômatos Finitos – AFD

Outros Exercícios Questões importantes


1 L = Σ∗ 1 Pode um AF entrar em loop?
2 L=∅ 2 Dado dois AFs M1 e M2 , pergunta-se:
Quando os dois AFs são equivalentes?

Pergunta-se ACEITA(M) ∩ REJEITA(M) =


Qual a principal diferença? ACEITA(M) ∪ REJEITA(M) =

Logo, como modificar um AFD M que reconhece L para ∼ACEITA(M) =


reconhecer L?
∼REJEITA(M) =

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 102 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 103 / 471
Linguagens Regulares – Autômatos Finitos – AFD

Questões importantes
1 Pode um AF entrar em loop?
2 Dado dois AFs M1 e M2 , pergunta-se:
Linguagens Regulares
Quando os dois AFs são equivalentes? L(M1 ) = L(M2 )
Autômatos Finitos
ACEITA(M) ∩ REJEITA(M) = ∅

ACEITA(M) ∪ REJEITA(M) = Σ∗ = U
Autômatos Finitos Não-Determinísticos
∼ACEITA(M) = REJEITA(M)

∼REJEITA(M) = ACEITA(M) = L(M)

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 103 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 104 / 471

Linguagens Regulares – Autômatos Finitos – AFND Linguagens Regulares – Autômatos Finitos – AFND

Composição Autômato Finito Não-Determinístico (AFND)


A construção de sistemas é composicional, geralmente Um AFND é uma quíntupla (Q, Σ, δND , q0 , F):
Q = conjunto finito de estados
É importante diferenciar três formas de composição:
Σ = alfabeto
Sequencial: A execução do próximo componente depende
do término do anterior δND : Q x Σ → P(Q) = função (total) de transições de estados
qo ∈ Q = estado inicial
Concorrente: A execução dos componentes é irrelevante, F ⊆ Q = conjunto de estados finais (aceitação)
i.e., são componentes independentes
Uma palavra w ∈ Σ∗ é dita ser aceita por um AFND se, e
Não-determinista: A execução do próximo componente é
uma escolha entre diversos componentes alternativos somente se, existe uma computação que a consome e
para em um estado final
Exemplo: sistema bancário (atendimento em caixas)
Para todo AFND, existe um AFD equivalente
i.e., não aumenta poder de expressão

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 105 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 106 / 471
Linguagens Regulares – Autômatos Finitos – AFND Linguagens Regulares – Autômatos Finitos – AFND

Exemplo Exemplo
L = palavras sobre {a, b} que começam e terminam com a L = palavras sobre {a, b} que começam e terminam com a
e possuem pelo menos um b e possuem pelo menos um b

AFND: AFND: δND a b


a a,b q0 {q1 } ∅
q1 {q1 } {q2 }
a b a q2 {q2 , q3 } {q2 }
q0 q1 q2 q3 q3 ∅ ∅

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 107 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 107 / 471

Linguagens Regulares – Autômatos Finitos – AFND Linguagens Regulares – Autômatos Finitos – AFND

Exemplo Exercício de Fixação


L = palavras sobre {a, b} que começam e terminam com a 1 L1 = palavras sobre {a, b} que contém aa ou bb
e possuem pelo menos um b
2 L2 = (a ∪ b)∗ bb
AFND: δND a b
a a,b q0 {q1 } ∅
3 L3 = palavras sobre {a, b} que terminam com aaa
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?

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 107 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 108 / 471
Linguagens Regulares – Autômatos Finitos – AFND Linguagens Regulares – Autômatos Finitos – AFND

Aceitação / Rejeição Função de Transição Estendida (δ̂ND )


Um AF aceita a entrada quando É uma extensão da função de transição original que a partir
após processar o último símbolo, em alguma das possíveis de um estado de origem (Q) e uma palavra (Σ∗ ), retorna
computações, assume um estado final (F) todos os possível estados finais do processamento (P(Q))

δ̂ND : Q x Σ∗ → P(Q)
Um AF rejeita a entrada quando
ACEITA(M) = {w ∈ Σ∗ | δ̂ND (q0 , w) ∩ F 6= ∅} = L(M)
(1) após processar o último símbolo, em todas as possíveis
computações, assume um estado não final REJEITA(M) = {w ∈ Σ∗ | δ̂ND (q0 , w) ∩ F = ∅}
(2) trava durante seu processamento, em todas as possíveis
computações
(3) qualquer combinação de (1) ou (2)
e.g., das 10 possíveis computações, 7 assumem estado
não final e 3 travam

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 109 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 110 / 471

Linguagens Regulares – Autômatos Finitos – AFND

Pontos Importantes
Muitas vezes, é muito mais fácil desenvolver um AFND do
que um AFD Linguagens Regulares
Por exemplo:
L = palavras sobre {a, b} cujo quinto último símbolo é a
Autômatos Finitos
Solução AFD: trabalhosa, 32 estados

Solução AFND: simples, 6 estados Autômatos Finitos Não-Determinísticos com Transições-λ

Um estratégia bem conhecida:


Construir o AFND

Aplicar o algoritmo AFND → AFD Algoritmo AFND → AFD

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 111 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 112 / 471
Linguagens Regulares – Autômatos Finitos – AFND-λ Linguagens Regulares – Autômatos Finitos – AFND-λ

Autômato Finito Não-Determinístico com Transições-λ (AFND-λ) Exemplo


Um AFND-λ é uma quíntupla (Q, Σ, δND−λ , q0 , F): L = {0k | k é múltiplo de 2 ou 3}
Q = conjunto finito de estados AFND-λ:
Σ = alfabeto
δND−λ : Q x (Σ ∪ {λ}) → P(Q) = f. de transições de estados
qo ∈ Q = estado inicial
F ⊆ Q = conjunto de estados finais (aceitação)

Para todo AFND-λ, existe um AFND e um AFD equivalentes


i.e., não aumenta poder de expressão

É muito similar ao AFND


Tem como vantagem facilitar construções e demonstrações
Por exemplo, o algoritmo ER → AFND-λ Algoritmo ER → AFND-λ

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 113 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 114 / 471

Linguagens Regulares – Autômatos Finitos – AFND-λ Linguagens Regulares – Autômatos Finitos – AFND-λ

Exemplo Exercício de Fixação


L = {0k | k é múltiplo de 2 ou 3} 1 L = (a ∪ b)∗ bb ou aa(a ∪ b)∗
AFND-λ: 2 L = palavras sobre {a, b, c} que terminam com a ou bb ou
0 δND−λ 0 λ ccc
q1 q2 q0 ∅ {q1 , q3 }
λ q1 {q2 } ∅
0 q2 {q1 } ∅
q0 q3 {q4 } ∅
q4 {q5 } ∅
λ
q5 {q3 } ∅
0
q3 q4

0 0
q5

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 114 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 115 / 471
Linguagens Regulares
Linguagens Regulares
Autômatos com Saída
Autômatos com Saída
Máquina de Moore

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 116 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 117 / 471

Linguagens Regulares – Autômatos com Saída – Moore Linguagens Regulares – Autômatos com Saída – Moore

Máquina de Moore Funcionamento da Máquina de Moore


Uma máquina de Moore é uma sêxtupla (Q, Σ, Γ, δD , σ, q0 ): Funcionamento semelhante aos AFDs
Q = conjunto finito de estados Ao invés de uma saída binária (aceita/rejeita), é uma
palavra
Σ = alfabeto de entrada
Na prática, é uma máquina de estados finitos transdutora
Γ = alfabeto da saída
δD : Q x Σ → Q = função (total) de transições de estados O primeiro símbolo da palavra de saída é sempre σ(q0 )
σ : Q → Γ = função (total) de saída Logo, o tamanho da saída é igual a |w| + 1
qo ∈ Q = estado inicial
Sempre que se atingir um estado Q/Y , concatena-se o
Uma máquina de Moore é um AFD com um símbolo de simbolo Y = σ(Q) à direita da palavra de saída
saída associado a cada estado No exemplo abaixo, ao se atingir o estado q3 , concatena-se
“2” à direita da palavra de saída, i.e., σ(q3 ) = 2

q3 /2

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 118 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 119 / 471
Linguagens Regulares – Autômatos com Saída – Moore Linguagens Regulares – Autômatos com Saída – Moore

Exemplo #1 Função de Saída Estendida (r)


Máquina de Moore que determina o número de a Dados um estado (Q) e uma palavra de entrada (Σ∗ ),
presentes nos dois últimos símbolos da palavra de entrada retorna a palavra de saída da máquina de Moore:
r : Q × Σ∗ → Γ+
ba/1
b a
a a
Formalização:
bb/0 a b aa/2 r(Q, λ) = σ(Q)

b b r(Q, ay) = σ(Q) r( δD (Q, a), y), ∀a ∈ Σ e y ∈ Σ∗


ab/1
Saída Computada:
O último símbolo da palavra de saída indica o resultado 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(bb, aaab)

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 120 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 121 / 471

Linguagens Regulares – Autômatos com Saída – Moore Linguagens Regulares – Autômatos com Saída – Moore

Simulação de AFDs com Máquinas de Moore Exemplo #2


Qualquer AFD M pode ser simulado utilizando-se uma Máquina de Moore que simula um AFD que reconhece as
máquina de Moore palavras que terminam com aa

Uma possibilidade é fazer: ba/0


b a
Γ = {0, 1} a a

1, se Q ∈ F bb/0 a
σ(Q) = b aa/1
0, se Q 6∈ F

Logo, w ∈ L(M) sse r(q0 , w) termina em 1 b b


ab/0

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 122 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 123 / 471
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} Linguagens Regulares
Dica1 : A máquina deve aceitar “13”, “1111”, “202”, . . .

Dica2 : Um estado para cada resto (e.g., 0%4, 1%4, . . . ) Autômatos com Saída
2 Projetar uma Máquina de Moore cujo último símbolo da
palavra de saída represente o resto das somas dos símbolos Máquinas de Mealy
da palavra por 4, considerando Σ = {0, 1, 2, 3}
Dica: Pequena alteração em (1)

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 124 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 125 / 471

Linguagens Regulares – Autômatos com Saída – Mealy Linguagens Regulares – Autômatos com Saída – Mealy

Máquina de Mealy Funcionamento da Máquina de Mealy


Uma máquina de Mealy é uma sêxtupla (Q, Σ, Γ, δD , σ, q0 ): Funcionamento semelhante aos AFDs
Q = conjunto finito de estados Ao invés de uma saída binária (aceita ou rejeita), é uma
Σ = alfabeto de entrada palavra
Γ = alfabeto da saída Na prática, é uma máquina de estados finitos transdutora
δD : Q x Σ → Q = função (total) de transições de estados O tamanho da saída é igual ao tamanho da palavra
σ : Q × Σ → Γ = função (total) de saída
qo ∈ Q = estado inicial Sempre que, a partir de um estado Q, é efetuada uma
transição a/d , concatena-se o símbolo d = σ(Q, a) à
Uma máquina de Mealy é um AFD com um símbolo de direita da palavra de saída
saída associado a cada transição 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

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 126 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 127 / 471
Linguagens Regulares – Autômatos com Saída – Mealy Linguagens Regulares – Autômatos com Saída – Mealy

Exemplo #3 Exemplo #4
Máquina de Mealy que determina o quociente da divisão Modificação 2 em 1
de um número binário por 6 Mealy: quociente da divisão por 6 (transições)
0/0 Moore: resto da divisão por 6 (estados)
1/1 0/0
1/1
1/0 0/1
q2 q5 q4
1/0 0/1
q2 /2 q5 /5 q4 /4
0/0 0/1 1/1
0/0 0/1 1/1
1/0
1/0
q1 q3
q1 /1 q3 /3

1/0 1/1
0/0 0/0 1/0 1/1

q0 0/1
q0 /0 0/1

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 128 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 129 / 471

Linguagens Regulares – Autômatos com Saída – Mealy Linguagens Regulares – Autômatos com Saída – Exercícios

Função de Saída Estendida (s) Exercício


Dados um estado (Q) e uma palavra de entrada (Σ∗ ), 1 Projetar uma Máquina de Mealy que troque a por b e
retorna a palavra de saída da máquina de Mealy: vice-versa, considerando Σ = {a, b}
s : Q × Σ∗ → Γ ∗ Dica: Não complique o que é simples

Formalização:
s(Q, λ) = λ

s(Q, ay) = σ(Q, a) s( δ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)
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 130 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 131 / 471
Algoritmos de Transformação

Algoritmos de Transformação
Existem algoritmos de transformação de uma Máquina de
Linguagens Regulares Moore para uma Máquina de Mealy e vice-versa, com
certas ressalvas

Autômatos com Saída No entanto, não serão abordados na disciplina


Os algoritmos podem ser encontrados em Vieira [8]
Algoritmos de Transformação

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 132 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 133 / 471

Linguagens Regulares
Linguagens Regulares
Algoritmos
Algoritmos
Transformação AFND-λ para AFD

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 134 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 135 / 471
Linguagens Regulares – Algoritmos – AFND-λ para AFD Linguagens Regulares – Algoritmos – AFND-λ para AFD

Transformação de um AFND-λ para AFD AFND-λ


a b
1 AFND-λ → AFND
a
q0 q1
i.e., δND−λ → δND
a λ

Importante: AFND pode ter mais de um estado inicial


q2

2 AFND → AFD
c
i.e., δND → δD
Importante: Dado um AFND com n estados, o AFD
correspondente pode ter até 2n estados (e.g., 5 → 32)
Por isso, abordaremos um algoritmo de construção de estados
sob demanda (para evitar estados inúteis)

Caso não haja transições λ, pular passo (1)

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 136 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 137 / 471

Linguagens Regulares – Algoritmos – AFND-λ para AFD Linguagens Regulares – Algoritmos – AFND-λ para AFD

AFND-λ AFND-λ
a b a b

q0
a
q1 δND−λ a b c λ fecho(λ) q0
a
q1 δND−λ a b c λ fecho(λ)
q0 {q0 , q1 , q2 } ∅ ∅ ∅ {q0 } q0 {q0 , q1 , q2 } ∅ ∅ ∅ {q0 }
a λ a λ
q1 ∅ {q1 } ∅ ∅ {q1 } q1 ∅ {q1 } ∅ ∅ {q1 }
q2 q2 ∅ ∅ {q2 } {q1 } {q1 , q2 } q2 q2 ∅ ∅ {q2 } {q1 } {q1 , q2 }

c *fecho−λ(qi ) = qi + estados acessíveis a partir de qi lendo λ c *fecho−λ(qi ) = qi + estados acessíveis a partir de qi lendo λ

1 δND−λ → δND
i. São estados iniciais: fecho−λ(q0 )
Se um estado inicial alcança um δND a b c
estado final, tal inicial será final

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 137 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 137 / 471
Linguagens Regulares – Algoritmos – AFND-λ para AFD Linguagens Regulares – Algoritmos – AFND-λ para AFD

AFND-λ AFND-λ
a b a b

q0
a
q1 δND−λ a b c λ fecho(λ) q0
a
q1 δND−λ a b c λ fecho(λ)
q0 {q0 , q1 , q2 } ∅ ∅ ∅ {q0 } q0 {q0 , q1 , q2 } ∅ ∅ ∅ {q0 }
a λ a λ
q1 ∅ {q1 } ∅ ∅ {q1 } q1 ∅ {q1 } ∅ ∅ {q1 }
q2 q2 ∅ ∅ {q2 } {q1 } {q1 , q2 } q2 q2 ∅ ∅ {q2 } {q1 } {q1 , q2 }

c *fecho−λ(qi ) = qi + estados acessíveis a partir de qi lendo λ c *fecho−λ(qi ) = qi + estados acessíveis a partir de qi lendo λ

1 δND−λ → δND 1 δND−λ → δND


i. São estados iniciais: fecho−λ(q0 ) i. São estados iniciais: fecho−λ(q0 )
Se um estado inicial alcança um δND a b c Se um estado inicial alcança um δND a b c
estado final, tal inicial será final q0 {q0 , q1 , q2 } ∅ ∅ estado final, tal inicial será final q0 {q0 , q1 , q2 } ∅ ∅
q1 ∅ {q1 } ∅ ii. Para os outros estados qi : q1 ∅ {q1 } ∅
q2 ∅ q2 ∅

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 137 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 137 / 471

Linguagens Regulares – Algoritmos – AFND-λ para AFD Linguagens Regulares – Algoritmos – AFND-λ para AFD

AFND-λ AFND-λ
a b a b

q0
a
q1 δND−λ a b c λ fecho(λ) q0
a
q1 δND−λ a b c λ fecho(λ)
q0 {q0 , q1 , q2 } ∅ ∅ ∅ {q0 } q0 {q0 , q1 , q2 } ∅ ∅ ∅ {q0 }
a λ a λ
q1 ∅ {q1 } ∅ ∅ {q1 } q1 ∅ {q1 } ∅ ∅ {q1 }
q2 q2 ∅ ∅ {q2 } {q1 } {q1 , q2 } q2 q2 ∅ ∅ {q2 } {q1 } {q1 , q2 }

c *fecho−λ(qi ) = qi + estados acessíveis a partir de qi lendo λ c *fecho−λ(qi ) = qi + estados acessíveis a partir de qi lendo λ

1 δND−λ → δND 1 δND−λ → δND


i. São estados iniciais: fecho−λ(q0 ) i. São estados iniciais: fecho−λ(q0 )
Se um estado inicial alcança um δND a b c Se um estado inicial alcança um δND a b c
estado final, tal inicial será final q0 {q0 , q1 , q2 } ∅ ∅ estado final, tal inicial será final q0 {q0 , q1 , q2 } ∅ ∅
ii. Para os outros estados qi : q1 ∅ {q1 } ∅ ii. Para os outros estados qi : q1 ∅ {q1 } ∅
considera todo estado em fecho−λ(qi ) q2 ∅ {q 1 } 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 )

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 137 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 137 / 471
Linguagens Regulares – Algoritmos – AFND-λ para AFD Linguagens Regulares – Algoritmos – AFND-λ para AFD

AFND (agora) AFND (agora)


a b

δND a b c q0
a
q1 δND a b c
q0 {q0 , q1 , q2 } ∅ ∅ q0 {q0 , q1 , q2 } ∅ ∅
a b,c
q1 ∅ {q1 } ∅ q1 ∅ {q1 } ∅
q2 ∅ {q 1 } {q 1 , q 2 } q2 q2 ∅ {q 1 } {q 1 , q 2 }

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 138 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 138 / 471

Linguagens Regulares – Algoritmos – AFND-λ para AFD Linguagens Regulares – Algoritmos – AFND-λ para AFD

AFND (agora) AFND (agora)


a b a b

q0
a
q1 δND a b c q0
a
q1 δND a b c
q0 {q0 , q1 , q2 } ∅ ∅ q0 {q0 , q1 , q2 } ∅ ∅
a b,c a b,c
q1 ∅ {q1 } ∅ q1 ∅ {q1 } ∅
q2 q2 ∅ {q 1 } {q 1 , q 2 } q2 q2 ∅ {q 1 } {q 1 , q 2 }

c c

2 δND → δD (construção de subconjuntos sob demanda) 2 δND → δD (construção de subconjuntos sob demanda)

i. É inicial: a união de todos i. É inicial: a união de todos


os estados iniciais: {q0 } δD a b c os estados iniciais: {q0 } δD a b c
q0 = hq0 i hq0 , q1 , q2 i − − 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

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 138 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 138 / 471
Linguagens Regulares – Algoritmos – AFND-λ para AFD Linguagens Regulares – Algoritmos – AFND-λ para AFD

AFND (agora) AFD (enfim)


a b a
c

q0
a
q1 δND a b c δD a b c
q0 {q0 , q1 , q2 } ∅ ∅ hq0 i
a
hq0 , q1 , q2 i
c
hq1 , q2 i hq0 i hq0 , q1 , q2 i − −
a b,c
q1 ∅ {q1 } ∅ hq0 , q1 , q2 i hq0 , q1 , q2 i hq1 i hq1 , q2 i
q2 q2 ∅ {q 1 } {q 1 , q 2 } hq1 i − hq1 i −
b b

hq1 , q2 i − hq1 i hq1 , q2 i


c b hq1 i

2 δND → δD (construção de subconjuntos sob demanda)

i. É inicial: a união de todos


os estados iniciais: {q0 } δD a b c
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 138 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 139 / 471

Linguagens Regulares – Algoritmos – AFND-λ para AFD Linguagens Regulares – Algoritmos – AFND-λ para AFD

Exercício de Fixação #1 Exercício de Fixação #2


a 0,1
q1 q2
1 0,1 0,1
q0 q1 q2 q3
λ b

q0

λ a

q3

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 140 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 141 / 471
Linguagens Regulares – Algoritmos – AFND-λ para AFD

Exercício de Fixação #3
a,b
Linguagens Regulares
a
q3 q4

λ Algoritmos
λ

λ Minimização de AFD
a b
q0 q1 q2

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 142 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 143 / 471

Linguagens Regulares – Algoritmos – Minimização de AFD Linguagens Regulares – Algoritmos – Minimização de AFD

Minimização de um AFD Algoritmo


1 Todos os estados são equivalentes Entrada: AFD M = (Q, Σ, δ, q0 , F)

1 Para todos os pares de estados qi e qj , i < j, faça:


2 Se um é estado final e o outro não, logo não são 1.1 D[i, j] = 0
equivalentes 1.2 S[i, j] = ∅

3 Conferir, estado por estado, se são "equivalentes" 2 Para cada par [i, j], i < j, se um é estado final e o outro não, faça D[i, j] = 1

Procedimento a ser detalhado 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
Toy Example (propósito ilustrativo apenas) (D[m, n] = 1 ou D[n, m] = 1) então:
a a,b,c 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
c a
q1
c a,b q4
se m < n e [i, j] 6= [m, n], então adicione [i, j] à S[m, n]
q0 b b q3 se m > n e [i, j] 6= [n, m], então adicione [i, j] à S[n, m]
q2 q5
b c c 4 Para cada D[i, j] = 0, os estados i e j podem ser fundidos

a a,b,c

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 144 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 145 / 471
Linguagens Regulares – Algoritmos – Minimização de AFD Linguagens Regulares – Algoritmos – Minimização de AFD
a,b

Exemplo q0
b
q1
b
q2
b
q3

a a a

a,b q4 q5 q6

a,b a,b a,b

b b b
q0 q1 q2 q3 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] = ∅
a a a
Í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 ∅
q4 q5 q6 [0, 3] X ∅ [2, 5] X ∅
[0, 4] X ∅ [2, 6] X ∅
[0, 5] X ∅ [3, 4] X ∅
a,b a,b a,b [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 ∅

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 146 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 147 / 471

Linguagens Regulares – Algoritmos – Minimização de AFD Linguagens Regulares – Algoritmos – Minimização de AFD
a,b a,b

b b b b b b
q0 q1 q2 q3 q0 q1 q2 q3

a a a a a a

q4 q5 q6 q4 q5 q6

a,b a,b a,b a,b a,b a,b

2 Para cada par [i, j], i < j, se um é estado final e o outro não, faça D[i, j] = 1 (aqui, x) 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
Índice D[i, j] = S[i, j] = Motivo Índice D[i, j] = S[i, j] = Motivo
[0, 1] X ∅ [2, 3] X ∅ (D[m, n] = 1 ou D[n, m] = 1) então:
[0, 2] X ∅ [2, 4] x ∅ DIST (i, j) //altera D[i, j] = 1 e propaga a distinção aos elementos de S[i, j]
[0, 3] X ∅ [2, 5] x ∅
3.2 para cada a ∈ Σ tal que δ(qi , a) = qm e δ(qj , a) = qn
[0, 4] x ∅ [2, 6] x ∅
[0, 5] x ∅ [3, 4] x ∅ se m < n e [i, j] 6= [m, n], então adicione [i, j] à S[m, n]
[0, 6] x ∅ [3, 5] x ∅ se m > n e [i, j] 6= [n, m], então adicione [i, j] à S[n, m]
[1, 2] X ∅ [3, 6] x ∅
[1, 3] X ∅ [4, 5] X ∅ Índice D[i, j] = S[i, j] = Motivo Índice D[i, j] = S[i, j] = Motivo
[1, 4] x ∅ [4, 6] X ∅ [0, 1] X { } [2, 3] X { }
[1, 5] x ∅ [5, 6] X ∅ [0, 2] X { } [4, 5] X { }
[1, 6] x ∅ [0, 3] X { } [4, 6] X { }
[1, 2] X { } [5, 6] X { }
[1, 3] X { }

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 148 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 149 / 471
Linguagens Regulares – Algoritmos – Minimização de AFD Linguagens Regulares – Algoritmos – Minimização de AFD
a,b a,b

b b b b b b
q0 q1 q2 q3 q0 q1 q2 q3

a a a a a a

q4 q5 q6 q4 q5 q6

a,b a,b a,b a,b a,b a,b

3 Para cada par [i, j], i < j e D[i, j] = 0, faça: 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 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: (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] 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 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= [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] se m > n e [i, j] 6= [n, m], então adicione [i, j] à S[n, m]

Índice D[i, j] = S[i, j] = Motivo Índice D[i, j] = S[i, j] = Motivo Índice D[i, j] = S[i, j] = Motivo Índice D[i, j] = S[i, j] = Motivo
 [0, 1] X { } [2, 3] X { } [0, 1] X { } [2, 3] X { }
[0, 2] X { } [4, 5] X { [0, 1] }  [0, 2] X { } [4, 5] X { [0, 1] }
[0, 3] X { } [4, 6] X { } [0, 3] X { } [4, 6] X { [0, 2] }
[1, 2] X { [0, 1] } [5, 6] X { } [1, 2] X { [0, 1] } [5, 6] X { }
[1, 3] X { } [1, 3] X { [0, 2] }

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 149 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 149 / 471

Linguagens Regulares – Algoritmos – Minimização de AFD Linguagens Regulares – Algoritmos – Minimização de AFD
a,b a,b

b b b b b b
q0 q1 q2 q3 q0 q1 q2 q3

a a a a a a

q4 q5 q6 q4 q5 q6

a,b a,b a,b a,b a,b a,b

3 Para cada par [i, j], i < j e D[i, j] = 0, faça: 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 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: (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] 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 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= [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] se m > n e [i, j] 6= [n, m], então adicione [i, j] à S[n, m]

Índice D[i, j] = S[i, j] = Motivo Índice D[i, j] = S[i, j] = Motivo Índice D[i, j] = S[i, j] = Motivo Índice D[i, j] = S[i, j] = Motivo
[0, 1] X { } [2, 3] X { } [0, 1] X { } [2, 3] X { [1, 2] }
[0, 2] X { } [4, 5] X { [0, 1] } [0, 2] X { } [4, 5] X { [0, 1] }
 [0, 3] X→x { } a [4, 6] X { [0, 2] } [0, 3] X→x { } a [4, 6] X { [0, 2] }
[1, 2] X { [0, 1] } [5, 6] X { }  [1, 2] X { [0, 1] } [5, 6] X { [1, 2] }
[1, 3] X { [0, 2] } [1, 3] X { [0, 2] }

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 149 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 149 / 471
Linguagens Regulares – Algoritmos – Minimização de AFD Linguagens Regulares – Algoritmos – Minimização de AFD
a,b a,b

b b b b b b
q0 q1 q2 q3 q0 q1 q2 q3

a a a a a a

q4 q5 q6 q4 q5 q6

a,b a,b a,b a,b a,b a,b

3 Para cada par [i, j], i < j e D[i, j] = 0, faça: 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 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: (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] 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 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= [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] se m > n e [i, j] 6= [n, m], então adicione [i, j] à S[n, m]

Índice D[i, j] = S[i, j] = Motivo Índice D[i, j] = S[i, j] = Motivo Índice D[i, j] = S[i, j] = Motivo Índice D[i, j] = S[i, j] = Motivo
[0, 1] X { } [2, 3] X { [1, 2] } [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, 2] X→x { } [1, 3] [4, 5] X { [0, 1] }
[0, 3] X→x { } a [4, 6] X { [0, 2] } [0, 3] X→x { } a [4, 6] X { [0, 2] }
[1, 2] X { [0, 1] } [5, 6] X { [1, 2] } [1, 2] X→x { [0, 1] } [2, 3] [5, 6] X { [1, 2] }
 [1, 3] X→x { [0, 2] } a [1, 3] X→x { [0, 2] } a

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 149 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 149 / 471

Linguagens Regulares – Algoritmos – Minimização de AFD Linguagens Regulares – Algoritmos – Minimização de AFD
a,b a,b

b b b b b b
q0 q1 q2 q3 q0 q1 q2 q3

a a a a a a

q4 q5 q6 q4 q5 q6

a,b a,b a,b a,b a,b a,b

3 Para cada par [i, j], i < j e D[i, j] = 0, faça: 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 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: (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] 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 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= [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] se m > n e [i, j] 6= [n, m], então adicione [i, j] à S[n, m]

Índice D[i, j] = S[i, j] = Motivo Índice D[i, j] = S[i, j] = Motivo Índice D[i, j] = S[i, j] = Motivo Índice D[i, j] = S[i, j] = Motivo
[0, 1] X→x { } [1, 2] [2, 3] X→x { [1, 2] } a [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, 2] X→x { } [1, 3] [4, 5] X { [0, 1] }
[0, 3] X→x { } a [4, 6] X { [0, 2] } [0, 3] X→x { } a  [4, 6] X { [0, 2] }
[1, 2] X→x { [0, 1] } [2, 3] [5, 6] X { [1, 2] } [1, 2] X→x { [0, 1] } [2, 3] [5, 6] X { [1, 2] }
[1, 3] X→x { [0, 2] } a [1, 3] X→x { [0, 2] } a

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 149 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 149 / 471
Linguagens Regulares – Algoritmos – Minimização de AFD Linguagens Regulares – Algoritmos – Minimização de AFD
a,b a,b

b b b b b b
q0 q1 q2 q3 q0 q1 q2 q3

a a a a a a

q4 q5 q6 q4 q5 q6

a,b a,b a,b a,b a,b a,b

3 Para cada par [i, j], i < j e D[i, j] = 0, faça: 4 Para cada D[i, j] = 0, os estados i e j podem ser fundidos

3.1 se existe um a ∈ Σ tal que δ(qi , a) = qm e δ(qj , a) = qn e a,b


(D[m, n] = 1 ou D[n, m] = 1) então:
b b b
DIST (i, j) //altera D[i, j] = 1 e propaga a distinção aos elementos de S[i, j] q0 q1 q2 q3

3.2 para cada a ∈ Σ tal que δ(qi , a) = qm e δ(qj , a) = qn a a


se m < n e [i, j] 6= [m, n], então adicione [i, j] à S[m, n] a

se m > n e [i, j] 6= [n, m], então adicione [i, j] à S[n, m]


{q4 , q5 , q6 }

Índice D[i, j] = S[i, j] = Motivo Índice D[i, j] = S[i, j] = Motivo


[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] }
a,b
[1, 2] X→x { [0, 1] } [2, 3]  [5, 6] X { [1, 2] }
[1, 3] X→x { [0, 2] } a Logo, um mesmo estado para q4 , q5 e q6 , já que D[4, 5] = 0, D[4, 6] = 0 e
D[5, 6] = 0

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 149 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 150 / 471

Linguagens Regulares – Algoritmos – Minimização de AFD

Exercício de Fixação
b
Linguagens Regulares
b
q1 q3

a Algoritmos
a a

q2 a,b Transformação de ER para AFND-λ


q0 q7
q5 a,b
b a a,b
a b

b
q4 q6

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 151 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 152 / 471
Linguagens Regulares – Algoritmos – ER para AFND-λ Linguagens Regulares – Algoritmos – ER para AFND-λ

Algoritmo de Thompson Exemplo: ((a ∪ b)c ∗ )∗


a b
a b

ab
a b

a ∪ b (ou a | b)
a
λ λ

λ b λ

a∗
λ

λ a λ

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 153 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 154 / 471

Linguagens Regulares – Algoritmos – ER para AFND-λ Linguagens Regulares – Algoritmos – ER para AFND-λ

Exemplo: ((a ∪ b)c ∗ )∗ Exemplo: ((a ∪ b)c ∗ )∗

a a
q2 q3 q2 q3

b
q4 q5

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 154 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 154 / 471
Linguagens Regulares – Algoritmos – ER para AFND-λ Linguagens Regulares – Algoritmos – ER para AFND-λ

Exemplo: ((a ∪ b)c ∗ )∗ Exemplo: ((a ∪ b)c ∗ )∗

a a
q2 q3 q2 q3
λ λ λ λ
c
q1 q6 q1 q6 q7 q8

λ b λ λ b λ
q4 q5 q4 q5

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 154 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 154 / 471

Linguagens Regulares – Algoritmos – ER para AFND-λ Linguagens Regulares – Algoritmos – ER para AFND-λ

Exemplo: ((a ∪ b)c ∗ )∗ Exemplo: ((a ∪ b)c ∗ )∗

λ λ
a a
q2 q3 q2 q3
λ λ λ λ
λ c λ λ c λ
q1 qq660 q7 q8 q9 q1 q6 q7 q8 q9

λ b λ λ b λ
q4 q5 q4 q5

λ λ

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 154 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 154 / 471
Linguagens Regulares – Algoritmos – ER para AFND-λ Linguagens Regulares – Algoritmos – ER para AFND-λ

Exemplo: ((a ∪ b)c ∗ )∗ Exercícios de Fixação


1 (a ∪ b ∪ c)∗
λ
2 (a ∪ b)∗ abb
3 ((λ ∪ a)b∗ )∗
λ
q2
a
q3
4 (a ∪ b)∗ abb(a ∪ b)∗
λ λ
λ λ c λ λ
q0 q1 q6 q7 q8 q9 q10 5 letra (letra ∪ digito)∗
λ b λ
q4 q5

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 154 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 155 / 471

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)
Linguagens Regulares
3 Através de um CR ou ER (formalismo axiomático)
Propriedades 4 Ou através de propriedades de fechamento
Por isso, é importante conhecer as propriedades de LR

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 156 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 157 / 471
Linguagens Regulares – Propriedades Linguagens Regulares – Propriedades

Propriedades de Fechamento Propriedades de Fechamento


Se L1 e L2 são regulares, então também são regulares: Se L1 e L2 são regulares, então também são regulares:
L1 ∪ L2 L1 ∪ L2
L1 L2 L1 L2
L1 ∗ L1 ∗

Se L1 é regular, então L1 também é regular Se L1 é regular, então L1 também é regular


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

Se L1 e L2 são regulares, então L1 ∩ L2 também é regular Se L1 e L2 são regulares, então L1 ∩ L2 também é regular

Objetivos: Objetivos:
Originar novas LRs a partir de existentes Originar novas LRs a partir de existentes
Provar (ou refutar) que alguma linguagem é regular Provar (ou refutar) que alguma linguagem é regular
Se L1 ∩ L2 = {a i bi | i > 0}, uma das linguagens não é regular Se L1 ∩ L2 = {a i bi | i > 0}, uma das linguagens não é regular

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 158 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 158 / 471

Linguagens Regulares – Propriedades Linguagens Regulares – Propriedades

Propriedades de Fechamento Propriedades de Fechamento


Se L1 e L2 são regulares, então também são regulares: Prove que a linguagem formada por palavras sobre {a,b}
L1 ∪ L2 que tenham aa e não tenham bb é regular (Exemplo 6.4.1, Sudkamp [6])
L1 L2 L1 = palavras com aa = (a ∪ b)∗ aa(a ∪ b)∗ é regular
L1 ∗
L2 = palavras com bb = (a ∪ b)∗ bb(a ∪ b)∗ é regular
Se L1 é regular, então L1 também é regular
L2 também é regular
Prova: basta inverter os estados finais com não-finais
Logo, L1 ∩ L2 é regular
Se L1 e L2 são regulares, então L1 ∩ L2 também é regular
Prova: Lei de Morgan: L1 ∩ L2 = (L1 ∪ L2 )

Objetivos:
Originar novas LRs a partir de existentes
Provar (ou refutar) que alguma linguagem é regular
Se L1 ∩ L2 = {a i bi | i > 0}, uma das linguagens não é regular

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 158 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 159 / 471
Linguagens Regulares – Propriedades Linguagens Regulares – Propriedades

Propriedades de Fechamento – Exemplo LR é Vazia, Finita ou Infinita?


Prove que L = {a i bj | i, j ≥ 0 e i 6= j} não é regular Dada uma linguagem L reconhecida por um AFD M com
Suponha que L seja regular n estados, logo L é:
1 Infinita sse M aceita palavras z tal que |z| ≥ n
Então, L também é regular
i.e., possui ciclo
i j
Mas, L = {a b | i, j ≥ 0 e i = j} não é regular 2 Finita sse M aceita apenas palavras z tal que |z| < n
Logo, L não pode ser regular i.e., não possui ciclo
3 Vazia sse M não aceita qualquer palavras z
i.e., F = ∅ ou é inalcançável
Método utilizado: Prova por contradição
Supõe-se que o contrário do que se deseja provar é verdade

Então, demonstra-se que essa suposição leva a um absurdo


(contradição)

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 160 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 161 / 471

Linguagens Regulares – Propriedades

É possível garantir que duas LRs são iguais?


Sim, é possível verificar se L1 = L2

Prova Linguagens Regulares


Suponha os AFs M1 e M2 onde L(M1 ) = L1 e L(M2 ) = L2

Pelas propriedades de fechamento, é possível construir um Lema do Bombeamento


AF M3 tal que:

L3 = (L1 ∩ L2 ) ∪ (L1 ∩ L2 )

Portanto, L1 = L2 sse L3 for vazia


E, como vimos anteriormente, é possível determinar se uma
linguagem é vazia

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 162 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 163 / 471
Linguagens Regulares – Lema do Bombeamento Linguagens Regulares – Lema do Bombeamento

Lema do Bombeamento (Pumping Lemma) (um teorema na verdade) Exemplo (k=2, pense em qualquer z tal que |z| ≥ k e z ∈ L)
Técnica usada para provar que linguagem não é regular b b
a
e só para linguagens infinitas (pq?)
q0 q1
Se um AFD tem k estados, então qualquer caminho de
aceitação de uma palavra z de tamanho |z| ≥ k contém a
um ciclo

b b
Caminhos de aceitação
a
O caminho de aceitação de qualquer palavra z tal que
q0 q1 |z| ≥ k e z ∈ L contém um ciclo
e.g., aa, baa, bb, . . .
a
Podem existir palavras de tamanho menor que 2
e.g. λ e b

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 164 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 165 / 471

Linguagens Regulares – Lema do Bombeamento Linguagens Regulares – Lema do Bombeamento

Decomposição Exemplo
Suponha uma palavra z ∈ L tal que |z| ≥ k a a

Logo, z pode ser dividida em três subpalavras z = uvw tal q0


b
q1
que |uv| ≤ k, v 6= λ e v é parte de z reconhecida pelo ciclo
Claramente, o ciclo pode ser executado (“bombeado”) a
b
b
várias vezes
uv i w ∈ L para todo i ≥ 0
q2 q3
v a, b

u w Decomponha as palavras z ∈ L e |z| ≥ k em z = uvw


q0 Q(s) qf
aabb
abaab
bababb
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 166 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 167 / 471
Linguagens Regulares – Lema do Bombeamento Linguagens Regulares – Lema do Bombeamento

Enunciado do Lema do Bombeamento Exemplo #1: L = {a i bi | i ≥ 0}


“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
uv i w ∈ L para todo i ≥ 0.”

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 168 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 169 / 471

Linguagens Regulares – Lema do Bombeamento Linguagens Regulares – Lema do Bombeamento

Exemplo #1: L = {a i bi | i ≥ 0} Exemplo #2: L = {a n | n é um quadrado perfeito }


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.

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 169 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 170 / 471
Linguagens Regulares – Lema do Bombeamento Linguagens Regulares – Lema do Bombeamento

Exemplo #2: L = {a n | n é um quadrado perfeito } Exercício de Fixação


Assuma que L é regular e seja k a constante especificada pelo Lema. 1 L1 = {0m 1n | m > n}
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:
2 L2 = {0n 12n | n > 0}

|uv 2 w| = |uvw| + |v|


3 L3 = {a i bm c n | 0 < i < m < n}
= k 2 + |v| (0 < |v| ≤ k) 4 L4 = {0m 1n 2m+n | m > 0 e n > 0}
≤ k2 + k
< k 2 + 2k + 1 5 L5 = {0n | n é um número primo }
= (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.

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 170 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 171 / 471

4. Linguagens Livres de Contexto – Conteúdo Linguagens Livres de Contexto

Revisão 3
Hierarquia de Chomsky
1

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-λ
Tipo Linguagem Gramática Máquina de aceitação
Máquina de Moore
Máquinas de Mealy
Algoritmos de Transformação
Transformação AFND-λ para AFD
0 Rec. enumerável Irrestrita Máquina de Turing
Minimização de AFD
Transformação de ER para AFND-λ

4 Linguagens Livres de Contexto 172


1 Recursiva Sensível ao contexto Autômato linearmente limitado
Gramática Livre de Contexto 178
Recursividade
Árvore de Derivação
Ambiguidade
2 Livre de contexto Livre de contexto Autômato com pilha
Backus-Nahur Form (BNF)
Formas Normais 207
Transformações de Gramática
Remoção de recursividade no símbolo inicial
214
3 Regular Regular Autômato finito
Eliminação de regras λ
Eliminação de regras de cadeia
Remoção de símbolos inúteis
Forma Normal de Chomsky 249
Remoção de recursividade à esquerda 257
Forma Normal de Greibach 265
Autômatos com Pilha 280
Variantes
Critérios de Aceitação
Algoritmos de Reconhecimento 308
Autômato com Pilha como Reconhecedor
Autômato com Pilha Descendente
Algoritmo de Cocke-Younger-Kasami (CYK)
Algoritmo de Early
Algoritmos 340
Transformação de GLCs para APs
Transformação de APs para GLCs
Propriedades 359

5 Linguagens Sensíveis ao Contexto 376

6 Linguagens Irrestritas 396


Teoremas
Variantes

7 Considerações Finais 462

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 172 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 173 / 471
Linguagens Livres de Contexto Linguagens Livres de Contexto

O que sabemos: LR, GR e AF (Tipo 3) LR x LLC


LR: LR descrevem linguagens simples
Ling. natural: Palavras sobre {a, b} que terminam com {a} Geradas por GR
Conj. regular: {a, b}∗ {a} Reconhecidas por AF
Expressão regular: (a ∪ b)∗ a
No entanto, existem uma ampla gama de linguagens que
GR: não podem ser descritas por LR
S → aS | bS | a Exemplo Clássico: L = {a i bi | i ≥ 0}

AF: Como já visto, o lema do bombeamento indica que a


b a linguagem L não é regular
a
Logo, devemos “subir” na Hierarquia de Chomsky!
S A

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 174 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 175 / 471

Linguagens Livres de Contexto Linguagens Livres de Contexto

De LR (tipo 3) para LLC (tipo 2) Aplicabilidade


LLC aumentam o poder de expressão da linguagem Como já vimos, LR são fundamentais no projeto de um
(veremos o porquê) analisador léxico
Padrões são descritos por ER
GLC é o sistema formal para geração de LLC
Diagramas de Transição (AF estendidos) são usados no
Assim, descrever L= {a i bi | i ≥ 0} é possível com uma GLC reconhecimento de tokens
S → aSb | λ Por outro lado, LLC são fundamentais no projeto de um
(e, pelo jeito, bem simples também) analisador sintático
A sequência de tokens segue a gramática da linguagem?
GLC especificam a gramática formal da LP

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 176 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 177 / 471
Linguagens Livres de Contexto – Gramática Livre de Contexto

Gramática Livre de Contexto (GLC)


Uma GLC é uma quádrupla (V , Σ, P, S):
V = conjunto de símbolos não-terminais (variáveis)
Linguagens Livres de Contexto Σ = conjunto de símbolos terminais (Σ ∩ V = φ)
P = conj. de regras (produções)
S = símbolo não-terminal inicial (S ∈ V )
Gramática Livre de Contexto

Regras: µ → ν
µ∈V (i.e., um não-terminal)

ν ∈ (V ∪ Σ)∗ (i.e., palavra formada por elementos de V e Σ)

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 178 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 179 / 471

Linguagens Livres de Contexto – Gramática Livre de Contexto Linguagens Livres de Contexto – Gramática Livre de Contexto

Regras Derivação
Mecânica: A → w Aplicação consecutiva de regras
o não-terminal A pode ser trocado por w
Definição de regra (→) 6= Aplicação de regra (⇒)
Exemplo: uAv ⇒ uwv v ⇒∗ w w é derivável a partir de v aplicando 0 ou mais regras

Livre de contexto: v ⇒+ w w é derivável a partir de v aplicando 1 ou mais regras

A sempre pode ser trocado por w (independentemente do v ⇒i w w é derivável a partir de v aplicando i regras
“contexto” u e v onde A ocorrer)

Portanto:
Característica Intrínseca
Uma palavra w ∈ (V ∪ Σ)∗ é uma forma sentencial se S ⇒∗ w
GLC permitem produzir duplo balanceamento
Uma palavra w ∈ Σ∗ é uma sentença se S ⇒∗ w
Em uma analogia com LPs
L(G) = {w ∈ Σ∗ | S ⇒∗ w}
Permitem blocos balanceado, e.g., beginn end n ou {n }n

Permitem parênteses balanceados (n )n


Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 180 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 181 / 471
Linguagens Livres de Contexto – Gramática Livre de Contexto Linguagens Livres de Contexto – Gramática Livre de Contexto

Exemplos Exemplos
Definir GLCs para as seguintes linguagens: Definir GLCs para as seguintes linguagens:
1 Palíndromas sobre {a, b}, i.e., L = {w ∈ {a, b}∗ | w = w R } 1 Palíndromas sobre {a, b}, i.e., L = {w ∈ {a, b}∗ | w = w R }

S → aSa | bSb | a | b | λ

2 Palavras sobre {a, b} com tamanho ímpar, i.e., 2 Palavras sobre {a, b} com tamanho ímpar, i.e.,
L = {w ∈ {a, b}∗ | |w| (mod 2) = 1} L = {w ∈ {a, b}∗ | |w| (mod 2) = 1}

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 182 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 182 / 471

Linguagens Livres de Contexto – Gramática Livre de Contexto Linguagens Livres de Contexto – Gramática Livre de Contexto

Exemplos Exercícios
Definir GLCs para as seguintes linguagens: Definir GLCs para as seguintes linguagens:
1 Palíndromas sobre {a, b}, i.e., L = {w ∈ {a, b}∗ | w = w R } 1 L = {a n bm a n | m > 0 e n > 0}
S → aSa | bSb | a | b | λ 2 L = {a n bm c m d 2n | m > 0 e n ≥ 0}
3 L = {a n bm | 0 ≤ n ≤ m ≤ 2n}
2 Palavras sobre {a, b} com tamanho ímpar, i.e.,
L = {w ∈ {a, b}∗ | |w| (mod 2) = 1}

S→A|a|b
A → aaS | abS | baS | bbS

Essa linguagem é, de fato, livre de contexto?

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 182 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 183 / 471
Linguagens Livres de Contexto – Gramática Livre de Contexto

Recursividade
Uma regra A → uAv é dita ser recursiva
Linguagens Livres de Contexto Uma regra A → Av é dita ser recursiva à esquerda

Uma regra A → uA é dita ser recursiva à direita


Gramática Livre de Contexto
Tipo de Derivações
Recursividade 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

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 184 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 185 / 471

Linguagens Livres de Contexto – Gramática Livre de Contexto Linguagens Livres de Contexto – Gramática Livre de Contexto

Exemplo Exemplo
Assuma a seguinte GLC: Assuma a seguinte GLC:
S → AA S → AA
A → AAA | bA | Ab | a A → AAA | bA | Ab | a

Possíveis derivações para palavra ababaa: Possíveis derivações para palavra ababaa:
S ⇒ AA ⇒ aA ⇒ aAAA ⇒ abAAA ⇒ abaAA ⇒ ababAA ⇒ S ⇒ AA ⇒ aA ⇒ aAAA ⇒ abAAA ⇒ abaAA ⇒ ababAA ⇒
ababaA ⇒ ababaa ababaA ⇒ ababaa (derivação mais à esq.)

S ⇒ AA ⇒ AAAA ⇒ aAAA ⇒ abAAA ⇒ abaAA ⇒ S ⇒ AA ⇒ AAAA ⇒ aAAA ⇒ abAAA ⇒ abaAA ⇒


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

S ⇒ AA ⇒ Aa ⇒ AAAa ⇒ AAbAa ⇒ AAbaa ⇒ AbAbaa ⇒ S ⇒ AA ⇒ Aa ⇒ AAAa ⇒ AAbAa ⇒ AAbaa ⇒ AbAbaa ⇒


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

S ⇒ AA ⇒ aA ⇒ aAAA ⇒ aAAa ⇒ abAAa ⇒ abAbAa ⇒ S ⇒ AA ⇒ aA ⇒ aAAA ⇒ aAAa ⇒ abAAa ⇒ abAbAa ⇒


ababAa ⇒ ababaa ababAa ⇒ ababaa (só derivação)

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 186 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 186 / 471
Linguagens Livres de Contexto – Gramática Livre de Contexto Linguagens Livres de Contexto – Gramática Livre de Contexto

Exemplo Teorema
Assuma a seguinte GLC: Seja G uma GLC. Uma palavra w pertence a L(G) sse existe
uma derivação mais à esquerda para w a partir de S
S → AA
A → AAA | bA | Ab | a Prova pode ser encontrada em Sudkamp [6]

Possíveis derivações para palavra ababaa:


S ⇒ AA ⇒ aA ⇒ aAAA ⇒ abAAA ⇒ abaAA ⇒ ababAA ⇒
ababaA ⇒ ababaa (derivação mais à esq.)

S ⇒ AA ⇒ AAAA ⇒ aAAA ⇒ abAAA ⇒ abaAA ⇒


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

S ⇒ AA ⇒ Aa ⇒ AAAa ⇒ AAbAa ⇒ AAbaa ⇒ AbAbaa ⇒


Ababaa ⇒ ababaa

S ⇒ AA ⇒ aA ⇒ aAAA ⇒ aAAa ⇒ abAAa ⇒ abAbAa ⇒


ababAa ⇒ ababaa
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 186 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 187 / 471

Linguagens Livres de Contexto – Gramática Livre de Contexto

Derivação de palavras em uma árvore


Partindo do símbolo inicial como raíz
Linguagens Livres de Contexto Terminando em símbolos terminais como folhas

Gramática Livre de Contexto Conveniente em muitas aplicações


Compiladores
Árvore de Derivação Processadores de texto

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 188 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 189 / 471
Linguagens Livres de Contexto – Gramática Livre de Contexto Linguagens Livres de Contexto – Gramática Livre de Contexto

Árvore de Derivação – Definição Exemplo #1

Raíz: símbolo inicial GLC: S → aSb | λ

Vértices interiores: variáveis Palavra: aabb

Se A é um vértice interior e X1 , X2 , ..., Xn são “filhos” de A S


A → X1 , X2 , ..., Xn é uma produção da gramática

X1 , X2 , ..., Xn são ordenados da esquerda para a direita


a S b
Folha: terminal ou símbolo vazio
Se vazio: único filho de seu pai (A → λ)
a S b

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 190 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 191 / 471

Linguagens Livres de Contexto – Gramática Livre de Contexto Linguagens Livres de Contexto – Gramática Livre de Contexto

Exemplo #2 Exemplo #2
GLC: E → E + E | E ∗ E | (E) | id GLC: E → E + E | E ∗ E | (E) | id

Palavra: id + id * id Palavra: id + id * id

E E

E + E E + E
Algum problema com a
GLC ou com a árvore?

id E ∗ E id E ∗ E

id id id id

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 192 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 192 / 471
Linguagens Livres de Contexto – Gramática Livre de Contexto

Ambiguidade
Uma GLC G é ambígua se existir uma palavra w em L(G)
Linguagens Livres de Contexto que possua duas derivações mais à esquerda diferentes
o que significa duas árvores de derivação diferentes

Gramática Livre de Contexto Exemplo: L(G) = a +

Exemplo de gramática ambígua para L(G):


Ambiguidade
S → aS | Sa | a
Ambiguidade para aa:

Exemplo de gramática não-ambígua para L(G):

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 193 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 194 / 471

Linguagens Livres de Contexto – Gramática Livre de Contexto Linguagens Livres de Contexto – Gramática Livre de Contexto

Ambiguidade Ambiguidade
Uma GLC G é ambígua se existir uma palavra w em L(G) Uma GLC G é ambígua se existir uma palavra w em L(G)
que possua duas derivações mais à esquerda diferentes que possua duas derivações mais à esquerda diferentes
o que significa duas árvores de derivação diferentes o que significa duas árvores de derivação diferentes

Exemplo: L(G) = a + Exemplo: L(G) = a +

Exemplo de gramática ambígua para L(G): Exemplo de gramática ambígua para L(G):
S → aS | Sa | a S → aS | Sa | a
Ambiguidade para aa: S ⇒ aS ⇒ aa e S ⇒ Sa ⇒ aa Ambiguidade para aa: S ⇒ aS ⇒ aa e S ⇒ Sa ⇒ aa

Exemplo de gramática não-ambígua para L(G): Exemplo de gramática não-ambígua para L(G):
S → aS | a (além de não-ambígua, é regular)

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 194 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 194 / 471
Linguagens Livres de Contexto – Gramática Livre de Contexto Linguagens Livres de Contexto – Gramática Livre de Contexto

Ambiguidade – Exemplo #1 Ambiguidade – Exemplo #1


Assuma a seguinte GLC G: Assuma a seguinte GLC G:
S → aSb | aSbb | λ S → aSb | aSbb | λ

Pergunta-se: Essa GLC é ambígua? Pergunta-se: Essa GLC é ambígua?


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

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 195 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 195 / 471

Linguagens Livres de Contexto – Gramática Livre de Contexto Linguagens Livres de Contexto – Gramática Livre de Contexto

Ambiguidade – Exemplo #1 Ambiguidade – Exemplo #2


Assuma a seguinte GLC G: Assuma a seguinte GLC G usada reconhecer expressões
S → aSb | aSbb | λ aritméticas em um analisador sintático
E → E + E | E ∗ E | (E) | id
Pergunta-se: Essa GLC é ambígua?
Sim. Assuma w = aabbb, logo: Pergunta-se: Essa GLC é ambígua?

S ⇒ aSb ⇒ aaSbbb ⇒ aabbb


S ⇒ aSbb ⇒ aaSbbb ⇒ aabbb

Gramática equivalentemente não ambígua:


S → aSb | A | λ
A → aAbb | abb
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 195 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 196 / 471
Linguagens Livres de Contexto – Gramática Livre de Contexto Linguagens Livres de Contexto – Gramática Livre de Contexto

Ambiguidade – Exemplo #2 Ambiguidade – Exemplo #2 – Árvores de Derivação


Assuma a seguinte GLC G usada reconhecer expressões GLC: E → E + E | E ∗ E | (E) | id
aritméticas em um analisador sintático
Derivações:
E → E + E | E ∗ E | (E) | id
E ⇒ E + E ⇒ id + E ⇒ id + E ∗ E ⇒ id + id ∗ E ⇒ id + id ∗ id

Pergunta-se: Essa GLC é ambígua? E ⇒ E ∗ E ⇒ E + E ∗ E ⇒ id + E ∗ E ⇒ id + id ∗ E ⇒ id + id ∗ id

Sim. Assuma w = id + id ∗ id, logo: E E

E ⇒ E + E ⇒ id + E ⇒ id + E ∗ E ⇒ id + id ∗ E ⇒ id + id ∗ id
E + E E ∗ E
E ⇒ E ∗ E ⇒ E + E ∗ E ⇒ id + E ∗ E ⇒ id + id ∗ E ⇒ id + id ∗ id

id E ∗ E E + E id

id id id id

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 196 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 197 / 471

Linguagens Livres de Contexto – Gramática Livre de Contexto Linguagens Livres de Contexto – Gramática Livre de Contexto

Ambiguidade – Exemplo #2 – Gramática equivalentemente não Ambiguidade – Indecibilidade


ambígua O problema de determinar se uma GLC arbitrária é
Deve definir a prioridade de operadores: ambígua é indecidível
E →E +T |T Portanto, isso significa que ...
T →T ∗F |F
F → (E) | id

É possível duas derivações mais à esquerda para


id + id ∗ id?

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 198 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 199 / 471
Linguagens Livres de Contexto – Gramática Livre de Contexto Linguagens Livres de Contexto – Gramática Livre de Contexto

Para refletir! Para refletir!


Seja a seguinte GLC que gere {λ} ∪ {ab}{ab}∗ {a}∗ : Seja a seguinte GLC que gere {λ} ∪ {ab}{ab}∗ {a}∗ :
S → abSA | λ S → abSA | λ
A → Aa | λ A → Aa | λ

Pergunta-se: Essa GLC é ambígua? Pergunta-se: Essa GLC é ambígua?


Sim

Pergunta-se: Essa GLC gera uma LLC? Pergunta-se: Essa GLC gera uma LLC?

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 200 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 200 / 471

Linguagens Livres de Contexto – Gramática Livre de Contexto Linguagens Livres de Contexto – Gramática Livre de Contexto

Para refletir! Ambiguidade – Gramáticas Inerentemente ambíguas


Seja a seguinte GLC que gere {λ} ∪ {ab}{ab}∗ {a}∗ : Maioria das LLC podem ser geradas por uma GLC não
S → abSA | λ ambígua

A → Aa | λ No entanto...
Nem toda LLC pode ser gerada por uma GLC não ambígua
Pergunta-se: Essa GLC é ambígua?
Tais LLC são inerentemente ambíguas
Sim

Pergunta-se: Essa GLC gera uma LLC?


Então, ela gera, de fato, uma LR. No entanto, LR ⊂ LLC

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 200 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 201 / 471
Linguagens Livres de Contexto – Gramática Livre de Contexto Linguagens Livres de Contexto – Gramática Livre de Contexto

Ambiguidade – Gramáticas Inerentemente ambíguas Ambiguidade – Gramáticas Inerentemente ambíguas


Exemplo clássico: Exemplo clássico:
n m m n n n m m
L= {a b c d ou a b c d | m ≥ 1 e n ≥ 1} 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 Crie uma GLC para L
Mostre a derivação de, e.g., aabbccdd Mostre a derivação de, e.g., aabbccdd

G(L):
S → aNd | aXbcYd
N → aNd | bMc
M → bMc | λ
X → aXb | λ
Y → cYd | λ

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 202 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 202 / 471

Linguagens Livres de Contexto – Gramática Livre de Contexto

Notação Backus-Nahur Form (BNF)


Proposta em ∼1960
Linguagens Livres de Contexto Notação normalmente utilizada para definir GLCs de LPs

Notação BNF:
Gramática Livre de Contexto
“→” é substituído por “::=” (ou apenas “:”)

Backus-Nahur Form (BNF) 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

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 203 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 204 / 471
Linguagens Livres de Contexto – Gramática Livre de Contexto Linguagens Livres de Contexto – Gramática Livre de Contexto

BNF de Java BNF de DCL (não apenas LP)


The Java Language Specification (http://java.sun.com/docs/books/jls/) 1 S ::= ModDecl | DCDecl

Fragmento de exemplo: 3 ModDecl ::= module ModId : ModDef { , ModDef} ( ModDecl | DCDecl )
IfThenStatement:
if ( Expression ) Statement 5 ModDef ::= ClassName | ClassName+ | Pkg* | Pkg** | RegExpr

7 DCDecl ::=
IfThenElseStatement: only RefMod can-Type { , can-Type} RefMod [ DCDecl ] |
if ( Expression ) StatementNoShortIf else Statement 9 RefMod cannot-Type {, cannot-Type} RefMod [DCDecl] |
RefMod can-Type-only {, can-Type-only} RefMod [DCDecl] |
BasicForStatement: 11 RefMod must-MustType { , must-MustType } RefMod [ DCDecl ]
for ( [ForInit] ; [Expression] ; [ForUpdate] ) Statement
13 RefMod ::= ( ModDef | ModId ) { , RefMod}

15 MustType ::= extend | implement | derive | throw | useannotation

17 Type ::= access | declare | handle | create | depend | MustType

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 205 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 206 / 471

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
Linguagens Livres de Contexto Isso facilita a construção das gramáticas
Embora dificulte a construção de analisadores sintáticos
Formas Normais
Formas Normais (FN)
Impõem restrições no lado direito das regras de uma GLC
Mas não reduzem o poder de expressão de GLC
Geradas automaticamente (via algoritmo)
Serão abordadas:
FN de Chomsky
FN de Greibach

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 207 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 208 / 471
Linguagens Livres de Contexto – Formas Normais Linguagens Livres de Contexto – Formas Normais

FN de Chomsky FN de Chomsky
Uma GLC G = (V , Σ, P, S) está na FN de Chomsky se suas Uma GLC G = (V , Σ, P, S) está na FN de Chomsky se suas
regras têm uma das seguintes formas: regras têm uma das seguintes formas:
A → BC onde B, C ∈ V − {S} A → BC onde B, C ∈ V − {S}
A→a onde a ∈ Σ A→a onde a ∈ Σ
S→λ S→λ

Propriedade: árvores de derivação são sempre binárias Propriedade: árvores de derivação são sempre binárias

Não é complexo converter uma GLC para a FN de Não é complexo converter uma GLC para a FN de
Chomsky quando a mesma: Chomsky quando a mesma:
Símbolo inicial não é recursivo (S 6→ αSβ) Símbolo inicial não é recursivo (S 6→ αSβ) ?
É essencialmente não-contrátil (só S → λ) É essencialmente não-contrátil (só S → λ) ?
Não possui regras de cadeia (A 6→ B) Não possui regras de cadeia (A 6→ B) ?
Não possui símbolos inúteis (∀B | B ⇒ Σ+ e S ⇒∗ αBβ) Não possui símbolos inúteis (∀B | B ⇒ Σ+ e S ⇒∗ αBβ) ?

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 209 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 209 / 471

Linguagens Livres de Contexto – Formas Normais Linguagens Livres de Contexto – Formas Normais

Forma normal não é minimização! (Parte 1) Forma normal não é minimização! (Parte 1 ainda)
Assuma a GLC clássica: Sem regras de cadeia: (A 6→ B)

S 0 → aSb | ab | λ
S → aSb | λ
S → aSb | ab
Símbolo inicial não recursivo: (S 6→ αSβ)

S0 → S Sem símbolos inúteis (que não geram terminais): (∀B | B ⇒ Σ+ )

Todos geram terminais!


S → aSb | λ
Sem símbolos inúteis (que não são alcançáveis): (∀B | S ⇒ αBβ)
Essencialmente não-contrátil: (só S → λ)
Todos são alcançáveis!
S0 → S | λ
S → aSb | ab Forma Normal de Chomsky (FNC):
S 0 → AX | AB | λ
Sem regras de cadeia: (A 6→ B)
X → SB
S 0 → aSb | ab | λ
S → AX | AB
S → aSb | ab
A→a
B→b
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 210 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 211 / 471
Linguagens Livres de Contexto – Formas Normais Linguagens Livres de Contexto – Formas Normais

FN de Greibach Forma normal não é minimização! (Parte 2)


Uma GLC G = (V , Σ, P, S) está na FN de Greibach se suas Forma Normal de Chomsky (FNC):
regras têm uma das seguintes formas: S 0 → AX | AB | λ
A → aA1 A2 A3 . . . An onde a ∈ Σ e A1..n ∈ V − {S} X → SB
A→a S → AX | AB
S→λ A→a
B→b
1o passo:
Transformar GLC para FN de Chomsky Forma Normal de Greibach (FNG):
S 0 → aX | aB | λ
2o passo:
X → aXB | aBB
Em um futuro próximo...
S → aX | aB
B→b

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 212 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 213 / 471

Linguagens Livres de Contexto – Formas Normais

Forma normal não é minimização! (Parte 2)


Forma Normal de Chomsky (FNC):
S 0 → AX | AB | λ
X → SB Linguagens Livres de Contexto
S → AX | AB
A→a
Transformações de Gramática
B→b

Forma Normal de Greibach (FNG):


S 0 → aX | aB | λ
X → aXB | aBB
S → aX | aB (inalcançável?)
B→b

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 213 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 214 / 471
Linguagens Livres de Contexto – Transformações de Gramática

Transformações de Gramática
Para alcançar uma FN, é importante que transformações
sejam realizadas na GLC Linguagens Livres de Contexto
As quais adicionam, modificam ou eliminam regras
Transformações de Gramática
Veremos uma série de transformações em GLC:
Remoção de recursividade no símbolo inicial (S 6→ αSβ)
Remoção de recursividade no símbolo inicial
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β)

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 215 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 216 / 471

Linguagens Livres de Contexto – Transformações de Gramática Linguagens Livres de Contexto – Transformações de Gramática

Remoção de recursividade no símbolo inicial Remoção de recursividade no símbolo inicial


Símbolo inicial (S) deve se limitar a iniciar derivações (V , Σ, P, S) =⇒ (V ∪ {S 0 }, Σ, P ∪ {S 0 → S}, S 0 )
i.e., S não deve ser uma variável recursiva
Exemplo
Não deve ser possível ter S ⇒∗ αSβ
S → aS | AB | AC
A → aA | λ
Assuma uma GLC G = (V , Σ, P, S) onde S é recursivo, logo: B → bB | bS
C → cC | λ
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

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 217 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 218 / 471
Linguagens Livres de Contexto – Transformações de Gramática Linguagens Livres de Contexto – Transformações de Gramática

Remoção de recursividade no símbolo inicial Exercício de Fixação


(V , Σ, P, S) =⇒ (V ∪ {S 0 }, Σ, P ∪ {S 0 → S}, S 0 ) G : S → bB | AB | bcC
A → aA | a
Exemplo
B → bB | abc | bA | b
S → aS | AB | AC
A → aA | λ C → cS | c
B → bB | bS D → cD | bDc | d
C → cC | λ

S0 → S
S → aS | AB | AC
A → aA | λ
B → bB | bS
C → cC | λ

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 218 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 219 / 471

Linguagens Livres de Contexto – Transformações de Gramática

Eliminação de regras λ
Variável anulável: V que pode derivar λ
Linguagens Livres de Contexto Se A é anulável, então: A ⇒∗ λ

Gramática não-contrátil:
Transformações de Gramática Não possui variáveis anuláveis, i.e., ¬∃A ∈ V (A → λ)
Assim, não diminuem tamanho forma sentencial, i.e., |µ| ≤ |ν|
Eliminação de regras λ
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 | λ
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 220 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 221 / 471
Linguagens Livres de Contexto – Transformações de Gramática Linguagens Livres de Contexto – Transformações de Gramática

Eliminação de regras λ Eliminação de regras λ


Variável anulável: V que pode derivar λ Variável anulável: V que pode derivar λ

Se A é anulável, então: A ⇒ λ Se A é anulável, então: A ⇒∗ λ

Gramática não-contrátil: Gramática não-contrátil:


Não possui variáveis anuláveis, i.e., ¬∃A ∈ V (A → λ) Não possui variáveis anuláveis, i.e., ¬∃A ∈ V (A → λ)
Assim, não diminuem tamanho forma sentencial, i.e., |µ| ≤ |ν| Assim, não diminuem tamanho forma sentencial, i.e., |µ| ≤ |ν|

Gramática essencialmente não-contrátil: Gramática essencialmente não-contrátil:


Gramática não-contrátil, mas admite uma regra λ: S → λ Gramática não-contrátil, mas admite uma regra λ: S → λ
Todas as derivações são não-contráteis, exceto S ⇒ λ Todas as derivações são não-contráteis, exceto S ⇒ λ

Exemplo: Exemplo:
S → aAb S → aAb
A → aA | B Variáveis anuláveis? A → aA | B Variáveis anuláveis? B e A
B → bB | λ B → bB | λ
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 221 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 221 / 471

Linguagens Livres de Contexto – Transformações de Gramática Linguagens Livres de Contexto – Transformações de Gramática

Algoritmo NULLABLE (estratégia bottom-up) Exemplo


Entrada: Uma GLC G = (V , Σ, P, S) S → ACA NULL = {A | {A → λ} ∈ P}
repita
PREV = NULL
Saída: Conjunto de variáveis anuláveis (NULLABLE) A → aAa | B | C para cada A ∈ V faça
se A → w e w ∈ PREV ∗ faça
B → bB | b NULL = NULL ∪ {A}
NULL = {A | {A → λ} ∈ P} até NULL == PREV
repita C → cC | λ
PREV = NULL
para cada A ∈ V faça
NULLABLE
se A → w e w ∈ PREV ∗ faça
NULL = NULL ∪ {A} NULL PREV
até NULL == PREV

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 222 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 223 / 471
Linguagens Livres de Contexto – Transformações de Gramática Linguagens Livres de Contexto – Transformações de Gramática

Exemplo Exemplo
S → ACA NULL = {A | {A → λ} ∈ P}
repita
S → ACA NULL = {A | {A → λ} ∈ P}
repita
PREV = NULL PREV = NULL
A → aAa | B | C para cada A ∈ V faça A → aAa | B | C para cada A ∈ V faça
se A → w e w ∈ PREV ∗ faça se A → w e w ∈ PREV ∗ faça
B → bB | b NULL = NULL ∪ {A} B → bB | b NULL = NULL ∪ {A}
até NULL == PREV até NULL == PREV
C → cC | λ C → cC | λ

NULLABLE NULLABLE
NULL PREV NULL PREV
(0) {C} ∅ (0) {C} ∅
(1) {C, A} {C}

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 223 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 223 / 471

Linguagens Livres de Contexto – Transformações de Gramática Linguagens Livres de Contexto – Transformações de Gramática

Exemplo Exemplo
S → ACA NULL = {A | {A → λ} ∈ P}
repita
S → ACA NULL = {A | {A → λ} ∈ P}
repita
PREV = NULL PREV = NULL
A → aAa | B | C para cada A ∈ V faça A → aAa | B | C para cada A ∈ V faça
se A → w e w ∈ PREV ∗ faça se A → w e w ∈ PREV ∗ faça
B → bB | b NULL = NULL ∪ {A} B → bB | b NULL = NULL ∪ {A}
até NULL == PREV até NULL == PREV
C → cC | λ C → cC | λ

NULLABLE NULLABLE
NULL PREV NULL PREV
(0) {C} ∅ (0) {C} ∅
(1) {C, A} {C} (1) {C, A} {C}
(2) {C, A, S} {C, A} (2) {C, A, S} {C, A}
(3) {C, A, S} {C, A, S}

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 223 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 223 / 471
Linguagens Livres de Contexto – Transformações de Gramática Linguagens Livres de Contexto – Transformações de Gramática

Técnica para eliminação de regras λ Exemplo #1


Calcular conjunto de variáveis anuláveis S → ACA
e eliminar regras que levam diretamente a λ A → aAa | B | C

Adicionar regras na gramática onde a ocorrência de B → bB | b


variáveis anuláveis é omitida, por exemplo: C → cC | λ
Assuma GLC com a seguinte regra: A → BABa ⇓ variáveis anuláveis:

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

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 224 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 225 / 471

Linguagens Livres de Contexto – Transformações de Gramática Linguagens Livres de Contexto – Transformações de Gramática

Exemplo #1 Exemplo #1
S → ACA S → ACA
A → aAa | B | C A → aAa | B | C
B → bB | b B → bB | b
C → cC | λ C → cC | λ
⇓ variáveis anuláveis: {S, A, C} ⇓ variáveis anuláveis: {S, A, C}

S → ACA | AC | AA | CA | A | C | λ
A → aAa | B | C | aa
B → bB | b
C → cC | c

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 225 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 225 / 471
Linguagens Livres de Contexto – Transformações de Gramática Linguagens Livres de Contexto – Transformações de Gramática

Exemplo #2 Exemplo #2
L(G) = a ∗ b∗ c ∗ L(G) = a ∗ b∗ c ∗

G : S → ABC G : S → ABC
A → aA | λ A → aA | λ
B → bB | λ B → bB | λ
C → cC | λ C → cC | λ
⇓ variáveis anuláveis: ⇓ variáveis anuláveis: {S, A, B, C}

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 226 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 226 / 471

Linguagens Livres de Contexto – Transformações de Gramática Linguagens Livres de Contexto – Transformações de Gramática

Exemplo #2 Exercício de Fixação


L(G) = a ∗ b∗ c ∗ 1 S → aBC | Ba
G : S → ABC A → aA | λ
A → aA | λ B → AC
B → bB | λ C → cA | b | A
C → cC | λ 2 S → aA | bAB
⇓ variáveis anuláveis: {S, A, B, C}
A → abC | λ
S → ABC | AB | BC | AC | A | B | C | λ B → Ac | AA
A → aA | a C → aBC | aB
B → bB | b
C → cC | c

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 226 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 227 / 471
Linguagens Livres de Contexto – Transformações de Gramática

Eliminação de regras de cadeia


Uma regra na forma A → B
Linguagens Livres de Contexto Não aumenta tamanho da forma sentencial

Não gera símbolos terminais


Transformações de Gramática
Apenas renomeia uma variável

Eliminação de regras de cadeia


Tais regras são chamadas regras de cadeia (chain rules)

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 228 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 229 / 471

Linguagens Livres de Contexto – Transformações de Gramática Linguagens Livres de Contexto – Transformações de Gramática

Eliminação de regras de cadeia – Exemplo Algoritmo CHAIN


Suponha a seguinte gramática: Entrada: Uma GLC essencialmente não contrátil G = (V , Σ, P, S) e
uma variável qualquer A ∈ V
A → aA | a | B
Saída: Conjunto de variáveis deriváveis a partir de A
B → bB | b | C aplicando-se apenas regras de cadeia

Eliminando a cadeia A → B: CHAIN(A) = {A}


A → aA | a | bB | b | C PREV = ∅
repita
B → bB | b | C NEW = CHAIN(A) − PREV
PREV = CHAIN(A)
Infelizmente, uma nova cadeia apareceu: A → C para cada B ∈ NEW faça
para cada B → C faça
Portanto, o procedimento deve ser reaplicado CHAIN(A) = CHAIN(A) ∪ {C}
até CHAIN(A) == PREV
Até não mais restarem cadeias

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 230 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 231 / 471
Linguagens Livres de Contexto – Transformações de Gramática Linguagens Livres de Contexto – Transformações de Gramática

Exemplo Exemplo
S → ACA | CA | AA | AC | A | C | λ S → ACA | CA | AA | AC | A | C | λ
A → aAa | aa | B | C A → aAa | aa | B | C
B → bB | b B → bB | b
C → cC | c C → cC | c

CHAIN(S) CHAIN(S)
CHAIN(S) PREV NEW CHAIN(S) PREV NEW
(0) {S} ∅ (0) {S} ∅ {S}
(1) (1)

(2) (2)

(3) (3)

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 232 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 232 / 471

Linguagens Livres de Contexto – Transformações de Gramática Linguagens Livres de Contexto – Transformações de Gramática

Exemplo Exemplo
S → ACA | CA | AA | AC | A | C | λ S → ACA | CA | AA | AC | A | C | λ
A → aAa | aa | B | C A → aAa | aa | B | C
B → bB | b B → bB | b
C → cC | c C → cC | c

CHAIN(S) CHAIN(S)
CHAIN(S) PREV NEW CHAIN(S) PREV NEW
(0) {S} ∅ {S} (0) {S} ∅ {S}
(1) {S, A, C} {S} (1) {S, A, C} {S} {A, C}
(2) (2)

(3) (3)

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 232 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 232 / 471
Linguagens Livres de Contexto – Transformações de Gramática Linguagens Livres de Contexto – Transformações de Gramática

Exemplo Exemplo
S → ACA | CA | AA | AC | A | C | λ S → ACA | CA | AA | AC | A | C | λ
A → aAa | aa | B | C A → aAa | aa | B | C
B → bB | b B → bB | b
C → cC | c C → cC | c

CHAIN(S) CHAIN(S)
CHAIN(S) PREV NEW CHAIN(S) PREV NEW
(0) {S} ∅ {S} (0) {S} ∅ {S}
(1) {S, A, C} {S} {A, C} (1) {S, A, C} {S} {A, C}
(2) {S, A, C, B} {S, A, C} (2) {S, A, C, B} {S, A, C} {B}
(3) (3)

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 232 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 232 / 471

Linguagens Livres de Contexto – Transformações de Gramática Linguagens Livres de Contexto – Transformações de Gramática

Exemplo Exemplo
S → ACA | CA | AA | AC | A | C | λ S → ACA | CA | AA | AC | A | C | λ
A → aAa | aa | B | C A → aAa | aa | B | C
B → bB | b B → bB | b
C → cC | c C → cC | c

CHAIN(S) CHAIN(S)
CHAIN(S) PREV NEW CHAIN(S) PREV NEW
(0) {S} ∅ {S} (0) {S} ∅ {S}
(1) {S, A, C} {S} {A, C} (1) {S, A, C} {S} {A, C}
(2) {S, A, C, B} {S, A, C} {B} (2) {S, A, C, B} {S, A, C} {B}
(3) {S, A, C, B} {S, A, C, B} (3) {S, A, C, B} {S, A, C, B} –

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 232 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 232 / 471
Linguagens Livres de Contexto – Transformações de Gramática Linguagens Livres de Contexto – Transformações de Gramática

Gramática Original Gramática Original


S → ACA | CA | AA | AC | A | C | λ S → ACA | CA | AA | AC | A | C | λ CHAIN(S) = {S, A, B, C}
CHAIN(A) = {A, B, C}
A → aAa | aa | B | C A → aAa | aa | B | C
CHAIN(B) = {B}
B → bB | b B → bB | b CHAIN(C) = {C}

C → cC | c C → cC | c

Novas Regras
Resultado do algoritmo aplicado em todas as variáveis
A→w onde B → w ∈ P, w 6∈ V e B ∈ CHAIN(A)
CHAIN(S) = {S, A, C, B}

CHAIN(A) = {A, B, C}

CHAIN(B) = {B}

CHAIN(C) = {C}

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 233 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 234 / 471

Linguagens Livres de Contexto – Transformações de Gramática Linguagens Livres de Contexto – Transformações de Gramática

Gramática Original Gramática Original


S → ACA | CA | AA | AC | A | C | λ CHAIN(S) = {S, A, B, C} S → ACA | CA | AA | AC | A | C | λ CHAIN(S) = {S, A, B, C}
CHAIN(A) = {A, B, C} CHAIN(A) = {A, B, C}
A → aAa | aa | B | C A → aAa | aa | B | C
CHAIN(B) = {B} CHAIN(B) = {B}
B → bB | b CHAIN(C) = {C} B → bB | b CHAIN(C) = {C}
C → cC | c C → cC | c

Novas Regras Novas Regras


A→w onde B → w ∈ P, w 6∈ V e B ∈ CHAIN(A) A→w onde B → w ∈ P, w 6∈ V e B ∈ CHAIN(A)

Nova Gramática sem Regras de Cadeia Nova Gramática sem Regras de Cadeia
S → ACA | CA | AA | AC | λ S → ACA | CA | AA | AC | λ | aAa | aa
A → aAa | aa A → aAa | aa
B → bB | b B → bB | b
C → cC | c C → cC | c
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 234 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 234 / 471
Linguagens Livres de Contexto – Transformações de Gramática Linguagens Livres de Contexto – Transformações de Gramática

Gramática Original Gramática Original


S → ACA | CA | AA | AC | A | C | λ CHAIN(S) = {S, A, B, C} S → ACA | CA | AA | AC | A | C | λ CHAIN(S) = {S, A, B, C}
CHAIN(A) = {A, B, C} CHAIN(A) = {A, B, C}
A → aAa | aa | B | C A → aAa | aa | B | C
CHAIN(B) = {B} CHAIN(B) = {B}
B → bB | b CHAIN(C) = {C} B → bB | b CHAIN(C) = {C}
C → cC | c C → cC | c

Novas Regras Novas Regras


A→w onde B → w ∈ P, w 6∈ V e B ∈ CHAIN(A) A→w onde B → w ∈ P, w 6∈ V e B ∈ CHAIN(A)

Nova Gramática sem Regras de Cadeia Nova Gramática sem Regras de Cadeia
S → ACA | CA | AA | AC | λ | aAa | aa | bB | b S → ACA | CA | AA | AC | λ | aAa | aa | bB | b | cC | c
A → aAa | aa A → aAa | aa
B → bB | b B → bB | b
C → cC | c C → cC | c
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 234 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 234 / 471

Linguagens Livres de Contexto – Transformações de Gramática Linguagens Livres de Contexto – Transformações de Gramática

Gramática Original Gramática Original


S → ACA | CA | AA | AC | A | C | λ CHAIN(S) = {S, A, B, C} S → ACA | CA | AA | AC | A | C | λ CHAIN(S) = {S, A, B, C}
CHAIN(A) = {A, B, C} CHAIN(A) = {A, B, C}
A → aAa | aa | B | C A → aAa | aa | B | C
CHAIN(B) = {B} CHAIN(B) = {B}
B → bB | b CHAIN(C) = {C} B → bB | b CHAIN(C) = {C}
C → cC | c C → cC | c

Novas Regras Novas Regras


A→w onde B → w ∈ P, w 6∈ V e B ∈ CHAIN(A) A→w onde B → w ∈ P, w 6∈ V e B ∈ CHAIN(A)

Nova Gramática sem Regras de Cadeia Nova Gramática sem Regras de Cadeia
S → ACA | CA | AA | AC | λ | aAa | aa | bB | b | cC | c S → ACA | CA | AA | AC | λ | aAa | aa | bB | b | cC | c
A → aAa | aa | bB | b A → aAa | aa | bB | b | cC | c
B → bB | b B → bB | b
C → cC | c C → cC | c
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 234 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 234 / 471
Linguagens Livres de Contexto – Transformações de Gramática Linguagens Livres de Contexto – Transformações de Gramática

Resumo Exercício de Fixação


GLCs essencialmente não-contráteis e sem regras de G : S → aS | b | A
cadeia tem uma das seguintes formas:
A → aA | a | C
S→λ
B→a|b
A→a
C→c|B
A→w onde w ∈ (V ∪ Σ)∗ e |w| ≥ 2
D → dD | B

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 235 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 236 / 471

Linguagens Livres de Contexto – Transformações de Gramática

Remoção de símbolos inúteis


Variável inútil
Linguagens Livres de Contexto não aparece em derivações que geram palavras

não contribui para geração de palavras


Transformações de Gramática

Remoção de símbolos inúteis

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 237 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 238 / 471
Linguagens Livres de Contexto – Transformações de Gramática Linguagens Livres de Contexto – Transformações de Gramática

Exemplo (Qual é a L(G)?) Algoritmo TERM


S → AC | BS | B D → aD | BD | C Entrada: Uma GLC G = (V , Σ, P, S)
A → aA | aF E → aA | BSA Saída: Conjunto de variáveis que geram terminais (TERM)
B → CF | b F → bB | b
TERM = {A | e x i s t e uma regra A → w ∈ P , com w ∈ Σ∗ }
C → cC | D repita
PREV = TERM
para cada A ∈ V faça
Símbolos Inúteis se A → w ∈ P e w ∈ (PREV ∪ Σ)∗ então
Um símbolo x ∈ (V ∪ Σ) é útil se: TERM = TERM ∪ A
até PREV == TERM
S ⇒∗ uxv ⇒∗ w, onde u, v ∈ (V ∪ Σ)∗ e w ∈ Σ∗

Um terminal é útil quando ocorre em uma palavra w ∈ L(G)

Uma variável A é útil se existe: S ⇒∗ uAv ⇒∗ w, w ∈ L(G)

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 239 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 240 / 471

Linguagens Livres de Contexto – Transformações de Gramática Linguagens Livres de Contexto – Transformações de Gramática

Exemplo Exemplo
S → AC | BS | B D → aD | BD | C S → AC | BS | B D → aD | BD | C
A → aA | aF E → aA | BSA A → aA | aF E → aA | BSA
B → CF | b F → bB | b B → CF | b F → bB | b
C → cC | D C → cC | D

TERM TERM
TERM PREV TERM PREV
(0) {B, F} ∅

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 241 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 241 / 471
Linguagens Livres de Contexto – Transformações de Gramática Linguagens Livres de Contexto – Transformações de Gramática

Exemplo Exemplo
S → AC | BS | B D → aD | BD | C S → AC | BS | B D → aD | BD | C
A → aA | aF E → aA | BSA A → aA | aF E → aA | BSA
B → CF | b F → bB | b B → CF | b F → bB | b
C → cC | D C → cC | D

TERM TERM
TERM PREV TERM PREV
(0) {B, F} ∅ (0) {B, F} ∅
(1) {B, F, A, S} {B, F} (1) {B, F, A, S} {B, F}
(2) {B, F, A, S, E} {B, F, A, S}

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 241 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 241 / 471

Linguagens Livres de Contexto – Transformações de Gramática Linguagens Livres de Contexto – Transformações de Gramática

Exemplo Gramática Original


S → AC | BS | B D → aD | BD | C S → AC | BS | B D → aD | BD | C
A → aA | aF E → aA | BSA A → aA | aF E → aA | BSA
B → CF | b F → bB | b B → CF | b F → bB | b
C → cC | D 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}

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 241 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 242 / 471
Linguagens Livres de Contexto – Transformações de Gramática Linguagens Livres de Contexto – Transformações de Gramática

Gramática Original Gramática Original


S → AC | BS | B D → aD | BD | C S → AC | BS | B D → aD | BD | C
A → aA | aF E → aA | BSA A → aA | aF E → aA | BSA
B → CF | b F → bB | b B → CF | b F → bB | b
C → cC | D C → cC | D

Variáveis que não geram terminal Variáveis que não geram terminal
V − {B, F, A, S, E} = {C, D} 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

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 242 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 242 / 471

Linguagens Livres de Contexto – Transformações de Gramática Linguagens Livres de Contexto – Transformações de Gramática

Algoritmo REACH Exemplo


Entrada: Uma GLC G = (V , Σ, P, S) S → BS | B E → aA | BSA
Saída: Conjunto de variáveis alcançáveis a partir de S (REACH) A → aA | aF F → bB | b
B→b
REACH = {S}
PREV = ∅
repita REACH
NEW = REACH − PREV REACH PREV NEW
PREV = REACH
para cada A ∈ NEW faça (0) {S} ∅
para cada A → w faça (1)
adicione todas as v a r iáv e i s de w em REACH (2)
até REACH == PREV

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 243 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 244 / 471
Linguagens Livres de Contexto – Transformações de Gramática Linguagens Livres de Contexto – Transformações de Gramática

Exemplo Exemplo
S → BS | B E → aA | BSA S → BS | B E → aA | BSA
A → aA | aF F → bB | b A → aA | aF F → bB | b
B→b B→b

REACH REACH
REACH PREV NEW REACH PREV NEW
(0) {S} ∅ {S} (0) {S} ∅ {S}
(1) (1) {S, B} {S}
(2) (2)

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 244 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 244 / 471

Linguagens Livres de Contexto – Transformações de Gramática Linguagens Livres de Contexto – Transformações de Gramática

Exemplo Exemplo
S → BS | B E → aA | BSA S → BS | B E → aA | BSA
A → aA | aF F → bB | b A → aA | aF F → bB | b
B→b B→b

REACH REACH
REACH PREV NEW REACH PREV NEW
(0) {S} ∅ {S} (0) {S} ∅ {S}
(1) {S, B} {S} {B} (1) {S, B} {S} {B}
(2) (2) {S, B} {S, B}

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 244 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 244 / 471
Linguagens Livres de Contexto – Transformações de Gramática Linguagens Livres de Contexto – Transformações de Gramática

Exemplo Gramática Original


S → BS | B E → aA | BSA S → BS | B E → aA | BSA
A → aA | aF F → bB | b A → aA | aF F → bB | b
B→b B→b

REACH
REACH PREV NEW
(0) {S} ∅ {S}
(1) {S, B} {S} {B}
(2) {S, B} {S, B} –

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 244 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 245 / 471

Linguagens Livres de Contexto – Transformações de Gramática Linguagens Livres de Contexto – Transformações de Gramática

Gramática Original Gramática Original


S → BS | B E → aA | BSA S → BS | B E → aA | BSA
A → aA | aF F → bB | b A → aA | aF F → bB | b
B→b B→b

Variáveis inalcançáveis: Variáveis inalcançáveis:


V − {S, B} = {A, E, F} V − {S, B} = {A, E, F}

Nova Gramática sem variáveis inalcançáveis (Qual a L(G)?)


S → BS | B
B→b

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 245 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 245 / 471
Linguagens Livres de Contexto – Transformações de Gramática Linguagens Livres de Contexto – Transformações de Gramática

Exercício de Fixação (TERM e REACH) Para remoção de variáveis inúteis: TERM e REACH (nesta ordem)
G : S → aB | aA | bcC G : S → a | AB
A → aA | ABA A→b
B → aB
B → bB | b
TERM = {S, A}
C → cC | BEA
GT : S → a
D → aE | bEc | d
A→b
E → cD | cEb REACH = {S}

GR : S → a

Se algoritmos forem aplicados na ordem inversa, o


resultado seria incorreto!

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 246 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 247 / 471

Linguagens Livres de Contexto – Transformações de Gramática

Se fosse na ordem errada:


G : S → a | AB
A→b
B → aB Linguagens Livres de Contexto
REACH = {S, A, B}

GR : S → a | AB Forma Normal de Chomsky


A→b
B → aB
TERM = {S, A}

GT : S → a
A→b

Bem esquisito!

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 248 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 249 / 471
Linguagens Livres de Contexto – Forma Normal de Chomsky Linguagens Livres de Contexto – Forma Normal de Chomsky

FN de Chomsky Exemplo #1
Uma GLC G = (V , Σ, P, S) está na FN de Chomsky se suas A → bDcF
regras têm uma das seguintes formas:
FN de Chomsky:
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β)

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 250 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 251 / 471

Linguagens Livres de Contexto – Forma Normal de Chomsky Linguagens Livres de Contexto – Forma Normal de Chomsky

Exemplo #1 Exemplo #1
A → bDcF A → bDcF

FN de Chomsky: FN de Chomsky:
Primeira transformação: Primeira transformação:
A→ B 0 DC 0 F A → B 0 DC 0 F
B0 → b B0 → b
C0 → c C0 → c

Segunda transformação:
A → B 0 T1
B0 → b
C0 → c
T1 → DT2
T2 → C 0 F
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 251 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 251 / 471
Linguagens Livres de Contexto – Forma Normal de Chomsky Linguagens Livres de Contexto – Forma Normal de Chomsky

Exemplo #2 Exemplo #2
S → aABC | a S → aABC | a
A → aA | a A → aA | a
B → bcB | bc B → bcB | bc
C → cC | c C → cC | c

FN de Chomsky: FN de Chomsky:
Já satisfaz pré-condições:
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β)

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 252 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 253 / 471

Linguagens Livres de Contexto – Forma Normal de Chomsky Linguagens Livres de Contexto – Forma Normal de Chomsky

Exemplo #2 Exemplo #3
S → aABC | a S → aXb | ab
A → aA | a X → aXb | ab
B → bcB | bc
C → cC | c FN de Chomsky:

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

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 253 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 254 / 471
Linguagens Livres de Contexto – Forma Normal de Chomsky Linguagens Livres de Contexto – Forma Normal de Chomsky

Exemplo #3 Exercício de Fixação (apenas FNC, confira os demais antes)


S → aXb | ab G : S → aA | bC | λ
X → aXb | ab A → bAba | ba
C → cCAba | c
FN de Chomsky:
S → AT | AB
T → XB
X → AT | AB
A→a
B→b

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 254 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 255 / 471

Linguagens Livres de Contexto – Forma Normal de Chomsky

Exercício de Fixação (todos os passos para chegar à FNC)


G : S → aAb | bAa | B | aS
A → bB | λ
Linguagens Livres de Contexto
B → cBc | Ba | aB | D
C→a|b|c
Remoção de rec. à esquerda
D → aDC
E → BB | F
F → FEB

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 256 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 257 / 471
Linguagens Livres de Contexto – Remoção de rec. à esquerda Linguagens Livres de Contexto – Remoção de rec. à esquerda

Remoção de recursividade à esquerda Exemplo #1


Recursividade direta à esquerda pode produzir “loops A → Aa | b
infinitos” em analisadores sintáticos descendentes (top-down)
⇓ remoção de recursividade à esq.

Exemplo:
S → Aa
A → Aa | b
S ⇒ Aa ⇒ Aaa ⇒ Aaaa ⇒ . . .
Exemplo #2
Suponha a regra genérica diretamente recursiva à esq.: A → Aa | Ab | b | c
A → Aµ1 | Aµ2 | . . . | Aµm | ν1 | ν2 | . . . | νn
⇓ remoção de recursividade à esq.

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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 258 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 259 / 471

Linguagens Livres de Contexto – Remoção de rec. à esquerda Linguagens Livres de Contexto – Remoção de rec. à esquerda

Exemplo #1 Exemplo #1
A → Aa | b A → Aa | b

⇓ remoção de recursividade à esq. ⇓ remoção de recursividade à esq.

A → bZ | b A → bZ | b
Z → aZ | a

Exemplo #2 Exemplo #2
A → Aa | Ab | b | c A → Aa | Ab | b | c

⇓ remoção de recursividade à esq. ⇓ remoção de recursividade à esq.

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 259 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 259 / 471
Linguagens Livres de Contexto – Remoção de rec. à esquerda Linguagens Livres de Contexto – Remoção de rec. à esquerda

Exemplo #1 Exemplo #1
A → Aa | b A → Aa | b

⇓ remoção de recursividade à esq. ⇓ remoção de recursividade à esq.

A → bZ | b A → bZ | b
Z → aZ | a Z → aZ | a

Exemplo #2 Exemplo #2
A → Aa | Ab | b | c A → Aa | Ab | b | c

⇓ remoção de recursividade à esq. ⇓ remoção de recursividade à esq.

A → bZ | cZ | b | c A → bZ | cZ | b | c
Z → aZ | bZ | a | b

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 259 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 259 / 471

Linguagens Livres de Contexto – Remoção de rec. à esquerda Linguagens Livres de Contexto – Remoção de rec. à esquerda

Exemplo #3 Exemplo #3
A → AB | BA | a A → AB | BA | a

B→b|c B→b|c

⇓ remoção de recursividade à esq. ⇓ remoção de recursividade à esq.

A → BAZ | aZ | BA | a

B→b|c

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 260 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 260 / 471
Linguagens Livres de Contexto – Remoção de rec. à esquerda Linguagens Livres de Contexto – Remoção de rec. à esquerda

Exemplo #3 Exemplo #4
A → AB | BA | a A → Aa | Aab | bb | b – gera (b ∪ bb)(a ∪ ab)∗

B→b|c ⇓ remoção de recursividade à esq.

⇓ remoção de recursividade à esq.

A → BAZ | aZ | BA | a

Z → BZ | B

B→b|c

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 260 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 261 / 471

Linguagens Livres de Contexto – Remoção de rec. à esquerda Linguagens Livres de Contexto – Remoção de rec. à esquerda

Exemplo #4 Exemplo #4
A → Aa | Aab | bb | b – gera (b ∪ bb)(a ∪ ab)∗ A → Aa | Aab | bb | b – gera (b ∪ bb)(a ∪ ab)∗

⇓ remoção de recursividade à esq. ⇓ remoção de recursividade à esq.

A → bbZ | bZ | bb | b – gera (b ∪ bb)(Z ∪ λ) A → bbZ | bZ | bb | b – gera (b ∪ bb)(Z ∪ λ)


Z → aZ | abZ | a | ab – gera (a ∪ ab)+

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 261 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 261 / 471
Linguagens Livres de Contexto – Remoção de rec. à esquerda Linguagens Livres de Contexto – Remoção de rec. à esquerda

Exercício de Fixação Remoção de Recursão à Esquerda


G : A → aA | ABc | ccA Problema: recursão à esquerda indireta
A → Bu
B → Av

Recursão indireta também pode gerar “loops infinitos”

Solução: Forma Normal de Greibach

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 262 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 263 / 471

Linguagens Livres de Contexto – Remoção de rec. à esquerda

Observação Relevante
Removemos recursividade como a seguir:
G:
A → Aµ1 | Aµ2 | . . . | Aµm | ν1 | ν2 | . . . | νn Linguagens Livres de Contexto
G’ (sem rec. à esquerda):
A → ν1 | ν2 | . . . | νn | ν1 Z | ν2 Z | . . . | νn Z Forma Normal de Greibach
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 | λ
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 264 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 265 / 471
Linguagens Livres de Contexto – Forma Normal de Greibach Linguagens Livres de Contexto – Forma Normal de Greibach

FN de Greibach FN de Greibach
Uma GLC G = (V , Σ, P, S) está na FN de Greibach se suas 1o passo:
regras têm uma das seguintes formas: Transformar GLC para FN de Chomsky
A → aA1 A2 A3 . . . An onde a ∈ Σ e A1..n ∈ V − {S}] 2o passo:
A→a Ordenar variáveis (i.e., cada variável ganha um número)
S→λ S = 1, A = 2, B = 3, . . .
Resolver, em ordem, as recursões
recursões diretas e indiretas

3o passo: regras das seguintes formas


S→λ
A → aw
A → Bw onde w ∈ V ∗ e num(B) > num(A)

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 266 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 267 / 471

Linguagens Livres de Contexto – Forma Normal de Greibach Linguagens Livres de Contexto – Forma Normal de Greibach

Exemplo FN de Greibach[1] (S = 1; A = 2; B = 3; C = 4)

S → AB | λ Eliminando recursão à esquerda em A:


A → AB | CB | a S → AB | λ – ok, A > S
B → AB | b A → CBR 1 | aR 1 | CB | a Aantes → AB | CB | a – ok, C > A
C → AC | c B → AB | b – não ok
C → AC | c – não ok
R 1 → BR 1 | B

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 268 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 269 / 471
Linguagens Livres de Contexto – Forma Normal de Greibach Linguagens Livres de Contexto – Forma Normal de Greibach

FN de Greibach[2] (S = 1; A = 2; B = 3; C = 4) FN de Greibach[3] (S = 1; A = 2; B = 3; C = 4)

Movendo lado direito de A para regra B → AB Movendo lado direito de A para regra C → AC
S → AB | λ S → AB | λ
A → CBR1 | aR1 | CB | a A → CBR1 | aR1 | CB | a
B → CBR 1 B | aR 1 B | CBB | aB | b Bantes → AB | b – ok, C > B B → CBR 1 B | aR 1 B | CBB | aB | b
C → AC | c – não ok C → CBR 1 C | aR 1 C | CBC | aC | c Cantes → AC | c – rec. esq.
R1 → BR1 | B R1 → BR1 | B

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 270 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 271 / 471

Linguagens Livres de Contexto – Forma Normal de Greibach Linguagens Livres de Contexto – Forma Normal de Greibach

FN de Greibach[4] (S = 1; A = 2; B = 3; C = 4) FN de Greibach[5] (S = 1; A = 2; B = 3; C = 4)

Eliminando recursão à esquerda em C: Movendo regra C para lado direito de B:


S → AB | λ – ok 3o passo S → AB | λ
A → CBR1 | aR1 | CB | a
A → CBR1 | aR1 | CB | a – ok 3o passo
B → aR1 B | aB | b | Bantes → CBR1 B | aR1 B | CBB | aB | b
B → CBR1 B | aR1 B | CBB | aB | b – ok 3o passo
aR 1 CBR1 B | aCBR1 B | cBR1 B | aR 1 CR 2 BR1 B | aCR 2 BR1 B | cR 2 BR1 B |
C → aR1 C | aC | c | aR1 CR 2 | aCR 2 | cR 2 – ok 3o passo
aR 1 CBB | aCBB | cBB | aR 1 CR 2 BB | aCR 2 BB | cR 2 BB
Cantes → CBR1 C | aR1 C | CBC | aC | c
C → aR1 C | aC | c | aR1 CR2 | aCR2 | cR2
R1 → BR1 | B R1 → BR1 | B
R 2 → BR1 CR 2 | BCR 2 | BR1 C | BC R2 → BR1 CR2 | BCR2 | BR1 C | BC

PS PS
C já está na FN de Greibach B agora também está na FN de Greibach
Mas e B? Repetir o procedimento para A, S, R1 e R2 (nesta ordem)

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 272 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 273 / 471
Linguagens Livres de Contexto – Forma Normal de Greibach Linguagens Livres de Contexto – Forma Normal de Greibach

FN de Greibach[6] (S = 1; A = 2; B = 3; C = 4) FN de Greibach[7] (S = 1; A = 2; B = 3; C = 4)

Movendo regra C para lado direito de A: Movendo regra A para lado direito de S: Santes → AB | λ
S → AB | λ Aantes → CBR1 | aR1 | CB | a S → aR 1 CBR 1 B | aCBR 1 B | cBR 1 B | aR 1 CR 2 BR 1 B | aCR 2 BR 1 B | cR 2 BR 1 B |
A → aR 1 CBR1 | aCBR1 | cBR1 | aR 1 CR 2 BR1 | aCR 2 BR1 | cR 2 BR1 | aR 1 B | aR 1 CBB | aCBB | cBB | aR 1 CR 2 BB | aCR 2 BB | cR 2 BB | aB | λ
aR1 | aR 1 CB | aCB | cB | aR 1 CR 2 B | aCR 2 B | cR 2 B | a A → aR1 CBR1 | aCBR1 | cBR1 | aR1 CR2 BR1 | aCR2 BR1 | cR2 BR1 |
B → aR1 B | aB | b | aR1 | aR1 CB | aCB | cB | aR1 CR2 B | aCR2 B | cR2 B | a
aR1 CBR1 B | aCBR1 B | cBR1 B | aR1 CR2 BR1 B | aCR2 BR1 B | cR2 BR1 B | B → aR1 B | aB | b |
aR1 CBB | aCBB | cBB | aR1 CR2 BB | aCR2 BB | cR2 BB aR1 CBR1 B | aCBR1 B | cBR1 B | aR1 CR2 BR1 B | aCR2 BR1 B | cR2 BR1 B |
C → aR1 C | aC | c | aR1 CR2 | aCR2 | cR2 aR1 CBB | aCBB | cBB | aR1 CR2 BB | aCR2 BB | cR2 BB
R1 → BR1 | B C → aR1 C | aC | c | aR1 CR2 | aCR2 | cR2
R2 → BR1 CR2 | BCR2 | BR1 C | BC R1 → BR1 | B
R2 → BR1 CR2 | BCR2 | BR1 C | BC

PS
PS
A agora também está na FN de Greibach
S agora também está na FN de Greibach
Repetir o procedimento para S, R1 e R2 (nesta ordem)
Repetir o procedimento para R1 e R2 (nesta ordem)
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 274 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 275 / 471

Linguagens Livres de Contexto – Forma Normal de Greibach Linguagens Livres de Contexto – Forma Normal de Greibach

FN de Greibach[8] (S = 1; A = 2; B = 3; C = 4) FN de Greibach[9] (S = 1; A = 2; B = 3; C = 4)

Movendo regra B para lado direito de R2 :


Movendo regra B para lado direito de R1 :
S → aR1 CBR1 B | aCBR1 B | cBR1 B | aR1 CR2 BR1 B | aCR2 BR1 B | cR2 BR1 B | S → | aCCBR1 B | cCBR1 B | aR1 CR2 CBR1 B | aCR2 CBR1 B | cR2 CBR1 B |
aR1 CCBR1 B
| aR1 CBB | aCBB | cBB | aR1 CR2 BB | aCR2 BB | cR2 BB | aB | λ
aR1 B
aR1 B | aR1 CBB | aCBB | cBB | aR1 CR2 BB | aCR2 BB | cR2 BB | aB | λ A → aR1 CCBR1 | aCCBR1 | cCBR1 | aR1 CR2 CBR1 | aCR2 CBR1 | cR2 CBR1 |
A → aR1 CCBR1 | aCCBR1 | cCBR1 | aR1 CR2 CBR1 | aCR2 CBR1 | cR2 CBR1 | aR1 | aR1 CB | aCB | cB | aR1 CR2 B | aCR2 B | cR2 B | a
B → aR1 B | aB | b |
aR1 | aR1 CB | aCB | cB | aR1 CR2 B | aCR2 B | cR2 B | a
aR1 CBR1 B | aCBR1 B | cBR1 B | aR1 CR2 BR1 B | aCR2 BR1 B | cR2 BR1 B |
B → aR1 B | aB | b | aR1 CBB | aCBB | cBB | aR1 CR2 BB | aCR2 BB | cR2 BB

aR1 CBR1 B | aCBR1 B | cBR1 B | aR1 CR2 BR1 B | aCR2 BR1 B | cR2 BR1 B | C → aR1 C | aC | c | aR1 CR2 | aCR2 | cR2
R1 → aR1 BR1 | aBR1 | bR1 |
aR1 CBB | aCBB | cBB | aR1 CR2 BB | aCR2 BB | cR2 BB
aR1 CBR1 BR1 | aCBR1 BR1 | cBR1 BR1 | aR1 CR2 BR1 BR1 | aCR2 BR1 BR1 | cR2 BR1 BR1 |
C → aR1 C | aC | c | aR1 CR2 | aCR2 | cR2 aR1 CBBR1 | aCBBR1 | cBBR1 | aR1 CR2 BBR1 | aCR2 BBR1 | cR2 BBR1

R1 → aR1 BR1 | aBR1 | bR1 | aR1 B | aB | b |


aR1 CBR1 B | aCBR1 B | cBR1 B | aR1 CR2 BR1 B | aCR2 BR1 B | cR2 BR1 B |
aR1 CBR1 BR1 | aCBR1 BR1 | cBR1 BR1 | aR1 CR2 BR1 BR1 | aCR2 BR1 BR1 | cR2 BR1 BR1 | aR1 CBB | aCBB | cBB | aR1 CR2 BB | aCR2 BB | cR2 BB
aR1 CBBR1 | aCBBR1 | cBBR1 | aR1 CR2 BBR1 | aCR2 BBR1 | cR2 BBR1 R2 → aR1 BR1 CR2 | aBR1 CR2 | bR1 CR2 |
aR1 CBR1 BR1 CR2 | aCBR1 BR1 CR2 | cBR1 BR1 CR2 | aR1 CR2 BR1 BR1 CR2 | aCR2 BR1 BR1 CR2 | cR2 BR1 BR1 CR2 |
aR1 B | aB | b |
aR1 CBBR1 CR2 | aCBBR1 CR2 | cBBR1 CR2 | aR1 CR2 BBR1 CR2 | aCR2 BBR1 CR2 | cR2 BBR1 CR2
aR1 CBR1 B | aCBR1 B | cBR1 B | aR1 CR2 BR1 B | aCR2 BR1 B | cR2 BR1 B | aR1 BCR2 | aBCR2 | bCR2 |

aR1 CBB | aCBB | cBB | aR1 CR2 BB | aCR2 BB | cR2 BB aR1 CBR1 BCR2 | aCBR1 BCR2 | cBR1 BCR2 | aR1 CR2 BR1 BCR2 | aCR2 BR1 BCR2 | cR2 BR1 BCR2 |
aR1 CBBCR2 | aCBBCR2 | cBBCR2 | aR1 CR2 BBCR2 | aCR2 BBCR2 | cR2 BBCR2
R2 → BR1 CR2 | BCR2 | BR1 C | BC
aR1 BR1 C | aBR1 C | bR1 C |
aR1 CBR1 BR1 C | aCBR1 BR1 C | cBR1 BR1 C | aR1 CR2 BR1 BR1 C | aCR2 BR1 BR1 C | cR2 BR1 BR1 C |
aR1 CBBR1 C | aCBBR1 C | cBBR1 C | aR1 CR2 BBR1 C | aCR2 BBR1 C | cR2 BBR1 C
aR1 BC | aBC | bC |

PS aR1 CBR1 BC | aCBR1 BC | cBR1 BC | aR1 CR2 BR1 BC | aCR2 BR1 BC | cR2 BR1 BC |
aR1 CBBC | aCBBC | cBBC | aR1 CR2 BBC | aCR2 BBC | cR2 BBC

R1 agora também está na FN de Greibach


Repetir o procedimento para R2 (nesta ordem) Agora está na Forma Normal de Greibach (FNG)! =)

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 276 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 277 / 471
Linguagens Livres de Contexto – Forma Normal de Greibach Linguagens Livres de Contexto – Forma Normal de Greibach

Comentários Finais Exercício de Fixação (apenas os passos da FNG)


FN de Greibach: G : S → AB | BA | a
Gramáticas grandes (i.e., diversas regras) A → AB | b | c
Gramáticas sem a simplicidade original
B → AB | BA | b
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

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 278 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 279 / 471

Linguagens Livres de Contexto – Autômatos com Pilha

Autômatos com Pilha


AFDs são incapazes de reconhecer a i bi porque possuem
uma “memória limitada”
Linguagens Livres de Contexto Memória de um AFD: seus estados, os quais são finitos

Autômatos com Pilha (AP):


Autômatos com Pilha
AFND-λ + Pilha de tamanho infinito

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 280 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 281 / 471
Linguagens Livres de Contexto – Autômatos com Pilha Linguagens Livres de Contexto – Autômatos com Pilha

Autômato com Pilha Não-Determinístico (APND) Autômatos com Pilha


Um APND é uma sextupla (Q, Σ, Γ, δ, q0 , F): Exemplo: δ(qi , a, A) = [qj , B]
Q = conjunto finito de estados a A/B
qi qj
Σ = alfabeto de entrada
Γ = alfabeto da pilha
δ : Q x (Σ ∪ λ) x (Γ ∪ λ) → P(Q x (Γ ∪ λ)) q i : estado atual
= função de transições de estados a: símbolo a ser lido pela entrada
qo ∈ Q = estado inicial A: símbolo no topo da pilha (a ser desempilhado)
F ⊆ Q = conjunto de estados finais (aceitação) q j : novo estado
B: novo topo da pilha (a ser empilhado)
Permite transições δ(qi , a, B) e δ(qi , a 0 , B 0 ) compatíveis:
É ND, i.e., δ(qi , a, B) = {[qj , C], [qk , D]} Se (estado== q i ) && (entrada== a) && (topo == A) então
Uma palavra w ∈ Σ∗ é dita ser aceita por um APND se, e Lê a da entrada
somente se, existe uma computação que a consome e Muda o estado atual de q i para q j
para em um estado final com pilha vazia Desempilha A do topo da pilha e empilha B
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 282 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 283 / 471

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

Autômatos com Pilha: Transições λ Autômatos com Pilha: Transições λ


Transições λ são permitidas Exemplos:
δ(qi , λ, A) = [qj , λ]
Exemplo: δ(qi , a, A) = [qj , B]
Se a = λ, não irá ler nada da entrada qi
λ A/λ
qj

Se A = λ, irá realizar a transição independente do símbolo


que estiver no topo da pilha δ(qi , λ, λ) = [qj , B]
Se B = λ, não irá empilhar nada após a transição λ λ/B
qi qj
Se A = λ e B = λ em todas as transições: o AP é um AFND-λ
δ(qi , a, λ) = [qj , λ]

a λ/λ
qi qj

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 284 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 285 / 471
Linguagens Livres de Contexto – Autômatos com Pilha Linguagens Livres de Contexto – Autômatos com Pilha

Autômatos com Pilha: Aceitação Exemplo Clássico


Seja M = (Q, Σ, Γ, δ, q0 , F) um AP L(G) = {a i bi | i > 0}
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

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 286 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 287 / 471

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

Exemplo Clássico Autômatos com Pilha: Exemplos


L(G) = {a i bi | i > 0} L1 = {wcw R | w = (a ∪ b)∗ }

AP: L2 = {a i | i ≥ 0} ∪ {a i bi | i ≥ 0}
a λ/X b X/λ L3 = palíndromos de tamanho par sobre {a, b}

b X/λ L4 = {a i b2i | i ≥ 1}
q0 q1
L5 = palavras sobre {a, b} com o mesmo número de a e b

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 287 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 288 / 471
Linguagens Livres de Contexto – Autômatos com Pilha Linguagens Livres de Contexto – Autômatos com Pilha

Autômatos com Pilha Determinísticos (APD) Poder computacional


Assuma as transições: qj AP sem uso da pilha
/C
uA
δ(qi , u, A) = [qj , C] Semelhante ao AF e reconheceria a classe das LR
qi
δ(qi , v, B) = [qk , D] v B/ APD
D qk
Aceita um importante subconjunto próprio da classe de LLC

Aplicação: analisadores sintáticos (compiladores)


Um AP é determinístico se não possui transições compatíveis
Essas duas transições são compatíveis se: APND
u=v eA=B Aceita a classe das LLC

u = v e (A = λ ou B = λ) Aceita L = {a i bi c i | i ≥ 0}? Não, por quê?

A = B e (u = λ ou v = λ) AP com 2 (ou mais) pilhas


Mesmo poder computacional da MT (dispositivo mais geral
(u = λ ou v = λ) e (A = λ ou B = λ)
da computação)
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 289 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 290 / 471

Linguagens Livres de Contexto – Autômatos com Pilha

APs Atômicos
Transições são sempre de uma das formas:
Linguagens Livres de Contexto δ(qi , a, λ) = [qj , λ] – apenas lê entrada

δ(qi , λ, A) = [qj , λ] – apenas desempilha


Autômatos com Pilha δ(qi , λ, λ) = [qj , A] – apenas empilha

Todo AP pode ser transformado em um AP atômico


Variantes

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 291 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 292 / 471
Linguagens Livres de Contexto – Autômatos com Pilha Linguagens Livres de Contexto – Autômatos com Pilha

APs Atômicos – Exemplo APs Atômicos – Exemplo


AP não atômico para L = {a i bi | i > 0} AP atômico para L = {a i bi | i > 0}
a λ/X b X/λ q1 q4

b X/λ
q0 q1

a λ/λ λ λ/X b λ/λ λ X/λ

b λ/λ λ X/λ
q0 q2 q3

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 293 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 294 / 471

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

APs Estendidos APs Estendidos – Exemplo #1


Pode-se empilhar mais de uma letra, como resultado de AP estendido para L = {a i b2i | i ≥ 1}
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

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 295 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 296 / 471
Linguagens Livres de Contexto – Autômatos com Pilha Linguagens Livres de Contexto – Autômatos com Pilha

APs Estendidos – Exemplo #1 APs Estendidos – Exemplo #2


AP estendido para L = {a i b2i | i ≥ 1} AP estendido para L = {a i (bc)i | i ≥ 1}
a λ/XX b X/λ

b X/λ
q0 q1

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 296 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 297 / 471

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

APs Estendidos – Exemplo #2 APs Atômicos e Estendidos


AP estendido para L = {a i (bc)i | i ≥ 1} Variantes de APs (i.e., Atômicos e Estendidos) não aumentam o
poder de expressão de APs
b B/λ
a λ/BC c C/λ

b B/λ
q0 q1

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 297 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 298 / 471
Linguagens Livres de Contexto – Autômatos com Pilha

Critério de Aceitação
Critério normal de aceitação: por estado final e pilha vazia
Linguagens Livres de Contexto ∗
[q0 , w, λ] ` [qi , λ, λ], qi ∈ F

Critério alternativo de aceitação: por estado final


Autômatos com Pilha ∗
[q0 , w, λ] ` [qi , λ, α], qi ∈ F, α ∈ Γ∗

Basta processar toda a palavra e terminar em estado final


Critérios de Aceitação
Critério alternativo de aceitação: por pilha vazia
+
[q0 , w, λ] ` [qi , λ, λ], qi ∈ Q

Basta processar toda a palavra e terminar com a pilha vazia

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 299 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 300 / 471

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

Aceitação por Estado Final Aceitação por Estado Final


Novo critério não aumenta o poder de expressão de APs 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
Quando a aceitação é por estado final e pilha vazia, às
final e pilha vazia
vezes são acrescentados transições e/ou estados apenas
para esvaziar a pilha Basta acrescentar um novo estado final qf 0 e

Exemplo: {a i | i > 0} ∪ {a i bi | i > 0} δ’(qi , λ, λ) = [qf 0 , λ], para todo qi ∈ F

No caso de aceitação por estado final, tais estados são δ’(qf 0 , λ, X ) = [qf 0 , λ], para todo X ∈ Γ
desnecessários ∗ ∗
Aceitação: [q0 , w, λ] ` [qi , λ, α] ` [qf 0 , λ, α] ` [qf 0 , λ, λ]
λ X/λ
λ X/λ
a λ/X Resumindo:
q1

q0
Aceita por estado final ⇒ aceita por estado final e pilha
vazia (pelo lema acima)
q2
b X/λ
Aceita por estado final e pilha vazia ⇒ aceita por estado final
b X/λ
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 301 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 302 / 471
Linguagens Livres de Contexto – Autômatos com Pilha Linguagens Livres de Contexto – Autômatos com Pilha

Aceitação por Estado Final – Exemplo Aceitação por Estado Final – Exemplo
L = {a i bj | i ≥ j ≥ 0} L = {a i bj | i ≥ j ≥ 0}
Estado Final (EF) Estado Final e Pilha Vazia (EF/PV) Estado Final (EF) Estado Final e Pilha Vazia (EF/PV)

a λ/A b A/λ

b A/λ
q0 q1

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 303 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 303 / 471

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

Aceitação por Estado Final – Exemplo Aceitação por Pilha Vazia


L = {a i bj | i ≥ j ≥ 0} Critério alternativo de aceitação: por pilha vazia
+
[q0 , w, λ] ` [qi , λ, λ], qi ∈ Q
Estado Final (EF) Estado Final e Pilha Vazia (EF/PV)
Observe que não se exige mais que qi ∈ F
a λ/A b A/λ a λ/A b A/λ
Basta que a palavra seja toda lida (sempre) e pilha vazia
b A/λ b A/λ ∗
q0 q1 q0 q1 Por que não [q0 , w, λ] ` [qi , λ, λ] ?

λ λ/λ
λ λ/λ

qf0

λ A/λ

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 303 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 304 / 471
Linguagens Livres de Contexto – Autômatos com Pilha Linguagens Livres de Contexto – Autômatos com Pilha

Aceitação por Pilha Vazia Aceitação por Pilha Vazia – Exemplo


Lema: Seja L uma linguagem aceita por um AP M por pilha L = {a i bi | i > 0}
vazia, então existe um AP M 0 que aceita L por estado final e
pilha vazia Pilha Vazia (PV) Estado Final e Pilha Vazia (EF/PV)
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 305 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 306 / 471

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

Aceitação por Pilha Vazia – Exemplo Aceitação por Pilha Vazia – Exemplo
L = {a i bi | i > 0} L = {a i bi | i > 0}
Pilha Vazia (PV) Estado Final e Pilha Vazia (EF/PV) Pilha Vazia (PV) Estado Final e Pilha Vazia (EF/PV)

a λ/A b A/λ a λ/A b A/λ a λ/A b A/λ

b A/λ b A/λ b A/λ


q0 q1 q0 q1 q0 q1

λ λ/λ
a λ/A

q00

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 306 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 306 / 471
Linguagens Livres de Contexto – Autômatos com Pilha

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 Linguagens Livres de Contexto
Existe um AP M2 que aceita L com critério de aceitação por
estado final Algoritmos de Reconhecimento
Existe um AP M3 que aceita L com critério de aceitação por
pilha vazia

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 307 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 308 / 471

Linguagens Livres de Contexto – Algoritmos de Reconhecimento Linguagens Livres de Contexto – Algoritmos de Reconhecimento

Algoritmos de Reconhecimento Reconhecedores que utilizam AP


Alguns problemas não possuem solução computacional: muito simples
1 Certa LLC é ambígua? em geral, ineficientes
2 Duas LLCs são iguais ou diferentes?
tempo de processamento é proporcional a k |w|
3 Uma palavra pertence a uma linguagem? w: palavra de entrada
No entanto, o problema (3) possui solução em LLCs k: constante que depende do autômato
Uma palavra pertence a uma LLC?
Reconhecedores que não utilizam AP
Algoritmos de reconhecimento
Tempo de processamento proporcional a |w|3
válidos para qualquer linguagem da classe
contudo limite não foi provado, pode ser até inferior
complexidade computacional (tempo e espaço)

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 309 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 310 / 471
Linguagens Livres de Contexto – Algoritmos de Reconhecimento Linguagens Livres de Contexto – Algoritmos de Reconhecimento

Algoritmos construídos a partir de uma GLC Classificação


Autômato com Pilha como Reconhecedor Top-Down (ou Preditivo)
constrói uma árvore de derivação
Autômato com Pilha Descendente
a partir da raiz (símbolo inicial da gramática)
Algoritmo de Cocke-Younger-Kasami (CYK)
com ramos em direção às folhas (terminais)
Algoritmo de Early
Bottom-up
oposto do Top-Down

parte das folhas

construindo a árvore de derivação em direção à raiz

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 311 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 312 / 471

Linguagens Livres de Contexto – Algoritmos de Reconhecimento

Autômato com Pilha como Reconhecedor


Reconhecedores usando AP
Linguagens Livres de Contexto Construção relativamente simples e imediata

Relação “direta” entre produções e as transições do AP


Algoritmos de Reconhecimento
Algoritmos
Top-Down
Autômato com Pilha como Reconhecedor
Simula derivação mais à esquerda

Não determinista

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 313 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 314 / 471
Linguagens Livres de Contexto – Algoritmos de Reconhecimento Linguagens Livres de Contexto – Algoritmos de Reconhecimento

Autômato com Pilha como Reconhecedor Exemplo


É direta a conversão de qualquer GLC na FN de Greibach L = {a n bn | n ≥ 1}
para um AP G(L) = {V , Σ, P, S} = {{S}, {a, b}, {S → aSb, S → ab}, S}
Cada produção gera exat. um terminal (FN de Greibach)
Forma Normal de Greibach:
Logo, geração de w requer |w| etapas de derivação
G0 (L) = {{S 0 , S, B}, {a, b},
No entanto, cada terminal pode ter diversas produções {S 0 → aSB, S 0 → aB, S → aSB, S → aB, B → b}, S 0 }
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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 315 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 316 / 471

Linguagens Livres de Contexto – Algoritmos de Reconhecimento

Exemplo
L = {a n bn | n ≥ 1}

G(L) = {V , Σ, P, S} = {{S}, {a, b}, {S → aSb, S → ab}, S} Linguagens Livres de Contexto


Forma Normal de Greibach:
Algoritmos de Reconhecimento
G0 (L) = {{S 0 , S, B}, {a, b},
{S 0 → aSB, S 0 → aB, S → aSB, S → aB, B → b}, S 0 }
Autômato com Pilha Descendente

a λ/SB
a λ/B
q0 q1

a S/SB
a S/B
b B/λ

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 316 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 317 / 471
Linguagens Livres de Contexto – Algoritmos de Reconhecimento Linguagens Livres de Contexto – Algoritmos de Reconhecimento

Autômato com Pilha Descendente Exemplo


Forma alternativa de construir AP L = {a n bn | n ≥ 1}
não há necessidade de estar na FNG
G(L) = {V , Σ, P, S} = {{S}, {a, b}, {S → AX , S → AB, X →
Igualmente simples e com o mesmo nível de eficiência SB, A → a, B → b}, S}
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

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 318 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 319 / 471

Linguagens Livres de Contexto – Algoritmos de Reconhecimento

Exemplo
L = {a n bn | n ≥ 1}

G(L) = {V , Σ, P, S} = {{S}, {a, b}, {S → AX , S → AB, X → Linguagens Livres de Contexto


SB, A → a, B → b}, S}
Algoritmos de Reconhecimento
λ λ/S λ λ/λ
q0 q1 q2

Algoritmo de Cocke-Younger-Kasami (CYK)


λ S/AX
λ S/AB
λ X /SB
λ A/a
λ B/b
a a/λ
b b/λ

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 319 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 320 / 471
Linguagens Livres de Contexto – Algoritmos de Reconhecimento Linguagens Livres de Contexto – Algoritmos de Reconhecimento

Algoritmo de Cocke-Younger-Kasami (CYK) Exemplo (contribuição de Alberto Hokari)


Proposto por J. Cocke, D. H. Younger e T. Kasami em 1965 Considere a seguinte GLC L:
S → AT | AB
GLC deve estar na FNC
T → XB
Mecânica:
X → AT | AB
Estratégia bottom-up para criação de todas as possíveis
árvores de derivação da palavra de entrada w A→a
B→b
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

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 321 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 322 / 471

Linguagens Livres de Contexto – Algoritmos de Reconhecimento Linguagens Livres de Contexto – Algoritmos de Reconhecimento

L aceita a palavra aaabbb? (contribuição de Alberto Hokari) L aceita a palavra aaabbb? (contribuição de Alberto Hokari)

Coloca-se a palavra a ser reconhecida na base da tabela Para preencher a 1a


linha devemos verificar qual variável
gera a sequencia de 1 terminal

S → AT | AB S → AT | AB
T → XB T → XB
X → AT | AB X → AT | AB
A→a A→a
a a a b b b B→b 1 A A A B B B B→b

a a a b b b

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 323 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 324 / 471
Linguagens Livres de Contexto – Algoritmos de Reconhecimento Linguagens Livres de Contexto – Algoritmos de Reconhecimento

L aceita a palavra aaabbb? (contribuição de Alberto Hokari) L aceita a palavra aaabbb? (contribuição de Alberto Hokari)

Para preencher a 2a linha devemos verificar qual variável O processo se repete


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 S → AT | AB
T → XB T → XB
2 - -
X → AT | AB X → AT | AB
A→a 1 A A A B B B A→a
B→b B→b
a a a b b b
2 -

1 A A A B B B

a a a b b b

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 325 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 326 / 471

Linguagens Livres de Contexto – Algoritmos de Reconhecimento Linguagens Livres de Contexto – Algoritmos de Reconhecimento

L aceita a palavra aaabbb? (contribuição de Alberto Hokari) L aceita a palavra aaabbb? (contribuição de Alberto Hokari)

Neste caso, existem duas regras que geram AB O processo se repete até completar a 2a linha
Logo, ambas são colocadas na célula

S → AT | AB S → AT | AB
T → XB T → XB
2 - - S,X - -
X → AT | AB X → AT | AB
2 - - S,X
A→a 1 A A A B B B A→a
1 A A A B B B B→b B→b
a a a b b b
a a a b b b

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 327 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 328 / 471
Linguagens Livres de Contexto – Algoritmos de Reconhecimento Linguagens Livres de Contexto – Algoritmos de Reconhecimento

L aceita a palavra aaabbb? (contribuição de Alberto Hokari) L aceita a palavra aaabbb? (contribuição de Alberto Hokari)

Para preencher a 3a linha devemos verificar qual variável 1 + 2 = A + − = A−


gera a sequência de 3 terminais Par inválido, logo marcamos a célula com um −
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 S → AT | AB
T → XB 3 - T → XB
X → AT | AB X → AT | AB
2 - - S,X - -
3 A→a A→a
B→b 1 A A A B B B B→b
2
a a a b b b
1

a a a b b b

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 329 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 330 / 471

Linguagens Livres de Contexto – Algoritmos de Reconhecimento Linguagens Livres de Contexto – Algoritmos de Reconhecimento

L aceita a palavra aaabbb? (contribuição de Alberto Hokari) L aceita a palavra aaabbb? (contribuição de Alberto Hokari)

2 + 1 = − + A = −A O processo se repete até completar a 3a linha


Par inválido, logo marcamos a célula com um −

S → AT | AB 3 - - T - S → AT | AB

3 - T → XB T → XB
2 - - S,X - -
X → AT | AB X → AT | AB
2 - - S,X - - 1 A A A B B B
A→a A→a
1 A A A B B B B→b a a a b b b B→b

a a a b b b

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 331 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 332 / 471
Linguagens Livres de Contexto – Algoritmos de Reconhecimento Linguagens Livres de Contexto – Algoritmos de Reconhecimento

L aceita a palavra aaabbb? (contribuição de Alberto Hokari) L aceita a palavra aaabbb? (contribuição de Alberto Hokari)

Para preencher a 4a linha devemos verificar qual variável Para preencher a 4a linha devemos verificar qual variável
gera a sequência de 4 terminais gera a sequência de 4 terminais
o processo se repete para as linhas superiores o processo se repete para as linhas superiores

S → AT | AB S → AT | AB
4 - T → XB 4 - T → XB
3 - - T - X → AT | AB 3 - - T - X → AT | AB
A→a A→a
2 - - S,X - - 2 - - S,X - -
B→b B→b
1 A A A B B B 1 A A A B B B

a a a b b b a a a b b b

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 333 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 333 / 471

Linguagens Livres de Contexto – Algoritmos de Reconhecimento Linguagens Livres de Contexto – Algoritmos de Reconhecimento

L aceita a palavra aaabbb? (contribuição de Alberto Hokari) L aceita a palavra aaabbb? (contribuição de Alberto Hokari)

Para preencher a 4a
linha devemos verificar qual variável Ao final do processo, se o símbolo inicial se encontra na
gera a sequência de 4 terminais primeira célula, a palavra é reconhecida pela linguagem
o processo se repete para as linhas superiores Neste exemplo, aaabbb ∈ L

Como S é a raiz então


6 S,X a palavra é reconhecida

5 - T
S → AT | AB S → AT | AB
4 - T → XB 4 - S,X - T → XB
3 - - T - X → AT | AB 3 - - T - X → AT | AB
A→a A→a
2 - - S,X - - 2 - - S,X - -
B→b B→b
1 A A A B B B 1 A A A B B B
a a a b b b a a a b b b

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 333 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 334 / 471
Linguagens Livres de Contexto – Algoritmos de Reconhecimento Linguagens Livres de Contexto – Algoritmos de Reconhecimento

Exercício de Fixação #1 Exercício de Fixação #2


Verifique se a palavra abab é aceita na seguinte GLC: Verifique se a palavra baaba é aceita na seguinte GLC:
S → XY S → AB | BC
T → ZT | a A → BA | a
X → TY B → CC | b
Y → YT | b C → AB | a
Z → TZ | b

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 335 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 336 / 471

Linguagens Livres de Contexto – Algoritmos de Reconhecimento

Algoritmo de Early
Possivelmente o mais rápido algoritmo para LLC
Linguagens Livres de Contexto Proposto em 1968

Tempo de processamento:
Algoritmos de Reconhecimento qualquer GLC sem produções λ: |w|3

qualquer GLC não ambígua: |w|2


Algoritmo de Early
muitas gramáticas de interesse prático: |w|

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 337 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 338 / 471
Linguagens Livres de Contexto – Algoritmos de Reconhecimento

Algoritmo de Early
Entrada: GLC sem produções vazias

Algoritmo Top-Down (a partir de S)


Linguagens Livres de Contexto
Executa sempre a derivação mais à esquerda

Cada iteração gera um terminal Algoritmos


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!

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 339 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 340 / 471

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
Linguagens Livres de Contexto Seja L uma LLC e G = (V , Σ, P, S) a GLC que gera L

Transforme G para a forma normal de Greibach:


Algoritmos
A → aA1 A2 A3 . . . An onde a ∈ Σ e A1..n ∈ V − {S}
A→a
Transformação de GLCs para APs
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

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 341 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 342 / 471
Linguagens Livres de Contexto – Algoritmos

Transformação de GLCs para APs – Exemplo


S → aAB | aB
A → aAB | aB Linguagens Livres de Contexto
B→b

Intuitivamente, uma regra A → aAB somente pode ser Algoritmos


aplicada quando o topo da pilha for A

Neste caso, aplicar a regra em questão implica em: Transformação de APs para GLCs

Desempilhar A

Ler a

Empilhar AB

Ou seja, a pilha armazena as variáveis que ainda devem ser


derivadas
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 343 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 344 / 471

Linguagens Livres de Contexto – Algoritmos Linguagens Livres de Contexto – Algoritmos

Transformação de APs para GLCs Transformação de APs para GLCs


Toda linguagem aceita por um AP é uma LLC Algoritmo para gerar uma GLC G a partir do AP M 0
Dado um AP, gerar um AP M’ estendido onde δ’ herda todas Variáveis não vão ser mais maiúsculas, mas sim tuplas da
as transições de δ e acrescenta duas novas transições: forma <qi , A, qj >
Se [qj , λ] ∈ δ(qi , u, λ) então estou em q i ,
0
[qj , A] ∈ δ (qi , u, A), para todo A ∈ Γ
quero ir para q j e
Se [qj , B] ∈ δ(qi , u, λ) então
existe A no topo da pilha
[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 )


Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 345 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 346 / 471
Linguagens Livres de Contexto – Algoritmos Linguagens Livres de Contexto – Algoritmos

Transformação de APs para GLCs Transformação de APs para GLCs – Exemplo


Regras de G: Construa uma gramática G para o seguinte AP M:
#1 S → <q0 , λ, qj >, para todo qj ∈ F Q = {q0 , q1 }

#2 Se [qj , B] ∈ δ 0 (qi , x, A), então (A e B ∈ Γ ∪ {λ}) Σ = {a, b, c}, Γ = {A}


<qi , A, qk > → x<qj , B, qk >, para todo qk ∈ Q F = {q1 }

#3 Se [qj , BA] ∈ δ 0 (qi , x, A), então (A e B ∈ Γ) L(M) = a n cbn , n ≥ 0


<qi , A, qk > → x<qj , B, qn >< qn , A, qk >, qk , qn ∈ Q

#4 Para todo qk ∈ Q
<qk , λ, qk > → λ

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 347 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 348 / 471

Linguagens Livres de Contexto – Algoritmos Linguagens Livres de Contexto – Algoritmos

Transformação de APs para GLCs – Exemplo Transformação de APs para GLCs – Exemplo
a λ/A b A/λ a λ/A
a A/AA b A/λ
c λ/λ c λ/λ
q0 q1
c A/A
q0 q1

Função de transição δ
Função de transição δ 0 é igual a δ mais duas regras:
δ(q0 , a, λ) = [q0 , A] – não desempilha e empilha A
δ 0 (q0 , a, A) = [q0 , AA] – pois A é o único elemento de Γ
δ(q0 , c, λ) = [q1 , λ] – não desempilha, não empilha
δ 0 (q0 , c, A) = [q1 , A]
δ(q1 , b, A) = [q1 , λ]

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 349 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 350 / 471
Linguagens Livres de Contexto – Algoritmos Linguagens Livres de Contexto – Algoritmos

Transformação de APs para GLCs – Exemplo Transformação de APs para GLCs – Exemplo
#1 S → <q0 , λ, qj >, para todo qj ∈ F #3 Se [qj , BA] ∈ δ 0 (qi , x, A), então (A e B ∈ Γ)

Logo, primeira regra da GLC será: S → <q0 , λ, q1 > <qi , A, qk > → x<qj , B, qn >< qn , A, qk >, qk , qn ∈ Q

#2 Se [qj , B] ∈ δ 0 (qi , x, A), então (A e B ∈ Γ ∪ {λ}) Como [q0 , AA] ∈ δ(q0 , a, A), então
<qi , A, qk > → x<qj , B, qk >, para todo qk ∈ Q <q0 , A, qk > → a<q0 , A, qn >

Como [q0 , A] ∈ δ(q0 , a, λ), então Novas regras:


<q0 , λ, qk > → a<q0 , A, qk > <q0 , A, q0 > → a<q0 , A, q0 >< q0 , A, q0 > –k = 0,n= 0

Novas regras: <q0 , A, q1 > → a<q0 , A, q0 >< q0 , A, q1 > –k = 1,n= 0


<q0 , λ, q0 > → a<q0 , A, q0 > –k = 0
<q0 , A, q0 > → a<q0 , A, q1 >< q1 , A, q0 > –k = 0,n= 1
<q0 , λ, q1 > → a<q0 , A, q1 > –k = 1
<q0 , A, q1 > → a<q0 , A, q1 >< q1 , A, q1 > –k = 1,n= 1

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 351 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 352 / 471

Linguagens Livres de Contexto – Algoritmos Linguagens Livres de Contexto – Algoritmos

Transformação de APs para GLCs – Exemplo Transformação de APs para GLCs – Exemplo
#2 Se [qj , B] ∈ δ 0 (qi , x, A), então (A e B ∈ Γ ∪ {λ}) #2 Se [qj , B] ∈ δ 0 (qi , x, A), então (A e B ∈ Γ ∪ {λ})

<qi , A, qk > → x<qj , B, qk >, para todo qk ∈ Q <qi , A, qk > → x<qj , B, qk >, para todo qk ∈ Q

Como [q1 , λ] ∈ δ(q0 , c, λ), então Como [q1 , A] ∈ δ(q0 , c, A) então


<q0 , λ, qk > → c<q1 , λ, qk > <q0 , A, qk > → c<q1 .A, qk >

Novas regras: Novas regras:


<q0 , λ, q0 > → c<q1 , λ, q0 > –k = 0 <q0 , A, q0 > → c<q1 , A, q0 > –k = 0

<q0 , λ, q1 > → c<q1 , λ, q1 > –k = 1 <q0 , A, q1 > → c<q1 , A, q1 > –k = 1

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 353 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 354 / 471
Linguagens Livres de Contexto – Algoritmos Linguagens Livres de Contexto – Algoritmos

Transformação de APs para GLCs – Exemplo Transformação de APs para GLCs – Exemplo
#2 Se [qj , B] ∈ δ 0 (qi , x, A), então (A e B ∈ Γ ∪ {λ}) #4 Para todo qk ∈ Q
<qi , A, qk > → x<qj , B, qk >, para todo qk ∈ Q <qk , λ, qk > → λ

Como [q1 , λ] ∈ δ(q1 , b, A) então Novas regras:


<q1 , A, qk > → b<q1 , λ, qk > <q0 , λ, q0 > → λ –k =0

Novas regras: <q1 , λ, q1 > → λ –k =1

<q1 , A, q0 > → b<q1 , λ, q0 > –k = 0

<q1 , A, q1 > → b<q1 , λ, q1 > –k = 1

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 355 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 356 / 471

Linguagens Livres de Contexto – Algoritmos Linguagens Livres de Contexto – Algoritmos

Transformação de APs para GLCs – Exemplo – GLC resultante Transformação de APs para GLCs – Exemplo – Derivação aacbb
S → <q0 , λ, q1 > S ⇒ <q0 , λ, q1 >
<q0 , λ, q0 > → a<q0 , A, q0 > ⇒ a<q0 , A, q1 >
<q0 , λ, q1 > → a<q0 , A, q1 >
<q0 , A, q0 > → a<q0 , A, q0 ><q0 , A, q0 > ⇒ aa<q0 , A, q1 ><q1 , A, q1 >
<q0 , A, q1 > → a<q0 , A, q0 ><q0 , A, q1 > ⇒ aac<q1 , A, q1 ><q1 , A, q1 >
<q0 , A, q0 > → a<q0 , A, q1 ><q1 , A, q0 > ⇒ aacb<q1 , λ, q1 ><q1 , A, q1 >
<q0 , A, q1 > → a<q0 , A, q1 ><q1 , A, q1 >
⇒ aacb<q1 , A, q1 >
<q0 , λ, q0 > → c<q1 , λ, q0 >
<q0 , λ, q1 > → c<q1 , λ, q1 > ⇒ aacbb<q1 , λ, q1 >
<q0 , A, q0 > → c<q1 , A, q0 > ⇒ aacbb
<q0 , A, q1 > → c<q1 , A, q1 >
<q1 , A, q0 > → b<q1 , λ, q0 >
<q1 , A, q1 > → b<q1 , λ, q1 >
<q0 , λ, q0 > → λ
<q1 , λ, q1 > → λ
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 357 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 358 / 471
Linguagens Livres de Contexto – Propriedades

LLCs
Mais geral que LRs

Mas, ainda é relativamente restrita


Linguagens Livres de Contexto

Propriedades

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 359 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 360 / 471

Linguagens Livres de Contexto – Propriedades Linguagens Livres de Contexto – Propriedades

Fácil definir linguagens que não são LLC Linguagens de Programação


Palavra duplicada, e.g., L = {ww | w ∈ {a, b}∗ } LPs normalmente são 99% LLC (e 1% safadão)
Analogia com compiladores: Mas, LPs são o quê então?
declaração de uma variável antes do seu uso
Mas, e a construção if −then−else?
Triplo balanceamento, e.g., L = {a n bn c n | n ≥ 0} Isso é encadeamento, não balanceamento
Mais importante limitação das LLC Não confunda!
(propositalmente) incomum em LPs

Usando Autômato com Pilha


fácil intuir por que não são LLC

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 361 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 362 / 471
Linguagens Livres de Contexto – Propriedades Linguagens Livres de Contexto – Propriedades

Como verificar... Propriedades de fechamento


... se uma LLC é fechada para operações Fechamento é importante para
união? construir novas linguagens a partir de operações sobre
linguagens conhecidas
interseção?
provar propriedades
concatenação? construir algoritmos
complemento? O conjunto das LLC é fechado para:
... se uma LLC é União
infinita? Concatenação
Kleene
finita?
Mas não é fechado para:
vazia?
Interseção
Complemento

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 363 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 364 / 471

Linguagens Livres de Contexto – Propriedades Linguagens Livres de Contexto – Propriedades

O conjunto das LLC é fechado para União O conjunto das LLC é fechado para Concatenação
Prova usando AP: Prova usando AP:
Seja M1 e M2 dois APs que reconhecem duas LLCs Seja M1 e M2 dois APs que reconhecem duas LLCs com
critério de aceitação por estado final
Basta criar um novo AP com um novo estado inicial que
possui transições λ para os estados iniciais de M1 e M2 Basta criar um novo AP em que o(s) estado(s) final(is) de M1
(que agora deixam de ser iniciais) possui(em) transições λ para o estado inicial de M2

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 365 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 366 / 471
Linguagens Livres de Contexto – Propriedades Linguagens Livres de Contexto – Propriedades

O conjunto das LLC é fechado para Kleene O conjunto das LLC não é fechado para Interseção
Prova usando AP: Prova por Contradição:
Seja M um AP que reconhece uma LLC com critério de Seja L1 = {a i bi c j | i, j ≥ 0} uma LLC
aceitação por estado final
Seja L2 = {a j bi c i | i, j ≥ 0} uma LLC
Basta fazer transições λ do(s) estado(s) final(is) para o estado
inicial No entanto, L1 ∩ L2 = {a i bi c i | i ≥ 0} não é LLC

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 367 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 368 / 471

Linguagens Livres de Contexto – Propriedades Linguagens Livres de Contexto – Propriedades

O conjunto das LLC não é fechado para complemento O conjunto das LLC não é fechado para complemento
Prova por Contradição: Prova por Intuição:
Suponha que seja fechado para complemento Suponha uma LLC L

Suponha que L1 e L2 são LLC Suponha um AP M que reconheça L (que pode ser APND)

Então L = L1 ∪ L2 também é LLC Uma palavra w ∈ L se alguma computação de M a aceitar

Mas, L = L1 ∩ L2 É possível um AP rejeitar o complemento de L, mas não


aceitar o complemento
Já foi mostrado que L1 ∩ L2 não necessariamente é LLC

Logo, revendo a hipótese, o conjunto das LLC não é


fechado para complemento

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 369 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 370 / 471
Linguagens Livres de Contexto – Propriedades Linguagens Livres de Contexto – Propriedades

O conjunto das LLC não é fechado para complemento Propriedades de fechamento


Prova por Intuição: Teorema: Seja R uma linguagem regular e L uma linguagem
Suponha uma LLC L livre de contexto, então R ∩ L é LC

Suponha um AP M que reconheça L (que pode ser APND) Suponha um AFD N que reconheça R

Uma palavra w ∈ L se alguma computação de M a aceitar Suponha um AP M que reconheça L

É possível um AP rejeitar o complemento de L, mas não Basta criar um AP M 0 que simule a operação de N e M
aceitar o complemento
Os estados nessa máquina composta serão pares ordenados
[qNi , qMj ], onde qNi é um estado de N e qMj é um estado de M

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 370 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 371 / 471

Linguagens Livres de Contexto – Propriedades Linguagens Livres de Contexto – Propriedades

LLC é Vazia? LLC é Finita ou Infinita?


Prova: Suponha uma LLC L Seja G = (V , Σ, P, S) uma GLC que reconhece L

Seja G = (V , Σ, P, S) uma GLC que reconhece L Seja G0 = (V 0 , Σ0 , P 0 , S) a GLC equivalente a G sem símbolos
inúteis, regras de cadeia e regras λ
Seja G0 = (V 0 , Σ0 , P 0 , S) a GLC equivalente a G sem símbolos
inúteis Crie um grafo de dependência das variáveis
Se existirem ciclos no grafo de dependência, L é infinita
Se P 0 for vazio, então L é vazia
Caso contrário, L é finita

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 372 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 373 / 471
Linguagens Livres de Contexto – Propriedades Linguagens Livres de Contexto – Propriedades

LLC é Finita ou Infinita? Investigação se é LLC


Seja G = (V , Σ, P, S) uma GLC que reconhece L Para demonstrar que uma linguagem L é LC, basta:
Seja G0 = (V 0 , Σ0 , P 0 , S) a GLC equivalente a G sem símbolos Criar um GLC que gere L
inúteis, regras de cadeia e regras λ Criar um AP que reconheça L
Crie um grafo de dependência das variáveis Para demostrar que uma linguagem L não é LC, deve-se:
Se existirem ciclos no grafo de dependência, L é infinita Aplicar o Lema do Bombeamento para LLCs
Caso contrário, L é finita

Exemplo (finita ou infinita?)


A
S → AB
A → aCb | a S C

B → bB | bb B

C → cBS

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 373 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 374 / 471

Linguagens Livres de Contexto – Propriedades 5. Linguagens Sensíveis ao Contexto – Conteúdo

Lema do Bombeamento para LLCs


1 Revisão 3

Ideia similar ao Lema do Bombeamento para LRs 2 Introdução 59

3 Linguagens Regulares 74
Autômatos Finitos Determinísticos
Autômatos Finitos Não-Determinísticos

LRs Autômatos Finitos Não-Determinísticos com Transições-λ


Máquina de Moore
Máquinas de Mealy
Algoritmos de Transformação

podem expressar bombeamentos sem qualquer Transformação AFND-λ para AFD


Minimização de AFD
Transformação de ER para AFND-λ

balanceamento 4 Linguagens Livres de Contexto


Recursividade
172

Árvore de Derivação
Ambiguidade

não podem expressar bombeamentos balanceados 2 a 2 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
Variantes

LLCs Critérios de Aceitação


Autômato com Pilha como Reconhecedor
Autômato com Pilha Descendente
Algoritmo de Cocke-Younger-Kasami (CYK)
Algoritmo de Early

podem expressar bombeamentos balanceados 2 a 2 Transformação de GLCs para APs


Transformação de APs para GLCs

5 Linguagens Sensíveis ao Contexto 376


Gramática Sensível ao Contexto 378
não podem expressar bombeamentos balanceados 3 a 3 Autômato Linearmente Limitado
Teoremas
384
391

6 Linguagens Irrestritas 396


Teoremas

Detalhes em Sudkamp [6] Variantes

7 Considerações Finais 462

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 375 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 376 / 471
Linguagens Sensíveis ao Contexto

Hierarquia de Chomsky
Tipo Linguagem Gramática Máquina de aceitação

0 Rec. enumerável Irrestrita Máquina de Turing

1 Recursiva Sensível ao contexto Autômato linearmente limitado


Linguagens Sensíveis ao Contexto
2 Livre de contexto Livre de contexto Autômato com pilha

3 Regular Regular Autômato finito Gramática Sensível ao Contexto

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 377 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 378 / 471

Linguagens Sensíveis ao Contexto – Gram. Sensível ao Contexto Linguagens Sensíveis ao Contexto – Gram. Sensível ao Contexto

Gramática Sensível ao Contexto (GSC) Gramáticas Sensíveis ao Contexto


Uma GSC é uma quádrupla (V , Σ, P, S): Se L1 é uma LR, então L1 é uma LLC
V = conjunto de símbolos não-terminais (variáveis)
Se L2 é uma LLC, então L2–{λ} é uma LSC
Σ = conjunto de símbolos terminais (Σ ∩ V = φ)
P = conj. de regras (produções) É uma GSC?
S = símbolo não-terminal inicial (S ∈ V )

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, o que indica que tamanho da forma
sentencial ou aumenta ou permanece constante)

λ nunca é uma palavra válida em uma LSC


Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 379 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 380 / 471
Linguagens Sensíveis ao Contexto – Gram. Sensível ao Contexto Linguagens Sensíveis ao Contexto – Gram. Sensível ao Contexto

Gramáticas Sensíveis ao Contexto Gramáticas Sensíveis ao Contexto


Se L1 é uma LR, então L1 é uma LLC Se L1 é uma LR, então L1 é uma LLC

Se L2 é uma LLC, então L2–{λ} é uma LSC Se L2 é uma LLC, então L2–{λ} é uma LSC

É uma GSC? É uma GSC?


S → aSCbc | λ S → aSCbc | λ
Cb → bc Cb → bc

É uma GSC?

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 380 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 380 / 471

Linguagens Sensíveis ao Contexto – Gram. Sensível ao Contexto Linguagens Sensíveis ao Contexto – Gram. Sensível ao Contexto

Gramáticas Sensíveis ao Contexto Exemplo Clássico


Se L1 é uma LR, então L1 é uma LLC L = {a i bi c i | i > 0}

Se L2 é uma LLC, então L2–{λ} é uma LSC GSC(L):

É uma GSC?
S → aSCbc | λ
Cb → bc

É uma GSC? Derivação, por exemplo, de aabbcc:


S → aAc | bc S ⇒ aAbc ⇒ aabCbc ⇒ aabbCc ⇒ aabbcc
Ac → b
Toda LSC é recursiva, logo:
existe um ALL que reconhece uma LSC
existe uma MT que decide LSC, i.e., sempre para para
qualquer entrada w ∈ Σ∗
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 380 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 381 / 471
Linguagens Sensíveis ao Contexto – Gram. Sensível ao Contexto Linguagens Sensíveis ao Contexto – Gram. Sensível ao Contexto

Exemplo Clássico Por que não usamos apenas terminais


L= {a i bi c i | i > 0} L = {a i bi c i | i > 0}
GSC(L): GSC(L):
S → aAbc | abc S → aAbc | abc
A → aAbC | abC A → aAbc | abc
Cb → bC cb → bc
Cc → cc cc → cc

Derivação, por exemplo, de aabbcc: Derivação, por exemplo, de aabbcc:


S ⇒ aAbc ⇒ aabCbc ⇒ aabbCc ⇒ aabbcc S ⇒ aAbc ⇒ aabcbc ⇒ aabbcc
Toda LSC é recursiva, logo: Durante uma derivação:
existe um ALL que reconhece uma LSC Se w ∈ Σ∗ , então w é uma palavra da linguagem
existe uma MT que decide LSC, i.e., sempre para para aabcbc ∈ L?
qualquer entrada w ∈ Σ∗
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 381 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 382 / 471

Linguagens Sensíveis ao Contexto – Gram. Sensível ao Contexto

Exercícios
1 Defina L(G) para a seguinte GSC:
S → SBA | a
BA → AB Linguagens Sensíveis ao Contexto
aA → aaB
B→b Autômato Linearmente Limitado
2 Desenvolva uma GSC G em que L(G) = {a i b2i c i | i > 0}

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 383 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 384 / 471
Linguagens Sensíveis ao Contexto – Autômato Linearm. Limitado Linguagens Sensíveis ao Contexto – Autômato Linearm. Limitado

Autômato Linearmente Limitado (ALL) Autômato Linearmente Limitado (ALL)


Um ALL é uma óctupla (Q, Σ, Γ, δ, q0 , <, >, F): Seja w uma palavra de entrada
Q = conjunto finito de estados Configuração inicial da fita: hwi
Σ = alfabeto de entrada
Delimitadores podem ser lidos, mas não apagados
Γ = alfabeto da fita
δ : Q × Γ → Q × Γ × {E, D} = função de transições de estados Delimitadores não podem ser ultrapassados
qo ∈ Q = estado inicial Tamanho da fita = |w| + 2
F ⊆ Q = conjunto de estados finais (aceitação)
Basicamente, um ALL é uma MT cuja quantidade de fita
< e > = delimitadores da palavra de entrada
disponível é limitada ao tamanho da palavra de entrada

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 385 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 386 / 471

Linguagens Sensíveis ao Contexto – Autômato Linearm. Limitado Linguagens Sensíveis ao Contexto – Autômato Linearm. Limitado

Por que sempre para? Exemplo Clássico


Assuma um ALL a verificar a palavra aabb L = {a i bi c i | i > 0}
Z /Z E
Logo, configuração inicial da fita: haabbi Y /Y E
c/c E
Como a fita é finita, o número máximo de combinações é Y /Y D Z /Z D b/b E
a/a D b/b D c/c D a/a E
dado pela fórmula:
</< D a/X D b/Y D c/Z D >/> E
max_combinacoes = |Q| × |w| × |Γ||w| q0 q1 q2 q3 q4 q5

onde Q é o conjunto de estados, w é a palavra e Γ é o alfabeto da fita


Y/Y D X/X D
Assuma, nesse exemplo, Q = {q0 , q1 } e Γ = {h, i, a, b, X }.
>/> E
Dessa forma, o número máximo de configurações seria: q6 q7

max_combinacoes = 2 × 4 × 54 = 5.000 Y /Y D
Z /Z D
Se o ALL ultrapassa esse limite, a palavra é rejeitada, pois
certamente está repetindo configurações (loop)

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 387 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 388 / 471
Linguagens Sensíveis ao Contexto – Autômato Linearm. Limitado Linguagens Sensíveis ao Contexto – Autômato Linearm. Limitado

Exercício de Fixação L1 = {wcw | w ∈ {a, b}∗ e tem o mesmo número de a e b}


a/a D X /X D
1 L1 = {w | w ∈ {a, b}∗ e w tem o mesmo número de a e b} b/b D Y /Y D

c/c D
q2 q4
2 L2 = {w | w ∈ {a, b, c}∗ e o número de b é o dobro do a/a E
a/X D b/b E a/X E
número de a não sucedidos por c} X /X D
</< D Y /Y D c/c E X /X E
q0 q1 q7 q6
Y /Y E
3 L3 = {wcw | w ∈ {a, b}∗ e tem o mesmo número de a e b}
c/c D
X /X D b/Y D b/Y E
q8
4 L4 = {ww | w ∈ {a, b}+ } Y /Y D
q3
c/c D
q5

>/> E X /X D
a/a D
X /a E a/a D X /X D
Y /b E q9 b/b D Y /Y D
c/c E q10
</< D b/X E
a/X D
</< D a/a E
X /X D q00 q30 b/b E
X /X E

c/c D b/X D a/X E


q20

q40
X /X D
b/b D

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 389 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 390 / 471

Linguagens Sensíveis ao Contexto – Teoremas

Teorema #1: Se G é GSC, então L(G) é recursiva


Mostrar que existe uma MT M que decide L(G)

Se p é derivável ou não por L(G), então p é decidido por M


Linguagens Sensíveis ao Contexto
M deve simular as derivações de G

Teoremas 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

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 391 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 392 / 471
Linguagens Sensíveis ao Contexto – Teoremas Linguagens Sensíveis ao Contexto – Teoremas

Teorema #1: Se G é GSC, então L(G) é recursiva Teorema #1: Se G é GSC, então L(G) é recursiva
Funcionamento de M (máquina que decide L): Funcionamento de M (máquina que decide L)
S# é gravado na posição 1 da Fita #3 Se xvy ocorrer em outra posição na Fita #3, parar em estado
de rejeição
Regras de G são escritas na Fita #2
Justificativa: derivações cíclicas S ⇒+ w ⇒+ w
loop
Escolher uma regra u#v na Fita #2 Se tam(xvy) > tam(p), parar em estado de rejeição
Justificativa: em GSC, derivações são não-contráteis
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

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 393 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 394 / 471

Linguagens Sensíveis ao Contexto – Teoremas 6. Linguagens Irrestritas – Conteúdo

Teorema #2: Se L é uma LSC, então tem uma GSC G tal que L(G) = L
1 Revisão 3

Se L é uma LSC, então existe um ALL M cuja L(M) = L 2 Introdução 59

3 Linguagens Regulares 74

Em uma LSC, nenhuma forma sentencial pode ser maior que Autômatos Finitos Determinísticos
Autômatos Finitos Não-Determinísticos
Autômatos Finitos Não-Determinísticos com Transições-λ

a palavra de entrada Máquina de Moore


Máquinas de Mealy
Algoritmos de Transformação
Transformação AFND-λ para AFD
Minimização de AFD

É impossível uma derivação S ⇒∗ α ⇒∗ w, onde


Transformação de ER para AFND-λ

4 Linguagens Livres de Contexto 172

tam(α) > tam(w) Recursividade


Árvore de Derivação
Ambiguidade
Backus-Nahur Form (BNF)
Remoção de recursividade no símbolo inicial
Eliminação de regras λ

Logo, “memória” (ou quantidade de fita) necessária para Eliminação de regras de cadeia
Remoção de símbolos inúteis
Variantes

realizar derivações pode ser limitada pelo tamanho da Critérios de Aceitação


Autômato com Pilha como Reconhecedor
Autômato com Pilha Descendente

palavra de entrada Algoritmo de Cocke-Younger-Kasami (CYK)


Algoritmo de Early
Transformação de GLCs para APs
Transformação de APs para GLCs

Gramáticas irrestritas não são reconhecidas por ALL 5 Linguagens Sensíveis ao Contexto 376

6 Linguagens Irrestritas 396

É possível uma derivação S ⇒∗ α ⇒∗ w, onde


Gramática Irrestrita 398
Teoremas
Máquinas de Turing 407
Variantes

tam(α) > tam(w) Teoremas 447

7 Considerações Finais 462

ALLs são mais parecidos com computadores reais do que


uma MT (já que essas assumem memória infinita)
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 395 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 396 / 471
Linguagens Irrestritas

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


Linguagens Irrestritas
2 Livre de contexto Livre de contexto Autômato com pilha

3 Regular Regular Autômato finito Gramática Irrestrita

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 397 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 398 / 471

Linguagens Irrestritas – Gramática Irrestrita Linguagens Irrestritas – Gramática Irrestrita

Gramática Irrestrita (GI) Exemplo Clássico


Todo o universo de linguagens é gerado por GIs L = {u[u] | u ∈ {a, b}∗ }

Uma GI é uma quádrupla (V , Σ, P, S): GI(L):


V = conjunto de símbolos não-terminais (variáveis) S → aT [a] | bT [b] | []
Σ = conjunto de símbolos terminais (Σ ∩ V = φ) T [→ aT [A | bT [B | [
Aa → aA
P = conj. de regras (produções)
Ab → bA
S = símbolo não-terminal inicial (S ∈ V )
Ba → aB
Bb → bB
Regras: µ → ν A] → a]
µ ∈ (V ∪ Σ)+ (i.e., palavra formada por elementos de V e Σ) B] → b]
ν ∈ (V ∪ Σ)∗ (i.e., palavra formada por elementos de V e Σ)
Toda GI é recursivamente enumerável, logo:
existe uma MT que reconhece LI, mas não necessariamente
“Quase” nenhuma restrição é imposta (|µ| > 0) para para qualquer entrada w ∈ Σ∗

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 399 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 400 / 471
Linguagens Irrestritas – Gramática Irrestrita Linguagens Irrestritas – Gramática Irrestrita

Exemplo Clássico Exercício


GI: L = {a i bj a i bj | i, j ≥ 0}
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

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 401 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 402 / 471

Linguagens Irrestritas – Gramática Irrestrita

Exercício
L = {a i bj a i bj | i, j ≥ 0}
Linguagens Irrestritas
GI(L): Derivação Exemplo
S → X | Y | aPAbQb S ⇒ aPAbQb Gramática Irrestrita
X → aaX | λ ⇒ aaPAAbQb
Y → bbY | λ ⇒ aaAAbQb Teoremas
P → aPA | λ ⇒ aaAAbEb
Q → bQb | E ⇒ aaAbAEb
Ab → bA ⇒ aabAAEb
AE → a ⇒ aabAab
Aa → aa ⇒ aabaab

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 402 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 403 / 471
Linguagens Irrestritas – Gramática Irrestrita Linguagens Irrestritas – Gramática Irrestrita

Teorema #3: Se G é GI, então L(G) é rec. enumerável Teorema #3: Se G é GI, então L(G) é rec. enumerável
Mostrar que existe uma MT M que reconhece L(G) Funcionamento de M:
S# é gravado na posição 1 da Fita #3
Se p é derivável por L(G), então p é reconhecida por M
Regras de G são escritas na Fita #2
Ou seja, M deve simular as derivações de G
loop
M é uma MT não-determinística com 3 fitas Escolher uma regra u#v na Fita #2
Fita #1: palavra de entrada p
Seja q# a palavra mais recente gravada na Fita #3
Fita #2: regras de G
Escolher uma instância de u em q (se existir). Senão, parar em
u → v na fita fica ##u#v## estado de rejeição
##: separador de regras e #: →
Sendo q = xuy#, gravar xvy# na Fita #3, logo após q#
Fita #3: usada para registrar todas as formas sentenciais de
Se xvy == p, parar em estado de aceitação
uma derivação
Ex.: S#aAbc#aabCbc#aabbCc#aabbcc

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 404 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 405 / 471

Linguagens Irrestritas – Gramática Irrestrita

Teorema #4: Se L é uma LRE, então tem uma GI G tal que L(G) = L
Dada uma MT M que reconhece L, prova consiste em
demonstrar como criar uma GI G, com L(G) = L

Prova completa pode ser encontrada no Teorema 10.1.3 Linguagens Irrestritas


em Sudkamp [6]
Máquinas de Turing

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 406 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 407 / 471
Linguagens Irrestritas – Máquinas de Turing Linguagens Irrestritas – Máquinas de Turing

Máquinas de Turing Máquina de Turing (MT)


Modelo abstrato para os computadores modernos Uma MT Padrão é uma quíntupla (Q, Σ, Γ, δ, q0 ):
Propostas por Alan Turing em 1936 Q = conjunto finito de estados
Σ = alfabeto de entrada
Considerado um dos pais da Ciência da Computação
Γ = alfabeto da fita
Prêmio Turing: “Prêmio Nobel” da área de Computação δ : Q × Γ → Q × Γ × {E, D} = função de transições de estados
qo ∈ Q = estado inicial

Memória ilimitada
Seja w uma palavra de entrada
Configuração inicial da fita: BwBBBBBBBB...

A fita é infinita à direita

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 408 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 409 / 471

Linguagens Irrestritas – Máquinas de Turing Linguagens Irrestritas – Máquinas de Turing

Máquinas de Turing 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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 410 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 411 / 471
Linguagens Irrestritas – Máquinas de Turing Linguagens Irrestritas – Máquinas de Turing

Função de Transição (δ) Exemplo: δ(qi , x) = [qj , y, E ou D]


MT padrão é determinística Se (estado atual == qi ) e (símbolo atual da fita == x) então
δ : Q × Γ → Q × Γ × {E, D} = função de transições de estados Novo estado = qj

Grave y na fita
Computação
Mova cabeça de leitura/gravação para esquerda (E) ou
Computação para quando encontra um estado/símbolo direita (D)
para o qual não exista transição definida
x/y E x/y D
qi qj qi qj
Se a cabeça for deslocada para esquerda da posição 0,
então a computação termina anormalmente (“quebra”)
Símbolo atual da fita: símbolo embaixo da cabeça de
leitura/gravação

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 412 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 413 / 471

Linguagens Irrestritas – Máquinas de Turing Linguagens Irrestritas – Máquinas de Turing

Exercício de Fixação #1 Exercício de Fixação #4


MT para ler uma entrada formada por uma palavra sobre MT para realizar as seguintes transformações na fita de
{a, b} e trocar a por b e vice-versa. Ao final do entrada:
processamento, rebobinar a cabeça de leitura/gravação Ba n Ba m B... ⇒ Ba n Ba m Ba n+m B..., n, m ≥ 0
para a posição zero da fita
Ba n Ba m B... ⇒ Ba n Ba m Ba n−m B..., n ≥ m
n
Exercício de Fixação #2 Ba n B... ⇒ Ba n Ba 2 B..., n ≥ 0
MT para realizar a seguinte transformação na fita de Ba n Ba m B... ⇒ Ba n Ba m Ba n∗m B..., n, m ≥ 0
entrada:
BuB... ⇒ BuBuB..., onde u = (a ∪ b)∗

Exercício de Fixação #3
MT para somar 1 em um número binário gravado
inicialmente na fita de entrada

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 414 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 415 / 471
Linguagens Irrestritas – Máquinas de Turing Linguagens Irrestritas – Máquinas de Turing

MT para Aceitação de Linguagens MT para Aceitação de Linguagens


Um MT é uma séxtupla (Q, Σ, Γ, δ, q0 , F): MTs que aceitam ou rejeitam uma palavra de entrada
Q = conjunto finito de estados Seja M = (Q, Σ, Γ, δ, q0 , F) uma MT, onde F ⊆ Q é o conjunto
Σ = alfabeto de entrada de estados finais
Γ = alfabeto da fita
δ : Q × Γ → Q × Γ × {E, D} = função de transições de estados Uma palavra u ∈ Σ∗ é aceita por estado final se a
qo ∈ Q = estado inicial
computação de M com entrada u para em um estado final
F ⊆ Q = conjunto de estados finais (aceitação) Isto é, MT não precisa ler toda a palavra para aceitá-la

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 416 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 417 / 471

Linguagens Irrestritas – Máquinas de Turing Linguagens Irrestritas – Máquinas de Turing

MT para Aceitação de Linguagens MT para Aceitação de Linguagens


Linguagem L(M): conjunto das palavras aceitas por M Uma MT pode:
Parar e aceitar uma palavra de entrada
Exemplos:
Parar e rejeitar uma palavra de entrada
L1 = (a ∪ b)∗ aa(a ∪ b)∗
Entrar em loop (isto é, não parar)
L2 = {a i bi c i | i ≥ 0}
MT reconhece uma linguagem L, logo L é recursivamente
L3 = {wcv | w e v tem o mesmo número de a e b} enumerável (LI)
L4 = {ww | w ∈ {a, b}+ } 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 (Σ∗ )

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 418 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 419 / 471
Linguagens Irrestritas – Máquinas de Turing

Reflexão
As linguagens L1...4 (anteriormente citadas) são:
a. recursivamente enumeráveis? Linguagens Irrestritas
b. recursivas?
Máquinas de Turing

Variantes

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 420 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 421 / 471

Linguagens Irrestritas – Máquinas de Turing Linguagens Irrestritas – Máquinas de Turing

MT com Fita Bidirecional (ida) Se uma linguagem L é aceita por uma MT com fita
Fita se estende infinitamente para esquerda e para direita bidirecional, então é aceita por uma MT padrão
Uma fita infinita à direita tem o mesmo tamanho de uma fita
Entrada pode ser inserida em qualquer ponto da fita
infinita à direita e à esquerda
Cabeça de leitura/gravação é posicionada no branco basicamente: ∞ = ∞ + ∞
imediatamente à esquerda da palavra de entrada
Para não utilizar a fita “da esquerda”, basta realizar o shift
Uma linguagem L é aceita por uma MT com fita bidirecional de toda a fita “da direita” antes de realizar uma transição
sse é aceita por uma MT padrão (por quê?) que utilizaria a fita “da esquerda”

Exercício de Fixação (volta) Se uma linguagem L é aceita por uma MT padrão, então
MT para somar 1 em um número binário é aceita por uma MT com fita bidirecional
Basta não utilizar a fita “da esquerda”

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 422 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 423 / 471
Linguagens Irrestritas – Máquinas de Turing Linguagens Irrestritas – Máquinas de Turing

MT com Movimento Estático (ida) Se uma linguagem L é aceita por uma MT com movimento
Modificação da função de transição de estados: estático, então é aceita por uma MT padrão
δ : Q × Γ → Q × Γ × {E, D, S} Basta substituir todas transições que possuem movimento
estático como a seguir:
Agora após uma leitura/gravação, é possível não mover a
cabeça de leitura/gravação (S) a/a S a/a D x/x E, ∀x ∈ Γ
qi qj qi qk qj

Seu uso só faz sentido quando se tem mais fitas (por quê?)

Uma linguagem L é aceita por uma MT com movimento (volta) Se uma linguagem L é aceita por uma MT padrão, então
estático sse é aceita por uma MT padrão (por quê?) é aceita por uma MT com movimento estático
Basta não utilizar o movimento estático

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 424 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 425 / 471

Linguagens Irrestritas – Máquinas de Turing Linguagens Irrestritas – Máquinas de Turing

MT Multitrilhas (ida) Se uma linguagem L é aceita por uma MT multitrilha, então


Fita é dividida em múltiplas trilhas, mantendo uma única é aceita por uma MT padrão
cabeça de leitura/gravação Assuma uma MT com duas trilhas
Trilha 1: x0 x1 x2 x3 x4 x5 . . .
Máquina com duas trilhas:
δ(qi , [x, y]) = [qj , [z, w], m], onde m ∈ {E, D} Trilha 2: y0 y1 y2 y3 y4 y5 . . .

x = símbolo a ser lido da Fita 1 1 Intercale as trilhas em uma única fita como a seguir:
y = símbolo a ser lido da Fita 2 Fita: x0 y0 x1 y1 x2 y2 x3 y3 x4 y4 x5 y5 . . .
Cabe, já que como visto ∞ = ∞ + ∞
z = símbolo a ser gravado na Fita 1

w = símbolo a ser gravado na Fita 2


2 Adapte as transições [x/y w/z M] como a seguir:
[x/y w/z M] =⇒ [x/y D] e [w/z D]
Uma linguagem L é aceita por uma MT com duas trilhas sse
é aceita por uma MT padrão (por quê?) Quando M = E, deve-se recuar o número de trilhas × 2

No nosso exemplo (2 trilhas), fazem-se 4 transições [Γ/Γ E]


Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 426 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 427 / 471
Linguagens Irrestritas – Máquinas de Turing Linguagens Irrestritas – Máquinas de Turing

(volta) Se uma linguagem L é aceita por uma MT padrão, então MT Multifitas


é aceita por uma MT multitrilha Máquina com k fitas e k cabeças de leitura/gravação
Basta utilizar somente uma trilha Máquina lê as k fitas simultaneamente (de forma síncrona)
i.e., as demais terão sempre transições B/B
Transição consulta:
Dessa forma, uma transição [x/y D] em uma MT padrão Estado atual (único)
ficaria da seguinte forma em uma MT com n trilhas: Símbolos lidos por cada uma das cabeças
[x/y B2 /B2 B3 /B3 . . . Bn /Bn D]
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ê?)
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 428 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 429 / 471

Linguagens Irrestritas – Máquinas de Turing Linguagens Irrestritas – Máquinas de Turing

MT Multifitas (ida) Se uma linguagem L é aceita por uma MT multifita, então é


Entrada é escrita na Fita 1 aceita por uma MT padrão
Assuma uma MT com duas fitas
Todas as outras fitas estão em branco (BBBBB...)
#1: B a b c B . . .
Todas as fitas começam com a cabeça de
#2: B x y z B . . .
leitura/gravação na posição 0
Assuma também as seguintes configurações:
Exercício de Fixação #1: B q i a b c B . . . (i.e., cabeça de leitura/gravação aponta para a)

MT para reconhecer as seguintes linguagens: #2: B x y q i z B . . . (i.e., cabeça de leitura/gravação aponta para z)
i i
L1 = {a b | i > 0}
1 Concatene as fitas separadas por #

L2 = {wdw | w ∈ {a, b, c} } Fita: B a b c B # B x y z B . . .
L3 = {wcw r | w ∈ {a, b}∗ } 2 Estenda o alfabeto da fita como a seguir:
∀x ∈ Γ → x ∈ Γ0 ∧ x̂ ∈ Γ0 (são adicionados B̂, â, b̂, ĉ, x̂, ŷ e ẑ)

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 430 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 431 / 471
Linguagens Irrestritas – Máquinas de Turing Linguagens Irrestritas – Máquinas de Turing

(ida) Se uma linguagem L é aceita por uma MT multifita, então é (ida) Se uma linguagem L é aceita por uma MT multifita, então é
aceita por uma MT padrão aceita por uma MT padrão
3 Dessa forma, os símbolos “acentuados” correspondem aos 5 A computação para uma transição [a/x D z/c E] será
símbolos que estão com a cabeça de leitura/gravação: realizada como a seguir:
Fita: B â b c B # B x y ẑ B . . . Substitua â por x na “Fita #1”
4 A cabeça de leitura/gravação sempre se inicia na Fita #1: “Acentue” o próximo símbolo da “Fita #1” (b → b̂)
Fita: B q i 0 â b c B # B x y ẑ B . . . Passe para a “Fita #2” (após o símbolo #)

Procure por ẑ (caso não ache, pare)


Substitua ẑ por c

“Acentue” o símbolo anterior da “Fita #2” (y → ŷ)

Retorne à “Fita #1” parando no símbolo “acentuado” e


compute a próxima transição

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 432 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 433 / 471

Linguagens Irrestritas – Máquinas de Turing Linguagens Irrestritas – Máquinas de Turing

(volta) Se uma linguagem L é aceita por uma MT padrão, então MT Não-Determinísticas


é aceita por uma MT multifita Modificação da função de transição de estados:
Basta utilizar somente uma fita δ : Q × Γ → P(Q × Γ × {E, D})
i.e., as demais terão sempre transições B/B S
P(X ): conjunto potência de X (todos subconjuntos de X)
Dessa forma, uma transição [x/y D] em uma MT padrão
Exemplo de transição:
ficaria da seguinte forma em uma MT com n fitas:
δ(q1 , c) = {[q1 , c, D], [q2 , c, D], [q3 , C, E]}
[x/y D, B2 /B2 S, B3 /B3 S, . . . , Bn /Bn S]
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ê?)

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 434 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 435 / 471
Linguagens Irrestritas – Máquinas de Turing Linguagens Irrestritas – Máquinas de Turing

Exercício de Fixação (ida) Se uma linguagem L é aceita por uma MT


MT para reconhecer as seguintes linguagens: Não-Determinística, então é aceita por uma MT padrão
Palavras contendo um c precedido ou sucedido por ab Prova é feita assumindo uma MT multifita
L = {ww | w ∈ {a, b}∗ } uma vez já provamos ter o mesmo poder computacional

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 436 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 437 / 471

Linguagens Irrestritas – Máquinas de Turing Linguagens Irrestritas – Máquinas de Turing

(ida) Se uma linguagem L é aceita por uma MT (ida) Se uma linguagem L é aceita por uma MT
Não-Determinística, então é aceita por uma MT padrão Não-Determinística, então é aceita por uma MT padrão
Assuma 3 fitas: Exemplificando:
#1: B a b b B . . . (palavra de entrada)
Assuma Lexemplo = {w ∈ {a, b}∗ | w termina com b}
#2: q 0 B a b b B # . . . (configurações iniciando com a 1a )
#3: B B B B B . . . (configuração em execução) Assuma a seguinte MTND M em que L(M) = Lexemplo

a/a D
Loop
b/b D
1 Mova a 1a configuração da Fita #2 para Fita #3 (se não tiver, rejeita)
2 Execute a MTND sobre a configuração presente na Fita #3 B/B D b/b D B/B D
q0 q1 q2 q3
Caso não haja transições, verifique se parou em estado final e aceite.
Caso contrário, pule para o passo (3)
Caso haja uma transição possível, execute e concatene a Simule a execução da MTND em uma MT padrão com a
configuração resultante + “#” na Fita #2 palavra abb
Caso hajam várias transições possíveis (ND), concatene todas as Antes, construa a árvore de computações possíveis para o
configurações resultantes + “#” na Fita #2
melhor entendimento
3 Apague Fita #3

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 438 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 439 / 471
Linguagens Irrestritas – Máquinas de Turing Linguagens Irrestritas – Máquinas de Turing

(ida) Se uma linguagem L é aceita por uma MT (ida) Se uma linguagem L é aceita por uma MT
Não-Determinística, então é aceita por uma MT padrão Não-Determinística, então é aceita por uma MT padrão
a/a D a/a D
b/b D b/b D

B/B D b/b D B/B D B/B D b/b D B/B D


q0 q1 q2 q3 q0 q1 q2 q3

#1: B a b b B . . . (palavra de entrada) #1: B a b b B . . . (palavra de entrada)

#2: q 0 B a b b B # . . . (configurações iniciando com a 1a ) #2: B B B B B . . . (mover 1a )

#3: B B B B B . . . (configuração em execução) #3: q 0 B a b b B . . . (executar)

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 440 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 440 / 471

Linguagens Irrestritas – Máquinas de Turing Linguagens Irrestritas – Máquinas de Turing

(ida) Se uma linguagem L é aceita por uma MT (ida) Se uma linguagem L é aceita por uma MT
Não-Determinística, então é aceita por uma MT padrão Não-Determinística, então é aceita por uma MT padrão
a/a D a/a D
b/b D b/b D

B/B D b/b D B/B D B/B D b/b D B/B D


q0 q1 q2 q3 q0 q1 q2 q3

#1: B a b b B . . . (palavra de entrada) #1: B a b b B . . . (palavra de entrada)

#2: B q 1 a b b B # . . . (transição resultante) #2: B B B B B . . . (mover 1a )

#3: B B B B B . . . #3: B q 1 a b b B . . . (executar)

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 440 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 440 / 471
Linguagens Irrestritas – Máquinas de Turing Linguagens Irrestritas – Máquinas de Turing

(ida) Se uma linguagem L é aceita por uma MT (ida) Se uma linguagem L é aceita por uma MT
Não-Determinística, então é aceita por uma MT padrão Não-Determinística, então é aceita por uma MT padrão
a/a D a/a D
b/b D b/b D

B/B D b/b D B/B D B/B D b/b D B/B D


q0 q1 q2 q3 q0 q1 q2 q3

#1: B a b b B . . . (palavra de entrada) #1: B a b b B . . . (palavra de entrada)

#2: B a q 1 b b B # . . . (transição resultante) #2: B B B B B . . . (mover 1a )

#3: B B B B B . . . #3: B a q 1 b b B # . . . (executar, ND)

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 440 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 440 / 471

Linguagens Irrestritas – Máquinas de Turing Linguagens Irrestritas – Máquinas de Turing

(ida) Se uma linguagem L é aceita por uma MT (ida) Se uma linguagem L é aceita por uma MT
Não-Determinística, então é aceita por uma MT padrão Não-Determinística, então é aceita por uma MT padrão
a/a D a/a D
b/b D b/b D

B/B D b/b D B/B D B/B D b/b D B/B D


q0 q1 q2 q3 q0 q1 q2 q3

#1: B a b b B . . . (palavra de entrada) #1: B a b b B . . . (palavra de entrada)

#2: B a b q 1 b B # B a b q 2 b B # . . . (transições resultantes) #2: B a b q 2 b B # . . . (mover 1a )

#3: B B B B B . . . #3: B a b q 1 b B # (executar, ND)

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 440 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 440 / 471
Linguagens Irrestritas – Máquinas de Turing Linguagens Irrestritas – Máquinas de Turing

(ida) Se uma linguagem L é aceita por uma MT (ida) Se uma linguagem L é aceita por uma MT
Não-Determinística, então é aceita por uma MT padrão Não-Determinística, então é aceita por uma MT padrão
a/a D a/a D
b/b D b/b D

B/B D b/b D B/B D B/B D b/b D B/B D


q0 q1 q2 q3 q0 q1 q2 q3

#1: B a b b B . . . (palavra de entrada) #1: B a b b B . . . (palavra de entrada)

#2: B a b q 2 b B # B a b b q 1 B # B a b b q 2 B # . . . (transições res.) #2: B a b b q 1 B # B a b b q 2 B # . . . (mover 1a )

#3: B B B B B . . . #3: B a b q 2 b B # (executar, para e rejeita)

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 440 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 440 / 471

Linguagens Irrestritas – Máquinas de Turing Linguagens Irrestritas – Máquinas de Turing

(ida) Se uma linguagem L é aceita por uma MT (ida) Se uma linguagem L é aceita por uma MT
Não-Determinística, então é aceita por uma MT padrão Não-Determinística, então é aceita por uma MT padrão
a/a D a/a D
b/b D b/b D

B/B D b/b D B/B D B/B D b/b D B/B D


q0 q1 q2 q3 q0 q1 q2 q3

#1: B a b b B . . . (palavra de entrada) #1: B a b b B . . . (palavra de entrada)

#2: B a b b q 1 B # B a b b q 2 B # . . . (antigas transições resultantes) #2: B a b b q 2 B # . . . (mover 1a )

#3: B B B B B . . . #3: B a b b q 1 B # (executar, para e rejeita)

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 440 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 440 / 471
Linguagens Irrestritas – Máquinas de Turing Linguagens Irrestritas – Máquinas de Turing

(ida) Se uma linguagem L é aceita por uma MT (ida) Se uma linguagem L é aceita por uma MT
Não-Determinística, então é aceita por uma MT padrão Não-Determinística, então é aceita por uma MT padrão
a/a D a/a D
b/b D b/b D

B/B D b/b D B/B D B/B D b/b D B/B D


q0 q1 q2 q3 q0 q1 q2 q3

#1: B a b b B . . . (palavra de entrada) #1: B a b b B . . . (palavra de entrada)

#2: B a b b q 2 B # . . . (antiga transição resultante) #2: B B B B B . . . (mover 1a )

#3: B B B B B . . . #3: B a b b q 2 B # . . . (executar)

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 440 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 440 / 471

Linguagens Irrestritas – Máquinas de Turing Linguagens Irrestritas – Máquinas de Turing

(ida) Se uma linguagem L é aceita por uma MT (ida) Se uma linguagem L é aceita por uma MT
Não-Determinística, então é aceita por uma MT padrão Não-Determinística, então é aceita por uma MT padrão
a/a D a/a D
b/b D b/b D

B/B D b/b D B/B D B/B D b/b D B/B D


q0 q1 q2 q3 q0 q1 q2 q3

#1: B a b b B . . . (palavra de entrada) #1: B a b b B . . . (palavra de entrada)

#2: B a b b B q 3 . . . (transição resultante) #2: B B B B B . . . (mover 1a )

#3: B B B B B . . . #3: B a b b B q 3 # . . . (executar, para e aceita)

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 440 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 440 / 471
Linguagens Irrestritas – Máquinas de Turing Linguagens Irrestritas – Máquinas de Turing

(volta) Se uma linguagem L é aceita por uma MT padrão, então MT Enumeradoras de Linguagens
é aceita por uma MT Não-Determinística MT vistas até o momento são aceitadoras de linguagens:
Basta não utilizar transições não-determinísticas Entrada: palavra de acordo com um alfabeto

Saída: palavra válida (parada em estado final) ou inválida

MT Enumeradoras de Linguagens
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

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 441 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 442 / 471

Linguagens Irrestritas – Máquinas de Turing Linguagens Irrestritas – Máquinas de Turing

MT Enumeradoras de Linguagens Exemplo


Uma MT com k-fitas E = (Q, Σ, Γ, δ, q0 ) enumera uma MT para enumerar a linguagem L = {a i bi | i > 0}
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)
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 443 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 444 / 471
Linguagens Irrestritas – Máquinas de Turing Linguagens Irrestritas – Máquinas de Turing

Exemplo Exemplo
MT para enumerar a linguagem L = {a i bi | i > 0} Descrição do funcionamento da MT anterior:
Escreve ## na F1 (já que λ ∈ L)
[B/a D, X /X E]
Escreve “X” na posição 1 da F2
[B/B D, B/B D] [B/# D, B/X S]
q0 q2 q3 Loop:
q3 : volta na F2: para cada X , escreve a na F1

[B/# D, B/X S] [B/B S, B/B D] 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


q4

[B/b D, X /X D]

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 444 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 445 / 471

Linguagens Irrestritas – Máquinas de Turing

Exercício de Fixação
MT para enumerar a linguagem L = {a i bi c i | i ≥ 0}

Linguagens Irrestritas

Teoremas

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 446 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 447 / 471
Linguagens Irrestritas – Teoremas Linguagens Irrestritas – Teoremas

Conceito Básico: Ordem Lexicográfica Linguagem Recursiva


Ordem lexicográfica de Σ: função que mapeia palavras de MT decide uma linguagem L, logo L é recursiva (LSC)
Σ para números naturais Uma MT decide uma linguagem L se ela para para todas as
possíveis palavras de entrada (Σ∗ )
Seja Σ = {a1 , ..., an } um alfabeto. A ordem lexicográfica lo
de Σ é definida recursivamente como:
Teorema #5: L é recursiva se, e somente se, L pode ser
Base: lo(λ) = 0, lo(ai ) = i enumerada em ordem lexicográfica
Passo recursivo: lo(ai u) = i ∗ ntam(u) + lo(u) Deve-se provar que:
Exemplo: Σ = {a, b, c} e a1 = a, a2 = b, a3 = c (ida) se L é recursiva, então L pode ser enumerada em
ordem lexicográfica
lo(λ)= 0, lo(a)= 1, lo(b)= 2, lo(c)= 3,
(volta) Se L pode ser enumerada em ordem lexicográfica,
lo(aa)= 4, lo(ba)= 7, lo(ca)= 10, lo(aaa)=13, lo(aba)=16, então L é recursiva
lo(ab)= 5, lo(bb)= 8, lo(cb)= 11, lo(aab)=14, lo(abb)=17,
lo(ac)= 6, lo(bc)= 9, lo(cc)= 12, lo(aac)=15, lo(abc)=18,

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 448 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 449 / 471

Linguagens Irrestritas – Teoremas Linguagens Irrestritas – Teoremas

Teorema #5 Teorema #5 (explicação gráfica)


(ida) se L é recursiva, então L pode ser enumerada em (ida) se L é recursiva, então L pode ser enumerada em
ordem lexicográfica ordem lexicográfica
Seja M a MT que decide L

Seja E ∗ uma MT que enumera Σ∗ em ordem lexicográfica

Prova consiste em mostrar que pode-se construir uma MT E


que enumera L em ordem lex. como a seguir:

loop:
Rode E ∗ e produza uma palavra u (em ordem lex.)

Rode M com u

Se M aceita u, escreva u na fita de saída de E

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 450 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 451 / 471
Linguagens Irrestritas – Teoremas Linguagens Irrestritas – Teoremas

Teorema #5 (explicação gráfica) Teorema #5


(ida) se L é recursiva, então L pode ser enumerada em (volta) Se L pode ser enumerada em ordem lexicográfica,
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

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 451 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 452 / 471

Linguagens Irrestritas – Teoremas Linguagens Irrestritas – Teoremas

Teorema #5 (explicação gráfica) Teorema #5 (explicação gráfica)


(volta) Se L pode ser enumerada em ordem lexicográfica, (volta) Se L pode ser enumerada em ordem lexicográfica,
então L é recursiva então L é recursiva

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 453 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 453 / 471
Linguagens Irrestritas – Teoremas Linguagens Irrestritas – Teoremas

Linguagem Recursivamente Enumerável Teorema #6


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

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 454 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 455 / 471

Linguagens Irrestritas – Teoremas Linguagens Irrestritas – Teoremas

Teorema #6 (explicação gráfica) Teorema #6 (explicação gráfica)


(volta) se L é enumerada por uma MT, então L é RE (volta) se L é enumerada por uma MT, então L é RE

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 456 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 456 / 471
Linguagens Irrestritas – Teoremas Linguagens Irrestritas – Teoremas

Teorema #6 Teorema #6 (explicação gráfica do porquê força bruta falha)


(ida) se L é RE, então L é enumerada por uma MT (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
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 457 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 458 / 471

Linguagens Irrestritas – Teoremas Linguagens Irrestritas – Teoremas

Preparando a Prova Voltando à Prova


Suponha as palavras de Σ em ordem lexicográfica Significado de par [i,j]: rode M com entrada ui por j passos
λ, u1 , u2 , u3 , ...
Finalmente, a prova que ficou pendente
Seja a seguinte tabela (diagonalização de Cantor):
"Ida": se L é RE, então L é enumerada por uma MT
Seja M a MT que reconhece L
Prova consiste em mostrar que pode-se construir uma MT E
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


Os pares dessa tabela podem ser enumerados “pelas
diagonais”: Cada palavra ui ∈ Σ∗ vai ser testada com 0, 1, 2, 3, ... passos
[λ, 0], [λ, 1], [u1 , 0], [λ, 2], [u1 , 1], [u2 , 0], [λ, 3], [u1 , 2], ... Se ui for válida, M vai parar para algum número k de passos
Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 459 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 460 / 471
Linguagens Irrestritas – Teoremas 7. Considerações Finais – Conteúdo

Teorema #6 (explicação gráfica)


1 Revisão 3

(ida) se L é RE, então L é enumerada por uma MT 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 172


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
Variantes
Critérios de Aceitação
Autômato com Pilha como Reconhecedor
Autômato com Pilha Descendente
Algoritmo de Cocke-Younger-Kasami (CYK)
Algoritmo de Early
Transformação de GLCs para APs
Transformação de APs para GLCs

5 Linguagens Sensíveis ao Contexto 376

6 Linguagens Irrestritas 396


Teoremas
Variantes

7 Considerações Finais 462


Hierarquia de Chomsky 463
Tese de Church-Turing 465

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 461 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 462 / 471

Considerações Finais – Hierarquia de Chomsky

Hierarquia de Chomsky
Tipo Linguagem Gramática Máquina de aceitação

0 Rec. enumerável Irrestrita Máquina de Turing


Considerações Finais 1 Recursiva Sensível ao contexto Autômato linearmente limitado

2 Livre de contexto Livre de contexto Autômato com pilha


Hierarquia de Chomsky 3 Regular Regular Autômato finito

Toda categoria é um subconjunto próprio da categoria superior

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 463 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 464 / 471
Considerações Finais – Tese de Church-Turing

“Toda ‘função naturalmente computável’ pode ser computada


por uma Máquina de Turing.”

Considerações Finais A tese não pode ser formalmente provada


O que é uma função naturalmente computável?
Tese de Church-Turing
No entanto, pode ser refutada
Basta a descoberta de uma máquina mais poderosa que
uma Máquina de Turing

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 465 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 466 / 471

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

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 467 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 468 / 471
Agradecimentos Referências I

P. F. Blauth Menezes.
Linguagens formais e autômatos, volume 3.
Bookman, 6 edition, 2011.
Kleber Marchetti Antunes S. L. G. de Oliveira.
Gostaria de agradecer ao aluno pela tarefa de conversão Algoritmos e seus fundamentos.
inicial da apostila em formato ppt para LaTeX Editora UFLA, 2011.
J. E. Hopcroft and J. D. Ullman.
Formal languages and their relation to automata.
Alberto Hokari Addison-Wesley, 1969.

Gostaria de agradecer ao aluno pelos desenhos das máquinas J. E. Hopcroft and J. D. Ullman.
em formato TikZ e ao desenvolvimento do material de CYK Introduction to Automata Theory, Languages, and Computation.
Addison-Wesley, 1979.

M. Sipser.
Introdução à Teoria da Computação.
Thompson, 2007.

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 469 / 471 Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 470 / 471

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.

Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Outubro, 2017 471 / 471