apostila linguagens formais e autômatos (lfa)

Linguagens Formais e Autômatos

Ricardo Terra

rterrabh [at] gmail.com

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

CV

Nome: Ricardo Terra

Email: terra [at] dcc.ufla.br

www: dcc.ufla.br/⇠terra

Twitter: rterrabh

Lattes: lattes.cnpq.br/ 0162081093970868

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

Background

Acadêmico : UFLA (desde 2014), UFSJ (1 ano ), FUMEC (3 anos ), UNIPAC (1 ano ), FAMINAS (3 anos )

Profissional : DBA Eng. (1 ano ), Synos (2 anos ), Stefanini (1 ano )


1. Revisão – Conteúdo

Conjuntos, relações e funções 4

1 Revisão 3Definições Recursivas 8

Indução Matemática 13

Linguagens Formais e Autômatos (LFA) 17

2 Introdução 59Autômatos Finitos Determinísticos

Autômatos Finitos Não-Determinísticos

Autômatos Finitos Não-Determinísticos com Transições-�

3 Linguagens Regulares 74Máquina de Moore

Máquinas de Mealy

Algoritmos de Transformação

Transformação AFND-� para AFD

Minimização de AFD

Transformação de ER para AFND-�

Recursividade

Árvore de Derivação

Ambiguidade

Backus-Nahur Form (BNF)

4 Linguagens Livres de Contexto 172Remoçã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 373Teoremas

6 Linguagens Irrestritas 393Variantes

7 Considerações Finais 459


Revisão

Conjuntos, relações e funções


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






Revisão

Definições Recursivas


Revisão – Definições Recursivas

Definições RecursivasConjuntos enumeráveis podem ser definidos por meio de

uma definição recursiva

Uma definição recursiva especifica como um conjunto

pode ser gerado a partir de um subconjunto do mesmo

aplicando-se operações um número finito de vezes



Definições RecursivasUma definição recursiva de um conjunto A consta de três

partes:

(i) base: especificação de um conjunto base B ⇢ A

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

que, se aplicadas a elementos de B, geram elementos de A

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

aqueles que podem ser obtidos a partir dos elementos de Baplicando-se um número finito de vezes as operações

especificadas em (ii)



Exemplo #1: Conjunto NO conjunto N pode ser definido a partir de {0} usando-se a

operação s (sucessor)

(i) base: {0} ⇢ N

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

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

obtido de acordo com (i) e (ii)



Exemplo #2: Função Fatorial fat : N ! N(i) base: fat(0) = 1

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

Mais formalmente(i) base: {(0, 1)} ⇢ fat

(ii) passo recursivo: se n � 1 e (n � 1, k) 2 fat , então

(n,n x k) 2 fat

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

conforme (i) e (ii)



Exemplo #2: Função Fatorial fat : N ! N(i) base: fat(0) = 1

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

Mais formalmente(i) base: {(0, 1)} ⇢ fat

(ii) passo recursivo: se n � 1 e (n � 1, k) 2 fat , então

(n,n x k) 2 fat

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

conforme (i) e (ii)


Revisão

Indução Matemática


Revisão – Indução Matemática

Indução MatemáticaTécnica usada para provar que uma propriedade é válida

para todos elementos de um conjunto definido

recursivamente (Veja Sudkamp [6], Seção 1.7)

Considere X um conjunto tendo como base X0

Seja X0

,X1

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

processo recursivo e P uma propriedade

Prova consiste em:

Base: Mostrar que P é válido 8x 2 X0

Hipótese: P é válido 8x 2 X0

, X1

, ..., Xk

Passo indutivo: Mostrar que P também é válido 8x 2 Xk+1

Assim, P é válido 8x 2 X



Exemplo #1: Provar quePn

i=1

i = n(n+1)2

Base: P(1) é verdadeiro, i.e.,

P1

i=1

i = 1(1+1)2

= 1

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

kX

i=1

i =k(k + 1)

2

Passo indutivo: Provar que

PK+1

i=1

i = (K+1)((K+1)+1)2

= (K+1)(K+2)2

PK+1

i=1

i

=PK

i=1

i + (k + 1) (definição somatório)

= k(k+1)2

+ (k + 1) (uso da hipótese de indução)

= k(k+1) + 2(k+1)2

(matemática básica)

= (k+1)(k+2)2



Exemplo #2: Provar que n! > 2

n, 8n > 4

Base: P(5) é verdadeiro, i.e., (5! = 120) > (32 = 2

5)

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

k! > 2

k , 8k > 4

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

(k+1)

(k + 1)!

= k!⇥ (k + 1) (definição fatorial)

> 2

k ⇥ (k + 1) (uso da hipótese de indução)

> 2

k ⇥ 2 (pela certeza que k > 4)

= 2

k+1


Revisão

Linguagens Formais e Autômatos (LFA)


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

Hierarquia de Chomsky

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

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

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

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

3 Regular Regular Autômato finito



Definições BásicasLinguagem: conjunto de palavras sobre um alfabeto

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

Palavra: sequência finita de símbolos de um alfabeto ⌃

|w | = n

ode símbolos da palavra w

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

Fecho de Kleene (

*

)

{a}⇤ = {�,a,aa,aaa,aaaa, ...}

⌃⇤= conjunto de todas as palavras do alfabeto

Fecho Positivo de Kleene (+)

{a}+ = {a}{a}⇤ = {a,aa,aaa,aaaa, ...}

⌃+= ⌃⇤ � {�}



Linguagem Regular (LR)Uma linguagem regular é aquela que pode ser definida por

um conjunto regular

Um conjunto regular pode ser gerado a partir de ⌃ usando

operador de Kleene, união e concatenação

Definição recursiva:

Base: �, {�} e {a}(8a 2 ⌃) são conjuntos regulares

Passo recursivo: se X e Y são conjuntos regulares, então

X [ Y , XY e X⇤também são conjuntos regulares



Linguagem Regular (LR) – ExemploL = palavras sobre {a,b} que começam e terminam com ae possuem pelo menos um bConjunto regular: {a}{a,b}⇤{b}{a,b}⇤{a}

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

L = palavras sobre {a,b} que começam com a e tenham

número par de b



Expressão Regular (ER)Alguns autores (e.g., Sudkamp) usam abreviações para denotar

conjunto regulares:

{�} ! �

{a}(8a 2 ⌃) ! a(8a 2 ⌃)

{a,b} ! (a [ b)

{ab} ! (ab)

{u}⇤ ! u⇤

{xx⇤} ! x+



Expressão Regular (ER) – ExemploL = palavras sobre {a,b} que começam e terminam com ae possuem pelo menos um bExpressão regular:

a(a [ b)⇤b(a [ b)⇤a

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

L = palavras sobre {a,b} que começam com b e tenham

número ímpar de a

2L = palavras sobre {a,b,c} que todo a seja precedido de

um b



Expressão Regular (ER) – ExemploL = palavras sobre {a,b} que começam e terminam com ae possuem pelo menos um bExpressão regular: a(a [ b)⇤b(a [ b)⇤a



número ímpar de a


um b



Expressão Regular (ER) – ExemploL = palavras sobre {a,b} que começam e terminam com ae possuem pelo menos um bExpressão regular: a(a [ b)⇤b(a [ b)⇤a



número ímpar de a


um b



Gramática Regular (GR)Uma GR é uma quádrupla (V ,⌃,P, S):

V = conjunto de símbolos não-terminais (variáveis)

⌃ = conjunto de símbolos terminais (⌃ \ V = �)

P = conj. de regras (produções)

S = símbolo não-terminal inicial (S 2 V )

Regras: µ ! ⌫

µ 2 V (i.e., µ é um elemento de V )

⌫ 2 � | ⌃ | ⌃V (i.e., palavra formada por elementos de V e ⌃)



Gramática Regular (GR) – ExemploL = palavras sobre {a,b} que começam e terminam com ae possuem pelo menos um b

GR(L):

S ! aAA ! aA | bBB ! aB | bB | a

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

L = palavras sobre {a,b,c} que todo b seja seguido de a

2L = palavras sobre {a,b} com número par de a




GR(L):








GR(L):







DerivaçãoAplicação consecutiva de regras

Definição de regra (!) 6= Aplicação de regra ())

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

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

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

Portanto:

Uma palavra w 2 (V [ ⌃)⇤ é uma forma sentencial se S )⇤ w

Uma palavra w 2 ⌃⇤é uma sentença se S )⇤ w

L(G) = {w 2 ⌃⇤ | S )⇤ w}



Dada a seguinte GR(L):S ! aAA ! aA | bBB ! aB | bB | a

Pergunta-se: ababa 2 L(G)?

S ) aA) abB) abaB) ababB) ababa

É uma sentença válida uma vez que S )⇤ ababa

E abbabb 2 L(G)?




Pergunta-se: ababa 2 L(G)?S ) aA) abB) abaB) ababB) ababa


E abbabb 2 L(G)?






E abbabb 2 L(G)?



Autômato FinitoMáquina Reconhecedora de LR

Podem ser determinísticos (AFD)

Podem ser não-determinísticos (AFND)

Podem ser não-determinísticos com transições-� (AFND-�)

Verifica se uma palavra satisfaz condições (i.e., se 2 ou 62 L)

Entrada: palavra qualquer do alfabeto

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



Autômato Finito Determinístico (AFD)Um AFD é uma quíntupla (Q,⌃, �D,q

0

, F):

Q = conjunto finito de estados

⌃ = alfabeto

�D : Q x ⌃ ! Q = função (total) de transições de estados

qo 2 Q = estado inicial

F ✓ Q = conjunto de estados finais (aceitação)

Uma palavra w 2 ⌃⇤é dita ser aceita por um AFD quando,

partindo do estado inicial, forem lidos todos os símbolos

de w e efetuadas as correspondentes transições de modo

que, ao ler o último símbolo, o AFD para em um estado final

A linguagem aceita por um AFD M (Q,⌃, �D,q0

, F) é o

conjunto L(M) = {w 2 ⌃⇤ | �(q0

,w) 2 F}, onde � é a função

de transição estendida para M



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

AFD:

q0

q1

q2

q3

a

a

b

b

a

a

b

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

Exercício de Fixação1

L = palavras sobre {a,b} que contém aaa

2L = palavras sobre {a,b} com número par de a e ímpar de b




AFD:

q0

q1

q2

q3

a

a

b

b

a

a

b








AFD:

q0

q1

q2

q3

a

a

b

b

a

a

b








AFD:

q0

q1

q2

q3

a

a

b

b

a

a

b







Autômato Finito Não-Determinístico (AFND)Um AFND é uma quíntupla (Q,⌃, �ND,q

0

, F):


⌃ = alfabeto

�ND : Q x ⌃ ! P(Q) = função (total) de transições de estados



Uma palavra w 2 ⌃⇤é dita ser aceita por um AFND se, e

somente se, existe uma computação que a consome e

para em um estado final

Para todo AFND, existe um AFD equivalente

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




AFND:

q0

q1

q2

q3

a b

a

a,b

a

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


L = palavras sobre {a,b} que contém aa ou bb

