**********************************

********** TEO - Resumo **********

**********************************
Data
:
Verso :
Professor:
Autor
:
*
-

02/09/2003 a 07/12/2003
04/07/2007
Francisco Aurlio de Souza Grossi
Leandro Salvador ( leandrosalvador.com.br )

ndice
Conjuntos
Alfabetos
Gramticas
Linguagem e Gramtica
Hierarquia de Chomsky
Gramticas Regulares (GR) (tipo 3)
Expresses Regulares (ER)
Autmatos Finitos (AF)
Autmatos Finitos Determinsticos (AFD)
Transies e Configuraes (I) - AFD
Transdutor Finito Determinstico (TFD)
Autmatos Finitos No-Determinsticos (AFN)
Transies e Configuraes (I) - AFN
AFD x AFN
Algoritmo para AFN
Eliminao de Indeterminismos (AFN --> AFD)
Gramtica --> AFN
AFN --> Gramtica
ER --> AFN
AFN --> ER
Algoritmo de Minimizao (nmero de estados)
Algoritmo de Minimizao (4 passos)
Resumo
GLD --> AFN
Gramticas Livres de Contexto (GLC) (tipo 2)
rvores Sintticas
Autmato com Pilha (AFP)
Reconhecedores de LLC's
Formalismo dos AFP's
Transies e Configuraes - AFP
Diagramas de Estado - AFP
Gramticas Sensveis a Contexto (GSC) (tipo 1)
Gramticas com Estrutura de Frase (GEF)(tipo 0)
Reconhecedores
Autmato Adaptativo
Mquina de Turing (MT)
Modelo de MT
Transies e Configuraes - MT
Diagrama de Estados - MT
Outros Exemplos na Apostila
Resumo

* Conjuntos
- no h membros repetidos nem uma ordem estabelecida
- notaes
a E A --> a um membro do conjunto A
a !E A --> a no um membro do conjunto A
A C B --> conjunto A est contido no conjunto B; A um subconjunto de B; todos
os membros de A tambm pertencem ao conjunto B
A !C B --> conjunto A contm conjunto B; A um superconjunto de B

dois conjuntos so iguais se A C B e A !C B

A = {x : p(x)} --> conjunto A composto de membros com a propriedade p
A = {x : x = 2k, k >= 0}
--> nmeros pares no negativos
A = {x : x = 2k + 1, k >= 0} --> nmeros mpares no negativos

*
-

Alfabetos
representado pela letra grega sigma maiscula (E)
alfabeto um conjunto finito de smbolos
uma sentena sobre um alfabeto uma seqncia finita de smbolos deste alfabeto
a sentena vazia representada pela letra lambda minscula (T)
notaes referentes a alfabetos
E* --> conjunto de todas as sentenas possveis sobre E, inclusive vazia
E+ --> conjunto de todas as sentenas possveis sobre E, exceto vazia
- por definio
E* = E+ U {T}
E+ = E* - {T}
- exemplos
1) E = {a, b}
E+ = {a, b, aa, ab, ba, bb, aaa, ...}
E* = {T, a, b, aa, ab, ba, bb, aaa, ...}
2) E = {a, b}
se w pertence E conseqentemente w = a ou w = b
se w pertence E+ conseqentemente w = a ou w = b ou w = aa ou w = ab ou w = aa
abbb ou ...
- OBS: apenas nesse tpico "Alfabetos" utilizaremos
- a letra T para representar lambda minscula
- a letra E para representar sigma maiscula
*
-

Gramticas
linguagem formal um conjunto de sentenas sobre um alfabeto
gramtica um dispositivo gerador de sentenas de uma linguagem
a gramtica definida como uma qudrupla (ou quadra)
- G = (V,T,P,S) = (no-terminais, terminais, regra de produo, smbolo inicial)
- V --> conjunto finito de smbolos no-terminais (ou variveis)
- T --> conjunto finito de smbolos terminais
- P --> conjunto finito de pares, denominados regras de produo,
tal que o primeiro componente uma sentena de (V U T)+
e o segundo componente uma sentena de (V U T)*
- S --> membro de V (S E V) denominado varivel inicial ou smbolo inicial
- uma regra de produo (a, b) representada por a --> b
* Linguagem e Gramtica
- uma gramtica um formalismo de gerao das sentenas de uma linguagem
- a linguagem gerada por uma gramtica G, denotada por L(G), o conjunto de todas a
s sentenas constitudas exclusivamente de smbolos terminais derivadas a partir do smb
olo inicial S
- duas gramticas so equivalentes se geram linguagens iguais
- L(G1) = L(G2) <==> G1 e G2 so equivalentes
- exemplo
1) L(G) = {w E T* : S ==>+ w}
- {
--> conjunto
- w
--> varivel
- T* --> sentenas
- :
--> tal que
- S
--> smbolo inicial
- ==>+ --> deriva
2) G = (V,T,P,S) = (no-terminais, terminais, regra de produo, smbolo inicial)
G = ({A,B}, {0,1}, {A --> 0A, A --> B, B --> 1B, B --> T}, A}
ou ento
V = {A,B}

T = {0,1}
P = {A --> 0A
A --> B
B --> 1B
B --> T (OBS: T = sentena vazia)
}
A ==> 0A ==> 00A ==> 000A ==> 000B ==> 0001B ==> 00011B ==> 00011
A ==>7 00011
3) G = ({S,A,B,C}, {a,b,c}, P, S)
P = {S --> BAb | CAc
A --> BA | a
B --> b
C --> c
}
- linguagem gerada por G
n
n
L(G) = {b ab : n > 0} U {cb ac : n >= 0}
- para produzir "cbbac"
S ==> CAc ==> CBAc ==> CBBAc ==> CBBac ==> CBbac ==> Cbbac ==> cbbac
4) G = ({S,A}, {a,b,c}, P, S}
P = {S --> bAb | cAc
A --> bA | a
}
- linguagem gerada por G
n
n
L(G) = {b ab : n > 0} U {cb ac : n >= 0}
m n p
5) L(G) = {a b c : m,n,p >= 0}
P = {A --> aA | ab | T
B --> bB | bC | T
C --> cC | T
}
- gramtica que gera L(G)
G = ({A,B,C}, {a,b,c}, P, A)
* Hierarquia de Chomsky
- Chomsky classificou as gramticas e respectivas linguagens em quatro tipos
- GR
--> Gramticas Regulares
- (tipo 3)
- GLC --> Gramticas Livres de Contexto
- (tipo 2)
- GSC --> Gramticas Sensveis a Contexto - (tipo 1)
- GEF --> Gramticas com Estrutura de Frase - (tipo 0)
- a nica diferena entre os diferentes tipos de gramtica so as regras de produo
- G = (V,T,P,S)
- P --> regras de produo --> nica diferena
- hierarquia
______________________
/
________________ \
/
/
__________ \ \
/
/
/
____ \ \ \
( GEF ( GSC ( GLC ( GR ) ) ) )
\
\
\
/ / /
\
\
/ /
\
/

* Gramticas Regulares (GR) (tipo 3)

- GLD
- Gramtica Linear Direita
- regras de produo
A --> wB

A --> w
- w --> seqncia de smbolos terminais
- B --> smbolo no terminal
A,B E V
w E T*
- T* --> seqncia de smbolos terminais, inclusive o vazio
- lado esquerdo consiste de uma nica varivel
- lado direito consiste de um nmero qualquer de terminais (inclusive zero) se
guido de uma nica varivel
- GLE
- Gramtica Linear Esquerda
- regras de produo
A --> Bw
A --> w
A,B E V
w E T*
- GLUD (utilizada nos exemplos)
- Gramtica Linear Unitria Direita
- GLD e, adicionalmente, |w| <= 1
- regras de produo
A --> aB
A --> a
A,B E V
a E T*
- GLUE
- Gramtica Linear Unitria Esquerda
- GLE e, adicionalmente, |w| <= 1
- regras de produo
A --> Ba
A --> a
A,B E V
a E T*
- GLD x GLUD
- GLD
A --> abc
A --> abcB
- GLUD
A --> a
A --> aB
- exemplo
1) G = ({B}, {0,1}, {B --> 0B, B --> 1B, B --> T}, B)
- gramtica para nmeros binrios
2) G = ({S}, {a, b}, {S --> aS, S --> b}, S)
L(G) = {a^n b : n >= 0}
3) G = ({S,A}, {a,b,c}, P, S)
P = {S --> aS, S --> bA, A --> c}
L(G) = {a^n bc : n >= 0}
4) G = ({D,I), {+,-,0,1,2,3,4,5,6,7,8,9}, P, I)
P = {I --> +D
I --> -D
D --> 0D | 1D | 2D | 3D | 4D | 5D | 6D | 7D | 8D | 9D
D --> 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
L(G) = {nmeros inteiros com sinal e com zeros esquerda}
5) G = ({S,A,B}, {0,1}, P, S}
P = {S --> 0A
S --> 1B
A --> 0A
A --> 0
B --> 1B
B --> 1

}
L(G) = {0^n : n >= 0} U {1^m : m >= 0}
6) Construir uma gramtica sobre {a,b,c} que gera uma linguagem cujas
ntm seqncias repetidas de nenhum smbolo
G = ({A,B,C}, {a,b,c}, P, A)
P = {A --> aB | a | T
B --> bC | B
C --> cA | c
}
7) Construir uma gramtica regular cuja linguagem seja o conjunto dos
os pares positivos com zeros esquerda
G = ({D}, {0,1,2,3,4,5,6,7,8,9}, P, D)
P = {D --> 0D | 1D | 2D | 3D | 4D | 5D | 6D | 7D | 8D | 9D
D --> 0 | 2 | 4 | 6 | 8
}
8) Construir uma gramtica regular cuja linguagem seja o conjunto dos
os pares positivos sem zeros esquerda
G = ({N,D}, {0,1,2,3,4,5,6,7,8,9}, P, N)
P = {N --> 1D | 2D | 3D | 4D | 5D | 6D | 7D | 8D | 9D
D --> 0D | 1D | 2D | 3D | 4D | 5D | 6D | 7D | 8D | 9D
D --> 0 | 2 | 4 | 6 | 8
}
9) Construir uma gramtica regular cuja linguagem seja o conjunto dos
terminados em 00
G = ({B,C}, {0,1}, P, B)
P = {B --> 0B | 1B | 0C
C --> 0
}
- linguagem gerada por G
L(G) = {w E T* : S ==>+ w}
- para produzir "00100"
B ==> 0B ==> 00B ==> 001B ==> 0010C ==> 00100
- expresso regular
(0 | 1) * 00
- exemplo --> 00000