2L = (a [ b)⇤bb




AFND:

q0

q1

q2

q3

a b

a

a,b

a




2L = (a [ b)⇤bb




AFND:

q0

q1

q2

q3

a b

a

a,b

a




2L = (a [ b)⇤bb




AFND:

q0

q1

q2

q3

a b

a

a,b

a




2L = (a [ b)⇤bb



Autômato Finito Não-Determinístico com Transições-� (AFND-�)Um AFND-� é uma quíntupla (Q,⌃, �ND��,q

0

, F):


⌃ = alfabeto

�ND�� : Q x (⌃ [ {�}) ! P(Q) = f. de transições de estados



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




ExemploL = palavras sobre {a,b} com tamanho par

AFND-�:

q0

q1

q3

a,b

�

a,b

�



ExemploL = palavras sobre {a,b} com tamanho par

AFND-�:

q0

q1

q3

a,b

�

a,b

�











Gramática Livre de Contexto (GLC)Uma GLC é uma quádrupla (V ,⌃,P, S):





Regras: µ ! ⌫

µ 2 V (i.e., um não-terminal)

⌫ 2 (V [ ⌃)⇤ (i.e., palavra formada por elementos de V e ⌃)



Exemplo Clássico

L(G) = {aibi | i > 0}

GLC(L):

S ! aSb | ab

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



Exemplo Clássico

L(G) = {aibi | i > 0}

GLC(L):

S ! aSb | ab




Exemplo Clássico 2

L(G) = {w 2 {a,b}⇤ | w = wR}

GLC(L):

S ! aSa | bSb | a | b | �




Exemplo Clássico 2

L(G) = {w 2 {a,b}⇤ | w = wR}

GLC(L):

S ! aSa | bSb | a | b | �





L = {anbman|n > 0,m > 0}

2L = {anbmcmd2n|n � 0,m > 0}




Autômato com PilhaMáquina Aceitadora de LLC

Podem ser determinísticos (APD)

Aceita todas as LR e um sub-grupo de LLC

Se forem não-determinísticos (APND)

Aceita todas as LLC

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



Autômato com Pilha Determinístico (APD)Um APD é uma sextupla (Q,⌃, �, �,q

0

, F):


⌃ = alfabeto de entrada

� = alfabeto da pilha

� : Q x (⌃ [ �) x (� [ �) ! P(Q x (� [ �))= função de transições de estados



Não permite transições �(qi ,a,b) e �(qi ,a0,b0) compatíveis:

(a = a0ou a = � ou a0 = �) e (b = b0

ou b = � ou b0 6= �)

Uma palavra w 2 ⌃⇤é dita ser aceita por um APD quando

for totalmente consumida e que a máquina termine em um

estado final com pilha vazia (aceitação por parada em estado final e pilha vazia)



Exemplo Clássico

L(G) = {aibi | i > 0}

APD:

q0

q1

a �/X

b X/�

b X/�



Exemplo Clássico

L(G) = {aibi | i > 0}

APD:

q0

q1

a �/X

b X/�

b X/�



Autômato com Pilha Não-Determinístico (APND)Um APND é uma sextupla (Q,⌃, �, �,q

0

, F):







Permite transições �(qi ,a,b) e �(qi ,a0,b0) compatíveis:

�(qi ,a,b) = {[qj ,B], [qk ,C]}

Uma palavra w 2 ⌃⇤é dita ser aceita por um APND se, e


para em um estado final com pilha vazia



Exemplo Clássico 2

L(G) = {w 2 {a,b}⇤ | w = wR}

APND:

q0

q1

a �/A

b �/B

a �/�b �/�� /�

a A/�b B/�

Toda LLC é aceita por um APND



Exemplo Clássico 2

L(G) = {w 2 {a,b}⇤ | w = wR}

APND:

q0

q1

a �/A

b �/B

a �/�b �/�� /�

a A/�b B/�

Toda LLC é aceita por um APND











Gramática Sensível ao Contexto (GSC)Uma GSC é uma quádrupla (V ,⌃,P, S):





Regras: µ ! ⌫

µ 2 (V [ ⌃)+ (i.e., palavra formada por elementos de V e ⌃)

⌫ 2 (V [ ⌃)+ (i.e., palavra formada por elementos de V e ⌃)

|µ| |⌫| (i.e., regras não-contráteis)

� nunca é uma palavra válida em uma LSC



Exemplo Clássico

L = {aibici | i > 0}

GSC(L):

S ! aAbc | abcA ! aAbC | abCCb ! bCCc ! cc

Toda LSC é recursiva, logo:

existe uma ALL que aceita LSC

existe uma MT que decide LSC, i.e., sempre para para

qualquer entrada w 2 ⌃⇤



Autômato Linearmente Limitado (ALL)Um ALL é uma óctupla (Q,⌃, �, �,q

0

, <,>, F):



� = alfabeto da fita

� : Q ⇥ � ! Q ⇥ �⇥ {E,D} = função de transições de estados



< e > = delimitadores da palavra de entrada



Autômato Linearmente Limitado (ALL)Seja w uma palavra de entrada

Configuração inicial da fita: <w>

Delimitadores podem ser lidos, mas não apagados

Delimitadores não podem ser ultrapassados

Tamanho da fita = |w |+ 2

Basicamente, um ALL é uma MT cuja quantidade de fita

disponível é limitada ao tamanho da palavra de entrada



Exemplo Clássico


q0

q1

q2

q3

q4

q5

q6

q7

</<Da/X D

Y/Y D

b/Y D

Y/Y , Da/a, D

c/Z D

Z/Z , Db/b, D

> / > E

c/c D

X/X D

c/c, EZ/Z , Eb/b, EY/Y , Ea/a, E

>/>E

Y/Y , DZ/Z , D

Z/Z , EY/Y , EX/X , E











Gramática Irrestrita (GI)Todo o universo de linguagens é gerado por GI

Uma GI é uma quádrupla (V ,⌃,P, S):





Regras: µ ! ⌫



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



Exemplo ClássicoL = {u[u] | u 2 {a,b}⇤}GI(L):

S ! aT [a] | bT [b] | []T [! aT [A | bT [B | [Aa ! aAAb ! bABa ! aBBb ! bBA] ! a]

B] ! b]

Toda GI é recursivamente enumerável, logo:

existe uma MT que reconhece LI, mas não necessariamente

para para qualquer entrada w 2 ⌃⇤



Máquina de Turing (MT)Um MT é uma séxtupla (Q,⌃, �, �,q

0

, F):







Memória ilimitadaSeja w uma palavra de entrada

Configuração inicial da fita: BwBBBBBBBB...

A fita é infinita à direita



Exemplo ClássicoL = {u[u] | u 2 {a,b}⇤}

q0

q1

q2

q3

q4

q5

q6

q7

q8

q9

q10

B/B D

a/X

D

b/YD

[/[ D

[/[ D

a/a Db/b D

a/XE

X/X DY/Y D

[/[ E X/X EY/Y E

X/X DY/Y D

a/a Eb/b E

[/[ D

a/a Db/b D

b/Y

E

X/X DY/Y D]/] D

X/X DY/Y D

B/B EX/a EY/b E[/[E]/]E


Revisão

Lemas, Teoremas, Corolários, etc.


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

DefiniçõesDefinem objetos e noções que são úteis em um

determinado estudo

Exemplo: Um AP é uma sextupla (Q,⌃, �, �,q0

, F)...

Lema e Teorema

Lema: É um pré-teorema, i.e., um resultado que leva a umteorema ou que é usado na prova de um teorema

Teorema: É um resultado mais importante e interessante

Existem exceções, e.g., Pumping Lemma é um teorema


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

CorolárioConsequência imediata de um teorema

ProposiçãoUma observação que pode ser facilmente comprovada

não associada a um teorema em particular

Axioma (ou postulado)Proposição que não precisa ser provada

por ser evidente, consensual, etc.

Exemplo: o sucessor de um natural é outro natural


2. Introdução – Conteúdo

1 Revisão 3Hierarquia de Chomsky 60

Conceitos Básicos 63





Máquinas de Mealy





Recursividade


Ambiguidade






Variantes





Algoritmo de Early







Introdução



Introdução – Hierarquia de Chomsky

Hierarquia de ChomskyNoam Chomsky (1927-presente): poeta, filósofo, linguista,

professor do MIT, e crítico do capitalismo e da política

externa americana

Noam Chomsky (1956) constitui uma classificação para

linguagens, gramáticas e autômatos


Introdução – Hierarquia de Chomsky







Toda categoria é um subconjunto próprio da categoria superior


Introdução

Conceitos Básicos


Introdução – Conceitos Básicos

DefiniçõesLinguagem: conjunto de palavras sobre um alfabeto

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

Palavra (string): sequência de símbolos de um alfabeto

Convenções:

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

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



Definições⌃⇤

é o conjunto de todas as palavras geradas por ⌃

⇤(estrela): operador de Kleene

Definição Recursiva Revisão

⌃⇤é definido recursivamente da seguinte forma:

1base: � 2 ⌃* (� é a palavra vazia)

2passo recursivo: se w 2 ⌃* e a 2 ⌃ então wa 2 ⌃*

3fechamento: w 2 ⌃* sse puder ser obtida a partir de � com

um número finito de aplicações de (2)



ExemploSe ⌃ = {a,b,c}, então ⌃⇤

inclui:

Tamanho zero: �

Tamanho um: a b c

Tamanho dois: aa ab ac ba bb bc ca cb cc

etc.



DefiniçõesTamanho de uma palavra w : número de aplicações do

passo recursivo para se obter w

Linguagem (L): subconjunto do conjunto de todas as

possíveis palavras de um alfabeto (L ✓ ⌃⇤)

Palavras que interessam são as palavras válidase.g., se ⌃ = {Maria, fala,alto}, quais são as palavras válidas?



ConcatenaçãoSeja u, v 2 ⌃⇤

. A concatenação de u e v , escrita uv , é uma

operação binária em ⌃⇤definida assim:

base: se tam(v) = 0, então v = � e uv = u

passo recursivo: se tam(v) = n, onde n > 0 então:

v = wa, com tam(w) = n � 1 e a 2 ⌃

Assim, uv = u(wa) = (uw)a

Concatenação não é comutativa

Prova: (por contra-exemplo)

Se u = ab e v = ca então uv = abca e vu = caab

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

Sim? Então prova!

Revisão de Indução Matemática



Prova de Associatividade (por indução no comprimento da palavra w)

Teorema: Seja u, v ,w 2 ⌃⇤, então (uv)w = u(vw)

Base: se tam(w) = 0, então w = �

(uv)w = (uv)� = uv e u(vw) = u(v�) = u(v) = uv

Logo, (uv)w = u(vw)

Hipótese: (uv)w = u(vw) 8w , tam(w) k

Passo indutivo: provar (uv)w = u(vw) 8w , tam(w) = k + 1

Seja w = xa, tam(x) = k , a 2 ⌃

(uv)w = (uv)(xa) == ((uv)x)a (definição concatenação)

= (u(vx))a (uso da hipótese de indução)

= u((vx)a) (definição concatenação)

= u(v(xa)) (definição concatenação)

= u(vw)



Subpalavra, Prefixo, Sufixo, Reversox é uma subpalavra de y se 9x , v , z | y = zxv

x é dito prefixo de y se z = �, ou seja, y = xv

x é dito sufixo de y se v = �, ou seja, y = zx

Seja w 2 ⌃⇤. O reverso de w , ou wR

, é definido por:

base: se tam(w) = 0, então w = � e �R = �

passo recursivo: se tam(w) = n, onde n � 1 então:

w = ua, com tam(u) = n � 1 e a 2 ⌃

Assim, wR = (ua)R = a(u)R = auR



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

Teorema: seja u, v 2 ⌃⇤, então (uv)R = vRuR

Base: se tam(v) = 0, então v = �

(uv)R = (u�)R = uRe vRuR = �RuR = uR

Hipótese: (uv)R = vRuR 8w , tam(w) k

Passo indutivo: provar (uv)R = vRuR 8v , tam(v) = k + 1

Seja v = wa, tam(w) = k , a 2 ⌃

(uv)R = (u(wa))R == ((uw)a)R

(associatividade concatenação)

= a(uw)R(definição de reverso)

= a(wRuR) (uso da hipótese de indução)

= (awR)uR(associatividade)

= (wa)RuR(definição de reverso)

= vRuR



Concatenação de LinguagensUma linguagem L é um subconjunto de ⌃* (L ✓ ⌃*)

Concatenação das linguagens X e Y, denotada XY, é a

linguagem: XY = {xy | x 2 X e y 2 Y}

Exemplo: X = {a,b,c} e Y = {abb,ba}XY = {aabb,aba,babb,bba,cabb,cba}

Xn: concatenação de X com X mesmo n vezes

X0 = {�}X1 = {a,b,c}X2 = {aa,ab,ac,ba,bb,bc,ca,cb,cc}

X⇤: todas as palavras construídas a partir de X



X⇤(definição formal)

X⇤ =1[

i=0

X i

X+(definição formal)

X+ =1[

i=1

X i


3. Linguagens Regulares – Conteúdo

1 Revisão 3

2 Introdução 59Conjuntos Regulares 76

Expressões Regulares 80

Gramáticas Regulares 85

Autômatos Finitos 92

Autômatos Finitos Determinísticos



3 Linguagens Regulares 74Autômatos com Saída 116

Máquina de Moore

Máquinas de Mealy


Algoritmos 134




Propriedades 156

Lema do Bombeamento 163

Recursividade


Ambiguidade






Variantes





Algoritmo de Early







Linguagens Regulares – Hierarquia de Chomsky








Linguagens Regulares

Conjuntos Regulares


Linguagens Regulares – Conjuntos Regulares

Especificação Finita de LinguagensRequer uma descrição não ambígua das palavras

Exemplo #1 (⌃ = {a,b})

Palavras com pelo menos uma ocorrência de bb:

L = {a,b}⇤{bb}{a,b}⇤

Palavras que possuem prefixo aa ou sufixo bbL = {aa}{a,b}⇤ [ {a,b}⇤{bb}

Exemplo #2 (⌃ = {b})

L1

= {bb} e L2

= {�,bb,bbbb}Palavras com número par de b: L

1

⇤e L

2

⇤

L1

⇤ = {�,bb,bbbb,bbbbbb, ...}L

2

⇤ = {�,bb,bbbb,bbbbbb, ...}



Conjuntos RegularesUma linguagem regular é aquela que pode ser definida por

um conjunto regular

Um conjunto é regular se pode ser gerado a partir de ⌃usando operador de Kleene, união e concatenação




Um conjunto regular é definido recursivamente da seguinte

forma:

1base: ;, {�} e {a}8a 2 ⌃ são conjuntos regulares

2passo recursivo: se X e Y são conjuntos regulares, então

X [ Y , XY e X⇤também são conjuntos regulares

ExemploPalavras sobre {a,b} que começam e terminam com a e

contêm pelo menos um b

{a}{a,b}⇤{b}{a,b}⇤{a}



Expressões Regulares


Linguagens Regulares – Expressões Regulares

Expressões RegularesAbreviação para conjuntos regulares

PS: x+denota xx⇤


Uma expressão regular é definido recursivamente da

seguinte forma:

1base: ;, � e a(8a 2 ⌃), são expressões regulares

2passo recursivo: se u e v são expressões regulares, então

u [ v , uv e u⇤são expressões regulares

Exemplos{a}{a,b}⇤{b}{a,b}⇤{a} = a(a [ b)⇤b(a [ b)⇤a

{a,b}⇤{bb}{a,b}⇤ = (a [ b)⇤bb(a [ b)⇤



Exercícios1

Considerando ⌃ = {a,b}, crie expressões regulares para as

seguintes linguagens:

L1

= {bawab | w 2 {a,b}⇤}

L2

= palavras contendo aa ou bb

L3

= palavras contendo aa e bb

L4

= palavras com número par de b

L5

= palavras que não contém aa

2Considerando ⌃ = {a,b,c} e L = c⇤(b [ (ac⇤))⇤, verifique se

as seguintes palavras estão em L:

acabaccbbaaacc



Identidades1 ;w = w; = ;

2 �w = w� = w

3 ;⇤ = �

4 �⇤ = �

5 w [ u = u [ w

6 w [ ; = w

7 w [ w = w

8 w⇤w⇤ = w⇤

9 (w⇤)⇤ = w⇤

10 w⇤w = ww⇤ = w+

11 w(x [ y) = wx [ wy

12 (x [ y)w = xw [ yw

13 (wy)⇤w = w(yw)⇤

14 (w [ y)⇤ = (w⇤ [ y)⇤

= w⇤(w [ y)⇤

= (w [ yw⇤)⇤

= (w⇤y⇤)⇤

= w⇤(yw⇤)⇤

= (w⇤y)⇤w⇤



ExercíciosMostre que:

b⇤(ab+)⇤ [ b⇤(ab+)⇤a = (b [ ab)⇤(� [ a)

a⇤(a⇤ba⇤ba⇤)⇤ = a⇤(ba⇤ba⇤)⇤

PSERs em Compiladores normalmente adotam | ao invés de [

i.e., a | b , a [ b

PS2Existem linguagens que não podem definidas por

expressões regulares

Por exemplo, {anbn | n � 0}

E aí, o que isso significa?



Gramáticas Regulares


Linguagens Regulares – Gramáticas Regulares

Gramática Regular (GR)Uma GR é uma quádrupla (V ,⌃,P, S):





Regras: µ ! ⌫

µ 2 V (i.e., µ é um elemento de V )

⌫ 2 � | ⌃ | ⌃V (i.e., palavra formada por elementos de V e ⌃)




GR(L):


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 ! �




GR(L):










GR(L):










L = a+b⇤

2L = {�} [ {ab}{ab}⇤{a}⇤

3L = palavras sobre {a,b,c} que todo b seja seguido de a






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

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

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

Portanto:



L(G) = {w 2 ⌃⇤ | S )⇤ w}




Pergunta-se: ababa 2 L(G)?

S ) aA) abB) abaB) ababB) ababa


E abbabb 2 L(G)?






E abbabb 2 L(G)?






E abbabb 2 L(G)?



EnfimUma linguagem é regular se pode ser gerada por alguma

gramática regular (ou CR ou ER)



Autômatos Finitos


Linguagens Regulares – Autômatos Finitos

Autômato FinitoMáquina Reconhecedora de LR

Podem ser determinísticos (AFD)

Podem ser não-determinísticos (AFND)

Podem ser não-determinísticos com transições-� (AFND-�)

Verifica se uma palavra satisfaz condições (i.e., se 2 ou 62 L)

Entrada: palavra qualquer do alfabeto

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

Linguagem L é regular sse existe um AF que reconhece L



Autômatos Finitos

Autômatos Finitos Determinísticos


Linguagens Regulares – Autômatos Finitos – AFD

Autômato Finito Determinístico (AFD)Um AFD é uma quíntupla (Q,⌃, �D,q

0

, F):


⌃ = alfabeto




Uma palavra w 2 ⌃⇤é dita ser aceita por um AFD quando,

partindo do estado inicial, forem lidos todos os símbolos

de w e efetuadas as correspondentes transições de modo

que, ao ler o último símbolo, o AFD para em um estado final

A linguagem aceita por um AFD M (Q,⌃, �D,q0

, F) é o

conjunto L(M) = {w 2 ⌃⇤ | �D(q0

,w) 2 F}, onde �D é a função

de transição estendida para M




AFD:

q0

q1

q2

q3

a

a

b

b

a

a

b





AFD:

q0

q1

q2

q3

a

a

b

b

a

a

b



�D a b

q0

q1

�q

1

q1

q2

q2

q3

q2

q3 q3

q2



AFD:

q0

q1

q2

q3

a

a

b

b

a

a

b



�D a b

q0

q1

�q

1

q1

q2

q2

q3

q2

q3 q3

q2


Exercícios de Fixação1


2L = palavras sobre {a,b} que contém aaa




Função de Transição (�D)�D : Q x ⌃ ! Q

se total, então

em todos os estados (Q), existe transições para todos os

símbolos (⌃)

AFD é completoAFD nunca trava

se parcial, então

em algum estado (Q), pode não existir transição para algum

símbolo (⌃)

AFD é incompletoAFD pode travar



Como transformar uma função parcial em uma total?1

Criar um estado não final qerro

2 8x 2 ⌃ =) �(qerro, x) ! qerro

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

3 �(qi , x) # =) �(qi , x) ! qerro

toda transição indefinida agora vai para qerro

q0

q1

q2

q3

a b

a b

a



Como transformar uma função parcial em uma total?1

Criar um estado não final qerro

2 8x 2 ⌃ =) �(qerro, x) ! qerro

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

3 �(qi , x) # =) �(qi , x) ! qerro

toda transição indefinida agora vai para qerro

q0

q1

q2

q3

qerro

a

b

b

a b

a

a,b



Aceitação / RejeiçãoUm AF aceita a entrada quando

após processar o último símbolo, assume um estado final (F)

Um AF rejeita a entrada quando

após processar o último símbolo, assume um estado não final

trava durante seu processamento



Função de Transição Estendida (�D)

É uma extensão da função de transição original que a partir

de um estado de origem (Q) e uma palavra (⌃⇤), retorna o

estado final do processamento (Q)

�D : Q x ⌃⇤ ! Q

ACEITA(M) = {w 2 ⌃⇤ | �D(q0

,w) 2 F} = L(M)

REJEITA(M) = {w 2 ⌃⇤ | �D(q0

,w) 62 F}

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



Outros Exercícios1

L = ⌃⇤

2L = ;

Pergunta-seQual a principal diferença?

Logo, como modificar um AFD M que reconhece L para

reconhecer L?



Questões importantes1

Pode um AF entrar em loop?

2Dado dois AFs M

1

e M2

, pergunta-se:

Quando os dois AFs são equivalentes?

ACEITA(M) \ REJEITA(M) =

ACEITA(M) [ REJEITA(M) =

⇠ACEITA(M) =

⇠REJEITA(M) =



Questões importantes1

Pode um AF entrar em loop?

2Dado dois AFs M

1

e M2

, pergunta-se:

Quando os dois AFs são equivalentes? L(M1

) = L(M2

)

ACEITA(M) \ REJEITA(M) = ;

ACEITA(M) [ REJEITA(M) = ⌃⇤ = U

⇠ACEITA(M) = REJEITA(M)

⇠REJEITA(M) = ACEITA(M) = L(M)



Autômatos Finitos



Linguagens Regulares – Autômatos Finitos – AFND

ComposiçãoA construção de sistemas é composicional, geralmente

É importante diferenciar três formas de composição:

Sequencial: A execução do próximo componente dependedo término do anterior

Concorrente: A execução dos componentes é irrelevante,

i.e., são componentes independentes

Não-determinista: A execução do próximo componente é

uma escolha entre diversos componentes alternativos

Exemplo: sistema bancário (atendimento em caixas)



Autômato Finito Não-Determinístico (AFND)Um AFND é uma quíntupla (Q,⌃, �ND,q

0

, F):


⌃ = alfabeto

�ND : Q x ⌃ ! P(Q) = função (total) de transições de estados



Uma palavra w 2 ⌃⇤é dita ser aceita por um AFND se, e


para em um estado final

Para todo AFND, existe um AFD equivalente





AFND:

q0

q1

q2

q3

a b

a

a,b

a

Qual seria a árvore de computações para a palavra abaaa?




AFND:

q0

q1

q2

q3

a b

a

a,b

a



�ND a b

q0

{q1

} ;q

1

{q1

} {q2

}q

2

{q2

,q3

} {q2

}q3 ; ;



AFND:

q0

q1

q2

q3

a b

a

a,b

a



�ND a b

q0

{q1

} ;q

1

{q1

} {q2

}q

2

{q2

,q3

} {q2

}q3 ; ;


Exercício de Fixação1 L

1

= palavras sobre {a,b} que contém aa ou bb

2 L2

= (a [ b)⇤bb

3 L3

= palavras sobre {a,b} que terminam com aaa



Aceitação / RejeiçãoUm AF aceita a entrada quando

após processar o último símbolo, em alguma das possíveis

computações, assume um estado final (F)

Um AF rejeita a entrada quando

(1) após processar o último símbolo, em todas as possíveis

computações, assume um estado não final

(2) trava durante seu processamento, em todas as possíveis

computações

(3) qualquer combinação de (1) ou (2)

e.g., das 10 possíveis computações, 7 assumem estado

não final e 3 travam



Função de Transição Estendida (�ND)

É uma extensão da função de transição original que a partir

de um estado de origem (Q) e uma palavra (⌃⇤), retorna

todos os possível estados finais do processamento (P(Q))

�ND : Q x ⌃⇤ ! P(Q)

ACEITA(M) = {w 2 ⌃⇤ | �ND(q0

,w) \ F 6= ;} = L(M)

REJEITA(M) = {w 2 ⌃⇤ | �ND(q0

,w) \ F = ;}



Pontos ImportantesMuitas vezes, é muito mais fácil desenvolver um AFND do

que um AFD

Por exemplo:

L = palavras sobre {a,b} cujo quinto último símbolo é a

Solução AFD: trabalhosa, 32 estados

Solução AFND: simples, 6 estados

Um estratégia bem conhecida:Construir o AFND

Aplicar o algoritmo AFND ! AFD

Algoritmo AFND ! AFD



Autômatos Finitos



Linguagens Regulares – Autômatos Finitos – AFND-�

Autômato Finito Não-Determinístico com Transições-� (AFND-�)Um AFND-� é uma quíntupla (Q,⌃, �ND��,q

0

, F):


⌃ = alfabeto

�ND�� : Q x (⌃ [ {�}) ! P(Q) = f. de transições de estados



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


É muito similar ao AFND

Tem como vantagem facilitar construções e demonstrações

Por exemplo, o algoritmo ER ! AFND-� Algoritmo ER ! AFND-�



Exemplo

L = {0

k | k é múltiplo de 2 ou 3}

AFND-�:

q0

q1

q2

q3

q5

q4

�

�

0

0

0

00



Exemplo

L = {0

k | k é múltiplo de 2 ou 3}

AFND-�:

q0

q1

q2

q3

q5

q4

�

�

0

0

0

00


�ND�� 0 �

q0

; {q1

,q3

}q1 {q

2

} ;q

2

{q1

} ;q3 {q

4

} ;q

4

{q5

} ;q

5

{q3

} ;



L = (a [ b)⇤bb ou aa(a [ b)⇤

2L = palavras sobre {a,b,c} que terminam com a ou bb ou

ccc



Autômatos com Saída




Máquina de Moore


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

Máquina de MooreUma máquina de Moore é uma sêxtupla (Q,⌃, �, �D,�,q

0

):



� = alfabeto da saída


� : Q ! � = função (total) de saída


Uma máquina de Moore é um AFD com um símbolo de

saída associado a cada estado



Funcionamento da Máquina de MooreFuncionamento semelhante aos AFDs

Ao invés de uma saída binária (aceita/rejeita), é uma

palavra

Na prática, é uma máquina de estados finitos transdutora

O primeiro símbolo da palavra de saída é sempre �(q0

)

Logo, o tamanho da saída é igual a w + 1

Sempre que se atingir um estado Q/Y , concatena-se o

simbolo Y = �(Q) à direita da palavra de saída

No exemplo abaixo, ao se atingir o estado q3

, concatena-se

“2” à direita da palavra de saída, i.e., �(q3

) = 2

q3

/2



Exemplo #1Máquina de Moore que determina o número de apresentes nos dois últimos símbolos da palavra de entrada

bb/0 aa/2

ab/1

ba/1

b

a a

b

a

b

a

b

O último símbolo da palavra de saída indica o resultado



Função de Saída Estendida (r)Dados um estado (Q) e uma palavra de entrada (⌃⇤

),

retorna a palavra de saída da máquina de Moore:

r : Q ⇥ ⌃⇤ ! �+

Formalização:

r(Q,�) = �(Q)

r(Q,ay) = �(Q) r( �D(Q,a), y), 8a 2 ⌃ e y 2 ⌃⇤

Saída Computada:

A saída de uma máquina de Moore M = (Q,⌃, �, �D,�,q0

)para a palavra w 2 ⌃⇤

é r(q0

,w)

Assim, retome o Exemplo #1 e compute r(bb,aaab)



Simulação de AFDs com Máquinas de MooreQualquer AFD M pode ser simulado utilizando-se uma

máquina de Moore

Uma possibilidade é fazer:

� = {0, 1}

�(Q) =

⇢1, se Q 2 F0, se Q 62 F

Logo, w 2 L(M) sse r(q0

,w) termina em 1



Exemplo #2Máquina de Moore que simula um AFD que reconhece as

palavras que terminam com aa

bb/0 aa/1

ab/0

ba/0

b

a a

b

a

b

a

b


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

Exercício1

Projetar uma AFD que cuja soma dos símbolos da palavra

seja divisível por 4, considerando ⌃ = {0, 1, 2, 3}Dica

1

: A máquina deve aceitar “13”, “1111”, “202”, . . .

Dica

2

: Um estado para cada resto (e.g., 0%4, 1%4, . . . )

2Projetar uma Máquina de Moore cujo último símbolo da

palavra de saída represente o resto da divisão por 4,

considerando ⌃ = {0, 1, 2, 3}Dica: Pequena alteração em (1)




Máquinas de Mealy


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

Máquina de MealyUma máquina de Mealy é uma sêxtupla (Q,⌃, �, �D,�,q

0

):



� = alfabeto da saída


� : Q ⇥ ⌃ ! � = função (total) de saída


Uma máquina de Mealy é um AFD com um símbolo de

saída associado a cada transição



Funcionamento da Máquina de MealyFuncionamento semelhante aos AFDs

Ao invés de uma saída binária (aceita ou rejeita), é uma

palavra

Na prática, é uma máquina de estados finitos transdutora

O tamanho da saída é igual ao tamanho da palavra

Sempre que, a partir de um estado Q, é efetuada uma

transição a/d , concatena-se o símbolo d = �(Q,a) à

direita da palavra de saída

No exemplo abaixo, a partir do estado q2

, ao se efetuar a

transição a/1, concatena-se “1” à direita da palavra de

saída, i.e., �(q2

,a) = 1

q2

q3

a/1



Exemplo #3Máquina de Mealy que determina o quociente da divisão

de um número binário por 6

q0

q1

q2

q3

q4

q5

0/0

1/0

1/0

0/0

1/0

0/0

1/1

0/1

1/1

0/1

1/1

0/1



Exemplo #4Modificação 2 em 1

Mealy: quociente da divisão por 6 (transições)

Moore: resto da divisão por 6 (estados)

q0

/0

q1

/1

q2

/2

q3

/3

q4

/4q5

/5

0/0

1/0

1/0

0/0

1/0

0/0

1/1

0/1

1/1

0/1

1/1

0/1



Função de Saída Estendida (s)Dados um estado (Q) e uma palavra de entrada (⌃⇤

),

retorna a palavra de saída da máquina de Mealy:

s : Q ⇥ ⌃⇤ ! �⇤

Formalização:

s(Q,�) = �

s(Q,ay) = �(Q,a) s( �D(Q,a), y), 8a 2 ⌃ e y 2 ⌃⇤

Saída Computada:

A saída de uma máquina de Mealy M = (Q,⌃, �, �D,�,q0

)para a palavra w 2 ⌃⇤

é s(q0

,w)

Assim, retome o Exemplo #3 e compute s(q0

, 1000) e

s(q0

, 1100)


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

Exercício1

Projetar uma Máquina de Mealy que troque a por b e

vice-versa, considerando ⌃ = {a,b}Dica: Não complique o que é simples







Algoritmos de TransformaçãoExistem algoritmos de transformação de uma Máquina de

Moore para uma Máquina de Mealy e vice-versa, com

certas ressalvas

No entanto, não serão abordados na disciplina

Os algoritmos podem ser encontrados em Vieira [8]



Algoritmos



Algoritmos



Linguagens Regulares – Algoritmos – AFND-� para AFD

Transformação de um AFND-� para AFD1

AFND-� ! AFND

i.e., �ND�� ! �ND

Importante: AFND pode ter mais de um estado inicial

2AFND ! AFD

i.e., �ND ! �D

Importante: Dado um AFND com n estados, o AFD

correspondente pode ter até 2

nestados (e.g., 5 ! 32)

Por isso, abordaremos um algoritmo de construção de estados

sob demanda (para evitar estados inúteis)

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



AFND-�

q0

q1

q2

a

a

a

b

�

c

�ND�� a b c � fecho(�)q

0

{q0

,q1

,q2

} ; ; ; {q0

}q

1

; {q1

} ; ; {q1

}q

2

; ; {q2

} {q1

} {q2

,q1

}

*fecho��(qi) = qi + estados acessíveis a partir de qi lendo �

1 �ND�� ! �ND

i. São estados iniciais: fecho��(q0

)

Se um estado inicial alcança um

estado final, tal inicial será final

ii. Para os outros estados qi :

considera todo estado em fecho��(qi )

consome, para em um estado qj e então

adiciona fecho��(qj )

�ND a b c

q0

{q0

,q1

,q2

} ; ;q

1

; {q1

} ;q

2

;

{q1} {q1,q2}



AFND-�

q0

q1

q2

a

a

a

b

�

c


0

{q0

,q1

,q2

} ; ; ; {q0

}q

1

; {q1

} ; ; {q1

}q

2

; ; {q2

} {q1

} {q2

,q1

}


1 �ND�� ! �ND


)







�ND a b c

q0

{q0

,q1

,q2

} ; ;q

1

; {q1

} ;q

2

;

{q1} {q1,q2}



AFND-�

q0

q1

q2

a

a

a

b

�

c


0

{q0

,q1

,q2

} ; ; ; {q0

}q

1

; {q1

} ; ; {q1

}q

2

; ; {q2

} {q1

} {q2

,q1

}


1 �ND�� ! �ND


)







�ND a b c

q0

{q0

,q1

,q2

} ; ;q

1

; {q1

} ;q

2

;

{q1} {q1,q2}



AFND-�

q0

q1

q2

a

a

a

b

�

c


0

{q0

,q1

,q2

} ; ; ; {q0

}q

1

; {q1

} ; ; {q1

}q

2

; ; {q2

} {q1

} {q2

,q1

}


1 �ND�� ! �ND


)







�ND a b cq

0

{q0

,q1

,q2

} ; ;q

1

; {q1

} ;q

2

;

{q1} {q1,q2}



AFND-�

q0

q1

q2

a

a

a

b

�

c


0

{q0

,q1

,q2

} ; ; ; {q0

}q

1

; {q1

} ; ; {q1

}q

2

; ; {q2

} {q1

} {q2

,q1

}


1 �ND�� ! �ND


)







�ND a b cq

0

{q0

,q1

,q2

} ; ;q

1

; {q1

} ;q

2

;

{q1} {q1,q2}



AFND-�

q0

q1

q2

a

a

a

b

�

c


0

{q0

,q1

,q2

} ; ; ; {q0

}q

1

; {q1

} ; ; {q1

}q

2

; ; {q2

} {q1

} {q2

,q1

}


1 �ND�� ! �ND


)







�ND a b cq

0

{q0

,q1

,q2

} ; ;q

1

; {q1

} ;q

2

; {q1}

{q1,q2}



AFND-�

q0

q1

q2

a

a

a

b

�

c


0

{q0

,q1

,q2

} ; ; ; {q0

}q

1

; {q1

} ; ; {q1

}q

2

; ; {q2

} {q1

} {q2

,q1

}


1 �ND�� ! �ND


)







�ND a b cq

0

{q0

,q1

,q2

} ; ;q

1

; {q1

} ;q

2

; {q1} {q1,q2}



AFND (agora)

q0

q1

q2

a

a

a

b

b,c

c

�ND a b cq

0

{q0

,q1

,q2

} ; ;q

1

; {q1

} ;q

2

; {q1} {q1,q2}

2 �ND ! �D (construção de subconjuntos sob demanda)

i. É inicial: a união de todos

os estados iniciais: {q0

}ii. Cada novo Q obtém a

união das transições dos

seus estados integrantes

iii. São finais: os estados que

contém pelo menos um

estado final

�D a b c

q0

=

hq0

i hq0

,q1

,q2

i � �

F 3

hq0

,q1

,q2

i hq0

,q1

,q2

i hq1

i hq1

,q2

i

F 3

hq1

i � hq1

i �

F 3

hq1

,q2

i � hq1

i hq1

,q2

i



AFND (agora)

q0

q1

q2

a

a

a

b

b,c

c

�ND a b cq

0

{q0

,q1

,q2

} ; ;q

1

; {q1

} ;q

2

; {q1} {q1,q2}









estado final

�D a b c

q0

=

hq0

i hq0

,q1

,q2

i � �

F 3

hq0

,q1

,q2

i hq0

,q1

,q2

i hq1

i hq1

,q2

i

F 3

hq1

i � hq1

i �

F 3

hq1

,q2

i � hq1

i hq1

,q2

i



AFND (agora)

q0

q1

q2

a

a

a

b

b,c

c

�ND a b cq

0

{q0

,q1

,q2

} ; ;q

1

; {q1

} ;q

2

; {q1} {q1,q2}




}

ii. Cada novo Q obtém a





estado final

�D a b cq

0

= hq0

i hq0

,q1

,q2

i � �

F 3

hq0

,q1

,q2

i hq0

,q1

,q2

i hq1

i hq1

,q2

i

F 3

hq1

i � hq1

i �

F 3

hq1

,q2

i � hq1

i hq1

,q2

i



AFND (agora)

q0

q1

q2

a

a

a

b

b,c

c

�ND a b cq

0

{q0

,q1

,q2

} ; ;q

1

; {q1

} ;q

2

; {q1} {q1,q2}









estado final

�D a b cq

0

= hq0

i hq0

,q1

,q2

i � �

F 3

hq0

,q1

,q2

i hq0

,q1

,q2

i hq1

i hq1

,q2

i

F 3

hq1

i � hq1

i �

F 3

hq1

,q2

i � hq1

i hq1

,q2

i



AFND (agora)

q0

q1

q2

a

a

a

b

b,c

c

�ND a b cq

0

{q0

,q1

,q2

} ; ;q

1

; {q1

} ;q

2

; {q1} {q1,q2}









estado final

�D a b cq

0

= hq0

i hq0

,q1

,q2

i � �F 3 hq

0

,q1

,q2

i hq0

,q1

,q2

i hq1

i hq1

,q2

iF 3 hq

1

i � hq1

i �F 3 hq

1

,q2

i � hq1

i hq1

,q2

i



AFD (enfim)

hq0

i hq0

,q1

,q2

i hq1

,q2

i

hq1

i

a

b

c

a

b

c

b

�D a b chq

0

i hq0

,q1

,q2

i � �hq

0

,q1

,q2

i hq0

,q1

,q2

i hq1

i hq1

,q2

ihq

1

i � hq1

i �hq

1

,q2

i � hq1

i hq1

,q2

i



Exercício de Fixação #1

q0

q1

q2

q3

�

�

a

b

a




q0

q1

q2

q3

0,1

1

0,1 0,1




q0

q1

q2

q3

q4

a

�

b

�

a

a,b

�



Algoritmos



Linguagens Regulares – Algoritmos – Minimização de AFD

Minimização de um AFD1

Todos os estados são equivalentes

2Se um é estado final e o outro não, logo não são

equivalentes

3Conferir, estado por estado, se são "equivalentes"

Procedimento a ser detalhado

Toy Example (propósito ilustrativo apenas)

q0

q1

q2

q3

q4

q5

a

b

c

a

b

c

a

b

c

a

,

b

c

a,b,c

a,b,c



AlgoritmoEntrada: AFD M = (Q,⌃, �,q

0

, F)

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

1.1 D[i, j] = 0

1.2 S[i, j] = ;

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

3Para cada par [i, j], i < j e D[i, j] = 0, faça:

3.1 se existe um a 2 ⌃ tal que �(qi ,a) = qm e �(qj ,a) = qn e

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

DIST (i, j) //altera D[i, j] = 1 e propaga a distinção aos elementos de S[i, j]

3.2 para cada a 2 ⌃ tal que �(qi ,a) = qm e �(qj ,a) = qn

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

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

4Para cada D[i, j] = 0, os estados i e j podem ser fundidos



Exemplo

q0

q1

q2

q3

q4

q5

q6

b

a

b

a

b

a

a,b

a,b a,b a,b



q0

q1

q2

q3

q4

q5

q6

b

a

b

a

b

a

a,b

a,b a,b a,b

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

1.1 D[i, j] = 0 (aqui, 0=X, 1=x)

1.2 S[i, j] = ;

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

[0, 1] X ;[0, 2] X ;[0, 3] X ;[0, 4] X ;[0, 5] X ;[0, 6] X ;[1, 2] X ;[1, 3] X ;[1, 4] X ;[1, 5] X ;[1, 6] X ;


[2, 3] X ;[2, 4] X ;[2, 5] X ;[2, 6] X ;[3, 4] X ;[3, 5] X ;[3, 6] X ;[4, 5] X ;[4, 6] X ;[5, 6] X ;



q0

q1

q2

q3

q4

q5

q6

b

a

b

a

b

a

a,b

a,b a,b a,b

2Para cada par [i, j], i < j, se um é estado final e o outro não, faça D[i, j] = 1 (aqui, x)


[0, 1] X ;[0, 2] X ;[0, 3] X ;[0, 4] x ;[0, 5] x ;[0, 6] x ;[1, 2] X ;[1, 3] X ;[1, 4] x ;[1, 5] x ;[1, 6] x ;


[2, 3] X ;[2, 4] x ;[2, 5] x ;[2, 6] x ;[3, 4] x ;[3, 5] x ;[3, 6] x ;[4, 5] X ;[4, 6] X ;[5, 6] X ;



q0

q1

q2

q3

q4

q5

q6

b

a

b

a

b

a

a,b

a,b a,b a,b



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






[0, 1] X { }[0, 2] X { }[0, 3] X { }[1, 2] X { }[1, 3] X { }


[2, 3] X { }[4, 5] X { }[4, 6] X { }[5, 6] X { }



q0

q1

q2

q3

q4

q5

q6

b

a

b

a

b

a

a,b

a,b a,b a,b



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






⌅ [0, 1] X { }[0, 2] X { }[0, 3] X { }[1, 2] X { [0, 1] }[1, 3] X { }


[2, 3] X { }[4, 5] X { [0, 1] }[4, 6] X { }[5, 6] X { }



q0

q1

q2

q3

q4

q5

q6

b

a

b

a

b

a

a,b

a,b a,b a,b



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






[0, 1] X { }⌅ [0, 2] X { }

[0, 3] X { }[1, 2] X { [0, 1] }[1, 3] X { [0, 2] }


[2, 3] X { }[4, 5] X { [0, 1] }[4, 6] X { [0, 2] }[5, 6] X { }



q0

q1

q2

q3

q4

q5

q6

b

a

b

a

b

a

a,b

a,b a,b a,b



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






[0, 1] X { }[0, 2] X { }

⌅ [0, 3] X ! x { } a

[1, 2] X { [0, 1] }[1, 3] X { [0, 2] }


[2, 3] X { }[4, 5] X { [0, 1] }[4, 6] X { [0, 2] }[5, 6] X { }



q0

q1

q2

q3

q4

q5

q6

b

a

b

a

b

a

a,b

a,b a,b a,b



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






[0, 1] X { }[0, 2] X { }[0, 3] X ! x { } a

⌅ [1, 2] X { [0, 1] }[1, 3] X { [0, 2] }


[2, 3] X { [1, 2] }[4, 5] X { [0, 1] }[4, 6] X { [0, 2] }[5, 6] X { [1, 2] }



q0

q1

q2

q3

q4

q5

q6

b

a

b

a

b

a

a,b

a,b a,b a,b



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






[0, 1] X { }[0, 2] X ! x { } [1, 3]

[0, 3] X ! x { } a

[1, 2] X { [0, 1] }⌅ [1, 3] X ! x { [0, 2] } a


[2, 3] X { [1, 2] }[4, 5] X { [0, 1] }[4, 6] X { [0, 2] }[5, 6] X { [1, 2] }



q0

q1

q2

q3

q4

q5

q6

b

a

b

a

b

a

a,b

a,b a,b a,b



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






[0, 1] X ! x { } [1, 2]

[0, 2] X ! x { } [1, 3]

[0, 3] X ! x { } a

[1, 2] X ! x { [0, 1] } [2, 3]

[1, 3] X ! x { [0, 2] } a


⌅ [2, 3] X ! x { [1, 2] } a

[4, 5] X { [0, 1] }[4, 6] X { [0, 2] }[5, 6] X { [1, 2] }



q0

q1

q2

q3

q4

q5

q6

b

a

b

a

b

a

a,b

a,b a,b a,b



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






[0, 1] X ! x { } [1, 2]

[0, 2] X ! x { } [1, 3]

[0, 3] X ! x { } a

[1, 2] X ! x { [0, 1] } [2, 3]

[1, 3] X ! x { [0, 2] } a


[2, 3] X ! x { [1, 2] } a

⌅ [4, 5] X { [0, 1] }[4, 6] X { [0, 2] }[5, 6] X { [1, 2] }



q0

q1

q2

q3

q4

q5

q6

b

a

b

a

b

a

a,b

a,b a,b a,b



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






[0, 1] X ! x { } [1, 2]

[0, 2] X ! x { } [1, 3]

[0, 3] X ! x { } a

[1, 2] X ! x { [0, 1] } [2, 3]

[1, 3] X ! x { [0, 2] } a


[2, 3] X ! x { [1, 2] } a

[4, 5] X { [0, 1] }⌅ [4, 6] X { [0, 2] }

[5, 6] X { [1, 2] }



q0

q1

q2

q3

q4

q5

q6

b

a

b

a

b

a

a,b

a,b a,b a,b



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






[0, 1] X ! x { } [1, 2]

[0, 2] X ! x { } [1, 3]

[0, 3] X ! x { } a

[1, 2] X ! x { [0, 1] } [2, 3]

[1, 3] X ! x { [0, 2] } a


[2, 3] X ! x { [1, 2] } a

[4, 5] X { [0, 1] }[4, 6] X { [0, 2] }

⌅ [5, 6] X { [1, 2] }



q0

q1

q2

q3

q4

q5

q6

b

a

b

a

b

a

a,b

a,b a,b a,b

4Para cada D[i, j] = 0, os estados i e j podem ser fundidos

q0

q1

q2

q3

{q4

,q5

,q6

}

b

a

b

a

b

a

a,b

a,b

Logo, um mesmo estado para q4

, q5

e q6

, já que D[4, 5] = 0, D[4, 6] = 0 e

D[5, 6] = 0



Exercício de Fixação

q0

q1

q2

q3

q4

q5

q6

q7

a

b

a

b

a

,

b

b

a

a

b

a

,

b

b

a

a,b



Algoritmos



Linguagens Regulares – Algoritmos – ER para AFND-�

Algoritmo de Thompsona b

a b

aba b

a [ b (ou a | b)

a

b

�

�

�

�

a⇤

�

�

a �

�



Exemplo: ((a [ b)c⇤)⇤

q0

q1

q2

q3

q4

q5

q6

q06

q7

q8

q9

q10

a

b

�

�

�

�

c�

�

�

�

�

�

�

�




q0

q1

q2

q3

q4

q5

q6

q06

q7

q8

q9

q10

a

b

�

�

�

�

c�

�

�

�

�

�

�

�




q0

q1

q2

q3

q4

q5

q6

q06

q7

q8

q9

q10

a

b

�

�

�

�

c�

�

�

�

�

�

�

�




q0

q1

q2

q3

q4

q5

q6

q06

q7

q8

q9

q10

a

b

�

�

�

�

c�

�

�

�

�

�

�

�




q0

q1

q2

q3

q4

q5

q6

q06

q7

q8

q9

q10

a

b

�

�

�

�

c

�

�

�

�

�

�

�

�




q0

q1

q2

q3

q4

q5

q6

q06

q7

q8

q9

q10

a

b

�

�

�

�

c�

�

�

�

�

�

�

�




q0

q1

q2

q3

q4

q5

q6

q06

q7

q8

q9

q10

a

b

�

�

�

�

c�

�

�

�

�

�

�

�




q0

q1

q2

q3

q4

q5

q6

q06

q7

q8

q9

q10

a

b

�

�

�

�

c�

�

�

�

�

�

�

�



Exercícios de Fixação1 (a [ b [ c)⇤

2 (a [ b)⇤abb

3 ((� [ a)b⇤)⇤

4 (a [ b)⇤abb(a [ b)⇤

5 letra (letra [ digito)⇤



Propriedades


Linguagens Regulares – Propriedades

Como provar que uma linguagem é regular?1

Através de uma GR (formalismo gerador)

2Através de um AFD, AFND ou AFND-� (formalismo operacional)

3Através de um CR ou ER (formalismo axiomático)

4Ou através de propriedades de fechamento

Por isso, é importante conhecer as propriedades de LR



Propriedades de FechamentoSe L

1

e L2

são regulares, então também são regulares:

L1

[ L2

L1

L2

L1

⇤

Se L1

é regular, então L1

também é regular

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

Se L1

e L2

são regulares, então L1

\ L2

também é regular

Prova: Lei de Morgan: L1

\ L2

= (L1

[ L2

)

Objetivos:

Originar novas LRs a partir de existentes

Provar (ou refutar) que alguma linguagem é regular

Se L1

\ L2

= {aibi | i > 0}, uma das linguagens não é regular




1

e L2


L1

[ L2

L1

L2

L1

⇤

Se L1


também é regular


Se L1

e L2


\ L2

também é regular


\ L2

= (L1

[ L2

)

Objetivos:



Se L1

\ L2





1

e L2


L1

[ L2

L1

L2

L1

⇤

Se L1


também é regular


Se L1

e L2


\ L2

também é regular


\ L2

= (L1

[ L2

)

Objetivos:



Se L1

\ L2




Propriedades de FechamentoProve que a linguagem formada por palavras sobre {a,b}

que tenham aa e não tenham bb é regular (Exemplo 6.4.1, Sudkamp [6])

L1

= palavras com aa = (a [ b)⇤aa(a [ b)⇤ é regular

L2

= palavras com bb = (a [ b)⇤bb(a [ b)⇤ é regular

L2

também é regular

Logo, L1

\ L2

é regular



Propriedades de Fechamento – Exemplo

Prove que L = {aibj | i, j � 0 e i 6= j} não é regular

Suponha que L seja regular

Então, L também é regular

Mas, L = {aibj | i, j � 0 e i = j} não é regular

Logo, L não pode ser regular

Método utilizado: Prova por contradição

Supõe-se que o contrário do que se deseja provar é verdade

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

(contradição)



LR é Vazia, Finita ou Infinita?Dada uma linguagem L reconhecida por um AFD M com

n estados, logo L é:

1 Infinita sse M aceita palavras z tal que |z| � ni.e., possui ciclo

2 Finita sse M aceita apenas palavras z tal que |z| < ni.e., não possui ciclo

3 Vazia sse M não aceita qualquer palavras zi.e., F = ; ou é inalcançável (ocorre apenas em autômatos

incompletos)



É possível garantir que duas LRs são iguais?Sim, é possível verificar se L

1

= L2

ProvaSuponha os AFs M

1

e M2

onde L(M1

) = L1

e L(M2

) = L2

Pelas propriedades de fechamento, é possível construir um

AF M3

tal que:

L3

= (L1

\ L2

) [ (L1

\ L2

)

Portanto, L1

= L2

sse L3

for vaziaE, como vimos anteriormente, é possível determinar se uma

linguagem é vazia



Lema do Bombeamento


Linguagens Regulares – Lema do Bombeamento

Lema do Bombeamento (Pumping Lemma) (um teorema na verdade)

Técnica usada para provar que linguagem não é regular

e só para linguagens infinitas (pq?)

Se um AFD tem k estados, então qualquer caminho de

aceitação de uma palavra z de tamanho |z| � k contém

um ciclo

q0

q1

ab b

a



Exemplo (k=2, pense em qualquer z tal que |z| � k e z 2 L)

q0

q1

ab b

a

Caminhos de aceitaçãoO caminho de aceitação de qualquer palavra z tal que

|z| � k e z 2 L contém um ciclo

e.g., aa, baa, bb, . . .

Podem existir palavras de tamanho menor que 2

e.g. � e b



DecomposiçãoSuponha uma palavra z 2 L tal que |z| � k

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

que |uv | k , v 6= � e v é parte de z reconhecida pelo ciclo

Claramente, o ciclo pode ser executado (“bombeado”)

várias vezes

uviw 2 L para todo i � 0

q0

Q(s) qfu

v

w



Exemplo

q0

q1

q2

q3

b

a a

bab

a,b

Decomponha as palavras z 2 L e |z| � k em z = uvw

aabbabaabbababb



Enunciado do Lema do Bombeamento“Seja L uma LR aceita pelo AFD M com k estados.

Seja z qualquer palavra de L tal que |z| � k.Então, z pode ser decomposta em z = uvw com

uv k, v 6= � euviw 2 L para todo i � 0.”



Exemplo #1: L = {aibi | i � 0}

Assuma que L é regular e seja k a constante especificada pelo Lema.

Seja z = akbk. Qualquer decomposição de z = uvw satisfazendo as

precondições do lema terão a seguinte forma:

u v w

ai aj ak�i�jbk

onde i + j k e j > 0. Bombeando alguma subpalavra nesta forma produzirá

uv2w = aiajajak�i�jbk = akajbkque não pertence a L.

Como z 2 L não possui decomposições que satisfaçam as condições do

Lema do Bombeamento, conclui-se que L não é regular.



Exemplo #1: L = {aibi | i � 0}Assuma que L é regular e seja k a constante especificada pelo Lema.

Seja z = akbk. Qualquer decomposição de z = uvw satisfazendo as

precondições do lema terão a seguinte forma:

u v w

ai aj ak�i�jbk

onde i + j k e j > 0. Bombeando alguma subpalavra nesta forma produzirá

uv2w = aiajajak�i�jbk = akajbkque não pertence a L.





Exemplo #2: L = {an | n é um quadrado perfeito }

Assuma que L é regular e seja k a constante especificada pelo Lema.

Seja z = ak2

e, portanto, |z| = k2

. Qualquer decomposição de z = uvw conterá

apenas a. Assim, conduziremos a prova no tamanho da palavra bombeada:

|uv2w | = |uvw |+ |v |= k2 + |v | (0 < |v| k)

k2 + k

< k2 + 2k + 1

= (k + 1)2

Como k2 < |uv2w | < (k + 1)2

, uv2w 62 L.





Exemplo #2: L = {an | n é um quadrado perfeito }Assuma que L é regular e seja k a constante especificada pelo Lema.

Seja z = ak2

e, portanto, |z| = k2

. Qualquer decomposição de z = uvw conterá

apenas a. Assim, conduziremos a prova no tamanho da palavra bombeada:

|uv2w | = |uvw |+ |v |= k2 + |v | (0 < |v| k)

k2 + k

< k2 + 2k + 1

= (k + 1)2

Como k2 < |uv2w | < (k + 1)2

, uv2w 62 L.






1

= {0

m1

n | m > n}

2 L2

= {0

n1

2n | n > 0}

3 L3

= {aibmcn | 0 < i, 0 < m < n}

4 L4

= {0

m1

n2

m+n | m > 0 e n > 0}

5 L5

= {0

n | n é um número primo }


4. Linguagens Livres de Contexto – Conteúdo

1 Revisão 3





Máquinas de Mealy





Gramática Livre de Contexto 178

Recursividade


Ambiguidade


4 Linguagens Livres de Contexto 172Formas Normais 207

Transformações de Gramática 214

Remoção de recursividade no símbolo inicial




Forma Normal de Chomsky 248

Remoção de recursividade à esquerda 256

Forma Normal de Greibach 264

Autômatos com Pilha 278

Variantes


Algoritmos de Reconhecimento 305




Algoritmo de Early

Algoritmos 337



Propriedades 356





Linguagens Livres de Contexto









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

LR:

Ling. natural: Palavras sobre {a,b} que terminam com {a}Conj. regular: {a,b}⇤{a}Abreviação: (a [ b)⇤a

GR:

S ! bS | aAA ! aA | bS | �

AF:

S A

b

a

a

b



LR x LLCLR descrevem linguagens simples

Geradas por GR

Reconhecidas por AF

No entanto, existem uma ampla gama de linguagens que

não podem ser descritas por LR

Exemplo Clássico: L = {aibi | i � 0}

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

linguagem L não é regular

Logo, devemos “subir” na Hierarquia de Chomsky!



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

LLC aumentam o poder de expressão da linguagem

(veremos o porquê)

GLC é o sistema formal para geração de LLC

Assim, descrever L= {aibi | i � 0} é possível com uma GLC

S ! aSb | �

(e, pelo jeito, bem simples também)



AplicabilidadeComo já vimos, LR são fundamentais no projeto de um

analisador léxico

Padrões são descritos por ER

Diagramas de Transição (AF estendidos) são usados no

reconhecimento de tokens

Por outro lado, LLC são fundamentais no projeto de um

analisador sintático

A sequência de tokens segue a gramática da linguagem?

GLC especificam a gramática formal da LP



Gramática Livre de Contexto


Linguagens Livres de Contexto – Gramática Livre de Contexto

Gramática Livre de Contexto (GLC)Uma GLC é uma quádrupla (V ,⌃,P, S):





Regras: µ ! ⌫

µ 2 V (i.e., um não-terminal)




RegrasMecânica: A ! w

o não-terminal A pode ser trocado por w

Exemplo: uAv ) uwv

Livre de contexto:

A sempre pode ser trocado por w (independentemente do

“contexto” u e v onde A ocorrer)

Característica IntrínsecaGLC permitem produzir duplo balanceamento

Em uma analogia com LPs

Permitem blocos balanceado, e.g., beginn endnou {n }n

Permitem parênteses balanceados (n )n





v )⇤ w w é derivável a partir de v aplicando 0 ou mais regras

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

v )i w w é derivável a partir de v aplicando i regras

Portanto:



L(G) = {w 2 ⌃⇤ | S )⇤ w}



ExemplosDefinir GLCs para as seguintes linguagens:

1Palíndromas sobre {a,b}, i.e., L = {w 2 {a,b}⇤ | w = wR}

S ! aSa | bSb | a | b | �

2Palavras sobre {a,b} com tamanho ímpar, i.e.,

L = {w 2 {a,b}⇤ | |w | (mod 2) = 1}

S ! A | a | bA ! aaS | abS | baS | bbS

Essa linguagem é, de fato, livre de contexto?





S ! aSa | bSb | a | b | �


L = {w 2 {a,b}⇤ | |w | (mod 2) = 1}







S ! aSa | bSb | a | b | �


L = {w 2 {a,b}⇤ | |w | (mod 2) = 1}





ExercíciosDefinir GLCs para as seguintes linguagens:

1 L = {an bm an | m > 0 e n > 0}

2 L = {an bm cm d2n | m > 0 e n � 0}

3 L = {an bm | 0 n m 2n}




Recursividade



RecursividadeUma regra A ! uAv é dita ser recursiva

Uma regra A ! Av é dita ser recursiva à esquerda

Uma regra A ! uA é dita ser recursiva à direita

Tipo de DerivaçõesDerivaçõ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



ExemploAssuma a seguinte GLC:

S ! AAA ! AAA | bA | Ab | a

Possíveis derivações para palavra ababaa:

S ) AA ) aA ) aAAA ) abAAA ) abaAA ) ababAA )ababaA ) ababaa

S ) AA ) AAAA ) aAAA ) abAAA ) abaAA )ababAA ) ababaA ) ababaa

S ) AA ) Aa ) AAAa ) AAbAa ) AAbaa ) AbAbaa )Ababaa ) ababaa

S ) AA ) aA ) aAAA ) aAAa ) abAAa ) abAbAa )ababAa ) ababaa






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 (derivação mais à dir.)

S ) AA ) aA ) aAAA ) aAAa ) abAAa ) abAbAa )ababAa ) ababaa (só derivação)






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



TeoremaSeja G uma GLC. Uma palavra w pertence a L(G) sse existe

uma derivação mais à esquerda para w a partir de S

Prova pode ser encontrada em Sudkamp [6]







Derivação de palavras em uma árvorePartindo do símbolo inicial como raíz

Terminando em símbolos terminais como folhas

Conveniente em muitas aplicaçõesCompiladores

Processadores de texto



Árvore de Derivação – Definição

Raíz: símbolo inicial

Vértices interiores: variáveis

Se A é um vértice interior e X1

,X2

, ...,Xn são “filhos” de A

A ! X1

,X2

, ...,Xn é uma produção da gramática

X1

,X2

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

Folha: terminal ou símbolo vazio

Se vazio: único filho de seu pai (A ! �)



Exemplo #1GLC: S ! aSb | �

Palavra: aabb

S

a S b

a

bS

�



Exemplo #2GLC: E ! E + E | E ⇤ E | (E) | id

Palavra: id + id * id

E

E + E

id E ⇤ E

id id



Exemplo #2GLC: E ! E + E | E ⇤ E | (E) | id

Palavra: id + id * id

E

E + E

id E ⇤ E

id id


Algum problema com a

GLC ou com a árvore?



Ambiguidade



AmbiguidadeUma GLC G é ambígua se existir uma palavra w em L(G)

que possua duas derivações mais à esquerda diferentes

o que significa duas árvores de derivação diferentes

Exemplo: L(G) = a+

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

S ! aS | Sa | a

Ambiguidade para aa:

S ) aS ) aa e S ) Sa ) aa

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

S ! aS | a

(além de não-ambígua, é regular)






Exemplo: L(G) = a+


S ! aS | Sa | a

Ambiguidade para aa: S ) aS ) aa e S ) Sa ) aa


S ! aS | a

(além de não-ambígua, é regular)






Exemplo: L(G) = a+


S ! aS | Sa | a

Ambiguidade para aa: S ) aS ) aa e S ) Sa ) aa