sentenas no co

nmeros inteir

nmeros inteir

nmeros binrios

* Expresses Regulares (ER)

- uma outra maneira de descrever uma linguagem regular
- definio
- dado um alfabeto E (sigma) qualquer
- qualquer smbolo de E, alm de T (sentena vazia), Expresso Regular
- se x e y so ER
x* ER (zero ou mais instncias de x)
x+ ER (uma ou mais instncias de x)
(x) ER
xy ER (concatenao)
x|y ER (unio)
- ordem de precedncia
^ *, +
| concatenao E (. "ponto" ou "nada")
| unio
OU (| "pipe")
- exemplo
1) E = {a,b}
a*
= {T, a, aa, aaa, aaaa, ...}
a+
= aa* = {a, aa, aaa, aaaa, ...}
(aa)* = {T, aa, aaaa, aaaaaa, ...}
a | bc* = {a, b, bc, bcc, bccc, ...}
(ab)* = {T, ab, abab, ababab, ...}
(a|b)* = {T, a, b, ab, aaa, aab, ...}
- exemplo

E = {0,1}
2) Sentenas com pelo menos trs 1's
L(G) = 0*10*10*1(0|1)*
- exemplo --> 00001T1000100000
3) Sentenas com comprimento no mximo 3
L(G) = (T|0|1).(T|0|1).(T|0|1)
4) Sentenas com nmero par de 0's ou exatamente dois 1's
L(G) = ((00)* 1*)*
|
0*10*10*0*
----------- --- ---------nmero par
ou
exatamente
de 0's
dois 1's
- exemplo
E = {a,b,c}
5) Qualquer sentena com no mais que trs a's
- sentena com 0, 1, 2 ou 3 a's --> (a|T)(a|T)(a|T)
- x so sentenas sem a
--> x(a|T)x(a|T)x(a|T)x
- x = (b|c)*
L(G) = (b|c)*(a|T)(b|c)*(a|T)(b|c)*(a|T)(b|c)*
6) Qualquer sentena que contenha, no mximo, dois a's consecutivos
- contem 0, 1 ou 2 a's --> (b|c)*(a|aa|T)(b|c)*
L(G) = (b|c)*(a|aa|T)(b|c)* ((b|c)+(a|aa|T)(b|c)*)*
7) Qualquer sentena em que o nmero de a's consecutivos mltiplo de 3
L(G) = (aaa|b|c)*
* Autmatos Finitos (AF)
- so mecanismos formais que reconhecem (sim | no) as sentenas de uma determinada li
nguagem regular
- uma linguagem regular se for reconhecida por um autmato finito e vice-versa
- AFD --> Autmato Finito Determinstico (tem um nico sentido determinado a seguir)
- AFND --> Autmato Finito No Determinstico
- o autmato finito s pra quando terminar a sentena de entrada
- representao grfica (diagrama de estados)
- estado inicial
--> -->(q0)
- estado intermedirio -->
(q1)
- estado final
--> ((q2))
- transio
-->
(qi)-----a----->(q1)
- significado --> estando no estado qi (corrente), a leitura do smbolo "a
" da fita de entrada causa a transio para o estado q1
- loop
-->
|_^
a,b
- quando passar pelo estado final no necessariamente o autmato pra
- mas quando o autmato pra, ele necessariamente est no estado final
- exemplo
1) Um AFD que s aceita nmeros binrios iniciados por 1
-->(A)-----1----->((B)) --> se entrar nesse loop a sentena aceita,
|
|_^
pois "morrer" no estado final
|
0,1
|
'------0------>(C) --> se entrar nesse loop a sentena no aceita,
|_^
pois "morrer" num estado que no o final
0,1
2) Um AFD que s aceita nmeros binrios sem 0 esquerda
-->(A)-----1----->((B))
|
|_^
|
0,1
|
'------0----->((C))-----0,1----->(D)

|_^
0,1
- se entrar 1 e mais algum outro
- se entrar apenas 0, aceita
- se entrar 0 e mais algum outro
- nesse caso, 0... significa
- o nmero 0 sozinho no 0

nmero, aceita
nmero, no aceita
0 esquerda
esquerda, por isso aceito

3) L(G) = {a^n b^m : n >= 0, m >= 0}

-->((I))-----b----->((F))
|_^
|_^
a
b
4) L(G) = {a^n b^n : n >= 0}
- essa linguagem no reconhecida por um autmato finito, pois a quantidade de a'
s necessariamente igual quantidade de b's, e o autmato finito no armazena a quanti
dade de loops
- essa no uma linguagem regular, mas sim uma linguagem no regular, conhecida c
omo linguagem livre de contexto
* Autmatos Finitos Determinsticos (AFD)
- um AFD uma quntupla
- M = (Q,E,d,q0,F) = (estados, alfabeto, funo de transio, estado inicial, estado
s finais)
- Q
- conjunto finito de estados
- E
- sigma maiscula
- alfabeto finito de smbolos de entrada
- d
- delta minscula
- funo de transio
- d : Q . E --> Q
- l-se: cada estado Q deve ter uma transio para cada smbolo E resultando
num nico estado Q
- exemplo
E = {a,b,c}
-----a---->
-->(1)-----b---->((2))
-----c---->
- q0
- estado inicial
- q0 pertence Q
- F
- conjunto de estados finais
- F est contido em Q
- representaes da funo de transio d
- diagrama de estados (dado)
-----1----->
-->((q0))
(q1)
^ | <----1------ ^ |
| |
| |
| |
| |
0 0
0 0
| |
| |
| |
| |
| v -----1-----> | v

(q2)

(q3)
<----1------ tabela (representao 1)
---------------------| estado | 0 | 1 |
---------------------| q0 | q2 | q1 |
| q1 | q3 | q0 |
| q2 | q0 | q3 |
| q3 | q1 | q2 |
---------------------- estados correntes --> q0,q1,q2,q3
- smbolos de E
--> 0,1
- estados aps transio --> q2,q1,q3,q0,q0,q3,q1,q2
- tabela (representao 2)
-----------------------------| estado | smbolo | transio |
-----------------------------| q
| ? per E | d(q,?) |
-----------------------------| q0 |
0
|
q2
|
| q0 |
1
|
q1
|
| q1 |
0
|
q3
|
| q1 |
1
|
q0
|
| q2 |
0
|
q0
|
| q2 |
1
|
q3
|
| q3 |
0
|
q1
|
| q3 |
1
|
q2
|
------------------------------ origem/consumo/destino (representao 3)
d(q0,0)
d(q0,1)
d(q1,0)
d(q1,1)
d(q2,0)
d(q2,1)
d(q3,0)
d(q3,1)

=
=
=
=
=
=
=
=

q2
q1
q3
q0
q0
q3
q1
q2

(l-se: delta, estando em q0, consumindo 0, resulta em q2)

- definio formal de computao com AFD

- seja M = (Q,E,d,q0,F) um Autmato Finito e w = w1 w2 w3 ... wn uma sentena do
alfabeto E
- diz-se que M aceita w se e somente se existir uma seqncia de estados r0,r1,r
2,...,rn tal que
- 1) r0 = q0
- comear no estado inicial
- 2) d(ri,wi+1) = ri+1
(0 <= i <= n-1)
- delta, estando em ri, consumindo wi+1, resulta em ri+1
- 3) rn E F
- terminar no estado final
- exemplo
-->(r0)----w1--->(r1)----w2--->(r2) ... (rn-1)----wn---->((rn))
* Transies e Configuraes (I) - AFD

- a relao binria |- aplica-se a duas configuraes de um autmato se e somente se a mquin

puder passar de uma para a outra como resultado de uma nica transio
- configurao de um autmato o par estado corrente e a subsentena da sentena de entrada
a partir do smbolo corrente
- exemplo
(qi,aw) |- (qj,w) <==> a pertence E, w pertence E*, d(qi,a) = qj
- onde
(qi,aw)
- mostra o AFD no estado qi com o smbolo corrente a seguido da subsen
tena w
- a subsentena w pode ser vazia se a o ltimo smbolo
|- indica que a nova configurao (qj,w)
- pois o AFD transita para qj aps consumir o smbolo a
- a configurao (q,T) significa que o AFD consumiu toda a sentena e que sua operao ter
minou
- define-se tambm (qi,w1) |-* (qj,w2) se (qi,w1) produz o estado qj aps um nmero qu
alquer de transies, reduzindo a entrada de w1 para w2
- uma sentena w aceita por um AFD M = (Q,E,d,q0,F) se h um estado q pertence F : (
q0,w) |-* (q,T)
- portanto, a linguagem reconhecida pelo AFD M
L(M) = {w pertence E* : (q0,w) |-* (qf,T), qf pertence F}
- l-se
- a definio da linguagem que o autmato M aceita
- w uma sentena de E*,
- tal que partindo do estado inicial q0,
- aps um nmero qualquer de transies |-*,
- atinjo um estado final qf,
- tendo consumido todos os smbolos de w
- (restando T e onde qf pertence ao conjunto dos estados finais F)
- exerccio
1)
I = d(q1,a)
d(q1,b)
d(q2,a)
d(q2,b)
AF =

=
=
=
=

q1
q2
q1
q2

(l-se: delta, estando em q1, consumindo a, resulta em q1)

a
b
|v
|v
-->(q1)-----b----->((q2))
<----a------

ER = (a|b)*b
a) Teste a sentena "aaba"
- seqncia de estados produzidas por "aaba"
q1 q1 q1 q2 q1
- requisitos
1) r0 = q0 --> comear no estado inicial
- o estado inicial q1
- a seqncia comeou em q1
- OK
2) d(r1,wi+1) = ri+1
- OK
3) rn E F --> terminar no estado final
- o estado final q2
- a seqncia terminou no estado q1
- NO OK
- computao do autmato

(q1,aaba) |- (q1,aba) |- (q1,ba) |- (q2,a) |- (q1,T)

- concluso
- q1 !E F
- a sentena "aaba" no aceita pelo AFD
b) Teste a sentena "aabab"
- computao do autmato
(q1,aabab) |- (q1,abab) |- (q1,bab) |- (q2,ab) |- (q1,b) |- (q2,T)
- concluso
- q2 E F
- a sentena "aabab" aceita pelo AFD
2) AFD que aceita a linguagem cujas sentenas possuem "aa" ou "bb" como subsentenas
- M = (Q,E,d,q0,F) = (estados, alfabeto, funo de transio, estado inicial, estado
s finais)
- M = ({q0,q1,q2,q3}, {a,b}, d, q0, {q3})
d:
---------------------| estado | a | b |
---------------------| q0 | q1 | q2 |
| q1 | q3 | q2 |
| q2 | q1 | q3 |
| q3 | q3 | q3 |
----------------------

d(q0,a)
d(q0,b)
d(q1,a)
d(q1,b)
d(q2,a)
d(q2,b)
d(q3,a)
d(q3,b)

=
=
=
=
=
=
=
=

q1
q2
q3
q2
q1
q3
q3
q3

a) Escreva uma expresso regular que gera a linguagem L(M)

- ER = (a|b)* aa|bb (a|b)**
b) Desenhe o diagrama de estados que reconhece a linguagem L(M)
-->(q0)-----a---->(q1)
|
/ ^ |
|
/ /
|
b
b a
a
|
/ /
|
| / /
|
v v /
v
(q2)-----b---->((q3))
|__^
a,b
3) Construir um AFD que aceite
L(M) = {w E {a,b}* : w no contm 3 b's consecutivos}
a) Desenhe o diagrama de estados que reconhece a linguagem L(M)
a
a,b
|v
|v
-->((1))-----b---->((2))-----b---->((3))-----b---->(4)
^ ^
|
|
| |
|
|
| '------a------|
'----------------a---------------'
b) Teste a sentena "aababba"
- computao do autmato
(1,aababba) |- (1,ababba) |- (1,babba) |- (2,abba) |- (1,bba) |- (2,ba)
|- (3,a) |- (1,T)

- 1 E F
- concluso
- a sentena "aababba" aceita pelo AFD
- pois a computao do autmato termina no estado 1, e 1 pertence ao conjunto
dos estados finais F
* Transdutor Finito Determinstico (TFD)
- um dispositivo similar aos AFD's
- tem o propsito de transformar sentenas de entrada em sentenas de sada
- inicia em um estado inicial e transita de estado em estado, dependendo do argu
mento (estado e smbolo) como os AFD's
- mas emite uma sentena de um alfabeto de sada em cada transio
- no h estados finais
- ele pra quando a sentena acaba
- o rtulo de transio expresso por
a/w
- que significa
- consuma o smbolo a
- mude de estado
- emita a sentena w
- AFD x TFD
- autmato
- diz se a sentena ou no aceita
- transdutor
- tem um estado inicial e transforma a sentena em outra sentena
- um TFD uma quntupla
- M = (Q,E,G,d,q0) = (estados, alfabeto de entrada, alfabeto de sada, funo de t
ransio, estado inicial)
- Q = AFD
- E = AFD
- G
- gama maiscula
- alfabeto de sada
- d
- delta minscula
- funo de transio
- d : Q . E --> Q . G*
- q0 = AFD
- exerccio
1) TFD que transmite todos os b's da palavra de entrada, mas elimina um a cada d
ois a's
a) Desenhe o diagrama de estados
b/b
b/b
|v
|v
-->(1)-----a/a---->(2)
<----a/T----b) Teste a sentena "abab"
- entrada: abab
- sada : abb
* Autmatos Finitos No-Determinsticos (AFN)
- um AFN uma quntupla
- M = (Q,E,d,q0,F) = (estados, alfabeto, funo de transio, estado inicial, estado
s finais)
- Q = AFD
- E = AFD

- d
-

delta minscula
funo de transio
d : Q . (E U {T}) --> 2^Q
exemplo (para explicar 2^Q)
Q = {1,2,3}
- 3 conjuntos
2^Q = {{},{1},{2},{3},{1,2},{1,3},{2,3},{1,2,3}}
- 8 conjuntos
2^Q = 2^3 = 8
- q0 = AFD
- F = AFD
- representaes da funo de transio d
- origem/consumo/destino (representao 3)
d(q,a) = {q1,q2,q3,...,qn}
- produz um conjunto de estados em vez de um nico estado dos AFD's
- este conjunto pode ser vazio, isto , pode no haver estado de transio para
o smbolo
* Transies e Configuraes (I) - AFN
- de forma semelhante aos AFD's, a relao binria |- aplica-se entre duas configuraes d
e um AFN
- se um autmato M est no estado q e o prximo smbolo de entrada a, ento M pode seguir
qualquer transio nas formas
(q1,a,q2) --> um smbolo da entrada consumido, no caso, o smbolo a
(q1,T,q2) --> nenhum smbolo da entrada consumido
- exemplo
(p,aw) |- (q,w) <==> a pertence (E U {T}), w pertence E*, q pertence d(p,a)
- d(p,a) --> conjunto de estados
- portanto, a linguagem reconhecida pelo AFN M
L(M) = {w pertence E* : (q0,w) |-* (qf,T), qf pertence F}
ou ento
L(M) = {w pertence E* : d*(q0,w) interseco F != 0}
- d* corresponde a aplicaes sucessivas da relao d

* AFD x AFN
- AFN no aumentam a capacidade de reconhecimento dos AFD's
- os AFN's reconhecem as mesmas linguagens (regulares) que os AFD's reconhecem
- o indeterminismo ajuda a expressar o autmato de uma maneira mais simples
- qualquer AFN pode ser convertido para um AFD equivalente
- o indeterminismo a capacidade de alterar estados de uma maneira parcialmente d
eterminada pelo estado corrente e smbolo de entrada
- a relao de transio, ao processar uma configurao, pode causar uma transio para um co
nto de novos estados ao invs de apenas um estado como nos AFD's
- o indeterminismo pode manifestar-se de duas formas
- um ou mais estados de onde sai mais de uma flecha rotulada com o mesmo smbo
lo (q1 e q3)
- quando o smbolo a ocorrer na entrada e o estado corrente for q1, por exempl
o, pode-se transitar para q1 ou q2
- exemplo
a,b
a,b
|v
|v
-->(q1)-----a---->(q2)-----a---->((q3))
<----b----<----b----- um ou mais estados de onde sai pelo menos uma flecha rotulada com T (vazio
)

- esta transio (em vazio) pode ocorrer sem consumir nenhum smbolo da entrada
- exemplo
a
a,b
|v -------------T-----------> |v
-->(q1)-----b---->(q2)-----a---->((q3))
<----b----- devido ao indeterminismo, a mesma sentena pode causar uma parada do AFN em mais
de um estado, dependendo das transies escolhidas
- considera-se a sentena aceita se pelo menos um destes possveis estados for um es
tado final do AFN
- um AFD apenas um caso especial de AFN em que no h transies em vazio ou mais de uma
transio com o mesmo smbolo em algum estado
- ambos os dispositivos (AFD e AFN) reconhecem linguagens regulares e, embora AF
N's sejam mais convenientes em alguns casos, eles tm o mesmo poder computacional
dos AFD's
- exemplo
1) Dada a linguagem cujas sentenas so repeties de ab e/ou aba
a) ER = (ab | aba)*
b) AFD
<------------a-------------->((1))-----a---->(2)-----b---->((3))-----a---->((4))
|
|
| <----b----|
|
|
|
a
|
- o determinismo exige que duas
|
|
|
flechas saiam de cada estado
|
v
|
(correspondentes aos dois
'-------b---->(5)<----b-------'
smbolos do alfabeto)
|_^
- o AFD no trivial
a,b
c) AFN (duas alternativas)
-->((1))-----a---->(2)
^ <----b----- |
|
|
a
b
|
|
'------(3)<----'

- no estado 1 ele pode receber apenas a

- no estado 2 h duas alternativas
- ou recebe b
- ou recebe ba
- terminando ou repetindo o ciclo

d) AFN (transio vazia)

-->((1))-----a---->(2)
^ ^
|
| |
|
a T
b
| '----|
'-------(3)<----'

- como o AFN pode transitar para um

conjunto de estados, podem existir
transies proibidas (conjunto vazio)

- exerccio
1) AFN que aceita nmeros inteiros com sinal opcional
a) Desenhe o diagrama de estados
digito

---- + --->
|v
-->(1)---- - --->(2)---digito-->((3))
---- T --->
b) Teste a sentena "+235"
- computao do autmato
(1,+235) |- (2,235) |- (3,35) |- (3,5) |- (3,T)
- concluso
- 3 E F
- a sentena "+235" aceita pelo AFN
c) Teste a sentena "32"
- computao do autmato
(1,32) |- (2,32) |- (3,2) |- (3,T)
- concluso
- 3 E F
- a sentena "32" aceita pelo AFN
2) AFN que aceita a linguagem cujas sentenas em {a,b} terminam em "aaa"
- M = (Q,E,d,q0,F) = (estados, alfabeto, funo de transio, estado inicial, estado
s finais)
- M = ({1,2,3,4}, {a,b}, d, 1, {4}}
d:
----------------------| estado | a | b |
----------------------|
1
| {1,2} | {1} |
|
2
| {3} | T |
|
3
| {4} | T |
|
4
| T | T |
-----------------------

d(1,a)
d(1,b)
d(2,a)
d(2,b)
d(3,a)
d(3,b)
d(4,a)
d(4,b)

=
=
=
=
=
=
=
=

{1,2}
{1}
{3}
T
{4}
T
T
T

a) Escreva uma expresso regular que gera a linguagem L(M)