S ! aS | a (além de não-ambígua, é regular)



Ambiguidade – Exemplo #1Assuma a seguinte GLC G:

S ! aSb | aSbb | �

Pergunta-se: Essa GLC é ambígua?

Sim. Assuma w = aabbb, logo:

S ) aSb ) aaSbbb ) aabbb

S ) aSbb ) aaSbbb ) aabbb

Gramática equivalentemente não ambígua:

S ! aSb | A | �

A ! aAbb | abb










S ! aSb | A | �

A ! aAbb | abb










S ! aSb | A | �

A ! aAbb | abb



Ambiguidade – Exemplo #2Assuma a seguinte GLC G usada reconhecer expressões

aritméticas em um analisador sintático

E ! E + E | E ⇤ E | (E) | id


Sim. Assuma w = id + id ⇤ id, logo:

E ) E + E ) id + E ) id + E ⇤ E ) id + id ⇤ E ) id + id ⇤ id

E ) E ⇤ E ) E + E ⇤ E ) id + E ⇤ E ) id + id ⇤ E ) id + id ⇤ id



Ambiguidade – Exemplo #2Assuma a seguinte GLC G usada reconhecer expressões

aritméticas em um analisador sintático

E ! E + E | E ⇤ E | (E) | id


Sim. Assuma w = id + id ⇤ id, logo:





Ambiguidade – Exemplo #2 – Árvores de DerivaçãoGLC: E ! E + E | E ⇤ E | (E) | id

Derivações:



E

E + E

id E ⇤ E

id id

E

E⇤E

idE+E

idid



Ambiguidade – Exemplo #2 – Gramática equivalentemente nãoambígua

Deve definir a prioridade de operadores:

E ! E + T | T

T ! T ⇤ F | F

F ! (E) | id

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

id + id ⇤ id?



Ambiguidade – IndecibilidadeO problema de determinar se uma GLC arbitrária é

ambígua é indecidível

Portanto, isso significa que ...



Para refletir!Seja a seguinte GLC que gere {�} [ {ab}{ab}⇤{a}⇤:

S ! abSA | �

A ! Aa | �


Não

Pergunta-se: Essa GLC gera uma LLC?

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




S ! abSA | �

A ! Aa | �


Não






S ! abSA | �

A ! Aa | �


Não





Ambiguidade – Gramáticas Inerentemente ambíguasMaioria das LLC podem ser geradas por uma GLC não

ambígua

No entanto...

Nem toda LLC pode ser gerada por uma GLC não ambígua

Tais LLC são inerentemente ambíguas



Ambiguidade – Gramáticas Inerentemente ambíguasExemplo clássico:

L= {an bm cm dn ou an bn cm dm | m � 1 e n � 1}Crie uma GLC para L

Mostre a derivação de, e.g., aabbccdd

G(L):

S ! aNd | aXbcYdN ! aNd | bMcM ! bMc | �X ! aXb | �Y ! cYd | �



Ambiguidade – Gramáticas Inerentemente ambíguasExemplo clássico:

L= {an bm cm dn ou an bn cm dm | m � 1 e n � 1}Crie uma GLC para L

Mostre a derivação de, e.g., aabbccdd

G(L):

S ! aNd | aXbcYdN ! aNd | bMcM ! bMc | �X ! aXb | �Y ! cYd | �







Notação Backus-Nahur Form (BNF)Proposta em ⇠1960

Notação normalmente utilizada para definir GLCs de LPs

Notação BNF:

“!” é substituído por “::=” (ou apenas “:”)

Terminais: negrito (ou começando com minúsculas)

Variáveis: < . . . > (ou começando com maiúsculas)

Não se usa �

{A} denota zero ou mais repetições de A

[A] denota que A é opcional



BNF de JavaThe Java Language Specification (http://java.sun.com/docs/books/jls/)

Fragmento de exemplo:

IfThenStatement:

if ( Expression ) Statement

IfThenElseStatement:

if ( Expression ) StatementNoShortIf else Statement

BasicForStatement:

for ( [ForInit] ; [Expression] ; [ForUpdate] ) Statement



BNF de DCL (não apenas LP)

1 S ::= ModDecl | DCDecl

3 ModDecl ::= module ModId : ModDef { , ModDef} ( ModDecl | DCDecl )

5 ModDef ::= ClassName | ClassName+ | Pkg

*

| Pkg

**

| RegExpr

7 DCDecl ::=

only RefMod can-Type { , can-Type} RefMod [ DCDecl ] |

9 RefMod cannot-Type {, cannot-Type} RefMod [DCDecl] |

RefMod can-Type-only {, can-Type-only} RefMod [DCDecl] |

11 RefMod must-MustType { , must-MustType } RefMod [ DCDecl ]

13 RefMod ::= ( ModDef | ModId ) { , RefMod}

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

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



Formas Normais


Linguagens Livres de Contexto – Formas Normais

ProblemaGLCs são muito flexíveis

Não existem restrições na forma do lado direito das regras

Isso facilita a construção das gramáticas

Embora dificulte a construção de analisadores sintáticos

Formas Normais (FN)Impõem restrições no lado direito das regras de uma GLC

Mas não reduzem o poder de expressão de GLC

Geradas automaticamente (via algoritmo)

Serão abordadas:

FN de Chomsky

FN de Greibach



FN de ChomskyUma GLC G = (V ,⌃,P, S) está na FN de Chomsky se suas

regras têm uma das seguintes formas:

A ! BC onde B,C 2 V � {S}A ! a onde a 2 ⌃

S ! �

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

Não é complexo converter uma GLC para a FN de

Chomsky quando a mesma:

Símbolo inicial não é recursivo (S 6! ↵S�)

É essencialmente não-contrátil (só S ! �)

Não possui regras de cadeia (A 6! B)

Não possui símbolos inúteis (8B | B ) ⌃+e S ) ↵B�)






S ! �




Símbolo inicial não é recursivo (S 6! ↵S�) ?É essencialmente não-contrátil (só S ! �) ?Não possui regras de cadeia (A 6! B) ?Não possui símbolos inúteis (8B | B ) ⌃+

e S ) ↵B�) ?



Forma normal não é minimização! (Parte 1)Assuma a GLC clássica:

S ! aSb | �

Símbolo inicial não recursivo: (S 6! ↵S�)

S0 ! SS ! aSb | �

Essencialmente não-contrátil: (só S ! �)

S0 ! S | �S ! aSb | ab

Sem regras de cadeia: (A 6! B)

S0 ! aSb | ab | �S ! aSb | ab



Forma normal não é minimização! (Parte 1 ainda)Sem regras de cadeia: (A 6! B)

S0 ! aSb | ab | �S ! aSb | ab

Sem símbolos inúteis (que não geram terminais): (8B | B ) ⌃+)

Todos geram terminais!

Sem símbolos inúteis (que não são alcançáveis): (8B | S ) ↵B�)

Todos são alcançáveis!

Forma Normal de Chomsky (FNC):

S0 ! AX | AB | �X ! SBS ! AX | ABA ! aB ! b



FN de GreibachUma GLC G = (V ,⌃,P, S) está na FN de Greibach se suas


A ! aA1

A2

A3

. . .An onde a 2 ⌃ e A1..n 2 V � {S}

A ! aS ! �

1

opasso:

Transformar GLC para FN de Chomsky

2

opasso:

Em um futuro próximo...



Forma normal não é minimização! (Parte 2)Forma Normal de Chomsky (FNC):

S0 ! AX | AB | �X ! SBS ! AX | ABA ! aB ! b

Forma Normal de Greibach (FNG):

S0 ! aX | aB | �X ! aXB | aBBS ! aX | aBB ! b



Transformações de Gramática


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

Transformações de GramáticaPara alcançar uma FN, é importante que transformações

sejam realizadas na GLC

As quais adicionam, modificam ou eliminam regras

Veremos uma série de transformações em GLC:

Remoção de recursividade no símbolo inicial (S 6! ↵S�)

Eliminação de regras � (NULLABLE, só S ! �)

Eliminação de regras de cadeia (CHAIN, A 6! B)

Remoção de símbolos inúteis [TERM, 8B | B )⇤ ⌃+e REACH, 8B | S )⇤ ↵B�)




Remoção de recursividade no símbolo inicial



Remoção de recursividade no símbolo inicialSímbolo inicial (S) deve se limitar a iniciar derivações

i.e., S não deve ser uma variável recursiva

Não deve ser possível ter S )⇤ ↵S�

Assuma uma GLC G = (V ,⌃,P, S) onde S é recursivo, logo:

G0 = (V [ {S0},⌃,P [ {S0 ! S}, S0)

L(G0) = L(G)

Símbolo inicial S0de G0

não é mais recursivo



Remoção de recursividade no símbolo inicial(V ,⌃,P, S) =) (V [ {S0},⌃,P [ {S0 ! S}, S0)

ExemploS ! aS | AB | ACA ! aA | �B ! bB | bSC ! cC | �

+

S0 ! SS ! aS | AB | ACA ! aA | �B ! bB | bSC ! cC | �



Remoção de recursividade no símbolo inicial(V ,⌃,P, S) =) (V [ {S0},⌃,P [ {S0 ! S}, S0)

ExemploS ! aS | AB | ACA ! aA | �B ! bB | bSC ! cC | �

+

S0 ! SS ! aS | AB | ACA ! aA | �B ! bB | bSC ! cC | �








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

Se A é anulável, então: A )⇤ �

Gramática não-contrátil:

Não possui variáveis anuláveis, i.e., ¬9A 2 V (A ! �)

Assim, não diminuem tamanho forma sentencial, i.e., |µ| |⌫|

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

Gramática não-contrátil, mas admite uma regra �: S ! �

Todas as derivações são não-contráteis, exceto S ) �

Exemplo:

S ! aAbA ! aA | B

Variáveis anuláveis?

B e A

B ! bB | �Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 220 / 468











Exemplo:

S ! aAbA ! aA | B Variáveis anuláveis?

B e A

B ! bB | �Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 220 / 468











Exemplo:

S ! aAbA ! aA | B Variáveis anuláveis? B e AB ! bB | �



Algoritmo NULLABLE (estratégia bottom-up)

Entrada: Uma GLC G = (V ,⌃,P, S)

Saída: Conjunto de variáveis anuláveis (NULLABLE)

NULL = {A | {A ! �} 2 P}repi ta

PREV = NULL

para cada A 2 V faça

se A ! w e w 2 PREV ⇤faça

NULL = NULL [ {A}até NULL == PREV



ExemploS ! ACAA ! aAa | B | CB ! bB | bC ! cC | �

NULLABLENULL PREV

(0) {C} ;(1) {C,A} {C}(2) {C,A, S} {C,A}(3) {C,A, S} {C,A, S}



PREV = NULL


se A ! w e w 2 PREV⇤faça




NULLABLENULL PREV

(0) {C} ;

(1) {C,A} {C}(2) {C,A, S} {C,A}(3) {C,A, S} {C,A, S}



PREV = NULL






NULLABLENULL PREV

(0) {C} ;(1) {C,A} {C}

(2) {C,A, S} {C,A}(3) {C,A, S} {C,A, S}



PREV = NULL






NULLABLENULL PREV

(0) {C} ;(1) {C,A} {C}(2) {C,A, S} {C,A}

(3) {C,A, S} {C,A, S}



PREV = NULL






NULLABLENULL PREV

(0) {C} ;(1) {C,A} {C}(2) {C,A, S} {C,A}(3) {C,A, S} {C,A, S}



PREV = NULL





Técnica para eliminação de regras �

Calcular conjunto de variáveis anuláveis

e eliminar regras que levam diretamente a �

Adicionar regras na gramática onde a ocorrência de

variáveis anuláveis é omitida, por exemplo:

Assuma GLC com a seguinte regra: A ! BABa

Assuma que B é anulável

Logo, as seguintes regras devem ser adicionadas:

A ! ABa

A ! BAa

A ! Aa

Se � 2 L(G), então regra S ! � deve estar presente



Exemplo #1S ! ACA

A ! aAa | B | C

B ! bB | b

C ! cC | �+ variáveis anuláveis:

{S, A, C}

S ! ACA | AC | AA | CA | A | C | �

A ! aAa | B | C | aa

B ! bB | b

C ! cC | c



Exemplo #1S ! ACA

A ! aAa | B | C

B ! bB | b

C ! cC | �+ variáveis anuláveis: {S, A, C}

S ! ACA | AC | AA | CA | A | C | �


B ! bB | b

C ! cC | c



Exemplo #1S ! ACA

A ! aAa | B | C

B ! bB | b

C ! cC | �+ variáveis anuláveis: {S, A, C}

S ! ACA | AC | AA | CA | A | C | �


B ! bB | b

C ! cC | c



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

G : S ! ABC

A ! aA | �

B ! bB | �

C ! cC | �+ variáveis anuláveis:

{S, A, B, C}

S ! ABC | AB | BC | AC | A | B | C | �

A ! aA | a

B ! bB | b

C ! cC | c




G : S ! ABC

A ! aA | �

B ! bB | �

C ! cC | �+ variáveis anuláveis: {S, A, B, C}

S ! ABC | AB | BC | AC | A | B | C | �

A ! aA | a

B ! bB | b

C ! cC | c




G : S ! ABC

A ! aA | �

B ! bB | �

C ! cC | �+ variáveis anuláveis: {S, A, B, C}

S ! ABC | AB | BC | AC | A | B | C | �

A ! aA | a

B ! bB | b

C ! cC | c



Exercício de FixaçãoG : S ! aBC | Ba

A ! aA | �

B ! AC

C ! cA | b | A







Eliminação de regras de cadeiaUma regra na forma A ! B

Não aumenta tamanho da forma sentencial

Não gera símbolos terminais

Apenas renomeia uma variável

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



Eliminação de regras de cadeia – ExemploSuponha a seguinte gramática:

A ! aA | a | B

B ! bB | b | C

Eliminando a cadeia A ! B:

A ! aA | a | bB | b | C

B ! bB | b | C

Infelizmente, uma nova cadeia apareceu: A ! C

Portanto, o procedimento deve ser reaplicado

Até não mais restarem cadeias



Algoritmo CHAINEntrada: Uma GLC essencialmente não contrátil G = (V ,⌃,P, S) e

uma variável qualquer A 2 V

Saída: Conjunto de variáveis deriváveis a partir de Aaplicando-se apenas regras de cadeia

CHAIN(A) = {A}

PREV = ;repi ta

NEW = CHAIN(A) � PREV

PREV = CHAIN(A)

para cada B 2 NEW faça

para cada B ! C faça

CHAIN(A) = CHAIN(A) [ {C}

até CHAIN(A) == PREV



ExemploS ! ACA | CA | AA | AC | A | C | �A ! aAa | aa | B | CB ! bB | bC ! cC | c

CHAIN(S)

CHAIN(S) PREV NEW(0) {S} ;

{S}

(1)

{S,A,C} {S} {A,C}

(2)

{S,A,C,B} {S,A,C} {B}

(3)

{S,A,C,B} {S,A,C,B} –




CHAIN(S)

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

{S,A,C} {S} {A,C}

(2)

{S,A,C,B} {S,A,C} {B}

(3)

{S,A,C,B} {S,A,C,B} –




CHAIN(S)

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

{A,C}

(2)

{S,A,C,B} {S,A,C} {B}

(3)

{S,A,C,B} {S,A,C,B} –




CHAIN(S)

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

{S,A,C,B} {S,A,C} {B}

(3)

{S,A,C,B} {S,A,C,B} –




CHAIN(S)

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

{B}

(3)

{S,A,C,B} {S,A,C,B} –




CHAIN(S)

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

{S,A,C,B} {S,A,C,B} –




CHAIN(S)

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

–




CHAIN(S)

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



Gramática OriginalS ! ACA | CA | AA | AC | A | C | �A ! aAa | aa | B | CB ! bB | bC ! cC | c

Resultado do algoritmo aplicado em todas as variáveisCHAIN(S) = {S,A,C,B}

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

CHAIN(B) = {B}

CHAIN(C) = {C}




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

Novas RegrasA ! w onde B ! w 2 P, w 62 V e B 2 CHAIN(A)

Nova Gramática sem Regras de CadeiaS ! ACA | CA | AA | AC | �

| aAa | aa | bB | b | cC | c

A ! aAa | aa

| bB | b | cC | c

B ! bB | bC ! cC | c






Nova Gramática sem Regras de CadeiaS ! ACA | CA | AA | AC | �

| aAa | aa | bB | b | cC | c

A ! aAa | aa

| bB | b | cC | c







Nova Gramática sem Regras de CadeiaS ! ACA | CA | AA | AC | � | aAa | aa

| bB | b | cC | c

A ! aAa | aa

| bB | b | cC | c







Nova Gramática sem Regras de CadeiaS ! ACA | CA | AA | AC | � | aAa | aa | bB | b

| cC | c

A ! aAa | aa

| bB | b | cC | c







Nova Gramática sem Regras de CadeiaS ! ACA | CA | AA | AC | � | aAa | aa | bB | b | cC | cA ! aAa | aa

| bB | b | cC | c







Nova Gramática sem Regras de CadeiaS ! ACA | CA | AA | AC | � | aAa | aa | bB | b | cC | cA ! aAa | aa | bB | b

| cC | c







Nova Gramática sem Regras de CadeiaS ! ACA | CA | AA | AC | � | aAa | aa | bB | b | cC | cA ! aAa | aa | bB | b | cC | cB ! bB | bC ! cC | c



ResumoGLCs essencialmente não-contráteis e sem regras decadeia tem uma das seguintes formas:

S ! �

A ! a

A ! w onde w 2 (V [ ⌃)⇤ e |w | � 2



Exercício de FixaçãoG : S ! aS | b | A

A ! aA | a | C

B ! a | b

C ! c | B

D ! dD | B







Remoção de símbolos inúteisVariável inútil

não aparece em derivações que geram palavras

não contribui para geração de palavras



Exemplo (Qual é a L(G)?)

S ! AC | BS | BA ! aA | aFB ! CF | bC ! cC | D

D ! aD | BD | CE ! aA | BSAF ! bB | b

Símbolos InúteisUm símbolo x 2 (V [ ⌃) é útil se:

S )⇤ uxv )⇤ w , onde u, v 2 (V [ ⌃)⇤ e w 2 ⌃⇤

Um terminal é útil quando ocorre em uma palavras w 2 L(G)

Uma variável A é útil se existe: S )⇤ uAv )⇤ w , w 2 L(G)



Algoritmo TERMEntrada: Uma GLC G = (V ,⌃,P, S)

Saída: Conjunto de variáveis que geram terminais (TERM)

TERM = {A | ex i s te uma regra A ! w 2 P , com w 2 ⌃⇤}

repi taPREV = TERM


se A ! w 2 P e w 2 (PREV [ ⌃)⇤ então

TERM = TERM [ A

até PREV == TERM



ExemploS ! AC | BS | BA ! aA | aFB ! CF | bC ! cC | D


TERMTERM 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}





TERMTERM 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}





TERMTERM 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}





TERMTERM 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}





TERMTERM PREV

(0) {B, F} ;(1) {B, F ,A, S} {B, F}(2) {B, F ,A, S, E} {B, F ,A, S}(3) {B, F ,A, S, E} {B, F ,A, S, E}



Gramática OriginalS ! AC | BS | BA ! aA | aFB ! CF | bC ! cC | D


Variáveis que não geram terminalV � {B, F ,A, S, E} = {C,D}

Nova Gramática sem variáveis que não geram terminalS ! BS | BA ! aA | aFB ! b

E ! aA | BSAF ! bB | b

















Algoritmo REACHEntrada: Uma GLC G = (V ,⌃,P, S)

Saída: Conjunto de variáveis alcançáveis a partir de S (REACH)

REACH = {S}PREV = ;repi ta

NEW = REACH � PREV

PREV = REACH

para cada A 2 NEW faça

para cada A ! w faça

adicione todas as var iáve i s de w em REACH

até REACH == PREV



ExemploS ! BS | BA ! aA | aFB ! b


REACHREACH PREV NEW

(0) {S} ;

{S}

(1)

{S,B} {S} {B}

(2)

{S,B} {S,B} –





REACHREACH PREV NEW

(0) {S} ; {S}(1)

{S,B} {S} {B}

(2)

{S,B} {S,B} –





REACHREACH PREV NEW

(0) {S} ; {S}(1) {S,B} {S}

{B}

(2)

{S,B} {S,B} –





REACHREACH PREV NEW

(0) {S} ; {S}(1) {S,B} {S} {B}(2)

{S,B} {S,B} –





REACHREACH PREV NEW

(0) {S} ; {S}(1) {S,B} {S} {B}(2) {S,B} {S,B}

–





REACHREACH PREV NEW

(0) {S} ; {S}(1) {S,B} {S} {B}(2) {S,B} {S,B} –



Gramática OriginalS ! BS | BA ! aA | aFB ! b


Variáveis inalcançáveis:V � {S,B} = {A, E, F}

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

S ! BS | BB ! b







S ! BS | BB ! b







S ! BS | BB ! b



Exercício de Fixação (TERM e REACH)G : S ! aB | aA | bcC

A ! aA | ABA

B ! bB | b

C ! cC | BEA

D ! aE | bEc | d

E ! cD | cEb



Para remoção de variáveis inúteis: TERM e REACH (nesta ordem)

G : S ! a | ABA ! bB ! aB

TERM = {S,A}

GT : S ! aA ! bREACH = {S}

GR : S ! a

Se algoritmos forem aplicados na ordem inversa, o

resultado seria incorreto!



Se fosse na ordem errada:G : S ! a | AB

A ! bB ! aB

REACH = {S,A,B}

GR : S ! a | ABA ! bB ! aB

TERM = {S,A}

GT : S ! aA ! b

Bem esquisito!



Forma Normal de Chomsky


Linguagens Livres de Contexto – Forma Normal de Chomsky




S ! �










Exemplo #1A ! bDcF

FN de Chomsky:

Primeira transformação:

A ! B0DC0FB0 ! bC0 ! c

Segunda transformação:

A ! B0T1

B0 ! bC0 ! cT

1

! DT2

T2

! C0F



Exemplo #1A ! bDcF

FN de Chomsky:Primeira transformação:



A ! B0T1

B0 ! bC0 ! cT

1

! DT2

T2

! C0F



Exemplo #1A ! bDcF

FN de Chomsky:Primeira transformação:



A ! B0T1

B0 ! bC0 ! cT

1

! DT2

T2

! C0F



Exemplo #2S ! aABC | aA ! aA | aB ! bcB | bcC ! cC | c

FN de Chomsky:Já satisfaz pré-condições:








FN de Chomsky:

S ! A0T1

| aA0 ! aT

1

! AT2

T2

! BCA ! A0A | a

B ! B0T3

| B0C0

T3

! C0BC ! C0C | cB0 ! bC0 ! c



Exercício de Fixação (todos os passos para chegar à FNC)G : S ! aAb | bAa | B | aS

A ! bB | �

B ! cBc | Ba | aB | D

C ! a | b | c

D ! aDC

E ! BB | F

F ! FEB



Remoção de rec. à esquerda


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

Remoção de recursividade à esquerdaRecursividade direta à esquerda pode produzir “loops

infinitos” em analisadores sintáticos descendentes (top-down)

Exemplo:

S ! AaA ! Aa | b

S ) Aa ) Aaa ) Aaaa ) . . .

Suponha a regra genérica diretamente recursiva à esq.:

A ! Aµ1

| Aµ2

| . . . | Aµm | ⌫1

| ⌫2

| . . . | ⌫n

Regra equivalente não-recursiva à esquerda:

A ! ⌫1

| ⌫2

| . . . | ⌫n | ⌫1

Z | ⌫2

Z | . . . | ⌫nZZ ! µ

1

Z | µ2

Z | . . . | µmZ | µ1

| µ2

| . . . | µm



Exemplo #1A ! Aa | b

+ remoção de recursividade à esq.

A ! bZ | b

Z ! aZ | a

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


A ! bZ | cZ | b | c

Z ! aZ | bZ | a | b





A ! bZ | b

Z ! aZ | a



A ! bZ | cZ | b | c

Z ! aZ | bZ | a | b





A ! bZ | b

Z ! aZ | a



A ! bZ | cZ | b | c

Z ! aZ | bZ | a | b





A ! bZ | b

Z ! aZ | a



A ! bZ | cZ | b | c

Z ! aZ | bZ | a | b





A ! bZ | b

Z ! aZ | a



A ! bZ | cZ | b | c

Z ! aZ | bZ | a | b



Exemplo #3A ! AB | BA | a

B ! b | c


A ! BAZ | aZ | BA | a

Z ! BZ | B

B ! b | c




B ! b | c



Z ! BZ | B

B ! b | c




B ! b | c



Z ! BZ | B

B ! b | c




B ! b | c



Z ! BZ | B

B ! b | c



Exemplo #4A ! Aa | Aab | bb | b – gera (b [ bb)(a [ ab)⇤