- ER = (a|b)* aaa
b) Desenhe o diagrama de estados que reconhece a linguagem L(M)
a,b
|v
-->(1)-----a---->(2)-----a---->(3)-----a---->((4))
* Algoritmo para AFN
- algoritmo
- A = {}
- s = estado inicial
- para cada estado a alcanvel a partir de s
- A = A U {a}
- enquanto sentena no vazia
- B = {}
- leia smbolo x
- para cada estado a em A
- para cada transio T de a para algum estado b
- B = B U {b}
- para cada transio em x de a para algum estado b
- B = B U {b}
- para cada transio T de algum estado b E B para algum estado c !E B
- B = B U {c}
- A = B
- se A interseco F != {}

- ento retorna verdadeiro // aceita a sentena

- seno // A interseco F == {}
- retorna falso
// rejeita a sentena
- aps cada ciclo do "enquanto", o conjunto A contm todos os estados alcanveis com o
consumo de um smbolo da sentena
- aps a exausto da sentena, basta verificar se um dos estados de A final
- exerccio
1) AFN que aceita qualquer sentena que termine com "ab" ou "aba"
a) Desenhe o diagrama de estados
a
a,b
|v
|v
-->(q0)-----b---->(q1)-----a---->(q2)
| -----T----> |
| ^
|
|
| |
b
b
b a
|
|
| |
v
v <--------' |
(q3)-----a---->((q4))------------'
<----T----b) Teste a sentena "aaaba"
- computao do autmato
(q0,aaaba) |- (q1,aaaba) |- (q2,aaba) |- (q2,aaba) |- (q2,aba) ||- (q2,ba) |- (q4,a) |- (q3,a) |- (q4,T)
- concluso
- q4 E F
- a sentena "aaaba" aceita pelo AFN
* Eliminao de Indeterminismos (AFN --> AFD)
- transies em vazio
- possvel transitar de p para q sem consumir smbolo de entrada
- portanto, substituem-se os dois estados por um nico
- exemplo
-----d1---->(q1)
-->(p)-----T---->(q)-----d2---->(q2)
|
...
'-----dn---->(qn)
- mais de uma transio
- um AFN com |Q| estados pode produzir um AFD equivalente com at 2^|Q| estado
s
- na maioria dos casos, o nmero de estados do AFD resultante bem menor
- muitos estados criados no AFD equivalente so suprfluos e podem ser unificado
s com outros estados usando um algoritmo de minimizao
- exemplo
-----d---->(q1)
-->(p)-----d---->(q2)
|
...
'-----d---->(qn)
- utilizando a
- criam-se
- para
- para
- o estado
- ou

tabela de converso
novos estados
cada unificao de transies em vazio
cada transio mltipla para o mesmo smbolo
inicial do AFD o mesmo do AFN
o novo estado que unificou o estado inicial do AFN

- todos os estados que unificaram algum estado final original do AFN um esta
do final do AFD
- exemplo
1) Transforme o AFN em AFD
a) AFN

c) AFD

x
y
|v
|v
-->(A)-----T---->((B))
| ^
^ |
| |
| |
y x
y y
| '---- -----' |
'----->(C)<------'
|_^
y

x
y
|v
|v
-->((D))<----x-----((E))
| ^
^
| |
|
y x
y
| '---|
'----->(C)-------'

b) Tabela de Converso
--------------------------------| estado | x | y | T |
--------------------------------| {A}
| {A} | {C} | {B} |
| {B}
| {B} | {C} | --- |
| {C}
| {A} | {B,C} | --- |
| D = {A,B} | {A,B} | {C} | --- |
| E = {B,C} | {A,B} | {B,C} | --- |
--------------------------------* Gramtica --> AFN
- dada uma gramtica regular, pode-se construir um AFN que aceite sua linguagem di
retamente das regras de produo
- exemplo
1) Dada a gramtica regular G, construa o AFN que aceite sua linguagem
a) G = (V,T,P,S) = (no-terminais, terminais, regra de produo, smbolo inicial)
G = ({S,B}, {0,1}, P, S)
P = {S
B
B
B
}

-->
-->
-->
-->

0B,
0B,
1S,
0

b) Funo de Transio
d(S,0) = {B}
// S --> OB
d(B,0) = {B,A} // B --> OB, B --> 0 (A estado final)
d(B,1) = {S}
// B --> 1S
c) AFN
0
|v
-->(S)-----0---->({A,B})-----0---->((A))
<----1----d) Tabela de Equivalncia

-----------------------| regra | transio |

-----------------------| A --> T | d(A,T) = qf |
| A --> a | d(A,a) = qf |
| A --> B | d(A,T) = B |
| A --> aB | d(A,a) = B |
-----------------------e) AFN Simplificado (visualmente / intuitivamente)
0
|v
-->(S)-----0---->((B))
<----1----* AFN --> Gramtica
- da mesma forma com que podemos construir um autmato a partir de uma gramtica reg
ular, uma gramtica regular pode ser facilmente escrita a partir de um autmato
- se o autmato contiver transies para estados de erros (estados de onde no possvel ac
eitar a sentena, as regras correspondentes no devem ser escritas porque elas no dev
em gerar sentenas
- se forem escritas elas podem gerar loops na gramtica
- exemplo
1) Dado o AFN, construa a Gramtica Regular que gera esse AFN
a) AFN
0
|v
-->(S)-----0---->((B))
<----1----b) Gramtica
S -->
em B)
B -->
B -->
B -->

OB

// d(S,0) = B

(l-se: delta, estando em S, consumindo 0, resulta

1S
OB
O

// d(B,1) = S
// d(B,0) = B
// B estado final

2) Construa uma gramtica que gera todas as sentenas sobre {a,b,c}* sem que haja smb
olos iguais consecutivos
- como a sentena vazia pertene linguagem, deve haver uma regra S --> T
- algumas sentenas comeam com a (bvio), que pode ser seguido por qualquer subse
ntena da linguagem que no comece com a
- o mesmo raciocnio aplica-se a "b" e "c"
S --> aA | bB | cC
- a varivel A pode ser vazia ou qualquer subsentena que comea com b ou com c
- se comear com b, deve ser seguido por uma subsentena, talvez vazia, que no co
mece com b, que a varivel B
- o mesmo ocorre com comeo c
- raciocnio semelhante aplicado a B e C leva a
A --> bB | cC | T
B --> aA | cC | T
C --> aA | bB | T
a) Gramtica
G = (V,T,P,S) = (no-terminais, terminais, regra de produo, smbolo inicial)

V = {S,A,B,C}
T = {a,b,c}
P = {S --> aA
A --> bB
B --> aA
C --> aA
}

|
|
|
|

bB
cC
cC
bB

|
|
|
|

cC | T
T
T
T

b) AFN
------.
,--------------a-------------->((A))<-. |
|
^ |
| |
|
| |
| |
|
a b
| |
|
-------------' /
| |
-->(S)-----b---->((B))<-------------a c
|
-------------. \
| |
|
c b
| |
|
| |
| |
|
v |
| |
'--------------b-------------->((C))--' |
<-----'
* ER --> AFN
- ER descrevem linguagens regulares
- possvel ento
- para qualquer ER, construir um AFN que aceita a linguagem descrita pela ER
(fcil)
- para qualquer AFN, construir uma ER que descreve a linguagem aceita pelo A
FN (difcil)
- para qualquer x pertence E, a expresso x denota a linguagem {x}, portanto
-->(A)-----x---->((B))
- a expresso T corresponde a
-->(A)-----T---->((B))
- os parnteses no corresopndem a nada especificamente
- um AFN que representa a ER (r1) o mesmo que representa r1
- a idia no construir o melhor autmato (menos estados), mas sim mostrar que existe
um AFN equivalente, que pode ser construdo por um algoritmo
- concatenao
- a concatenao pode ser simplesmente representada pelo encadeamento de AFN's
- um novo estado inicial construdo na frente do 1 AFN e um novo estado final c
onstrudo aps o 2 AFN
- AFN para r1 . r2
M(r1)
M(r2)
,----------------------.
,----------------------.
|
|
|
|
-->( )-----T--|-->( )--\/\/\,->( )--|--T--|-->( )--\/\/\,->( )--|--T-----(
( ))
|
|
'----------------------'
- unio
- a unio representa uma escolha
- AFN para r1 | r2

|
|
'----------------------'

M(r1)
,----------------------.
|
|
,-----T--|-->( )--\/\/\,->( )--|--T-----.
|
|
|
|
|
'----------------------'
|
|
v
-->( )
(( ))
|
M(r2)
^
|
,----------------------.
|
|
|
|
|
'-----T--|-->( )--\/\/\,->( )--|--T-----'
|
|
'----------------------'
- repetio
- zero ou mais vezes
- AFN para r1*
,---------------------T---------------------.
|
|
|
M(r1)
|
|
,----------------------.
|
|
|
|
v
-->( )-----T--|-->( )--\/\/\,->( )--|--T---->(( ))
|
|
|
^
|
'----------------------'
|
|
|
|
|
'---------------------T---------------------'
* AFN --> ER
- a construo de uma ER a partir de um autmato no to trivial quanto a tarefa inversa,
pois um AFN pode ter ciclos e loops arbitrrios
- a estratgia bsica a seguinte
- se o AFN tiver mais de um estado final, converta-o para um AFN com um nico
estado final
- para isso, transforme os estados finais em no-finais e adicione uma transio e
m vazio de cada um destes antigos estados finais at o novo estado final criado
- exemplo
-->(( ))
|
|
v
-->(( ))
^
|
|
-->(( ))

==>

-->((A))
|
|
v
-->((B))-----T---->(( ))
^
|
|
-->((C))

VOLTAR PRA PGINA 71 E 72!!!

* Algoritmo de Minimizao (nmero de estados)
- requisitos
- autmato tem que ser determinstico (AFD)
- no pode ter estados inalcanveis a partir do estado inicial
- exemplo de estados inalcanveis que devem ser removidos antes da execuo do algoritm
o

<----a------>((1))-----a---->(2)-----b---->((3))<----b-----(8)
^ |
|
^ |
^ |
| |
|
| |
| |
a b
a
a b
b a
| |
|
| |
| |
| v
v
| v
| v
(4)-------b---->(5)<----b-----(6)<------a-----(7)
|_^
a,b

- os estados
7 e 8 so
inalcanveis
a partir do
estado 1

- o conjunto de estados alcanveis pode ser computado assim