A ! bbZ | bZ | bb | b – gera (b [ bb)(Z [ �)

Z ! aZ | abZ | a | ab – gera (a [ ab)+















Exercício de FixaçãoG : A ! aA | ABc | ccA



Remoção de Recursão à EsquerdaProblema: recursão à esquerda indireta

A ! Bu

B ! Av

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

Solução: Forma Normal de Greibach



Observação RelevanteRemovemos recursividade como a seguir:

G:

A ! Aµ1

| Aµ2

| . . . | Aµm | ⌫1

| ⌫2

| . . . | ⌫n

G’ (sem rec. à esquerda):

A ! ⌫1

| ⌫2

| . . . | ⌫n | ⌫1

Z | ⌫2

Z | . . . | ⌫nZZ ! µ

1

Z | µ2

Z | . . . | µmZ | µ1

| µ2

| . . . | µm

Outros autores (e.g., Aho) removem como a seguir:

G:

A ! Aµ1

| Aµ2

| . . . | Aµm | ⌫1

| ⌫2

| . . . | ⌫n

G’ (sem rec. à esquerda):

A ! ⌫1

Z | ⌫2

Z | . . . | ⌫nZZ ! µ

1

Z | µ2

Z | . . . | µmZ | �Ricardo Terra (rterrabh [at] gmail.com) Linguagens Formais e Autômatos (LFA) Maio, 2017 263 / 468


Forma Normal de Greibach


Linguagens Livres de Contexto – Forma Normal de Greibach

FN de GreibachUma GLC G = (V ,⌃,P, S) está na FN de Greibach se suas


A ! aA1

A2

A3

. . .An onde a 2 ⌃ e A1..n 2 V � {S}]

A ! aS ! �



FN de Greibach1

opasso:

Transformar GLC para FN de Chomsky

2

opasso:

Ordenar variáveis (i.e., cada variável ganha um número)

S = 1, A = 2, B = 3, . . .

Resolver, em ordem, as recursões

recursões diretas e indiretas

3

opasso: regras das seguintes formas

S ! �

A ! awA ! Bw onde w 2 V ⇤

e num(B) > num(A)



ExemploS ! AB | �A ! AB | CB | aB ! AB | bC ! AC | c



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

Eliminando recursão à esquerda em A:

S ! AB | � – ok, A > S

A ! CBR1 | aR1 | CB | a Aantes ! AB | CB | a – ok, C > A

B ! AB | b – não ok

C ! AC | c – não ok

R1 ! BR1 | B




Movendo lado direito de A para regra B ! AB e C ! ACS ! AB | �A ! CBR

1

| aR1

| CB | aB ! CBR1B | aR1B | CBB | aB | b Bantes ! AB | b – ok, C > B

C ! CBR1C | aR1C | CBC | aC | c Cantes ! AC | c – rec. esq.

R1

! BR1

| B



Autômatos com Pilha


Linguagens Livres de Contexto – Autômatos com Pilha

Autômatos com PilhaAFDs são incapazes de reconhecer aibi

porque possuem

uma “memória limitada”

Memória de um AFD: seus estados, os quais são finitos

Autômatos com Pilha (AP):

AFND-� + Pilha de tamanho infinito



Autômato com Pilha Não-Determinístico (APND)Um APND é uma sextupla (Q,⌃, �, �,q

0

, F):







Permite transições �(qi ,a,b) e �(qi ,a0,b0) compatíveis:

É ND, i.e., �(qi ,a,B) = {[qj ,C], [qk ,D]}

Uma palavra w 2 ⌃⇤é dita ser aceita por um APND se, e


para em um estado final com pilha vazia



Autômatos com PilhaExemplo: �(qi ,a,A) = [qj ,B]

qi qja A/B

q

i

: estado atual

a: símbolo a ser lido pela entrada

A: símbolo no topo da pilha (a ser desempilhado)

q

j

: novo estado

B: novo topo da pilha (a ser empilhado)

Se (estado== q

i

) && (entrada== a) && (topo == A) então

Lê a da entrada

Muda o estado atual de q

i

para q

j

Desempilha A do topo da pilha e empilha B



Autômatos com Pilha: Transições �

Transições � são permitidas

Exemplo: �(qi ,a,A) = [qj ,B]

Se a = �, não irá ler nada da entrada

Se A = �, irá realizar a transição independente do símbolo

que estiver no topo da pilha

Se B = �, não irá empilhar nada após a transição

Se A = � e B = � em todas as transições: o AP é um AFND-�



Autômatos com Pilha: Transições �

Exemplos:

�(qi ,�,A) = [qj ,�]

qi qj� A/�

�(qi ,�,�) = [qj ,B]

qi qj� �/B

�(qi ,a,�) = [qj ,�]

qi qja �/�



Autômatos com Pilha: AceitaçãoSeja M = (Q,⌃, �, �,q

0

, F) um AP

Uma palavra w 2 ⌃⇤é aceita por M se existe uma

computação da forma:

[q0

,w ,�] `⇤ [qi ,�,�], onde qi 2 F

Ou seja:

A palavra de entrada deve ser toda lida

Deve-se terminar em um estado final

A pilha deve começar e terminar vazia

A linguagem de M, denotada por L(M), é o conjunto das

palavras aceitas por M



Exemplo Clássico

L(G) = {aibi | i > 0}

AP:

q0

q1

a �/X

b X/�

b X/�



Exemplo Clássico

L(G) = {aibi | i > 0}

AP:

q0

q1

a �/X

b X/�

b X/�



Autômatos com Pilha: Exemplos

L1

= {wcwR | w = (a [ b)⇤}

L2

= {ai | i � 0} [ {aibi | i � 0}

L3

= palíndromos de tamanho par sobre {a,b}

L4

= {aib2i | i � 1}

L5

= palavras sobre {a,b} com o mesmo número de a e b



Autômatos com Pilha Determinísticos (APD)Assuma as transições:

�(qi ,u,A) = [qj ,C]

�(qi , v ,B) = [qk ,D]qi

qj

qk

u

A

/

C

v

B

/

D

Um AP é determinístico se não possui transições compatíveisEssas duas transições são compatíveis se:

u = v e A = B

u = v e (A = � ou B = �)

A = B e (u = � ou v = �)

(u = � ou v = �) e (A = � ou B = �)



Poder computacionalAP sem uso da pilha

Semelhante ao AF e reconheceria a classe das LR

APD

Aceita um importante subconjunto próprio da classe de LLC

Aplicação: analisadores sintáticos (compiladores)

APND

Aceita a classe das LLC

AP com 2 (ou mais) pilhas

Mesmo poder computacional da MT (dispositivo mais geral

da computação)




Variantes



APs AtômicosTransições são sempre de uma das formas:

�(qi ,a,�) = [qj ,�] – apenas lê entrada

�(qi ,�,A) = [qj ,�] – apenas desempilha

�(qi ,�,�) = [qj ,A] – apenas empilha

Todo AP pode ser transformado em um AP atômico



APs Atômicos – Exemplo

AP atômico para L = {aibi | i > 0}



APs Atômicos – Exemplo

AP atômico para L = {aibi | i > 0}

q0

q1

q2

q3

q4

a �/� � �/A

b �/� � A/�

b �/� � A/�



APs EstendidosPode-se empilhar mais de uma letra, como resultado de

uma única transição

�(qi ,a,A) = [qj ,BCD]

Leia a,

Desempilha A e

Empilha D, C e B (i.e., B é o novo topo)

qi qja A/BCD



APs Estendidos – Exemplo #1

AP estendido para L = {aib2i | i � 1}




AP estendido para L = {aib2i | i � 1}

q0

q1

a �/XX

b X/�

b X/�




AP estendido para L = {ai(bc)i | i � 1}




AP estendido para L = {ai(bc)i | i � 1}

q0

q1

a �/BC

b B/�

b B/�c C/�



APs Atômicos e EstendidosVariantes de APs (i.e., Atômicos e Estendidos) não aumentam o

poder de expressão de APs







Critério de AceitaçãoCritério normal de aceitação: por estado final e pilha vazia

[q0

,w ,�] `⇤ [qi ,�,�], qi 2 F

Critério alternativo de aceitação: por estado final

[q0

,w ,�] `⇤ [qi ,�,↵], qi 2 F , ↵ 2 �⇤

Basta processar toda a palavra e terminar em estado final

Critério alternativo de aceitação: por pilha vazia

[q0

,w ,�] `+ [qi ,�,�], qi 2 Q

Basta processar toda a palavra e terminar com a pilha vazia



Aceitação por Estado FinalNovo critério não aumenta o poder de expressão de APs

Quando a aceitação é por estado final e pilha vazia, às

vezes são acrescentados transições e/ou estados apenas

para esvaziar a pilha

Exemplo: {ai | i > 0} [ {aibi | i > 0}

No caso de aceitação por estado final, tais estados são

desnecessários

q0

q1

q2

a �/X � X/�

b X/�

� X/�

b X/�



Aceitação por Estado FinalLema: Seja L uma linguagem aceita por um AP M porestado final, então existe um AP M0

que aceita L por estadofinal e pilha vazia

Basta acrescentar um novo estado final qf0

e

�’(qi ,�,�) = [qf0,�], para todo qi 2 F

�’(qf0,�,X) = [qf

0,�], para todo X 2 �

Aceitação: [q0

,w ,�] `⇤ [qi ,�,↵] ` [qf0,�,↵] `⇤ [qf

0,�,�]

Resumindo:

Aceita por estado final ) aceita por estado final e pilhavazia (pelo lema acima)

Aceita por estado final e pilha vazia ) aceita por estado final



Aceitação por Estado Final – Exemplo

L = {aibj | i � j � 0}

Estado Final (EF) Estado Final e Pilha Vazia (EF/PV)




L = {aibj | i � j � 0}

Estado Final (EF)

q0

q1

a �/A

b A/�

b A/�

Estado Final e Pilha Vazia (EF/PV)




L = {aibj | i � j � 0}

Estado Final (EF)

q0

q1

a �/A

b A/�

b A/�


q0

q1

q0f

a �/A

b A/�

� �/�� /�

b A/�

� A/�



Aceitação por Pilha VaziaCritério alternativo de aceitação: por pilha vazia

[q0

,w ,�] `+ [qi ,�,�], qi 2 Q

Observe que não se exige mais que qi 2 F

Basta que a palavra seja toda lida (sempre) e pilha vazia

Por que não [q0

,w ,�] `⇤ [qi ,�,�] ?



Aceitação por Pilha VaziaLema: Seja L uma linguagem aceita por um AP M por pilhavazia, então existe um AP M0

que aceita L por estado final epilha vazia

Todo estado de M é um estado final em M0

Novo estado inicial q0

0

�0(q0

0, x ,A) = �(q0

, x ,A) e

�0(qi0, x ,A) = �(qi , x ,A)

para todo qi 2 Q, x 2 ⌃ [ {�}, A 2 � [ {�}

Resumindo:

Aceita por pilha vazia ) aceita por estado final e pilha vazia(pelo lema acima)

Aceita por estado final e pilha vazia ) aceita por pilha vazia



Aceitação por Pilha Vazia – Exemplo

L = {aibi | i > 0}

Pilha Vazia (PV) Estado Final e Pilha Vazia (EF/PV)




L = {aibi | i > 0}

Pilha Vazia (PV)

q0

q1

a �/A

� �/�

b A/�





L = {aibi | i > 0}

Pilha Vazia (PV)

q0

q1

a �/A

� �/�

b A/�


q0

q1

q00

a �/A

� �/�

b A/�

a �/A

� �/�



Critérios de Aceitação: TeoremaAssuma uma LLC L, logo

Existe um AP M1

que aceita L com critério de aceitação porpilha vazia e estado final

Existe um AP M2

que aceita L com critério de aceitação porestado final

Existe um AP M3

que aceita L com critério de aceitação porpilha vazia



Algoritmos de Reconhecimento


Linguagens Livres de Contexto – Algoritmos de Reconhecimento

Algoritmos de ReconhecimentoAlguns problemas não possuem solução computacional:

1Certa LLC é ambígua?

2Duas LLCs são iguais ou diferentes?

3Uma palavra pertence a uma linguagem?

No entanto, o problema (3) possui solução em LLCs

Uma palavra pertence a uma LLC?

Algoritmos de reconhecimento

válidos para qualquer linguagem da classe

complexidade computacional (tempo e espaço)



Reconhecedores que utilizam APmuito simples

em geral, ineficientes

tempo de processamento é proporcional a k |w |

w : palavra de entrada

k : constante que depende do autômato

Reconhecedores que não utilizam AP

Tempo de processamento proporcional a |w |3

contudo limite não foi provado, pode ser até inferior



Algoritmos construídos a partir de uma GLCAutômato com Pilha como Reconhecedor



Algoritmo de Early



ClassificaçãoTop-Down (ou Preditivo)

constrói uma árvore de derivação

a partir da raiz (símbolo inicial da gramática)

com ramos em direção às folhas (terminais)

Bottom-up

oposto do Top-Down

parte das folhas

construindo a árvore de derivação em direção à raiz







Autômato com Pilha como ReconhecedorReconhecedores usando AP

Construção relativamente simples e imediata

Relação “direta” entre produções e as transições do AP

Algoritmos

Top-Down

Simula derivação mais à esquerda

Não determinista




É direta a conversão de qualquer GLC na FN de Greibach

para um AP

Cada produção gera exat. um terminal (FN de Greibach)

Logo, geração de w requer |w | etapas de derivação

No entanto, cada terminal pode ter diversas produções

associadas

AP testa as diversas alternativas

número de passos para reconhecer w é proporcional a k |w|

k = aprox. metade da média de produções das variáveis

Logo, o tempo de reconhecimento é pode ser muito

ineficiente para entradas mais longas



ExemploL = {anbn | n � 1}

G(L) = {V ,⌃,P, S} = {{S}, {a,b}, {S ! aSb, S ! ab}, S}

Forma Normal de Greibach:

G0(L) = {{S0, S,B}, {a,b},{S0 ! aSB, S0 ! aB, S ! aSB, S ! aB,B ! b}, S0}

q0

q1

a �/SBa �/B

a S/SBa S/Bb B/�




G(L) = {V ,⌃,P, S} = {{S}, {a,b}, {S ! aSb, S ! ab}, S}

Forma Normal de Greibach:

G0(L) = {{S0, S,B}, {a,b},{S0 ! aSB, S0 ! aB, S ! aSB, S ! aB,B ! b}, S0}

q0

q1

a �/SBa �/B

a S/SBa S/Bb B/�







Autômato com Pilha DescendenteForma alternativa de construir AP

não há necessidade de estar na FNG

Igualmente simples e com o mesmo nível de eficiência

a partir de uma GLC sem recursão à esquerda

simula a derivação mais à esquerda

Algoritmo

inicialmente, empilha o símbolo inicial

se topo == variável, então substitui (não determinismo) por todas

as produções da variável

se topo = terminal, então testa se é igual ao próximo símbolo

da entrada




G(L) = {V ,⌃,P, S} = {{S}, {a,b}, {S ! AX , S ! AB,X !SB,A ! a,B ! b}, S}

q0

q1

q2

� �/S

� S/AX� S/AB� X/SB� A/a� B/ba a/�b b/�

� �/�




G(L) = {V ,⌃,P, S} = {{S}, {a,b}, {S ! AX , S ! AB,X !SB,A ! a,B ! b}, S}

q0

q1

q2

� �/S

� S/AX� S/AB� X/SB� A/a� B/ba a/�b b/�

� �/�







Algoritmo de Cocke-Younger-Kasami (CYK)Proposto por J. Cocke, D. H. Younger e T. Kasami em 1965

GLC deve estar na FNC

Mecânica:

Estratégia bottom-up para criação de todas as possíveis

árvores de derivação da palavra de entrada w

Tempo de processamento proporcional a |w |3 (ruim)

Ideia básica:

Tabela triangular de derivação

Célula: raízes que podem gerar a correspondente subárvore



Exemplo (contribuição de Alberto Hokari)

Considere a seguinte GLC L:

S ! AT | AB

T ! XB

X ! AT | AB

A ! a

B ! b



L aceita a palavra aaabbb? (contribuição de Alberto Hokari)

Coloca-se a palavra a ser reconhecida na base da tabela

a a a b b b


S ! AT | AB

T ! XB

X ! AT | AB

A ! a

B ! b



Para preencher a 1

alinha devemos verificar qual variável

gera a sequencia de 1 terminal

a a a b b b

A A A B B B1


S ! AT | AB

T ! XB

X ! AT | AB

A ! a

B ! b



Para preencher a 2


gera a sequencia de 2 terminais

Por exemplo, existe alguma regra que produza AA?

A resposta é não, então marcamos a célula com um –

a a a b b b

A A A B B B1

2 -


S ! AT | AB

T ! XB

X ! AT | AB

A ! a

B ! b



O processo se repete

a a a b b b

A A A B B B1

2 - -


S ! AT | AB

T ! XB

X ! AT | AB

A ! a

B ! b



Neste caso, existem duas regras que geram ABLogo, ambas são colocadas na célula

S,X

a a a b b b

A A A B B B1

2 - -


S ! AT | AB

T ! XB

X ! AT | AB

A ! a

B ! b



O processo se repete até completar a 2

alinha

S,X

a a a b b b

A A A B B B1

2 - - - -


S ! AT | AB

T ! XB

X ! AT | AB

A ! a

B ! b



Para preencher a 3


gera a sequência de 3 terminais

as setas mostram quais pares de células devemos trabalhar a

fim de se obter a sequência de três terminais

a a a b b b

1

2

3


S ! AT | AB

T ! XB

X ! AT | AB

A ! a

B ! b



1 + 2 = A +� = A�Par inválido, logo marcamos a célula com um �

S,X

a a a b b b

A A A B B B1

2 - - - -

-3


S ! AT | AB

T ! XB

X ! AT | AB

A ! a

B ! b



2 + 1 = �+ A = �APar inválido, logo marcamos a célula com um �

S,X

a a a b b b

A A A B B B1

2 - - - -

-3


S ! AT | AB

T ! XB

X ! AT | AB

A ! a

B ! b



O processo se repete até completar a 3

alinha

S,X

a a a b b b

A A A B B B1

2 - - - -

-3 - -T


S ! AT | AB

T ! XB

X ! AT | AB

A ! a

B ! b



Para preencher a 4



o processo se repete para as linhas superiores

S,X

a a a b b b

A A A B B B1

2 - - - -

-3 - -T

4 -


S ! AT | AB

T ! XB

X ! AT | AB

A ! a

B ! b



Para preencher a 4




S,X

a a a b b b

A A A B B B1

2 - - - -

-3 - -T

4 -


S ! AT | AB

T ! XB

X ! AT | AB

A ! a

B ! b



Para preencher a 4




S,X

a a a b b b

A A A B B B1

2 - - - -

-3 - -T

4 -


S ! AT | AB

T ! XB

X ! AT | AB

A ! a

B ! b



Ao final do processo, se o símbolo inicial se encontra na

primeira célula, a palavra é reconhecida pela linguagem

Neste exemplo, aaabbb 2 L

Como S é a raiz então a palavra é reconhecida

S,X

a a a b b b

A A A B B B1

2 - - - -

-3 - -T

4 - S,X -

5

6

T-

S,X


S ! AT | AB

T ! XB

X ! AT | AB

A ! a

B ! b


Exercício de Fixação #1Verifique se a palavra abab é aceita na seguinte GLC:

S ! XY

T ! ZT | a

X ! TY

Y ! YT | b

Z ! TZ | b



Exercício de Fixação #2Verifique se a palavra baaba é aceita na seguinte GLC:

S ! AB | BC

A ! BA | a

B ! CC | b

C ! AB | a




Algoritmo de Early



Algoritmo de EarlyPossivelmente o mais rápido algoritmo para LLC

Proposto em 1968

Tempo de processamento:

qualquer GLC sem produções �: |w |3

qualquer GLC não ambígua: |w |2

muitas gramáticas de interesse prático: |w |



Algoritmo de EarlyEntrada: GLC sem produções vazias

Algoritmo Top-Down (a partir de S)

Executa sempre a derivação mais à esquerda

Cada iteração gera um terminal

comparado com o símbolo da entrada

continua se puder achar uma produção que gere o próximo

símbolo

Algoritmos eficientes como o de Early serão abordados em

Compiladores!



Algoritmos



Algoritmos



Linguagens Livres de Contexto – Algoritmos

Transformação de GLCs para APs (veja Autômato com Pilha como Reconhecedor)

Teorema: Se L é uma LLC, então há um AP que aceita L

Seja L uma LLC e G = (V ,⌃,P, S) a GLC que gera L

Transforme G para a forma normal de Greibach:

A ! aA1

A2

A3

. . .An onde a 2 ⌃ e A1..n 2 V � {S}

A ! aS ! �

Crie um AP estendido M = (Q,⌃, �, �,q0

, F): (estado inicial q0

)

QM = {q0

,q1

}, ⌃M = ⌃G, �M = VG � {S}, FM = {q1

}�(q

0

,a,�) = { [q1

,w ] | S ! aw 2 P }�(q

1

,a,A) = { [q1

,w ] | A ! aw 2 P e A 2 V � {S} }�(q

0

,�,�) = [q1

,�], se S ! � 2 P



Transformação de GLCs para APs – ExemploS ! aAB | aBA ! aAB | aBB ! b

Intuitivamente, uma regra A ! aAB somente pode ser

aplicada quando o topo da pilha for A

Neste caso, aplicar a regra em questão implica em:

Desempilhar A

Ler a

Empilhar AB

Ou seja, a pilha armazena as variáveis que ainda devem ser

derivadas



Algoritmos




Transformação de APs para GLCsToda linguagem aceita por um AP é uma LLC

Dado um AP, gerar um AP M’ estendido onde �’ herda todas

as transições de � e acrescenta duas novas transições:

Se [qj ,�] 2 �(qi ,u,�) então

[qj ,A] 2 �0(qi ,u,A), para todo A 2 �

Se [qj ,B] 2 �(qi ,u,�) então

[qj ,BA] 2 �0(qi ,u,A), para todo A 2 �

Interpretação para novas transições:

Todas transições que não desempilham, passam agora a

empilhar e desempilhar o mesmo símbolo

Veja que é para todo A 2 �M (qualquer que seja o topo)

Claramente, L(M) = L(M0)



Transformação de APs para GLCsAlgoritmo para gerar uma GLC G a partir do AP M0

Variáveis não vão ser mais maiúsculas, mas sim tuplas da

forma <qi ,A,qj>

estou em q

i

,

quero ir para q

j

e

existe A no topo da pilha



Transformação de APs para GLCsRegras de G:

#1 S ! <q0

,�,qj>, para todo qj 2 F

#2 Se [qj ,B] 2 �0(qi , x ,A), então (A e B 2 � [ {�})

<qi ,A, qk > ! x<qj ,B, qk >, para todo qk 2 Q

#3 Se [qj ,BA] 2 �0(qi , x ,A), então (A e B 2 �)

<qi ,A, qk > ! x<qj ,B, qn >< qn ,A, qk >, qk , qn 2 Q

#4 Para todo qk 2 Q

<qk ,�,qk> ! �



Transformação de APs para GLCs – ExemploConstrua uma gramática G para o seguinte AP M:

Q = {q0

,q1

}

⌃ = {a,b,c}, � = {A}

F = {q1

}

L(M) = ancbn, n � 0



Transformação de APs para GLCs – Exemplo

q0

q1

a �/A

c �/�

b A/�

Função de transição �

�(q0

,a,�) = [q0

,A] – não desempilha e empilha A

�(q0

,c,�) = [q1

,�] – não desempilha, não empilha

�(q1

,b,A) = [q1

,�]



Transformação de APs para GLCs – Exemplo

q0

q1

a �/A

a A/AA

c �/�c A/A

b A/�

Função de transição �0 é igual a � mais duas regras:

�0(q0

,a,A) = [q0

,AA] – pois A é o único elemento de �

�0(q0

,c,A) = [q1

,A]



Transformação de APs para GLCs – Exemplo#1 S ! <q

0

,�,qj>, para todo qj 2 F

Logo, primeira regra da GLC será: S ! <q0

,�,q1

>

#2 Se [qj ,B] 2 �0(qi , x ,A), então (A e B 2 � [ {�})


Como [q0

,A] 2 �(q0

,a,�), então

<q0

,�,qk> ! a<q0

,A,qk>

Novas regras:

<q0

,�, q0

> ! a<q0

,A, q0

> – k = 0

<q0

,�, q1

> ! a<q0

,A, q1

> – k = 1



Transformação de APs para GLCs – Exemplo#3 Se [qj ,BA] 2 �0(qi , x ,A), então (A e B 2 �)

<qi ,A, qk > ! x<qj ,B, qn >< qn ,A, qk >, qk , qn 2 Q

Como [q0

,AA] 2 �(q0

,a,A), então

<q0

,A,qk> ! a<q0

,A,qn>

Novas regras:

<q0

,A, q0

> ! a<q0

,A, q0

>< q0

,A, q0

> – k = 0 , n = 0

<q0

,A, q1

> ! a<q0

,A, q0

>< q0

,A, q1

> – k = 1 , n = 0

<q0

,A, q0

> ! a<q0

,A, q1

>< q1

,A, q0

> – k = 0 , n = 1

<q0

,A, q1

> ! a<q0

,A, q1

>< q1

,A, q1

> – k = 1 , n = 1



Transformação de APs para GLCs – Exemplo#2 Se [qj ,B] 2 �0(qi , x ,A), então (A e B 2 � [ {�})


Como [q1

,�] 2 �(q0

,c,�), então

<q0

,�,qk> ! c<q1

,�,qk>

Novas regras:

<q0

,�, q0

> ! c<q1

,�, q0

> – k = 0

<q0

,�, q1

> ! c<q1

,�, q1

> – k = 1





Como [q1

,A] 2 �(q0

,c,A) então

<q0

,A,qk> ! c<q1

.A,qk>

Novas regras:

<q0

,A, q0

> ! c<q1

,A, q0

> – k = 0

<q0

,A, q1

> ! c<q1

,A, q1

> – k = 1





Como [q1

,�] 2 �(q1

,b,A) então

<q1

,A,qk> ! b<q1

,�,qk>

Novas regras:

<q1

,A, q0

> ! b<q1

,�, q0

> – k = 0

<q1

,A, q1

> ! b<q1

,�, q1

> – k = 1



Transformação de APs para GLCs – Exemplo#4 Para todo qk 2 Q

<qk ,�,qk> ! �

Novas regras:

<q0

,�,q0

> ! � – k = 0

<q1

,�,q1

> ! � – k = 1



Transformação de APs para GLCs – Exemplo – GLC resultante

S ! <q0

,�,q1

><q

0

,�,q0

> ! a<q0

,A,q0

><q

0

,�,q1

> ! a<q0

,A,q1

><q

0

,A,q0

> ! a<q0

,A,q0

><q0

,A,q0

><q

0

,A,q1

> ! a<q0

,A,q0

><q0

,A,q1

><q

0

,A,q0

> ! a<q0

,A,q1

><q1

,A,q0

><q

0

,A,q1

> ! a<q0

,A,q1

><q1

,A,q1

><q

0

,�,q0

> ! c<q1

,�,q0

><q

0

,�,q1

> ! c<q1

,�,q1

><q

0

,A,q0

> ! c<q1

,A,q0

><q

0

,A,q1

> ! c<q1

,A,q1

><q

1

,A,q0

> ! b<q1

,�,q0

><q

1

,A,q1

> ! b<q1

,�,q1

><q

0

,�,q0

> ! �<q

1

,�,q1

> ! �



Transformação de APs para GLCs – Exemplo – Derivação aacbb

S ) <q0

,�,q1

>

) a<q0

,A,q1

>

) aa<q0

,A,q1

><q1

,A,q1

>

) aac<q1

,A,q1

><q1

,A,q1

>

) aacb<q1

,�,q1

><q1

,A,q1

>

) aacb<q1

,A,q1

>

) aacbb<q1

,�,q1

>

) aacbb



Propriedades


Linguagens Livres de Contexto – Propriedades

LLCsMais geral que LRs

Mas, ainda é relativamente restrita



Fácil definir linguagens que não são LLCPalavra duplicada, e.g., L = {ww | w 2 {a,b}⇤}

Analogia com compiladores:

declaração de uma variável antes do seu uso

Triplo balanceamento, e.g., L = {anbncn | n � 0}Mais importante limitação das LLC

(propositalmente) incomum em LPs

Usando Autômato com Pilha

fácil intuir por que não são LLC



Linguagens de ProgramaçãoLPs normalmente são 99% LLC (e 1% safadão)

Mas, LPs são o quê então?

Mas, e a construção if�then�else?

Isso é encadeamento, não balanceamento

Não confunda!



Como verificar...... se uma LLC é fechada para operações

união?

interseção?

concatenação?

complemento?

... se uma LLC é

infinita?

finita?

vazia?



Propriedades de fechamentoFechamento é importante para

construir novas linguagens a partir de operações sobre

linguagens conhecidas

provar propriedades

construir algoritmos

O conjunto das LLC é fechado para:

União

Concatenação

Kleene

Mas não é fechado para:

Interseção

Complemento



O conjunto das LLC é fechado para UniãoProva usando AP:

Seja M1

e M2

dois APs que reconhecem duas LLCs

Basta criar um novo AP com um novo estado inicial que

possui transições � para os estados iniciais de M1

e M2

(que agora deixam de ser iniciais)



O conjunto das LLC é fechado para ConcatenaçãoProva usando AP:

Seja M1

e M2

dois APs que reconhecem duas LLCs com

critério de aceitação por estado final

Basta criar um novo AP em que o(s) estado(s) final(is) de M1

possui(em) transições � para o estado inicial de M2



O conjunto das LLC é fechado para Kleene

Prova usando AP:

Seja M um AP que reconhece uma LLC com critério de

aceitação por estado final

Basta fazer transições � do(s) estado(s) final(is) para o estado

inicial



O conjunto das LLC não é fechado para InterseçãoProva por Contradição:

Seja L1

= {aibicj | i, j � 0} uma LLC

Seja L2

= {ajbici | i, j � 0} uma LLC

No entanto, L1

\ L2

= {aibici | i � 0} não é LLC



O conjunto das LLC não é fechado para complementoProva por Contradição:

Suponha que seja fechado para complemento

Suponha que L1

e L2

são LLC

Então L = L1 [ L2 também é LLC

Mas, L = L1

\ L2

Já foi mostrado que L1

\ L2

não necessariamente é LLC

Logo, revendo a hipótese, o conjunto das LLC não é

fechado para complemento



O conjunto das LLC não é fechado para complementoProva por Intuição:

Suponha uma LLC L

Suponha um AP M que reconheça L (que pode ser APND)

Uma palavra w 2 L se alguma computação de M a aceitar

É possível um AP rejeitar o complemento de L, mas não

aceitar o complemento



O conjunto das LLC não é fechado para complementoProva por Intuição:

Suponha uma LLC L

Suponha um AP M que reconheça L (que pode ser APND)

Uma palavra w 2 L se alguma computação de M a aceitar

É possível um AP rejeitar o complemento de L, mas não

aceitar o complemento



Propriedades de fechamentoTeorema: Seja R uma linguagem regular e L uma linguagem

livre de contexto, então R \ L é LC

Suponha um AFD N que reconheça R

Suponha um AP M que reconheça L

Basta criar um AP M0que simule a operação de N e M

Os estados nessa máquina composta serão pares ordenados

[qNi,qMj

], onde qNié um estado de N e qMj

é um estado de M



LLC é Vazia?Prova: Suponha uma LLC L

Seja G = (V ,⌃,P, S) uma GLC que reconhece L

Seja G0 = (V 0,⌃0,P 0, S) a GLC equivalente a G sem símbolos

inúteis

Se P 0for vazio, então L é vazia



LLC é Finita ou Infinita?Seja G = (V ,⌃,P, S) uma GLC que reconhece L


inúteis, regras de cadeia e regras �

Crie um grafo de dependência das variáveis

Se existirem ciclos no grafo de dependência, L é infinita

Caso contrário, L é finita

Exemplo (finita ou infinita?)

S ! ABA ! aCb | aB ! bB | bbC ! cBS

S

A

B

C



LLC é Finita ou Infinita?Seja G = (V ,⌃,P, S) uma GLC que reconhece L


inúteis, regras de cadeia e regras �

Crie um grafo de dependência das variáveis

Se existirem ciclos no grafo de dependência, L é infinita

Caso contrário, L é finita

Exemplo (finita ou infinita?)

S ! ABA ! aCb | aB ! bB | bbC ! cBS

S

A

B

C



Investigação se é LLCPara demonstrar que uma linguagem L é LC, basta:

Criar um GLC que gere L

Criar um AP que reconheça L

Para demostrar que uma linguagem L não é LC, deve-se:

Aplicar o Lema do Bombeamento para LLCs



Lema do Bombeamento para LLCsIdeia similar ao Lema do Bombeamento para LRs

LRs

podem expressar bombeamentos sem qualquer

balanceamento

não podem expressar bombeamentos balanceados 2 a 2

LLCs

podem expressar bombeamentos balanceados 2 a 2

não podem expressar bombeamentos balanceados 3 a 3

Detalhes em Sudkamp [6]


5. Linguagens Sensíveis ao Contexto – Conteúdo

1 Revisão 3





Máquinas de Mealy





Recursividade


Ambiguidade






Variantes





Algoritmo de Early



Gramática Sensível ao Contexto 375

Autômato Linearmente Limitado 381

Teoremas 388





Linguagens Sensíveis ao Contexto









Gramática Sensível ao Contexto


Linguagens Sensíveis ao Contexto – Gram. Sensível ao Contexto

Gramática Sensível ao Contexto (GSC)Uma GSC é uma quádrupla (V ,⌃,P, S):





Regras: µ ! ⌫


⌫ 2 (V [ ⌃)+ (i.e., palavra formada por elementos de V e ⌃)

|µ| |⌫| (i.e., regras não-contráteis, o que indica que tamanho da forma

sentencial ou aumenta ou permanece constante)

� nunca é uma palavra válida em uma LSC



Gramáticas Sensíveis ao ContextoSe L1 é uma LR, então L1 é uma LLC

Se L2 é uma LLC, então L2–{�} é uma LSC

É uma GSC?

S ! aSCbc | �Cb ! bc

É uma GSC?

S ! aAc | bcAc ! b





É uma GSC?


É uma GSC?

S ! aAc | bcAc ! b





É uma GSC?


É uma GSC?

S ! aAc | bcAc ! b





É uma GSC?


É uma GSC?

S ! aAc | bcAc ! b



Exemplo Clássico


GSC(L):

S ! aAbc | abcA ! aAbC | abCCb ! bCCc ! cc

Derivação, por exemplo, de aabbcc:

S ) aAbc ) aabCbc ) aabbCc ) aabbcc


existe um ALL que reconhece uma LSC





Exemplo Clássico


GSC(L):S ! aAbc | abcA ! aAbC | abCCb ! bCCc ! cc


S ) aAbc ) aabCbc ) aabbCc ) aabbcc


existe um ALL que reconhece uma LSC





Por que não usamos apenas terminais


GSC(L):S ! aAbc | abcA ! aAbc | abccb ! bccc ! cc


S ) aAbc ) aabcbc ) aabbcc

Durante uma derivação:

Se w 2 ⌃⇤, então w é uma palavra da linguagem

aabcbc 2 L?



Exercícios1

Defina L(G) para a seguinte GSC:

S ! SBA | aBA ! ABaA ! aaBB ! b

2Desenvolva uma GSC G em que L(G) = {aib2ici | i > 0}



Autômato Linearmente Limitado


Linguagens Sensíveis ao Contexto – Autômato Linearm. Limitado

Autômato Linearmente Limitado (ALL)Um ALL é uma óctupla (Q,⌃, �, �,q

0

, <,>, F):







< e > = delimitadores da palavra de entrada



Autômato Linearmente Limitado (ALL)Seja w uma palavra de entrada

Configuração inicial da fita: hwi

Delimitadores podem ser lidos, mas não apagados

Delimitadores não podem ser ultrapassados

Tamanho da fita = |w |+ 2

Basicamente, um ALL é uma MT cuja quantidade de fita

disponível é limitada ao tamanho da palavra de entrada



Por que sempre para?Assuma um ALL a verificar a palavra aabb

Logo, configuração inicial da fita: haabbi

Como a fita é finita, o número máximo de combinações é

dado pela fórmula:

max_combinacoes = |Q|⇥ |w |⇥ |�||w|

onde Q é o conjunto de estados, w é a palavra e � é o alfabeto da fita

Assuma, nesse exemplo, Q = {q0

,q1

} e � = {h, i,a,b,X}.

Dessa forma, o número máximo de configurações seria:

max_combinacoes = 2 ⇥ 4 ⇥ 5

4 = 5.000

Se o ALL ultrapassa esse limite, a palavra é rejeitada, pois

certamente está repetindo configurações (loop)



Exemplo Clássico


q0

q1

q2

q3

q4

q5

q6

q7

</< Da/X D

Y/Y D

b/Y D

Y/Y Da/a D

c/Z D

Z/Z Db/b D

>/> E

c/c D

X/X D

Z/Z EY/Y Ec/c Eb/b Ea/a E

>/> E

Y/Y DZ/Z D

Z/Z EY/Y EX/X E




1

= {wcw | w 2 {a,b}⇤ e tem o mesmo número de a e b}

2 L2

= {ww | w 2 {a,b}+}



L1

= {wcw | w 2 {a,b}⇤ e tem o mesmo número de a e b}

q0

q1

q2

q3

q4

q5

q6

q7

q8

q9

q00

q01

q02

q03

q04

</< D

a/X D

b/Y D

c/c D

a/a Db/b D

c/c D

a/a Db/b D

a/X E

X/X DY/Y D

b/Y E

X/X DY/Y D

c/c E X/X EY/Y E

X/X DY/Y D

a/a Eb/b E

c/c D

>/> E

X/X DY/Y D

</< D

X/a EY/b Ec/c E

c/c D

a/X D

b/X D

X/X D

b/X E

X/X Da/a D

a/X E

X/X Db/b D

</< D a/a Eb/b EX/X E



Teoremas


Linguagens Sensíveis ao Contexto – Teoremas

Teorema #1: Se G é GSC, então L(G) é recursivaMostrar que existe uma MT M que decide L(G)

Se p é derivável ou não por L(G), então p é decidido por M

M deve simular as derivações de G

M é uma MT não-determinística com 3 fitas

Fita #1: palavra de entrada p

Fita #2: regras de G

u ! v na fita fica ##u#v##

##: separador de regras e #: !

Fita #3: usada para registrar todas as formas sentenciais de

uma derivação

Ex.: S#aAbc#aabCbc#aabbCc#aabbcc



Teorema #1: Se G é GSC, então L(G) é recursivaFuncionamento de M (máquina que decide L):

S# é gravado na posição 1 da Fita #3

Regras de G são escritas na Fita #2

loopEscolher uma regra u#v na Fita #2

Seja q# a palavra mais recente gravada na Fita #3

Escolher uma instância de u em q (se existir). Senão, parar em

estado de rejeição

Sendo q = xuy#, gravar xvy# na Fita #3, logo após q#

Se xvy == p, parar em estado de aceitação

Se xvy ocorrer em outra forma sentencial na Fita #3 ou

tam(xvy) > tam(p), parar em estado de rejeição



Teorema #1: Se G é GSC, então L(G) é recursivaFuncionamento de M (máquina que decide L)

Se xvy ocorrer em outra posição na Fita #3, parar em estado

de rejeição

Justificativa: derivações cíclicas S )+ w )+ w

Se tam(xvy) > tam(p), parar em estado de rejeição

Justificativa: em GSC, derivações são não-contráteis



Teorema #2: Se L é uma LSC, então tem uma GSC G tal que L(G) = L

Se L é uma LSC, então existe um ALL M cuja L(M) = L

Em uma LSC, nenhuma forma sentencial pode ser maior que

a palavra de entrada

É impossível uma derivação S )⇤ ↵ )⇤ w , onde

tam(↵) > tam(w)

Logo, “memória” (ou quantidade de fita) necessária para

realizar derivações pode ser limitada pelo tamanho da

palavra de entrada

Gramáticas irrestritas não são reconhecidas por ALL

É possível uma derivação S )⇤ ↵ )⇤ w , onde

tam(↵) > tam(w)

ALLs são mais parecidos com computadores reais do que

uma MT (já que essas assumem memória infinita)


6. Linguagens Irrestritas – Conteúdo

1 Revisão 3





Máquinas de Mealy





Recursividade


Ambiguidade






Variantes





Algoritmo de Early



5 Linguagens Sensíveis ao Contexto 373Gramática Irrestrita 395

Teoremas

6 Linguagens Irrestritas 393Máquinas de Turing 404

Variantes

Teoremas 444



Linguagens Irrestritas









Gramática Irrestrita


Linguagens Irrestritas – Gramática Irrestrita

Gramática Irrestrita (GI)Todo o universo de linguagens é gerado por GIs

Uma GI é uma quádrupla (V ,⌃,P, S):





Regras: µ ! ⌫



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



Exemplo ClássicoL = {u[u] | u 2 {a,b}⇤}

GI(L):S ! aT [a] | bT [b] | []T [! aT [A | bT [B | [Aa ! aAAb ! bABa ! aBBb ! bBA] ! a]B] ! b]

Toda GI é recursivamente enumerável, logo:

existe uma MT que reconhece LI, mas não necessariamente

para para qualquer entrada w 2 ⌃⇤



Exemplo ClássicoGI:

S ! aAbc | �A ! aAbC | �Cb ! bC (b’s podem ser passados para antes dos C’s)

CC ! Cc

Derivações:

S ) aAbc )i�1 aiA(bC)i�1bc ) ai(bC)i�1bc

Exemplificando (i=3):

aaabCbCbc ) aaabCbbCc ) aaabCbbcc )aaabbCbcc ) aaabbbCcc ) aaabbbccc

Logo: L(GI) = aibici, i � 0



ExercícioL = {aibjaibj | i, j � 0}

GI(L):S ! X | Y | aPAbQbX ! aaX | �Y ! bbY | �P ! aPA | �Q ! bQb | EAb ! bAAE ! aAa ! aa

Derivação Exemplo

S ) aPAbQb) aaPAAbQb) aaAAbQb) aaAAbEb) aaAbAEb) aabAAEb) aabAab) aabaab



ExercícioL = {aibjaibj | i, j � 0}

GI(L):S ! X | Y | aPAbQbX ! aaX | �Y ! bbY | �P ! aPA | �Q ! bQb | EAb ! bAAE ! aAa ! aa

Derivação Exemplo

S ) aPAbQb) aaPAAbQb) aaAAbQb) aaAAbEb) aaAbAEb) aabAAEb) aabAab) aabaab



Gramática Irrestrita

Teoremas



Teorema #3: Se G é GI, então L(G) é rec. enumerávelMostrar que existe uma MT M que reconhece L(G)

Se p é derivável por L(G), então p é reconhecida por M

Ou seja, M deve simular as derivações de G

M é uma MT não-determinística com 3 fitas

Fita #1: palavra de entrada p

Fita #2: regras de G

u ! v na fita fica ##u#v##

##: separador de regras e #: !

Fita #3: usada para registrar todas as formas sentenciais de

uma derivação

Ex.: S#aAbc#aabCbc#aabbCc#aabbcc



Teorema #3: Se G é GI, então L(G) é rec. enumerávelFuncionamento de M:

S# é gravado na posição 1 da Fita #3

Regras de G são escritas na Fita #2

loopEscolher uma regra u#v na Fita #2

Seja q# a palavra mais recente gravada na Fita #3

Escolher uma instância de u em q (se existir). Senão, parar em

estado de rejeição

Sendo q = xuy#, gravar xvy# na Fita #3, logo após q#

Se xvy == p, parar em estado de aceitação



Teorema #4: Se L é uma LRE, então tem uma GI G tal que L(G) = L

Dada uma MT M que reconhece L, prova consiste em

demonstrar como criar uma GI G, com L(G) = L

Prova completa pode ser encontrada no Teorema 10.1.3

em Sudkamp [6]



Máquinas de Turing


Linguagens Irrestritas – Máquinas de Turing

Máquinas de TuringModelo abstrato para os computadores modernos

Propostas por Alan Turing em 1936

Considerado um dos pais da Ciência da Computação

Prêmio Turing: “Prêmio Nobel” da área de Computação



Máquina de Turing (MT)Uma MT Padrão é uma quíntupla (Q,⌃, �, �,q

0

):






Memória ilimitadaSeja w uma palavra de entrada

Configuração inicial da fita: BwBBBBBBBB...

A fita é infinita à direita



Máquinas de TuringMáquina de estados com uma fita e uma cabeça de

leitura/gravação

Cada posição da fita possui um símbolo de �

Fita começa na posição zero

Fita possui infinitas posições para a direita

B (branco): simbolo especial de �

Entrada é gravada na fita, começando na posição 1

Posição 0 é sempre um B

Posições depois da palavra de entrada são todas B

Cabeça começa posicionada na posição 0



Máquinas de Turing



Função de Transição (�)MT padrão é determinística


ComputaçãoComputação para quando encontra um estado/símbolo

para o qual não exista transição definida

Se a cabeça for deslocada para esquerda da posição 0,

então a computação termina anormalmente (“quebra”)



Exemplo: �(qi , x) = [qj , y , E ou D]

Se (estado atual == qi) e (símbolo atual da fita == x) então

Novo estado = qj

Grave y na fita

Mova cabeça de leitura/gravação para esquerda (E) ou

direita (D)

qi qj qi qjx/y E x/y D

Símbolo atual da fita: símbolo embaixo da cabeça de

leitura/gravação



Exercício de Fixação #1MT para ler uma entrada formada por uma palavra sobre

{a,b} e trocar a por b e vice-versa. Ao final do

processamento, rebobinar a cabeça de leitura/gravação

para a posição zero da fita

Exercício de Fixação #2MT para realizar a seguinte transformação na fita de

entrada:

BuB... ) BuBuB..., onde u = (a [ b)⇤

Exercício de Fixação #3MT para somar 1 em um número binário gravado

inicialmente na fita de entrada



Exercício de Fixação #4MT para realizar as seguintes transformações na fita de

entrada:

BanBamB... ) BanBamBan+mB..., n,m � 0

BanBamB... ) BanBamBan�mB..., n � m

BanB... ) BanBa2

nB..., n � 0

BanBamB... ) BanBamBan⇤mB..., n,m � 0



MT para Aceitação de LinguagensUm MT é uma séxtupla (Q,⌃, �, �,q

0

, F):









MT para Aceitação de LinguagensMTs que aceitam ou rejeitam uma palavra de entrada

Seja M = (Q,⌃, �, �,q0

, F) uma MT, onde F ✓ Q é o conjunto

de estados finais

Uma palavra u 2 ⌃⇤é aceita por estado final se a

computação de M com entrada u para em um estado final

Isto é, MT não precisa ler toda a palavra para aceitá-la



MT para Aceitação de LinguagensLinguagem L(M): conjunto das palavras aceitas por M

Exemplos:

L1

= (a [ b)⇤aa(a [ b)⇤

L2

= {aibici | i � 0}

L3

= {wcv | w e v tem o mesmo número de a e b}

L4

= {ww | w 2 {a,b}+}



MT para Aceitação de LinguagensUma MT pode:

Parar e aceitar uma palavra de entrada

Parar e rejeitar uma palavra de entrada

Entrar em loop (isto é, não parar)

MT reconhece uma linguagem L, logo L é recursivamenteenumerável (LI)

Uma MT reconhece uma linguagem L se ela para para todas

as palavras de L, mas pode não parar para as palavras que

não estão em L

MT decide uma linguagem L, logo L é recursiva (LSC)

Uma MT decide uma linguagem L se ela para para todas as

possíveis palavras de entrada (⌃⇤)



ReflexãoAs linguagens L

1...4 (anteriormente citadas) são:

a. recursivamente enumeráveis?

b. recursivas?



Máquinas de Turing

Variantes



MT com Fita BidirecionalFita se estende infinitamente para esquerda e para direita

Entrada pode ser inserida em qualquer ponto da fita

Cabeça de leitura/gravação é posicionada no branco

imediatamente à esquerda da palavra de entrada

Uma linguagem L é aceita por uma MT com fita bidirecional

sse é aceita por uma MT padrão (por quê?)

Exercício de FixaçãoMT para somar 1 em um número binário



(ida) Se uma linguagem L é aceita por uma MT com fitabidirecional, então é aceita por uma MT padrão

Uma fita infinita à direita tem o mesmo tamanho de uma fita

infinita à direita e à esquerda

basicamente: 1 = 1+1

Para não utilizar a fita “da esquerda”, basta realizar o shiftde toda a fita “da direita” antes de realizar uma transição

que utilizaria a fita “da esquerda”

(volta) Se uma linguagem L é aceita por uma MT padrão, entãoé aceita por uma MT com fita bidirecional

Basta não utilizar a fita “da esquerda”



MT com Movimento EstáticoModificação da função de transição de estados:

� : Q ⇥ � ! Q ⇥ �⇥ {E,D, S}

Agora após uma leitura/gravação, é possível não mover a

cabeça de leitura/gravação (S)

Seu uso só faz sentido quando se tem mais fitas (por quê?)

Uma linguagem L é aceita por uma MT com movimento

estático sse é aceita por uma MT padrão (por quê?)



(ida) Se uma linguagem L é aceita por uma MT com movimentoestático, então é aceita por uma MT padrão

Basta substituir todas transições que possuem movimento

estático como a seguir:

qi qj qi qk qja/a S a/a D x/x E, 8x 2 �

(volta) Se uma linguagem L é aceita por uma MT padrão, entãoé aceita por uma MT com movimento estático

Basta não utilizar o movimento estático



MT MultitrilhasFita é dividida em múltiplas trilhas, mantendo uma única

cabeça de leitura/gravação

Máquina com duas trilhas:

�(qi , [x , y ]) = [qj , [z,w ],m], onde m 2 {E,D}

x = símbolo a ser lido da Fita 1

y = símbolo a ser lido da Fita 2

z = símbolo a ser gravado na Fita 1

w = símbolo a ser gravado na Fita 2

Uma linguagem L é aceita por uma MT com duas trilhas sseé aceita por uma MT padrão (por quê?)



(ida) Se uma linguagem L é aceita por uma MT multitrilha, entãoé aceita por uma MT padrão

Assuma uma MT com duas trilhas

Trilha 1: x0

x1

x2

x3

x4

x5

. . .

Trilha 2: y0

y1

y2

y3

y4

y5

. . .

1Intercale as trilhas em uma única fita como a seguir:

Fita: x0

y0

x1

y1

x2

y2

x3

y3

x4

y4

x5

y5

. . .

2Adapte as transições [x/y w/z M] como a seguir:

[x/y w/z M] =) [x/y D] e [w/z D]

Quando M = E, deve-se recuar o número de trilhas ⇥ 2

No nosso exemplo (2 trilhas), fazem-se 4 transições [�/� E]



(volta) Se uma linguagem L é aceita por uma MT padrão, entãoé aceita por uma MT multitrilha

Basta utilizar somente uma trilha

i.e., as demais terão sempre transições B/B

Dessa forma, uma transição [x/y D] em uma MT padrão

ficaria da seguinte forma em uma MT com n trilhas:

[x/y B2

/B2

B3

/B3

. . . Bn/Bn D]



MT MultifitasMáquina com k fitas e k cabeças de leitura/gravação

Máquina lê as k fitas simultaneamente (de forma síncrona)

Transição consulta:

Estado atual (único)

Símbolos lidos por cada uma das cabeças

Uma transição pode:

Mudar o estado

Escrever um símbolo em cada uma das fitas

Reposicionar de forma independente cada uma das

cabeças de leitura/gravação

Uma linguagem L é aceita por uma MT Multifitas sse é

aceita por uma MT padrão (por quê?)



MT MultifitasEntrada é escrita na Fita 1

Todas as outras fitas estão em branco (BBBBB...)

Todas as fitas começam com a cabeça de

leitura/gravação na posição 0

Exercício de FixaçãoMT para reconhecer as seguintes linguagens:

L1

= {aibi | i > 0}

L2

= {wdw | w 2 {a,b,c}⇤}

L3

= {wcwr | w 2 {a,b}⇤}



(ida) Se uma linguagem L é aceita por uma MT multifita, então éaceita por uma MT padrão

Assuma uma MT com duas fitas

#1: B a b c B . . .

#2: B x y z B . . .

Assuma também as seguintes configurações:

#1: B q

i

a b c B . . . (i.e., cabeça de leitura/gravação aponta para a)

#2: B x y q

i

z B . . . (i.e., cabeça de leitura/gravação aponta para z)

1Concatene as fitas separadas por #

Fita: B a b c B # B x y z B . . .

2Estenda o alfabeto da fita como a seguir:

8x 2 � ! x 2 �0 ^ x 2 �0 (são adicionados B, a, b, c, x , y e z)




3Dessa forma, os símbolos “acentuados” correspondem aos

símbolos que estão com a cabeça de leitura/gravação:

Fita: B a b c B # B x y z B . . .

4A cabeça de leitura/gravação sempre se inicia na Fita #1:

Fita: B q

i

0a b c B # B x y z B . . .




5A computação para uma transição [a/x D z/c E] será

realizada como a seguir:

Substitua a por x na “Fita #1”

“Acentue” o próximo símbolo da “Fita #1” (b ! b)

Passe para a “Fita #2” (após o símbolo #)

Procure por z (caso não ache, pare)

Substitua z por c

“Acentue” o símbolo anterior da “Fita #2” (y ! y)

Retorne à “Fita #1” parando no símbolo “acentuado” e

compute a próxima transição



(volta) Se uma linguagem L é aceita por uma MT padrão, entãoé aceita por uma MT multifita

Basta utilizar somente uma fita

i.e., as demais terão sempre transições B/B S

Dessa forma, uma transição [x/y D] em uma MT padrão

ficaria da seguinte forma em uma MT com n fitas:

[x/y D B2

/B2

S B3

/B3

S . . . Bn/Bn S]



MT Não-DeterminísticasModificação da função de transição de estados:

� : Q ⇥ � ! P(Q ⇥ �⇥ {E,D})

P(X): conjunto potência de X (todos subconjuntos de X)

Exemplo de transição:

�(q1

,c) = {[q1

,c,D], [q2

,c,D], [q3

,C, E]}

ND não aumenta o poder de expressão de MTs

Uma linguagem L é aceita por uma MT Não-Determinística

sse é aceita por uma MT padrão (por quê?)



Exercício de FixaçãoMT para reconhecer as seguintes linguagens:

Palavras contendo um c precedido ou sucedido por abL = {ww | w 2 {a,b}⇤}



(ida) Se uma linguagem L é aceita por uma MTNão-Determinística, então é aceita por uma MT padrão

Prova é feita assumindo uma MT multifita

uma vez já provamos ter o mesmo poder computacional




Assuma 3 fitas:

#1: B a b b B . . . (palavra de entrada)

#2: q0B a b b B # . . . (configurações iniciando com a 1

a)

#3: B B B B B . . . (configuração em execução)

Loop1

Mova a 1

aconfiguração da Fita #2 para Fita #3

2Execute a MTND sobre a configuração presente na Fita #3

Caso não haja transições, verifique se é igual a palavra de entrada. Se

for, pare e aceite. Se não for, pule para o passo (3)

Caso haja uma transição possível, execute e concatene a

configuração resultante + “#” na Fita #2

Caso hajam várias transições possíveis (ND), concatene todas as

configurações resultantes + “#” na Fita #2

3Apague Fita #3




Exemplificando:

Assuma Lexemplo = {w 2 {a,b}⇤ | w termina com b}

Assuma a seguinte MTND M em que L(M) = Lexemplo

q0

q1

q2

q3

B/B D

a/a Db/b D

b/b D B/B D

Simule a execução da MTND em uma MT padrão com a

palavra abbAntes, construa a árvore de computações possíveis para o

melhor entendimento




q0

q1

q2

q3

B/B D

a/a Db/b D

b/b D B/B D


#2: q0B a b b B # . . . (configurações iniciando com a 1

a)

#3: B B B B B . . . (configuração em execução)




q0

q1

q2

q3

B/B D

a/a Db/b D

b/b D B/B D


#2: B B B B B . . . (mover 1

a)

#3: q0B a b b B . . . (executar)




q0

q1

q2

q3

B/B D

a/a Db/b D

b/b D B/B D


#2: B q1a b b B # . . . (transição resultante)

#3: B B B B B . . .




q0

q1

q2

q3

B/B D

a/a Db/b D

b/b D B/B D


#2: B B B B B . . . (mover 1

a)

#3: B q1a b b B . . . (executar)




q0

q1

q2

q3

B/B D

a/a Db/b D

b/b D B/B D


#2: B a q1b b B # . . . (transição resultante)

#3: B B B B B . . .




q0

q1

q2

q3

B/B D

a/a Db/b D

b/b D B/B D


#2: B B B B B . . . (mover 1

a)

#3: B a q1b b B # . . . (executar, ND)




q0

q1

q2

q3

B/B D

a/a Db/b D

b/b D B/B D


#2: B a b q1b B # B a b q2b B # . . . (transições resultantes)

#3: B B B B B . . .




q0

q1

q2

q3

B/B D

a/a Db/b D

b/b D B/B D


#2: B a b q2b B # . . . (mover 1

a)

#3: B a b q1b B # (executar, ND)




q0

q1

q2

q3

B/B D

a/a Db/b D

b/b D B/B D


#2: B a b q2b B # B a b b q1B # B a b b q2B # . . . (transições res.)

#3: B B B B B . . .




q0

q1

q2

q3

B/B D

a/a Db/b D

b/b D B/B D


#2: B a b b q1B # B a b b q2B # . . . (mover 1

a)

#3: B a b q2b B # (executar, para e rejeita)




q0

q1

q2

q3

B/B D

a/a Db/b D

b/b D B/B D


#2: B a b b q1B # B a b b q2B # . . . (antigas transições resultantes)

#3: B B B B B . . .




q0

q1

q2

q3

B/B D

a/a Db/b D

b/b D B/B D


#2: B a b b q2B # . . . (mover 1

a)

#3: B a b b q1B # (executar, para e rejeita)




q0

q1

q2

q3

B/B D

a/a Db/b D

b/b D B/B D


#2: B a b b q2B # . . . (antiga transição resultante)

#3: B B B B B . . .




q0

q1

q2

q3

B/B D

a/a Db/b D

b/b D B/B D


#2: B B B B B . . . (mover 1

a)

#3: B a b b q2B # . . . (executar)




q0

q1

q2

q3

B/B D

a/a Db/b D

b/b D B/B D


#2: B a b b B q3 . . . (transição resultante)

#3: B B B B B . . .




q0

q1

q2

q3

B/B D

a/a Db/b D

b/b D B/B D


#2: B B B B B . . . (mover 1

a)

#3: B a b b B q3 . . . (executar, para e aceita)



(volta) Se uma linguagem L é aceita por uma MT padrão, entãoé aceita por uma MT Não-Determinística

Basta não utilizar transições não-determinísticas



MT Enumeradoras de LinguagensMT vistas até o momento são aceitadoras de linguagens:

Entrada: palavra de acordo com um alfabeto

Saída: palavra válida (parada em estado final) ou inválida

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



MT Enumeradoras de LinguagensUma MT com k-fitas E = (Q,⌃, �, �,q

0

) enumera uma

linguagem L se:

Sua computação começa com todas fitas vazias

Fita 1 é chamada de fita de saída

A cada transição, cabeça da Fita 1 permanece parada (S)

ou se move para a direita (D)

Parte “não-branca” da Fita 1 tem uma das formas:

B#u1

#u2

#...#uk# ou

B#u1

#u2

#...#uk#v onde ui 2 L e v 2 ⌃⇤

ui é escrito na Fita 1 (entre #0s) sse ui 2 L

Definição não requer que a máquina pare (mesmo que a

linguagem seja finita)



Exemplo

MT para enumerar a linguagem L = {aibi | i > 0}

q0

q2

q3

q4

[B/B D, B/B D] [B/# D, B/X S]

[B/B S, B/B D]

[B/a D, X/X E]

[B/# D, B/X S]

[B/b D, X/X D]



Exemplo

MT para enumerar a linguagem L = {aibi | i > 0}

q0

q2

q3

q4

[B/B D, B/B D] [B/# D, B/X S]

[B/B S, B/B D]

[B/a D, X/X E]

[B/# D, B/X S]

[B/b D, X/X D]



ExemploDescrição do funcionamento da MT anterior:

Escreve ## na F1 (já que � 2 L)

Escreve “X” na posição 1 da F2

Loop:

q3

: volta na F2: para cada X , escreve a na F1

q4

: avança na F2: para cada X , escreve b na F1

q4

para q3

: escreve X no final da F2 e escreve # na F1



Exercício de Fixação

MT para enumerar a linguagem L = {aibici | i � 0}



Teoremas


Linguagens Irrestritas – Teoremas

Linguagem RecursivaMT decide uma linguagem L, logo L é recursiva (LSC)

Uma MT decide uma linguagem L se ela para para todas as

possíveis palavras de entrada (⌃⇤)

Teorema #5: L é recursiva se, e somente se, L pode serenumerada em ordem lexicográfica

Deve-se provar que:

(ida) se L é recursiva, então L pode ser enumerada em

ordem lexicográfica

(volta) Se L pode ser enumerada em ordem lexicográfica,

então L é recursiva



Teorema #5(ida) se L é recursiva, então L pode ser enumerada em


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 Eque enumera L em ordem lex. como a seguir:

loop:

Rode E⇤e produza uma palavra u (em ordem lex.)

Rode M com u

Se M aceita u, escreva u na fita de saída de E



Teorema #5 (explicação gráfica)(ida) se L é recursiva, então L pode ser enumerada em




Teorema #5 (explicação gráfica)(ida) se L é recursiva, então L pode ser enumerada em




Teorema #5(volta) Se L pode ser enumerada em ordem lexicográfica,


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



Teorema #5 (explicação gráfica)(volta) Se L pode ser enumerada em ordem lexicográfica,




Teorema #5 (explicação gráfica)(volta) Se L pode ser enumerada em ordem lexicográfica,




Linguagem Recursivamente EnumerávelMT reconhece uma linguagem L, logo L é recursivamenteenumerável (LI)

Uma MT reconhece uma linguagem L se ela para para todas

as palavras de L, mas pode não parar para as palavras que

não estão em L

Teorema #6: Uma linguagem é rec. enumerável se, e somentese, ela puder ser enumerada por uma MT

Deve-se provar que:

(ida) se L é RE, então L é enumerada por uma MT

(volta) se L é enumerada por uma MT, então L é RE



Teorema #6(volta) se L é enumerada por uma MT, então L é RE

Seja E a MT que enumera L

Prova consiste em mostrar que pode-se construir uma

máquina M que reconhece L

M recebe como entrada uma palavra u 2 ⌃⇤

Sempre que E escrever uma palavra w na fita de saída, Mverifica se w == u. Se for, M para em um estado final

Veja que M não vai parar se u 62 L

Porém, definição de RE não exige parada em caso de

palavras não pertencentes à linguagem



Teorema #6 (explicação gráfica)(volta) se L é enumerada por uma MT, então L é RE



Teorema #6 (explicação gráfica)(volta) se L é enumerada por uma MT, então L é RE



Teorema #6(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 LProva consiste em mostrar que pode-se construir uma MT Eque enumera LPara cada palavra u 2 ⌃⇤

(i.e., gerar todas palavras de ⌃)

Se M aceitar u, escrever u na fita de saída de E

Essa tentativa não funciona, pois:

Requer que todas palavras de u sejam geradas (ok)

Porém, ao se gerar uma palavra inválida, M pode não parar

ao analisar uCom isso, próximas palavras de u não serão geradas e

testadas



Teorema #6 (explicação gráfica do porquê força bruta falha)(ida) se L é RE, então L é enumerada por uma MT



Ordem LexicográficaOrdem lexicográfica de ⌃: função que mapeia palavras de

⌃ para números naturais

Seja ⌃ = {a1

, ...,an} um alfabeto. A ordem lexicográfica lode ⌃ é definida recursivamente como:

Base: lo(�) = 0, lo(ai) = i

Passo recursivo: lo(aiu) = lo(u) + i ⇤ ntam(u)

Exemplo: ⌃ = {a,b,c} e a1

= a, a2

= b, a3

= c

lo(�)= 0, lo(a)= 1, lo(b)= 2, lo(c)= 3,

lo(aa)= 4, lo(ba)= 7, lo(ca)= 10, lo(aaa)=13, lo(aba)=16,

lo(ab)= 5, lo(bb)= 8, lo(cb)= 11, lo(aab)=14, lo(abb)=17,

lo(ac)= 6, lo(bc)= 9, lo(cc)= 12, lo(aac)=15, lo(abc)=18,



Preparando a ProvaSuponha as palavras de ⌃ em ordem lexicográfica

�,u1

,u2

,u3

, ...

Seja a seguinte tabela:

Os pares dessa tabela podem ser enumerados “pelas

diagonais”:

[�, 0], [�, 1], [u1

, 0], [�, 2], [u1

, 1], [u2

, 0], [�, 3], [u1

, 2], ...



Voltando à ProvaSignificado de par [i,j]: rode M com entrada ui por j passos

Finalmente, a prova que ficou pendente

"Ida": se L é RE, então L é enumerada por uma MT

Seja M a MT que reconhece LProva 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

Cada palavra ui 2 ⌃⇤vai ser testada com 0, 1, 2, 3, ... passos

Se ui for válida, M vai parar para algum número k de passos



Teorema #6 (explicação gráfica)(ida) se L é RE, então L é enumerada por uma MT


7. Considerações Finais – Conteúdo

1 Revisão 3





Máquinas de Mealy





Recursividade


Ambiguidade






Variantes





Algoritmo de Early





Hierarquia de Chomsky 460

Tese de Church-Turing 462



Considerações Finais



Considerações Finais – Hierarquia de Chomsky







Toda categoria é um subconjunto próprio da categoria superior


Considerações Finais

Tese de Church-Turing


Considerações Finais – Tese de Church-Turing

“Toda ‘função naturalmente computável’ pode ser computada

por uma Máquina de Turing.”

A tese não pode ser formalmente provada

O que é uma função naturalmente computável?

No entanto, pode ser refutada

Basta a descoberta de uma máquina mais poderosa que

uma Máquina de Turing


Considerações Finais – Tese de Church-Turing

Linguagens de ProgramaçãoSe uma LP é capaz de manipular uma MT de uma única fita,

essa LP é capaz de expressar qualquer algoritmo

Normalmente, LPs provêem abstrações mais elaboradas

O poder de computação, contudo, é o mesmo de uma MT


Agradecimentos


Agradecimentos

Kleber Marchetti AntunesGostaria de agradecer ao aluno pela tarefa de conversão

inicial da apostila em formato ppt para LaTeX

Alberto HokariGostaria de agradecer ao aluno pelos desenhos das máquinas

em formato TikZ e ao desenvolvimento do material de CYK


Referências I

P. F. Blauth Menezes.

Linguagens formais e autômatos, volume 3.

Bookman, 6 edition, 2011.

S. L. G. de Oliveira.

Algoritmos e seus fundamentos.Editora UFLA, 2011.

J. E. Hopcroft and J. D. Ullman.

Formal languages and their relation to automata.

Addison-Wesley, 1969.

J. E. Hopcroft and J. D. Ullman.

Introduction to Automata Theory, Languages, and Computation.

Addison-Wesley, 1979.

M. Sipser.

Introdução à Teoria da Computação.

Thompson, 2007.


Referências II

T. A. Sudkamp.

Languages and machines: an introduction to the theory of ComputerScience.

Addison-Wesley, 2 edition, 2005.

M. T. Valente.

Notas de aula da disciplina Fundamentos Teóricos da Computação.

Programa de Pós-graduação em Informática, PUC Minas, 2007.

N. J. Vieira.

Introdução aos Fundamentos da Computação: Linguagens e máquinas.Thomson, 2006.

N. J. Vieira.

Notas de aula da disciplina fundamentos da teoria da computação.

Bacharelado em Ciência da Computação, UFMG, 2009.


apostila linguagens formais e autômatos (lfa)

Education