R <-- {q0}
enquanto existir estado p pertence R e a pertence E : d(p,a) !pertence R
R <-- R U {d(p,a)}
- exemplo de AFD com estados inalcanveis removidos (pode ser minimizado com o algo
ritmo)
<----a------>((1))-----a---->(2)-----b---->((3))
^ |
|
^ |
| |
|
| |
a b
a
a b
| |
|
| |
| v
v
| v
(4)-------b---->(5)<----b-----(6)<
|_^
a,b

R
R
R
R
R
R

<-<-<-<-<-<--

{1}
{1,2}
{1,2,4}
{1,2,4,5}
{1,2,3,4,5}
{1,2,3,4,5,6}

* Algoritmo de Minimizao (4 passos)

- construa uma tabela relacionando os estados distintos, onde cada par aparece
apenas uma vez
- marque todos os pares constitudos de um estado final e outro no-final
- para cada par {qu,qv} no marcado para cada smbolo a pertence E
- calcule
d(qu,a) = pu
d(qv,a) = pv
- se pu == pv, no faa nada
- se pu != pv e o par {pu,pv} no estiver marcado, adicione {qu,qv} a uma list
a encabeada por {pu,pv} para anlise posterior
- se pu != pv e o par {pu,pv} estiver marcado
- marque {qu,qv}
- se {qu,qv} encabear alguma lista, marque todos os pares desta lista e,
recursivamente, se algum par da lista encabear outra lista
- os estados dos pares no marcados so equivalentes e podem ser unificados
- um estado unificado deve ser inicial se um de seus componentes originais e
ra inicial
- as transies do par unificado so a unio das transies dos dois estados originais
- a equivalncia de estados (pares no marcados) transitiva
- se {a,b} e {b,c} so equivalentes, ento {a,c} so equivalentes
- observao
- por construo, somente dois estados do mesmo tipo, final ou no-final, so declar
ados equivalentes
- quando se analisa um par e a primeira transio resulta na marcao deste par, pod
em-se ignorar as anlises das outras transies relativas a este par
- no entanto, se essas anlises forem feitas, no causam problemas (apenas um tr
abalho desnecessrio)

- exemplo
1)
a) AFD
<----a------>((1))-----a---->(2)-----b---->((3))
^ |
|
^ |
| |
|
| |
a b
a
a b
| |
|
| |
| v
v
| v
(4)-------b---->(5)<----b-----(6)<
|_^
a,b
b) Tabela
X = no so equivalentes
.-------.
| 2 | X |
'-----------.
| 3 | | X |
'---------------.
| 4 | X | | X |
'-------------------.
| 5 | X | | X | |
'-----------------------.
| 6 | X | | X | | |
'-----------------------'
| 1 | 2 | 3 | 4 | 5 |
'-------------------'

- aps os dois primeiros passos do

algoritmo, os pares marcados
no so equivalentes
- os pares no marcados podem ser
equivalentes, mas ainda no temos
certeza

c) Anlise dos Pares No Marcados

par {1,3}
d(1,a) = 2 no faz
d(3,a) = 2 nada
d(1,b) = 4 o par {4,6} no est marcado ==> adicionar {1,3)
d(3,b) = 6 lista encabeada por {4,6}
par {2,4}
d(2,a) = 5 {1,5} est marcado ==> marca {2,4} e verifica lista
d(4,a) = 1 encabeada por {2,4} (vazia)
d(2,b) = 3 {3,5} est marcado, mas esta anlise desnecessria
d(4,b) = 5 porque {2,4} j foi marcado na anlise anterior (acima)
par {2,5}
d(2,a) = 5 no faz
d(5,a) = 5 nada
d(2,b) = 3 {3,5} est marcado ==> marca {2,5} e verifica lista
d(5,b) = 5 encabeada por {2,5} (vazia)

par {2,6)
d(2,a) = 5 (3,5) est marcado ==> marca {2,6} e verifica lista
d(6,a) = 3 encabeada por {2,6} (vazia)
d(2,b) = 3 idem
d(6,b) = 5
par {4,5}
d(4,a) = 1 {1,5} est marcado ==> marca {4,5} e verifica lista
d(5,a) = 5 encabeada por {4,5} (vazia)
d(4,b) = 5 no faz
d(5,b) = 5 nada
par {4,6}
d(4,a) = 1 {1,3} no est marcado ==> adicionar {4,6}
d(6,a) = 3 lista encabeada por {1,3}
d(4,b) = 5 no faz
d(6,b) = 5 nada
par {5,6}
d(5,a) = 5 {3,5} est marcado ==> marca {5,6} e verifica lista
d(6,a) = 3 encabeada por {5,6} (vazia)
d(5,b) = 5 j foi verificado
d(6,b) = 6 na anlise anterior
d) Tabela aps este passo
.-------.
| 2 | X |
'-----------.
| 3 | . | X |
'---------------.
| 4 | X | x | X |
'-------------------.
| 5 | X | x | X | x |
'-----------------------.
| 6 | X | x | X | . | x |
'-----------------------'
| 1 | 2 | 3 | 4 | 5 |
'-------------------'

- aps este passo, o exemplo mostra

que dois pares (identificados por .),
{1,3} e {4,6} so equivalentes e
podem ser unificados
- novas marcaes foram feitas
com x
- marcaes originais foram feitas
com X

e) Estado das Listas

--------------| {4,6} | {1,3} |
--------------| {1,3} | {4,6} |
--------------f) Unificao dos Pares No Marcados
- o ltimo passo do algoritmo consiste na unificao destes dois pares no-marcados

- olhando o diagrama de estados do AFD pode-se ver que fazemos uma rotao dos e
stados 3 e 6 em torno da aresta que une os estados 2 e 5 at faz-los coincidir com
os estados 1 e 4, respectivamente
- AFD resultante da unificao dos pares no marcados
<----b------>((13))-----a---->(2)
^ |
|
| |
|
a b
a
| |
|
| v
v
(46)------b---->(5)
|_^
a,b
* Resumo
- uma gramtica regular gera uma linguagem regular, ou seja, produz todas as sente
nas de uma linguagem regular
- uma expresso regular outra forma de expressar uma linguagem regular
- uma expresso regular tambm produz todas as sentenas de uma linguagem regular
- um AFD ou AFI aceita as palavras de uma linguagem regular
- uma linguagem regular se e somente se for possvel construir um autmato finito qu
e a aceite
- uma linguagem regular se e somente se for possvel express-la por uma gramtica reg
ular
- uma linguagem regular se e somente se for possvel express-la por uma expresso reg
ular
- a classe das linguagens regulares fechada para as operaes
- unio
- concatenao
- interseco
- complemento
* GLD --> AFN
- GLD = Gramtica Linear Direita
- AFN = Autmato Finito No Determinstico
- qualquer AFN tem um AFD equivalente, ou seja, que aceita a mesma linguagem
- geralmente, o algoritmo de converso AFN --> AFD cria estados equivalentes que p
odem ser verificados atravs de um algoritmo de minimizao de estados
- exemplo
----------------------------------------------------------------GLD
|
AFN
|
----------------------------------------------------------------|
|
|
| A --> xB
| (A)-----x---->(B)
|
| A --> xyzB | (A)-----x----->( )-----y---->( )-----z---->(B) |
| A --> B
| (A)-----T----->(B)
|
| A --> x
| (A)-----x----->(( ))
|
| A --> T
| (A)-----T----->(( ))
|
|
|
|
----------------------------------------------------------------|

* Gramticas Livres de Contexto (GLC) (tipo 2)

- so gramticas, definidas usualmente como
G = (V,T,P,S) = (no-terminais, terminais, regra de produo, smbolo inicial)
- com restries menos proibitivas que as Gramticas Regulares (GR)
- ou seja, uma GLC mais ampla que uma GR
- as regras de produo de uma GLC so da forma

A --> a
A pertence V
a pertence (V unio T)*
- OBS: neste caso, T = letra t maiscula, no lmbda
- em outras palavras, o lado esquerdo de qualquer regra compe-se de uma nica varive
l (como nas GR) e o lado direito qualquer combinao de terminais e no-terminais
- uma linguagem livre de contexto (LLC) se for gerada por uma GLC
- por definio, toda GR tambm GLC
- mas nem toda GLC GR
- GLC --> ampla, genrica
- GR --> restrita
- estas linguagens mais genricas que as regulares conseguem expressar
- parnteses balanceados
- blocos estruturados
- outras construes tpicas de linguagens de programao
- os algoritmos so relativamente simples e incluem, por exemplo, analisadores sin
tticos, processadores de texto, etc...
- o nome "livre de contexto" vem da possibilidade de substituir um no-terminal in
dependentemente do contexto onde ele aparece
- esta substituio sempre possvel porque os no-terminais aparecem sozinhos no lado es
querdo das regras
- exemplo
1)
a) Gramtica
G = (V,T,P,S) = (no-terminais, terminais, regra de produo, smbolo inicial)
G = ({S}, {a,b}, {S --> aSb, S --> T}, S)
b) Funcionamento
S --> aSb --> aaSbb --> aaaSbbb --> aaabbb
c) Linguagem
L(G) = {a^n b^n : n >= 0}
d) Para que a linguagem fosse
L(G) = {a^n b^n : n > 0}
- bastaria substituir a regra
S --> T
por
S --> ab
2) Gramtica que gera sentenas com parnteses equilibrados
G = ({S}, {(,)}, {S --> SS, S --> (S), S --> T}, S)
3) Dada a gramtica livre de contexto G, determine a linguagem L(G) gerada por G
a) Gramtica
G = ({S,A,B}, {0,1}, P, S)
P = {S --> AB
A --> 0A11 | T
B --> 0B | T

}
b) Linguagem
L(G) = {0^n 1^2n 0^m : n >= 0, m >= 0}
4) Gramtica para nmeros naturais sem zeros esquerda
G = ({N,P,R,D}, {0,1,2,3,4,5,6,7,8,9}, P, N)
P = {N
R
D
P
}

-->
-->
-->
-->

PR | 0
DR | D
0 | P
1|2|3|4|5|6|7|8|9

5) Determinte a linguagem gerada pela gramtica G

a) Gramtica
G = ({S,A}, {0,1}, {S --> S0, S --> A1, A --> 0A0, A --> 1}, S)
b) Funcionamento
S --> S0 --> S00 --> S000 --> A1000 --> 0A01000 --> 00A001000 --> 000A000100
0 --> 00010001000
c) Linguagem
L(G) = {0^n 1 0^n 1 0^m : n >= 0, m >= 0}
d) Gramtica Equivalente
- uma gramtica equivalente pode ser constituda considerando que a linguagem
{0^n 1 0^n 1 0^m}
a concatenao das linguagens
{0^n 1 0^n} e {1 0^m}
G = ({S,A,B}, {0,1}, {S --> AB, A --> 0A0 | 1, B --> B0 | 1}, S)
- as regras de A geram {0^n 1 0^n}
- as regras de B geram {1 0^m}
- a regra de S concatena A e B
* rvores Sintticas
- considere a GLC
G = ({E}, {+,*,(,),a}, P, E)
P = {E
E
E
E
}

-->
-->
-->
-->

E + E
E * E
(E)
a

- a sentena
(a + a) * a
pode ser derivada assim
E --> E * E --> (E) * E --> (E + E) * E --> (a + E) * E --> (a + a) * E -->
(a + a) * a

- conveniente para os algoritmos representar a derivao de sentenas de LLC's atravs d

e uma rvore sinttica de derivao
- funcionamento
- a raiz o smbolo inicial da gramtica
- os ns internos so no-terminais
- uma regra
A --> X1 X2 ... Xn
representada por uma subrvore com A na raiz e filhos X1, X2, ..., Xn
- as folhas (ns sem filhos) so smbolos terminais
- as sentenas so lidas da esquerda para a direita
- chama-se derivao mais esquerda seqncia de produo aplicada sempre ao no-terminal
esquerda da forma sentencial produzida at o momento
- de forma semelhante, define-se derivao mais direita
- diz-se que h ambigidade quando uma mesma sentena possui rvores sintticas diferentes
para a mesma sentena usando derivaes mais esquerda ou mais direita
- a ambigidade uma caracterstica indesejvel de uma gramtica, pois pode alterar a semn
tica de uma mesma sentena
- no caso de um compilador, por exemplo, ele poderia calcular valores diferentes
para uma mesma expresso aritmtica ou emparelhar "else" com "then" de maneiras dif
erentes
- exemplo
1) Sentenas da linguagem gerada pela gramtica G
a) Gramtica
G = ({E}, {+,*,(,),a}, P, E)
P = {E
E
E
E
}

-->
-->
-->
-->

E + E
E * E
(E)
a

b) rvore --> (a + a) * a
E
/|\
.-- | `--.
/
|
\
/
|
\
E
*
E
/|\
|
.-- | `--.
|
/
|
\
|
/
|
\
|
(
E
)
a
/|\
.-- | `--.
/
|
\
/
|
\
a
+
a

c) rvore --> a + (a * a)
E
/|\
.-- | `--.
/
|
\
/
|
\
E
+
E
|
/|\
|
.-- | `--.
|
/
|
\
|
/
|
\
a
(
E
)
/|\
.-- | `--.
/
|
\
/
|
\
a
*
a

c) Ambigidade
- podemos gerar a sentena
a + a * a
de vrias maneiras
E --> E + E --> a + E --> a + E * E --> a + a * E --> a + a * a

E --> E + E --> E + E * E --> E + E * a --> E + a * a --> a + a * a

E --> E + E --> E + E * E --> a + E * E --> a + a * E
2) Usando a GLC do exemplo anterior e derivaes mais esquerda
a) Sentena 1
E --> E + E --> a + E

--> a + E * E --> a + a * E --> a + a * a

b) Sentena 2
E --> E * E --> E + E * E --> a + E * E --> a + a * E --> a + a * a
c) rvore 1

d) rvore 2

E
/|\
.-- | `--.
/
|
\
/
|
\
E
+
E
|
/|\
|
.-- | `--.
|
/
|
\
|
/
|
\
a
E
*
E
|
|
|
|
a
a

E
/|\
.-- | `--.
/
|
\
/
|
\
E
*
E
/|\
|
.-- | `--.
|
/
|
\
|
/
|
\
|
E
+
E
a
|
|
|
|
a
a

(* tem precedncia sobre +)

(+ tem precedncia sobre *)

d) Gramtica que resolve este problema

G = ({E,T,F}, {+,*,(,)}, P, E)
P = {E
E
T
T
F
F
}

-->
-->
-->
-->
-->
-->

T
E + T
F
T * F
(E)
a

e) rvore Sinttica da sentena a + a * a

E --> E + T --> T + T --> F + T --> a + T --> a + T * F --> a + F * F --> a
+ a * F --> a + a * a
E
/|\
.-- | `--.
/
|
\
/
|
\
E
+
T
|
/|\
|
.-- | `--.
|
/
|
\
|
/
|
\
T
T
*
F

|
|
F
|
|
a

|
|
F
|
|
a

|
|
a

- nota-se que nesta gramtica o operador * tem precedncia sobre o operador +

f) rvore Sinttica da sentena a * (a + a)
E
|
|
T
/|\
.-- | `--.
/
|
\
/
|
\
T
*
F
|
/|\
|
.-- | `--.
|
/
|
\
|
/
|
\
F
(
E
)
|
/|\
|
.-- | `--.
|
/
|
\
|
/
|
\
a
E
+
E
|
|
T
T
|
|
F
F
|
|
a
a
- se for necessrio somar (+) antes da multiplicao, a gramtica gera parnteses para
alterar a precedncia implcita dos dois operadores
* Autmato com Pilha (AFP)
- para simular regras do tipo A --> xBy, podemos considerar A e B como estados e
transitar de A para B consumindo x e empilhando y para futura comparao com os smbo
los da sentena de entrada
- a operao de empilhamento adequada para levar em conta regras do tipo B --> uCv,
j que no processamento deste tipo de regra, v deve ser empilhado para ser compara
do (usado) antes de y, porque B processado antes (A --> xBy)
- o dispositivo AFP semelhante a um autmato finito, mas tem uma pilha como memria
auxiliar para acomodar as caractersticas das LLC's, conforme descrito acima
- "assim os ltimos sero os primeiros, e os primeiros sero os ltimos" (Matheus, 20:16
)
* Reconhecedores de LLC's
- as LLC's exigem algo mais que um autmato finito para seu reconhecimento
- necessria uma mamria auxiliar para o registro dos fatos de parte j consumida da s
entena de entrada
- no-determinismos tambm so convenientes para facilitar o emprego da informao anterio
rmente memorizada durante o processo de reconhecimento
- um autmato para o reconhecimento de LLC's deve inspirar-se nas GLC's
- o dispositivo reconhecedor de tais linguagens o autmato com pilha (push-down au

tomata)
* Formalismo dos AFP's
- teorema
- toda LLC aceita por algum AFP
- toda linguagem aceita por um AFP e livre uma LLC
- dada uma LLC, h um AFP com, no mximo, trs estados, que aceita a linguagem
- embora no seja possvel garantir que um AFP pra (transies em vazio), h um AFP que
pra para qualquer LLC
- definio formal de AFP
- um AFP uma sxtupla
- M = (Q,E,V,d,q0,F) = (estados, alfabeto de entrada, alfabeto da pilha,
funo de transio, estado inicial, estados finais)
- Q = AFD
- E = AFD
- V
- alfabeto finito de smbolos da pilha
- embora V = E em muitos casos, o formalismo d a liberdade de emp
ilhar/desempilhar smbolos diferentes dos da sentena analisada
- d
- delta minscula
- funo de transio
- d : Q . (E unio {T}) . V --> 2 ^ ((Q . V)*)
- q0 = AFD
- F = AFD
* Transies e Configuraes - AFP
- a linguagem aceita por um AFP M pode ser formalmente descrita assim
- M = (Q,E,V,d,q0,F) = (estados, alfabeto de entrada, alfabeto da pilha, funo
de transio, estado inicial, estados finais)
- L(M) = {w : (q0,w,T) |-* (p,T,T) : p E F}
- se na ltima configurao temos (estado_final,T,T), ento a sentena aceita, pois
- encerrou num estado final
- no h mais smbolos do alfabeto de entrada para consumir (alfabeto da pilha
est vazio)
- no h mais smbolos do alfabeto da pilha para consumir (pilha est vazia)
- exemplo
1)
d(p,a,z) = {(q1,a1), (q2,a2), ..., (qn,an)}
- p, qi pertence Q
- a
pertence E
- Z
pertence V
- ai
pertence V*
- esta transio indica que
- no estado p
- consome smbolo a da entrada
- desempilha z
- transita para um dos possveis estados qi (no determinstico)
- empilhando a sentena a do alfabeto da pilha
2)
d(p,T,z) = {(q,T)}
- esta transio indica que
- no estado p
- no consome smbolo de entrada
- desempilha z
- transita para q

- no empilha nada
3) Descrever a configurao de um AFP num determinado instante
- listar o contedo da pilha
(p,aw,zA) |- (q,w,BA) se d(p,a,z) = (q,B)
- esta transio indica que
- no estado p
- com a subsentena aw
- com contedo de pilha zA (z no topo)
- pode-se transitar para o estado q
- consumindo a
- contedo de pilha BA (desempilhou z e empilhou B)
- l-se
- delta
- estando em p
- consumindo a
- desempilha z
- transita para q
- empilha B
* Diagramas de Estado - AFP
- embora haja outros funcionamentos (todos equivalentes), um AFP funciona assim
- o estado inicial da pilha vazio
- o AFP transita
- a partir do estado inicial
- para outros estados (no-determinstico)
- consumindo smbolos da entrada (ou vazio)
- e consumindo smbolos da pilha (ou vazio)
- se um dos possveis estados atingidos aps o consumo da sentena for final e a p
ilha estiver vazia
- aceita a sentena
- seno
- rejeita a sentena
- exemplo
1)
a) Linguagem
L(M) = {w c w^r : w pertence {a,b}*}
OBS: w^r = reversa de w
b)
M = ({q0,q1}, {a,b,c}, {a,b}, d, q0, {q1})
d(q0,a,T) = {(q0,a)}
- l-se
- estando em q0
- consome a
- sem desempilhar
- transita para q0
- empilha a
d(q0,b,T) = {(q0,b)}

- l-se
- estando em q0
- consome b
- sem desempilhar
- transita para q0
- empilha b
d(q0,c,T) = {(q1,T)}
- l-se
- estando em q0
- consome c
- sem desempilhar
- transita para q1
- sem empilhar
d(q1,a,a) = {(q1,T)}
- l-se
- estando em q1
- consome a
- desempilha a
- transita para q1
- sem empilhar
d(q1,b,b) = {(q1,T)}
- l-se
- estando em q1
- consome b
- desempilha b
- transita para q1
- sem empilhar
c) AFP
a[v a]
a[^ a]
|v
|v
-->(q0)-----c---->((q1))
|__^
|__^
b[v b]
b[^ b]
d) Linguagem
- L(M) aceita palndromos mpares
e) Teste a sentena "abacaba"
(q0,abacaba,T) |- (q0,bacaba,a) |- (q0,acaba,ba) |- (q0,caba,aba) |- (q1,aba
,aba) |- (q1,ba,ba) |- (q1,a,a) |- (q1,T,T)
- portanto, a linguagem reconhecida pelo AFP M
L(M) = aceita palndromos mpares
2)
a) Linguagem
L(M) = {w pertence {a,b}* : w com mesmo nmero de a's e b's}
b)
M = ({q0,q1,q2}, {a,b}, {a,b,c}, d, q0, {q2})

d(qo,T,T)
d(q1,a,c)
d(q1,a,a)
d(q1,a,b)
d(q1,b,c)
d(q1,b,b)
d(q1,b,a)
d(q1,T,c)

=
=
=
=
=
=
=
=

{(q1,c)}
{(q1,ac)}
{(q1,aa)}
{(q1,T)}
{(q1,bc)}
{(q1,bb)}
{(q1,T)}
{(q2,T)}

c) AFP
-->(q0)-----T[vc]---->(q1)-----T[^c]---->((q2))
|__^
a[^b]
a[^a vaa]
a[^c vac]
b[^a]
b[^b vbb]
b[^c vbc]
d) Linguagem
- L(M) aceita sentenas com mesmo nmero de a's e b's
e) Teste a sentena "abba"
(q0,abba,T) |- (q1,abba,c) |- (q1,bba,ac) |- (q1,ba,c) |- (q1,a,bc) |- (q1,T
,c) |- (q2,T,T)
- portanto, a linguagem reconhecida pelo AFP M
L(M) = aceita sentenas com mesmo nmero de a's e b's
* Gramticas Sensveis a Contexto (GSC) (tipo 1)
- relaxando as regras das GLC's a ponto de permitir que o lado esquerdo possa co
nter uma forma sentencial em vez de um nico no-terminal, temos uma gramtica mais am
pla
- para distinguir estas gramticas das mais genricas (tipo 0), h uma restrio
- nenhuma substituio pode reduzir o tamanho da forma sentencial a que a substi
tuio foi aplicada
- isso significa que as regras das GSC's so do seguinte tipo
aAb --> ayb
- a,b pertence (V unio T)*
- A pertence V
- y pertence (V unio T)+
- como A substitudo por y, que no pode ser vazio, o tamanho do lado direito no meno
r que o esquerdo
- o nome "sensvel a contexto" vem da permisso de substituio de A apenas quando ele a
parece no contexto aAb, ou seja, depois de a e antes de b
- exemplo
1) Aceita nmeros naturais sem zeros esquerda
a) Linguagem
L(G) aceita nmeros naturais sem zeros esquerda
b) Gramtica
G = ({N,D}, {0,1,2,3,4,5,6,7,8,9}, P, N)

P = {N --> ND | D
ND --> 1D | 2D | 3D | 4D | 5D | 6D | 7D | 8D | 9D
D --> 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
}
2) a^n b^n c^n
a) Linguagem
L(G) = {a^n b^n c^n : n > 0}
b) Gramtica
G = ({S,B,C}, {a,b,c}, P, S)
P = {S --> aSBC
S --> aBC
CB --> BC
aB --> ab
bB --> bb
bC --> bc
cC --> cc
}
c) Teste a derivao de a^4 b^4 c^4
S --> aSBC --> aaSBCBC --> aaaSBCBCBC --> aaaaBCBCBCBC --> aaaaBBCBCBCC -->
aaaaBBCBCBCC --> aaaaBBBCBCCC --> aaaaBBBBCCCC --> aaaabBBBCCCC --> aaaabbBBCCCC
--> aaaabbbBCCCC --> aaaabbbbCCCC --> aaaabbbbcCCC --> aaaabbbbccCC --> aaaabbb
bcccC --> aaaabbbbcccc
* Gramticas com Estrutura de Frase (GEF)(tipo 0)
- so aquelas sem quaisquer restries s suas regras de produo
- portanto, estas regras so do tipo
a --> b
a pertence (V* unio T+)
b pertence (V unio T )*
- as linguagens geradas por estas gramticas so conhecidas como linguagens enumervei
s recursivamente, ou linguagens tipo 0
* Reconhecedores
- as LSC so reconhecidas por autmatos adaptativos (alteram-se dinamicamente), ou p
or Mquinas de Turing
- as linguagens enumerveis recursivamente so reconhecidas por Mquinas de Turing
- existem linguagens no-enumerveis recursivamente, que no podem ser reconhecidas po
r nenhum dispositivo algortmico
- o modelo de Chomsky foi definido para o estudo de linguagens naturais
- no caso de linguagens naturais, o estudo das LLC tem sido de especial interess
e, pois ela permite uma representao simples da sintaxe, adequada tanto para a estr
uturao formal, como para a anlise computacional
- mas h problemas no-solucionveis...
- quanto s linguagens de programao, as LR e LLC so usadas em muitas partes sem estud
o e anlise
- no entanto, h aspectos que no conseguem ser tratados pelas LLC, como declaraes e u
so de identificadores
- a hierarquia de Chomsky nem sempre adequada para as linguagens de programao
- h casos em que as LLC no so suficientes, mas as LSC so excessivas
- em outros casos, as LLC so excessivas, mas as LR so insuficientes
- o campo vasto e existem muitos problemas no solucionados...
* Autmato Adaptativo

)
-

cria o autmato em tempo de execuo

reconhece uma LLC sem pilha
o Autmato Adaptativo um reconhecedor de LLC e LSC
a Mquina de Turing um reconhecedor das LRE (Linguagens Recursivamente Enumerveis
toda LR LLC
exemplo

1)
a) Linguagem
LLC: {a^n b^n : n > 0}
b) Autmato
-->( )
(( ))
|
^
|
|
a
b
|
|
v
|
( )---T--->(( ))
|
^
|
|
a
b
|
|
v
|
( )---T--->(( ))
|
^
|
|
a
b
|
|
v
|
( )---T--->(( ))
* Mquina de Turing (MT)
- um modelo matemtico simples de um computador
- apesar de sua simplicidade, seu poder de computao no menor do que qualquer outro
dispositivo, por mais complexo que possa ser
- esta simplicidade til, pois elimina muitos detalhes suprfluos na demonstrao de teo
remas e no estudo de algoritmos
- o matemtico David Hilbert quis encontrar um algoritmo para determinar a veracid
ade ou falsidade de qualquer proposio matemtica
- no entanto, Kurt Gdel publicou seu famoso teorema da incompletude em 1931, que
demonstrou que tal algoritmo no pode existir
- ele construiu uma proposio cuja definio mostrava que ela no podia ser nem provada n
em rejeitada dentro do mesmo sistema lgico onde a proposio fora feita
- esta concluso pode ser considerada como uma das grandes conquistas intelectuais
do sculo XX
- baseado no pensamento de Gdel, o conceito de procedimento efetivo ou algoritmo
foi formalizado e verificado que no existem algoritmos para computar muitos probl
emas
- atualmente, a MT aceita como a formalizao de algoritmo
- no possvel provar que uma MT equivalente a nossa noo intuitiva de um computador, m
as h argumentos fortes para esta equivalncia
- esta a chamada hiptese de Church
- "a capacidade de computao representada pela MT o limite mximo que pode ser at
ingido por qualquer dispositivo de computao"
- com esta hiptese, prova-se, por exemplo, o teorema de Bshm-Jacopini

- "qualquer problema que tenha soluo pode ser resolvido com apenas trs estrutur
as bsicas de controle: seqncia, seleo, iterao"
* Modelo de MT
- este modelo consiste de
- um controle de estados finitos
- uma fita que pode ser lida e gravada
- um cabeote capaz de mover para a esquerda e direita
- responsvel pela comunicao entre a fita e o cabeote
- a fita dividida em clulas, cada uma capaz de armazenar um smbolo, mas infinita e
m ambas as direes com um smbolo especial (branco), normalmente denotado por #, como
smbolo de fundo
- ou seja, assume-se que todas as clulas da fita contm brancos exceto aquelas ocup
adas pela sentena de entrada
- graficamente, podemos representar a MT assim
___________________________________________
|...| # | a1| a2|...| ai|...| an| # | # |...|
^
|
p
a
-

a mquina est no estado p com o cabeote apontando para o smbolo ai

a unidade de controle opera em passos discretos
em cada passo, ela realiza quatro funes, que dependem do seu estado e do smbolo d
fita que est na clula apontada pelo cabeote
passos
- 1) l o smbolo corrente da fita
- 2) grava um novo smbolo, substituindo o smbolo lido
- 3) move o cabeote para a clula da direita ou da esquerda
- 4) transita para um novo estado
- a MT alimentada com uma sentena e o cabeote posicionado no primeiro smbolo desta
sentena, com o controle assumindo o estado inicial
- a MT transita de estado em estado de acordo com uma relao de transio, alterando a
fita neste processo, e aceitando a sentena no momento em que atingir um estado fi
nal
- a MT definida como uma sptupla
- M = (Q,E,V,d,q0,F,B)
= (estados, alfabeto entrada, alfabeto auxiliar, relao de transio, estado in
icial, estados finais, smbolo branco)
- Q = AFD
- E = AFD
- V
- alfabeto auxiliar
- d
- delta minsculo
- relao de transio
- d : (Q - F) . (E unio V) --> Q . (E unio V) . {E,D}
- E --> esquerda (cabeote)
- D --> direita (cabeote)
- q0 = AFD
- F = AFD
- B
- smbolo branco (B pertence V)
- a relao de transio d mapeia uma dupla (estado atual, smbolo de entrada ou auxiliar)
numa trinca (novo estado, smbolo de entrada auxiliar, direo do cabeote)
- a relao no est definida para os estados finais (por isso, Q - F)
- ou seja, a mquina pra e aceita a sentena se um dos estados finais for atingido, i
ndependentemente da posio do cabeote e do contedo atual da fita
* Transies e Configuraes - MT

- exemplo
1) d(p,a) = (q,b,D)
p pertence Q - F
q pertence Q
a pertence E unio V
b pertence E unio V
- quando M estiver no estado p e ler o smbolo a da fita,
grava b,
substituindo a,
move o cabeote uma clula direita,
e transita para o estado q
2) d(p,a) = (q,b,E)
p pertence Q - F
q pertence Q
a pertence E unio V
b pertence E unio V
- quando M estiver no estado p e ler o smbolo a da fita,
grava b,
substituindo a,
move o cabeote uma clula esquerda,
e transita para o estado q
- como uma MT grava smbolos na fita, uma MT de fato um transdutor
- alm de reconhecer sentenas de uma linguagem, a MT tambm computa funes, com a sentena
de entrada como parmetro e a finta final como resultado da computao
- uma configurao de uma MT definida por
(p,y1 a y2)
p pertence Q
y1 pertence (E unio V)*
y2 pertence (E unio V)*
a pertence (E unio V)
- significa
- o estado corrente p
- o cabeote aponta o smbolo a
- que precedido e seguido por outros smbolos do alfabeto total da fita
- graficamente
___________
| y1| a | y2|
^
|
p
- se d(p,a1) = (q,b,D) ento uma configurao passa para outra configurao]
(p,y1 a1 a2 y2) |- (q, y1 b a2 y2)
- l-se
- estando em p
- l o smbolo a1
- substitui-o por b
- move o cabeote para a direita
- transitando para o estado q
- graficamente
_______________
_______________
| y1| a1| a2| y2| |- | y1| b | a2| y2|
^
^

|
p

|
q

- exemplo
1)
(p,y1 a1 a2 y2) |- (q, y1 a1 b y2)
se d(p,a2) = (q,b,E)
_______________
_______________
| y1| a1| a2| y2| |- | y1| a1| b| y2|
^
^
|
|
p
q
(p,d a) |- (q, wb #)
se d(p,a) = (q,b,0)
- o movimento de uma clula direita do ltimo smbolo da fita (ou esquerda do primeiro
) faz o cabeote apontar um branco (smbolo #)
- a fita contm infinitos brancos antes do primeiro smbolo e aps o ltimo
- estes brancos no so mostrados nas configuraes
- a linguagem aceita por uma MT M o conjunto de sentenas em E* que fazem M atingi
r um estado final partir do estado inicial com o cabeote iniciando no primeiro smb
olo da sentena
L(M) = {w pertence E* : (q0, q) |-* (qf,y) : qf pertence F, y pertence (E un
io V)*
* Diagrama de Estados - MT
- definio
(p)---a1/a2/s---(q)
- p
--> estado anterior
- a1
--> smbolo lido
- a2
--> smbolo gravado
- s
--> sentido do movimento (E, D)
- q
--> novo estado
- as condies de parada so
- 1) a mquina atinge um estado final --> aceita o resultado
- 2) a relao de transio indefinida para o argumento (smbolo e estado corrente) -> rejeita o resultado
- a mquina pode entrar em loop infinito
- neste caso, a sentena no aceita nem rejeitada
- exemplo
1) Reconhecimento de {a^n b^n : n >= 0}
a) Gramtica
M = (Q,E,V,d,q0,F,B)
M = (estados, alfabeto entrada, alfabeto auxiliar,
relao de transio, estado inicial, estados finais,
smbolo branco)
M = ({q0,q1,q2,q3,q4}, {a,b}, {A,B,#}, d, q0, {q4}, #)
b) Autmato
,-------------A/A/D-------------------.

v
|
-->(q0)-----a/A/D---->(q1)-----b/B/E---->(q2)
| |
|_^
|_^
| '---B/B/D---. a/a/D
a/a/E
#/#/E
| B/B/D
B/B/E
|
|
v
v
((q4))<--#/#/E---(q3)
|_^
B/B/D
c) Reconhecimento de
_____________
|a|a|a|b|b|b|#|
^
q0
_____________
|A|a|a|b|b|b|#|
^
q1
_____________
|A|a|a|B|b|b|#|
^
q2
_____________
|A|A|a|B|b|b|#|
^
q1
_____________
|A|A|a|B|B|b|#|
^
q2
_____________
|A|A|A|B|B|b|#|
^
q1
_____________
|A|A|A|B|B|B|#|
^
q2
_____________
|A|A|A|B|B|B|#|
^
q0
_____________
|A|A|A|B|B|B|#|
^
q3

a^3 b^3
_____________
|A|a|a|B|B|B|#|
^
q1
_____________
|A|a|a|B|b|b|#|
^
q2
_____________
|A|a|a|B|b|b|#|
^
q0
_____________
|A|A|a|B|b|b|#|
^
q1
_____________
|A|A|A|B|B|b|#|
^
q2
_____________
|A|A|A|B|B|b|#|
^
q1
_____________
|A|A|A|B|B|B|#|
^
q2
_____________
|A|A|A|B|B|B|#|
^
q3
_____________
|A|A|A|B|B|B|#|
^
q4

_____________
|A|a|a|B|B|B|#|
^
q1
_____________
|A|a|a|B|b|b|#|
^
q2
_____________
|A|A|a|B|b|b|#|
^
q1
_____________
|A|A|a|B|B|b|#|
^
q2
_____________
|A|A|a|B|B|b|#|
^
q0
_____________
|A|A|A|B|B|b|#|
^
q1
_____________
|A|A|A|B|B|B|#|
^
q2
_____________
|A|A|A|B|B|B|#|
^
q3

- pra, aceitando a palavra!!!

d) Funcionamento {a^n b^n : n >= 0}
- inicialmente, a fita contm a^n b^n seguida e precedida de uma infinidade de
brancos
- o cabeote est no primeiro smbolo
- a mquina substitui o smbolo a mais esquerda por A e move para a direita at o
primeiro b, substituindo-o por B
- em seguida, move para a esquerda at o A mais direita, move uma clula direita
at o primeiro a e repete o ciclo

- se, ao procurar b, a mquina achar um branco, ela pra, rejeitando a sentena

- se, depois de trocar b por B, a mquina no achar nenhum a, ela verifica se no
h outro b, aceitando a sentena se no houver
- informalmente, cada estado representa uma instruo ou um grupo de instrues de u
m programa
- especificamente, a MT do exemplo {a^n b^n | n > 0} tem o seguinte funciona
mento
- o estado q0 o inicial, mas chega-se-lhe tambm antes de cada substituio de a p
or A
- o estado q1 usado para pesquisar direita, pulando os a's e B's at achar um
b
- se achar um b, troca-o por um B, entrando em q2
- o estado q2 procura um A esquerda e entra em q0 quando o acha, movendo dir
eita para o primeiro a quando muda de estado
- na pesquisa direita (no estado q1), se um branco ou A for encontrado antes
de um b, a sentena rejeitada
- h muitos a's ou a sentena no do tipo a* b*
- o estado q0 tem outra funo
- se, aps o estado q2 encontrar o A mais direita, houver um B sua direita
, ento os smbolos a esgotaram-se
- de q0, pulando B's, vai-se at q3 que pula os B's at encontrar # (verifica se
no h outros b's)
- ao encontrar o #, entra-se no estado final q4, aceitando a sentena
- seno, rejeita a sentena
e) Tabela para representar a relao de transio d
--------------------------------------------------------------| estado |
a
|
b
|
A
|
B
|
#
|
--------------------------------------------------------------| q0 | (q1,A,D) |
|
| (q3,B,D) | (q4,#,D) |
| q1 | (q1,A,D) | (q2,B,E) |
| (q1,B,D) |
|
| q2 | (q2,a,E) |
| (q0,A,D) | (q2,B,E) |
|
| q3 |
|
|
| (q3,B,D) | (q4,#,D) |
| q4 |
|
|
|
|
|
--------------------------------------------------------------- como a MT produz smbolos de sada na fita, alm de reconhecedora de linguagens irre
stritas, ela tambm um transdutor
- a MT capaz, por exemplo, de computar uma funo f: N --> N, pois nmero natural pode
ser representado por uma sentena I^n onde I um dgito (notao unria)
* Outros Exemplos na Apostila
- 127 --> somar 1 em um nmero unrio
- 128 --> calcular a soma de dois nmeros naturais representados em unrio
- 129 --> ordenar uma sentena sobre {a,b}*
- 130 --> reconhecedor da linguagem {a^n b^n c^n | n >= 0}
- 131 --> contador binrio (esta mquina no pra; ela incrementa, ininterruptamente, o
contador)
- 132 --> Extenses da MT
- 133 --> MT Universais
- 134 --> Concluses MT
* Resumo
- Gramticas (GR, GLC, GSC, GEF)
G = (V,T,P,S)
= (no-terminais, terminais, regra de produo, smbolo inicial)
- AFD
M = (Q,E,d,q0,F)
= (estados, alfabeto, funo de transio, estado inicial, estados finais)

- TFD
M = (Q,E,G,d,q0)
= (estados, alfabeto de entrada, alfabeto de sada, funo de transio, estado inic
ial)
- AFN
M = (Q,E,d,q0,F)
= (estados, alfabeto, funo de transio, estado inicial, estados finais)
- AFP
M = (Q,E,V,d,q0,F)
= (estados, alfabeto de entrada, alfabeto da pilha, funo de transio, estado in
icial, estados finais)
- MT
M = (Q,E,V,d,q0,F,B)
= (estados, alfabeto entrada, alfabeto auxiliar, relao de transio, estado inic
ial, estados finais, smbolo branco)
----------//----------