Introdução a Conjuntos, Funções e Relações

Captulo 0: Conjuntos, funes, relaes
Notao. Usaremos Nat para representar o conjunto dos nmeros naturais; Int para
representar o conjunto dos nmeros inteiros. Para cada n Nat, [n] representa o
conjunto dos naturais menores ou iguais a n:
[n] = { i Nat | 0 < i n }.
Este conjunto [n] s vezes representado por {1, 2, , n}, convencionando-se

que nos casos especiais n = 0 e n = 1, essa notao indica, respectivamente, o conjunto
vazio e o conjunto unitrio {1}.
Produto Cartesiano. O produto cartesiano de dois conjuntos A e B o conjunto A B

de pares ordenados de elementos de A e B:
A B = { (x, y) | x A e y B }.
Esse conceito pode ser estendido, usando n-tuplas, para definir o produto cartesiano de n
conjuntos:
A1 A2 An = { (x1, x2, xn ) | para cada i [n], xi Ai }
Podemos definir potncias de um conjunto, a partir da definio de produto

Cartesiano:
An = A A A (n vezes) = { (x1, x2, xn) | para i [n], xi A}.
Naturalmente, A1 = A.
Exemplo: Sejam A = { a, b, c }, B = { d, e }. Ento,
A B = { (a, d), (a, e), (b, d), (b, e), (c, d), (c, e) }
B A = { (d, a), (d, b), (d, c), (e, a), (e, b), (e, c) }
A1 = A = { a, b, c }
A2 = A A = { a, b, c } { a, b, c } =
= { (a, a), (a, b), (a, c), (b, a), (b, b), (b, c), (c, a), (c, b), (c, c) }
o
Relaes. Podemos agora definir relao: dados n conjuntos A1, A2, , An, uma
relao em A1, A2, , An um conjunto qualquer de tuplas de elementos de A1, A2, ,
An. Portanto, usando a definio acima, R uma relao em A1, A2, , An se
R A1 A2 An.
Um caso especial que ser muito importante no que se segue o caso n=2, com
A1=A2=A. R uma relao binria em um conjunto A, se R A A.
J.L.Rangel - Ling. Formais - 0-1

Funes. Outro caso especial o das funes: uma relao f em A B, ou seja, um
conjunto f A B, uma funo, com domnio A e codomnio B, se para cada x A
existe em f um nico y B tal que (x, y) f. Essa unicidade pode tambm ser expressa
por
(x, y) f e (x, z) f implicam em y = z.
Naturalmente, esse valor nico de y que f faz corresponder a x indicado pela

notao habitual f(x), e podemos escrever tambm f: x a y. Escrevemos f: A B, para
indicar que f uma funo com domnio A e codomnio B.
Definimos o contradomnio de f: A B como sendo o conjunto
{ y B | ( x A) (f(x) = y) }.
Exemplo: Se considerarmos o conjunto Int dos nmeros inteiros, e a funo suc:

Int Int que a cada valor em Int associa seu sucessor, poderemos escrever
para cada i Int, suc(i) = i + 1,
ou
suc: i a i + 1
ou ainda
suc = { , (-2, -1), (-1, 0), (0, 1), (1, 2), }
o
Injeo, sobrejeo, bijeo. Dizemos que uma funo f: AB uma injeo se para
cada b B existe no mximo um a A tal que f(a) = b; dizemos que f: AB uma
sobrejeo se para cada b B existe no mnimo um a A tal que f(a) = b; dizemos que
f uma bijeo se f ao mesmo tempo, uma injeo e uma sobrejeo.
No caso de sobrejees (e bijees), codomnio e contradomnio so iguais.
Alternativamente, podemos falar em funes injetoras, sobrejetoras ou "sobre",

e bijetoras.
Conjuntos enumerveis. Um conjunto A enumervel se vazio, ou se existe uma

funo sobrejetora f: Nat .
O nome enumervel se deve ao fato de que, se A no vazio, a sequncia

f(0), f(1), f(2), f(3), uma lista infinita da qual fazem parte todos os elementos de A,
ou seja, uma enumerao de A. Em particular, como no esto proibidas repeties em
uma enumerao, temos:
Fato: Todos os conjunto finitos so enumerveis.

Dem.: Exerccio.
o

No que se segue, estaremos interessados principalmente em conjuntos
enumerveis infinitos. Neste caso, podemos usar uma numerao, em vez de uma
enumerao. Por numerao entendemos aqui uma funo como a funo g mencionada
na propriedade abaixo, que associa a cada elemento de A um nmero natural distinto.
Fato: Um conjunto infinito enumervel, se e somente se existe uma funo injetora

g: A Nat.
Dem. () Seja A um conjunto enumervel infinito. Pela definio, existe uma funo
sobrejetora f: Nat A. Podemos definir a injeo g:A Nat fazendo, para cada
a A, g(a) ser igual ao menor valor de i tal que f(i) = a. Assim, a funo g definida
para qualquer valor de a, porque f sobrejetora. Alm disso, g injetora, porque, pela
prpria definio, g(a) = g(b) implica em f(g(a)) = f(g(b)).
() Seja A um conjunto tal que existe uma injeo g:A Nat. Uma vez que A
no vazio, seja q um elemento qualquer de A. Defina agora a sobrejeo f: Nat A
por
a, se existir um a tal que g(a) = i

f(i) =
q, se no existir
Note que f bem definida para todos os valores de i, porque g uma injeo, e, para
cada i, pode haver, no mximo, um a tal que g(a) = i; f uma sobrejeo, porque g
definida para todos os elementos de A.
o
Fato: Um conjunto infinito A enumervel se e somente se existe uma bijeo
f: A Nat.
Dem.: Exerccio.
o
Fato: Entre dois conjuntos infinitos enumerveis A e B existe sempre uma bijeo
f: AB.
Dem.: Exerccio.
o
Exemplo: O conjunto Nat enumervel.
Basta tomar f como sendo a funo identidade I: Nat Nat, que , claramente, uma
bijeo.
o
Exemplo: O conjunto Nat = Nat Nat de pares de nmeros naturais enumervel.
2
Podemos fazer a caracterizao de diversas maneiras:
1. atravs da injeo g:Nat2 Nat definida por g( (i,j) ) = 2i 3j. Esta numerao
dos pares de inteiros s vezes chamada de numerao de Goedel. Esse
processo pode ser estendido a potncias superiores de Nat. Por exemplo,
podemos associar tripla (i, j, k) o nmero 2i 3j 5k. Para n-uplas, poderiam ser
usados como bases os primeiros n nmeros primos.
2. definindo diretamente a ordem de enumerao:
repita para cada k = 0, 1, 2,
enumere os pares (i, j) tais que i+j = k, na ordem crescente de i:
(0, k), (1, k-1), , (k-1, 1), (k, 0).

Isso corresponde a
(0, 0), (0, 1), (1, 0), (0, 2), (1, 1), (2, 0), (0, 3)
ou seja, a uma sobrejeo f: Nat Nat dada por
f(0) = (0,0), f(1) = (0,1), f(2) = (1,0), f(3) = (0,2),
o
Exemplo: O conjunto Int dos inteiros enumervel.
Basta usar uma enumerao como 0, -1, +1, -2, +2, -3, +3,
o
Teorema: O conjunto P(Nat) dos subconjuntos de Nat no um conjunto enumervel.
Dem.: por "diagonalizao".
Uma vez que a definio de conjunto enumervel se baseia na existncia de uma

funo com certas propriedades, devemos mostrar que tal funo no existe, e a
demonstrao ser feita por contradio (ou reduo ao absurdo).
Suponhamos que o conjunto P(Nat) enumervel. Isto significa que existe uma
enumerao de P(Nat), ou seja uma sobrejeo f: Nat P(Nat). Assim, para cada
elemento A de P(Nat) (um conjunto A de naturais), existe um nmero i tal que f(i) = A.
Vamos considerar o conjunto X definido a seguir:
X = { j Nat | j f(j) }
Como X um conjunto de naturais, X P(Nat). Entretanto, veremos que X no faz

parte da enumerao acima. Seja k qualquer. Duas possibilidades podem ocorrer:
ou k f(k), e neste caso k X,
ou k f(k), e neste caso k X.
Em qualquer das possibilidades, portanto, os conjuntos X e f(k) diferem em pelo menos

um elemento. Assim, X f(k) para todos os k. Desta forma, X no faz parte da
enumerao definida por f, caracterizando-se a contradio. Consequentemente, P(Nat)
no enumervel.
o
Esta tcnica de demonstrao recebeu o nome de diagonalizao.
Representamos um conjunto A Nat por uma sequncia infinita de 0's e 1's: se i A, o
i-simo smbolo da sequncia ser 1; caso contrrio, ser 0. Assim, se fizssemos uma
tabela infinita com uma linha correspondendo a cada conjunto f(k), kNat, o conjunto X
seria definido invertendo o que se encontra na diagonal da tabela: se na posio (i,i) se
encontra um 1, indicando que if(i), na linha correspondente a X teramos um 0 na
i-sima coluna, indicando que iX, e (vice-versa) se na posio i,i se encontra um 0,
indicando que if(i), na linha correspondente a X teramos um 1 na i-sima coluna,
indicando que iX.
Desta forma, podemos ver que, para qualquer i, f(i) X. Para isso, basta notar
que i pertence a exatamente um dos dois conjuntos f(i) e X. Portanto, qualquer que fosse
a enumerao de P(Nat), X no pertenceria a ela.

Esta tcnica ser usada neste curso em diversas ocasies para demonstraes
semelhantes anterior; foi usada por Cantor, para mostrar que a cardinalidade de um
conjunto P(A) sempre superior cardinalidade de A. O mesmo vale aqui: a
cardinalidade de todos os conjuntos enumerveis infinitos A a mesma, equivalente de
Nat, mas a cardinalidade dos conjuntos potncia P(A) superior de Nat, sendo
equivalente de P(Nat). Falando informalmente,
"todo conjunto enumervel tem o mesmo nmero de elementos que Nat."

"h mais elementos em P(Nat) do que em Nat."
"para qualquer conjunto A enumervel, P(A) tem o mesmo nmero de elementos
que P(Nat)."
Fato: Se um conjunto A enumervel, e se B um subconjunto de A, B tambm

enumervel.
Dem. Exerccio.
o
Exerccios:
(1) Mostre que, se A e B so conjuntos enumerveis, ento AB tambm enumervel.
Sugesto: se A e B so enumerveis, existem numeraes nA: ANat e nB: BNat;
seja ento g: Nat2 Nat a mesma numerao de Nat2 vista anteriormente; considere
ento a funo n: AB Nat definida por
n( (a, b) ) = g(nA (a), nB (b)).
(2) Uma das definies possveis para par ordenado a seguinte: definimos o par
ordenado (a, b) como sendo o conjunto {{a, b}, {a}}. Mostre que, com esta definio,
vale a propriedade fundamental:
(a, b) = (c, d) se e somente se a=c e b=d.
(3) Podemos definir uma tripla (ou 3-tupla) a partir da definio de par ordenado:
(a, b, c) = ((a, b), c).
Isto corresponde a definir Nat3 como Nat2Nat. Mostre que com esta definio, vale a
propriedade fundamental:
(a, b, c) = (d, e, f) se e somente se (a=d) e (b=e) e (d=f).
(4) Para definir uma numerao dos elementos de Nat, podemos usar as funes F1 e F2
definidas a seguir:
F1 ( (i,j,k) ) = 2i 3j 5k
F2 ( (i,j,k) ) = g( (i, g( (j,k) ) ) ),
onde g a funo definida anteriormente:
g( (i,j) ) = 2i 3j.
Experimente calcular F1 ( (5, 5, 5) ) e F2 ( (5, 5, 5) ).
o
Relaes binrias. Quando tratamos de relaes binrias, normalmente usamos uma
notao mais simples para indicar que (x, y) um elemento de uma relao binria R em
A: escrevemos apenas x R y. Essa notao semelhante usada para relaes comuns,
como as relaes de ordem <, , etc.: no escrevemos (x, y) , mas, mais
simplesmente, x y.
Vamos a seguir introduzir algumas propriedades de relaes binrias. Seja R uma

relao binria em um conjunto A (R A2 ). Ento dizemos que
R reflexiva se para qualquer x A, x R x;

R simtrica se, para quaisquer x, y A, x R y implica y R x.
R transitiva se, para quaisquer x, y, z A, x R y e y R z implicam em x R z.
Exemplos: As relaes <, , =, so relaes binrias definidas no conjunto Nat, e tem

as propriedades indicadas a seguir:
reflexiva simtrica transitiva

< no no sim
sim no sim
= sim sim sim
no sim no
o
Equivalncia. Uma relao R uma relao de equivalncia (ou simplesmente uma
equivalncia) se reflexiva, simtrica, e transitiva.
Exemplo: A relao = no conjunto Nat uma relao de equivalncia; outros exemplos

de relaes de equivalncia so as relaes de paralelismo entre retas, de semelhana de
tringulos, de congruncia mdulo n. (Dois naturais x e y so congruentes mdulo n se o
resto da diviso de x por n igual ao resto da diviso de y por n.)
o
Composio de relaes: definimos a composio de relaes da forma a seguir:

se R A B e S B C so relaes, definimos a relao RS A C, a composio
de R e S, por
RS = { (x, z) A C | y B, (x, y) R e (y, z) S }.
Se as relaes R e S so funes, a composio RS se reduz exatamente

composio de funes: se (x, y) R e (y, z) S, temos y = R(x), z = S(y) = S(R(x)), e
portanto (RS)(x) = S(R(x)), como era de se esperar1.
Exemplo: Sejam as relaes

R = { (1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4) }
S = { (2, 1), (3, 2), (4, 3) }
Temos:
RS = { (1, 1), (1, 2), (1, 3), (2, 2), (2, 3), (3, 3) }
SR = { (2, 2), (2, 3), (2, 4), (3, 3), (3, 4), (4, 4) }
1Alguns autores preferem a ordem inversa: (RS)(x) = R(S(x)). A diferena apenas de notao.
Exemplo: Sejam as relaes
R = { (1, 2), (2, 3), (3, 4), (4, 1) }
S = { (1, 1), (2, 1), (3, 1), (4, 2) }
J que R e S so funes, o mesmo vale para as composies:
RS = { (1, 1), (2, 1), (3, 2), (4, 1) }
SR = { (1, 2), (2, 2), (3, 2), (4, 3) }
o
Operaes com relaes binrias. Se R uma relao binria num conjunto A (isto ,
R A A), podemos definir as potncias Ri de R, para i Nat de forma recursiva:
R0 = IA = { (x, x) | x A }
Ri+1 = Ri R, para i Nat
Fato:
1. A relao IA a identidade para a composio de relaes, associada ao conjunto
A, ou seja, para qualquer R A2, R IA = IA R = R.
2. Para qualquer R A2, R1 = R.
3. Para quaisquer R A2, i, j Nat, Ri Rj = Rj Ri, ou seja, potncias da mesma
relao sempre comutam.
Dem.: Exerccio.
o
Exemplo: Sejam A = { 1, 2, 3, 4 } e R = { (1,2), (1,3), (1,4), (2,3), (2,4), (3,4) }.As
potncias de R so:
R0 = I = { (1,1), (2,2), (3,3), (4,4) }.
R1 = R = { (1,2), (1,3), (1,4), (2,3), (2,4), (3,4) }
R2 = R1 R = R R = { (1,3), (1,4), (2,4) }
R3 = R2 R = { (1,4) }
R4 = R5 = = .
No caso do exemplo, podemos provar que (x, y) R se y-x 1. Assim, em

geral, (x, y) Ri se y-x i. Naturalmente, no conjunto A, a maior diferena possvel 3,
e todas as potncias alm da terceira so relaes vazias: nunca podem ser satisfeitas.
o
Fechamento. Definimos o fechamento reflexivo-transitivo R* de uma relao binria R
em um conjunto A atravs de
x R* y se e somente se para algum i Nat, x Ri y,
ou, equivalentemente,

R = U R i = R 0 U R1 U R 2 U R 3 U L
*
i =0
Exemplo: Seja a relao R, no conjunto Nat definida por

x R y se e somente se y = x + 1.
Temos x Ri y se e somente se y = x + i, de forma que x R* y se e somente y x.

o
O nome de fechamento reflexivo-transitivo de R dado relao R* se deve ao
fato de que R* a menor relao (no sentido da incluso de conjuntos) que contm R e
reflexiva e transitiva. Ou seja, qualquer relao S
(1) que satisfaa x R y implica x S y (isto , S R) e

(2) que seja reflexiva e transitiva
satisfaz tambm S R*.
De forma semelhante, a notao R+ frequentemente utilizada para descrever o
fechamento transitivo da relao R:

+
R = U R i = R1 U R 2 U R 3 U L
i =1
ou seja, x R+ y se e somente se para algum i>0, x Ri y.
Exemplo: Seja a mesma relao R do exemplo anterior. Neste caso, temos

x R+ y se e somente se y > x.
o
Parties. Dado um conjunto A, definimos uma partio de A como sendo uma famlia
de conjuntos (chamados de blocos da partio) = { Bi | i I } com as seguintes
propriedades:
(1) para cada i I, Bi . nenhum bloco vazio
(2) U = U Bi = A a unio dos blocos A

i I
(3) se ij, Bi I Bj = . blocos so disjuntos dois a dois
Dessa maneira, cada elemento a de A pertence a exatamente um bloco da partio P.
Observao: Na maioria das vezes o conjunto I usado para indexar os elementos da

famlia ser um conjunto enumervel, um subconjunto dos naturais.
Exemplo: Seja o conjunto A = { a, b, c, d, e }. Temos a seguir alguns exemplos de

parties de A:
{ { a, b, c, d, e } }
{ { a }, { b }, { c }, { d }, { e } }
{ { a, b }, { c, d, e } }
{ { a, e }, { b, c, d } }
o
Exerccio: Escreva todas as parties de { a, b, c, d, e }.
o
Classes de equivalncia. Seja R uma equivalncia em um conjunto A. Definimos a classe
de equivalncia [a] de a A da seguinte maneira:
[a] = { x A | x R a },
ou seja, a classe de equivalncia de aA o conjunto dos elementos de A que so
equivalentes a a. Note que como R uma equivalncia, a [a], para qualquer a.
Exemplo: Seja a equivalncia R em A = {a, b, c, d, e, f}, dada pelas seguintes

propriedades:
(1) R uma equivalncia
(2) a R b, b R c, d R e.
(3) x R y somente se isto decorre de (1) e (2).
Temos ento, examinando todos os casos possveis:

a R a, b R b, c R c, d R d, e R e, f R f (reflexividade)
b R a, c R b, e R d (simetria)
a R c, c R a (transitividade)
e R composta dos pares: (a, a), (a, b), (a, c), (b, a), (b, b), (b, c), (c, a), (c, b), (c, c),
(d, d), (d, e), (e, d), (e, e), (f, f).
Assim podemos ver diretamente que [a] = [b] = [c] = { a, b, c }, que [d] = [e] = { d, e }
e que [f] = { f }.
o
Conjunto quociente. Definimos o conjunto quociente A/R de A por uma equivalncia R
em A, atravs de
A/R = { [x] | x A },
ou seja, A/R o conjunto das classes de equivalncia de R em A.
Exemplo: Sejam A e R como no exemplo anterior. As classes de equivalncia de R

formam uma partio de A, que exatamente o conjunto quociente A/R:
A/R = { { a, b, c }, { d, e }, { f } }
o
Fato: Seja R uma equivalncia em um conjunto A. Ento A/R uma partio de A.
Dem.:
(1) note que as classes de equivalncia no so vazias: classe [a] pertence pelo
menos o elemento a;
(2) a unio das classes de equivalncia A, porque cada elemento a de A pertence a

pelo menos uma classe de equivalncia: a [a].
(3) Classes de equivalncia diferentes so disjuntas. Com efeito, suponha que duas
classes [a] e [b] tem sua interseo no vazia, com um elemento c em comum:
c [a] e c [b]. Neste caso, usando o fato de que R simtrica e transitiva,
temos c R a, c R b, e, portanto, a R b. Assim, pela propriedade transitiva, x R a
se e somente se x R b, e [a] = [b]. Consequentemente, as classes de equivalncia
so disjuntas duas a duas, e formam uma partio de A.
o

Fato: Dada uma partio P de um conjunto A, a relao R definida por
x R y se e somente se x e y fazem parte do mesmo bloco de P
uma relao de equivalncia em A, e A/R = P.

Dem.: Exerccio.
o
Induo finita. Muitas das demonstraes que veremos nas sees seguintes utilizam
uma tcnica conhecida por induo finita. A idia fundamental simples: suponha que
desejamos provar que a propriedade P vale para todos os elementos de Nat, isto , que
queremos provar que, para todo x Nat, P(x).
Uma propriedade fundamental de Nat que Nat composto por um elemento

especial, 0, e por seus sucessores. Dito de outra forma, Nat o menor conjunto que
contm 0 e fechado para a funo sucessor s. Esquematicamente,
Nat = { 0, s(0), s(s(0)), s(s(s(0))), s(s(s(s(0)))) }.
Assim, se provarmos
I. (base da induo)
P(0)
II. (passo de induo)
Para qualquer i Nat, P(i) implica P(s(i)).
estaremos provando P para todos os naturais, pois teremos
(0) P(0) (I)

(1) P(0) P(1) (II)
(2) P(1) P(2) (II)
(3) P(2) P(3) (II)

e, portanto, P(0), P(1), P(2), P(3),
Exemplo: Suponhamos que queremos demonstrar a frmula da soma dos elementos de

uma progresso geomtrica de razo q 1,
a0 , a1 , a2 , a3 , ,
com ai+1 = ai q.
A frmula da soma
(a q a 0 )
S n = f(n) = n
(q 1)
Devemos provar inicialmente a base de induo (para n=0): S0 = f(0). A demonstrao
se resume verificao de que
(a q a 0 )
f(0) = n = a0
(q 1)

Para provar o passo de induo, devemos assumir a hiptese de induo Si= f(i) e provar
a tese de induo Si+1 = f(i+1). Temos ai+1 = ai q, e Si+1 = Si + ai+1.
Portanto,
(a q a 0 ) (a a )
Si +1 = Si + a i +1 = f (i) + a i +1 = i + a i +1 = i +1 0 + a i +1 =
(q 1) (q 1)
(a a + a q a i +1 ) (a i +1q a 0 )
= i +1 0 i +1 = = f (i + 1).
(q 1) (q 1)
o
Uma forma alternativa de induo, que pode facilitar as demonstraes, em vez
de usar apenas o ltimo resultado anterior P(i) para provar P(i+1), usa todos os
resultados anteriores, ou seja, P(0), P(1), , P(i).
Assim, para mostrar P(i) para todos os naturais i, mostramos
I. P(0)
II. ji P(j) P(i+1).
Induo em estrutura. Quando trabalhamos com estruturas que apresentam uma lei de
formao bem definida, tais como cadeias, rvores, expresses, podemos usar para a
induo um nmero natural, como, por exemplo, o tamanho da estrutura considerada;
muitas vezes, entretanto, isso no necessrio, ou no conveniente, e podemos fazer a
induo de outra forma, baseada na prpria estrutura.
Por exemplo, dados um conjunto I e uma propriedade Q, suponha um conjunto X

definido como o menor conjunto, no sentido da incluso, que satisfaz 1 e 2 a seguir:
1. todo x I pertence a X, ou seja, I X.

2. se x X e Q(x,y), ento y X.
Ou seja, um elemento x de X ou pertence a um conjunto inicial I, ou satisfaz a

propriedade Q, que liga x a um (outro) elemento y de X. Para provarmos uma
propriedade P(x) para todos os elementos de X, basta provar:
I. (base da induo)
se x I, P(x)
II. (passo de induo)
se x X, P(x) e Q(x,y), ento P(y).
Este esquema pode ser generalizado para permitir vrias propriedades Q, e para
incluir a possibilidade que essas propriedades relacionem vrios elementos de X a um
(novo) elemento. Este caso mais geral de induo em estrutura est ilustrado a seguir.
Exemplo: Suponha que definimos uma expresso da seguinte maneira:

1. a, b, c so expresses.
2. Se e so expresses, ento + uma expresso.
3. Se e so expresses, ento * uma expresso.
4. Se uma expresso, [] uma expresso.

Suponha adicionalmente que queremos provar a propriedade: "toda expresso tem
comprimento (nmero de smbolos) mpar". Vamos indicar " tem comprimento mpar"
por P(). Devemos ento, para provar "para qualquer expresso , P()", provar:
1. P(a), P(b), P(c).
2. Se P() e P(), ento P(+).
3. Se P() e P(), ento P(*).
4. Se P(), ento P([]).
Neste caso, (1) a base da induo; (2)..(4) so passos de induo. Naturalmente, para
mostrar (1), basta observar que
|a| = |b| = |c| = 1;
para mostrar os demais, basta observar que
|+| = || + || + 1,
|*| = || + || + 1, e
|[]| = || + 2.
o
(reviso de 27fev97)

Captulo 1: Alfabetos, cadeias, linguagens
Smbolos e alfabetos. Um alfabeto , para os nossos fins, um conjunto finito no vazio
cujos elementos so chamados de smbolos. Dessa maneira, os conceitos de smbolo e
alfabeto so introduzidos de forma interdependente: um alfabeto um conjunto de
smbolos, e um smbolo um elemento qualquer de um alfabeto.
Note que consideramos aqui apenas alfabetos finitos: isso feito por
simplicidade, naturalmente, e tambm porque so raros os casos em que a considerao
de um alfabeto infinito seria desejvel.1
Qual o alfabeto que devemos considerar, ou seja, quais so os smbolos do

alfabeto considerado depende do contexto em que pretendemos trabalhar. Como
exemplos de alfabetos, citamos {0, 1} ou {a, b}, o alfabeto da lngua portuguesa { a, b,
c, , z}, o conjunto de caracteres ASCII, etc.
At certo ponto, podemos arbitrar os smbolos que nos interessam, e incluir

apenas esses smbolos no alfabeto. Para cada aplicao especfica, o usurio deve
escolher o alfabeto que pretende utilizar: para exemplos no quadro negro, alfabetos
como {0, 1}, e {a, b} so boas escolhas; para ensinar a linguagem Pascal, o alfabeto
escolhido dever conter smbolos como program, begin, end, if, then, else; para
implementar a linguagem Pascal, provavelmente o alfabeto adequado no conter
smbolos como os vistos acima, mas sim caracteres como os do conjunto ASCII (letras,
dgitos, +, *, etc.), uma vez que so estes os componentes bsicos de um arquivo fonte.
Cadeias. Formalmente, uma cadeia de smbolos em um alfabeto pode ser definida

como uma funo: uma sequncia s de comprimento n no alfabeto , uma funo
s:[n] , com domnio [n], e com contradomnio . O nmero natural n o
comprimento de s, e representado por |s|.
Por exemplo, se o alfabeto considerado for = {a, b, c}, a sequncia de

comprimento 4 (composta por quatro ocorrncias de smbolos) s = cbba pode ser vista
como a funo s:[4] , definida por s(1) = c, s(2) = b, s(3) = b, s(4) = a.
Concatenao. A principal operao sobre sequncias a operao de concatenao.

Informalmente, o resultado da concatenao das sequncias x e y a sequncia xy, ou
xy, composta pelos smbolos de x, seguidos pelos smbolos de y, nessa ordem. Mais
formalmente, dadas duas sequncias (funes) x:[m] e y:[n] , de comprimentos
m e n, no mesmo alfabeto , definimos a sequncia (funo) xy:[m+n] , de
comprimento m+n, por
x (i ), se i m
x o y (i ) =
y (i m), se i > m
1Em geral, possvel usar alguma forma de codificao, e representar cada smbolo de um alfabeto
infinito enumervel atravs de uma sequncia de smbolos de um alfabeto finito.
Assim, se tivermos = {a, b, c}, x = cbba, e y = ac, teremos xy = cbbaac.
Representando as funes atravs de tabelas, temos:
i x(i) i y(i) i xy(i)

1 c 1 a 1 c
2 b 2 c 2 b
3 b 3 b
4 a 4 a
5 a
6 c
Naturalmente, |xy| = |x| + |y|.
No que se segue, em geral no faremos referncia ao fato de que sequncias so

funes. Se considerarmos smbolos x1 , x2 , xn , de um alfabeto , representaremos a
sequncia formada por ocorrncias desses smbolos, nessa ordem, por x1x2xn. Note
que no caso especial n = 1, a notao acima confunde a sequncia a de comprimento 1
com o smbolo a. Esta ambiguidade no causa maiores problemas.
Um outro caso especial importante o caso n = 0, em que falamos da sequncia

vazia, indicada por . Usamos um nome "" para a sequncia vazia simplesmente porque
no possvel usar a mesma notao das outras sequncias. Afinal, se escrevermos zero
smbolos, como convencer algum de que alguma coisa foi escrita? A sequncia vazia
o elemento neutro (identidade) da concatenao: qualquer que seja a sequncia x,
temos
x=x=x
Linguagens. Dado um alfabeto , uma linguagem em um conjunto de sequncias de

smbolos de .
O conjunto de todas as sequncias de smbolos de um alfabeto uma

linguagem, indicada por *. A linguagem * inclui todas as sequncias de smbolos de ,
incluindo tambm a sequncia vazia . Com essa notao, uma linguagem L em um
subconjunto de *, ou seja, L *.
Note que todas essas sequncias satisfazem a definio anterior, e tem como
comprimento um nmero natural finito. Podemos assim ter linguagens infinitas, mesmo
sem considerar sequncias infinitas.
Exemplo: Os conjuntos a seguir so linguagens em = {a, b}.

{}
{a, aa, aaa}
{a, b}*
{x | |x| par}
{a, b} notao ambgua

Nota: J observamos que a notao aqui usada ambgua; essa ambiguidade se torna
aparente neste ltimo exemplo: {a, b} pode ser uma linguagem (conjunto de sequncias)
ou um alfabeto (conjunto de smbolos). Isto vale para qualquer alfabeto . Se isso fosse
necessrio, a ambiguidade poderia ser evitada usando-se uma notao apropriada: em
uma das notaes possveis, representamos sequncias entre aspas, e smbolos entre
plicas, de forma que "a" fica sendo a sequncia, 'a' o smbolo, {"a", "b"} a linguagem e
{'a', 'b'} o alfabeto. Para ns, entretanto, tais distines no sero necessrias.
Operaes com linguagens. Linguagens so conjuntos, de forma que as operaes de

conjuntos podem ser diretamente usadas com linguagens. Assim, no h necessidade de
definir unio, interseo ou diferena de linguagens; no caso do complemento, podemos
usar como universo o conjunto * de todas as sequncias no alfabeto considerado .
Se L e M so linguagens em , temos:
unio: L M = { x | x L ou x M }
interseo: LM={x|xLexM}
diferena: L-M={x|xLexM}
complemento: L = * - L = { x * | x L }
Exemplo: Seja o alfabeto = {a, b, c} , e sejam as linguagens L = {a, bc, cb} e

M = {aa, bb, cc, bc, cb} , em . Temos:
L M = {a, bc, cb, aa, bb, cc}

L M = {bc, cb}
L - M = {a}
M - L = {aa, bb, cc}
L = { x * | x a, x bc e x cb } =
= {, b, aa, ab, ac, ba, bb, ca, cb, cc, aaa, }
o
Concatenao de linguagens. A operao de concatenao, que foi definida para
sequncias, pode ser estendida a linguagens:
L M = { xy | x L e y M } .
Exemplo: Sendo L e M como no exemplo anterior,

L M = {aaa, abb, acc, abc, acb, bcaa, bcbb, bccc, bcbc,
bccb, cbaa, cbbb, cbcc, cbbc, cbcb}
M L = {aaa, aabc, aacb, bba, bbbc, bbcb, cca, ccbc,
cccb, bca, bcbc, bccb, cba, cbbc, cbcb}
o
Fato: A linguagem I = { } o elemento neutro (identidade) da concatenao de
linguagens, ou seja, para qualquer linguagem L,
L I = I L = L.
Dem.: Exerccio.
o
Potncias. Podemos introduzir as potncias Li (para i natural) de uma linguagem L
atravs de uma definio recursiva:

L0 = { }
Li+1 = L Li, para qualquer iNat.
Exemplo: Seja L = {0, 11}. Ento temos:
L0 = { }
L1 = L L0 = { } {0, 11} = {0, 11}
L2 = L L1 = {0, 11} {0, 11} = {00, 011, 110, 1111}
L3 = L L2 = {0, 11} {00, 011, 110, 1111} =
= {000, 0011, 0110, 01111, 1100, 11011, 11110, 111111}
e assim por diante.
o
Fato:
(1) Para qualquer linguagem L, L1 = L.
(2) Para qualquer linguagem L, temos Li Lj = Li+j , para i e j quaisquer.
Dem.: Exerccio.
o
Fechamento. Podemos definir, para uma linguagem L qualquer, o seu fechamento L*

como sendo a unio de todas as potncias de L:

L* = U Li = L0 L1 L2 L3
i =0
Outra notao frequentemente utilizada L+, que indica a unio de todas as

potncias de L, excluda a potncia 0:

L+ = U Li = L1 L2 L3
i =1
Exemplo: Para a linguagem L do exemplo anterior, temos:

L* = { , 0, 11, 00, 011, 110, 1111, 000, 0011, 0110,
01111, 1100, 11011, 11110, 111111, }
L+ = { 0, 11, 00, 011, 110, 1111, 000, 0011, 0110,
01111, 1100, 11011, 11110, 111111, }
Exerccio: Caracterize a classe das linguagens L para as quais L* = L+.
o
Fato: Para qualquer alfabeto , o conjunto * de todas as sequncias de smbolos de
enumervel. (Note que pode ser considerado um alfabeto ou uma linguagem, sem que
isso altere o valor de *.)
Dem. Considere (por exemplo) a seguinte enumerao:
1. Escolha uma ordem qualquer (ordem alfabtica) para os elementos do alfabeto .
2. Enumere as sequncias por ordem crescente de comprimento, e, dentro de cada
comprimento, por ordem alfabtica. Por exemplo, se = {a, b, c}, a enumerao
pode ser
, a, b, c, aa, ab, ac, ba, bb, bc, ca, cb, cc, aaa, aab,

Observamos que a ordem alfabtica simples no seria adequada para as cadeias, uma vez
que teramos, neste caso,
, a, aa, aaa, aaaa, aaaaa, .
excluindo, portanto, da enumerao, todas as sequncias que no pertencessem a {a}*
Assim, a cadeia b, por exemplo, nunca seria atingida.
O esquema apresentado se baseia no fato de que, para cada comprimento, o nmero de
sequncias de comprimento n finito. Assim, se pudesse ser infinito, a enumerao
no seria possvel, como descrita, uma vez que no teramos um nmero finito de
sequncias para cada comprimento.
o
No que se segue, usaremos a notao xi para representar a i-sima sequncia
numa enumerao de *, para um alfabeto fixo, supondo uma ordenao fixada para
*.
Fato: Qualquer linguagem enumervel.

Dem.: Toda linguagem em um subconjunto de *.
o
Fato: A classe de todas as linguagens em um alfabeto no enumervel.
Dem.: A classe de todas as linguagens em P(*), e j vimos que o conjunto formado
por todos os subconjuntos de um conjunto enumervel infinito no enumervel.
o
Exerccio: Aplique a tcnica da diagonalizao diretamente, para mostrar que a classe
P(*) de todas as linguagens no alfabeto no enumervel.
o
Exerccio: Suponha = { a, b, c }.
(a) Escreva um programa que, quando recebe como entrada o natural i, determina a
cadeia xi *.
(b) Escreva um programa que, quando recebe como entrada uma cadeia x *,
determina o natural i tal que x = xi.
rev. 17/6/96

Captulo 2: Procedimentos e algoritmos
Para estudar o processo de computao de um ponto de vista terico, com a
finalidade de caracterizar o que ou no computvel, necessrio introduzir um
modelo matemtico que represente o que se entende por computao. Entretanto, cada
estudioso do assunto tem seu modelo matemtico favorito, e por isso h diversas
definies essencialmente distintas. (Por exemplo, um programador FORTRAN tenderia
certamente a afirmar que computvel exatamente aquilo que pode ser feito por um
programa FORTRAN).
Diversos modelos foram apresentados, e podem ser estudados na literatura (veja,

por exemplo, [BrLa74]1 ). Neste curso veremos apenas dois destes modelos: as funes
recursivas parciais e as mquinas de Turing. O modelo das funes recursivas parciais se
baseia em idias semelhantes s da programao funcional, enquanto o modelo das
mquinas de Turing procura introduzir um computador elementar, com repertrio de
instrues e estrutura de memria com a maior simplicidade possvel. Outros modelos,
que no veremos aqui, so baseados em algoritmos de Markov (com algumas
semelhanas com a linguagem SNOBOL), em linguagens de programao mais
convencionais (como o FORTRAN citado acima), ou em outras arquiteturas de
computadores ideais ou linguagens de programao.
O fato surpreendente a respeito disso que (at hoje) todos os modelos usados
(se no so completamente absurdos) concordam na definio do que quer dizer
"computvel". Uma conjectura, enunciada por Alonzo Church, diz que todos os modelos
razoveis do processo de computao, definidos e por definir, so equivalentes. Essa
conjectura conhecida como a tese de Church. Por sua prpria natureza, a tese de
Church no admite nenhuma prova formal, mas at hoje todos os modelos propostos se
mostraram equivalentes.
Neste captulo, entretanto, no queremos ainda definir modelos matemticos

precisos, mas queremos apenas trabalhar com a idia intuitiva do que quer dizer
computvel. Para isso, vamos introduzir, mais abaixo, informalmente, dois conceitos
relacionados: o conceito de procedimento, e o conceito de algoritmo.
Codificao: Na discusso que se segue, levaremos em considerao apenas conjuntos

enumerveis. A razo para isto que nenhum modelo "razovel" proposto para o
processo de computao admite o tratamento de conjuntos no enumerveis. Precisamos
ter alguma garantia de que podemos representar de forma finita todos os elementos do
conjunto considerado, e isso no seria possvel no caso de conjuntos no enumerveis.
Por exemplo, o conjunto dos nmeros reais no enumervel, mas o conjunto dos
nmeros racionais enumervel, e, por essa razo, o tratamento computacional de
nmeros reais feito atravs de aproximaes racionais.
Adicionalmente, sem perda de generalidade, conveniente considerar que todos

os conjuntos considerados ou so conjuntos de nmeros naturais (subconjuntos de Nat)
ou so linguagens em algum alfabeto conhecido (subconjuntos de *). Sabemos que
*, Nat e seus subconjuntos so enumerveis, e que existe uma bijeo entre quaisquer
1Walter S. Brainerd, Lawrence H. Landweber, Theory of Computation, John Wiley, 1974

dois conjuntos enumerveis infinitos. Isso significa que podemos, usando essa bijeo
como codificao, usar valores em um conjunto enumervel qualquer para substituir
valores em outro. Em particular, a codificao atravs de nmeros naturais (numerao),
e a descrio atravs de cadeias de smbolos (muitas vezes conhecidos como
identificadores) so idias familiares.
Procedimentos. Vamos definir um procedimento como sendo uma sequncia finita de

instrues, e definir instruo como uma operao claramente descrita, que pode ser
executada mecanicamente, em tempo finito.
"mecanicamente" quer dizer que no h dvidas sobre o que deve ser feito;
"em tempo finito" quer dizer que no h dvidas de que a tarefa correspondente
instruo pode, em qualquer caso, ser levada at sua concluso.
Para descrever um procedimento podemos usar uma linguagem natural, uma

linguagem de programao, ou a linguagem normalmente usada em matemtica.
Frequentemente, usamos uma mistura de todas estas. Sobre a forma de descrever
instrues e procedimentos, suporemos apenas que existe uma linguagem, comum a
todos os interessados, em que instrues e procedimentos podem ser descritos sem
ambiguidades.
Como exemplos, citamos:
o algoritmo de Euclides para clculo do mximo divisor comum de dois nmeros

naturais;
um programa em FORTRAN que calcula a soma de dois nmeros;
a frmula que calcula as razes da equao do segundo grau.
Exemplo: O procedimento a seguir pra e diz "sim" se o nmero inteiro i, dado como
entrada, for par e no negativo.
1. se i = 0, pare e diga "sim".

2. diminua o valor de i de duas unidades.
3. v para 1.
Note que se i for originalmente mpar ou negativo, o procedimento no pra. Na

definio de procedimento, dada acima, exigimos que cada instruo possa ser executada
em tempo finito, mas no exigimos nada de semelhante para os procedimentos. Isso
significa, em particular, que no poderamos usar como instruo em algum outro
procedimento uma chamada do procedimento do exemplo acima, uma vez que no
podemos garantir sua parada em tempo finito, para qualquer valor da entrada.

Exemplo: O procedimento a seguir pra e diz "sim" se o nmero inteiro i for par e no
negativo; pra e diz "no" nos demais casos.

1. se i = 0, pare e diga "sim".
2. se i < 0, pare e diga "no".
3. diminua o valor de i de duas unidades
4. v para 1.
Algoritmo. Definimos um algoritmo como sendo um procedimento que sempre pra,

quaisquer que sejam os valores de suas entradas.
O segundo exemplo de procedimento dado acima , portanto, um algoritmo.

Programas corretos normalmente so algoritmos; em geral, um programa que no pra
para alguns valores de suas entradas um programa incorreto, um "programa com loop",
um "programa com erro de lgica". Em alguns casos, entretanto, isso no verdade, e o
desejado , exatamente, que a execuo do programa se estenda por um tempo ilimitado.
O exemplo mais caracterstico desse tipo de procedimento parece ser o de um sistema
operacional: uma vez iniciada sua execuo, ela continua (em condies normais) at que
a mquina seja desligada.
A seguir temos outro exemplo de procedimento que no tem parada prevista:
Exemplo: O procedimento a seguir enumera as sequncias de {a, b}*, emitindo

(imprimindo, por exemplo) todas essas sequncias.
1. Faa X = {}.
2. Emita todas as sequncias de X.
3. Para cada y X, acrescente a X as sequncias ya e yb.
4. V para 2.
O procedimento acima emite todas as sequncias formadas por a's e b's.

, , a, b, , a, b, aa, ab, ba, bb, , a, b,
Cada sequncia emitida uma infinidade de vezes, como permitido numa enumerao.
o
Exemplo: Seja uma funo f: Nat Nat. Suporemos que est disponvel um algoritmo
para calcular f(i), a partir de qualquer i Nat. Considere o procedimento a seguir:
1. faa i = 0.
2. calcule j = f(i), usando o algoritmo dado
3. se j = k, emita i, e pare
4. incremente o valor de i de 1
5. v para 2.
Note que o passo 2 s pode ser considerado uma instruo por causa da disponibilidade
de um algoritmo para clculo dos valores da funo. O procedimento do exemplo aceita
como entrada um valor k Nat, e s pra se existir um valor de i tal que f(i) = k. Em
particular, o valor de i emitido o menor possvel.
o
Conjuntos recursivamente enumerveis. Dizemos que um conjunto A
recursivamente enumervel (r.e.) se existe um procedimento que enumera os elementos
de A. Isto quer dizer que existe um procedimento que emite todos os elementos de A,
possivelmente com repeties.
Exemplo: Em um dos exemplos anteriores vimos que existe um procedimento que

enumera as sequncias pertencentes ao conjunto A = { a, b }*. Logo, o conjunto A
recursivamente enumervel.
o
Exemplo: Seja f: Nat Nat. O procedimento a seguir mostra que o contradomnio de f
recursivamente enumervel, supondo que existe um algoritmo que calcula o valor de
f(i), a partir de i.
1. i := 0;
2. emita f(i);
3. i := i + 1;
4. v para 2.
o
Conjuntos recursivos. Dizemos que um conjunto A recursivo se existe um algoritmo
que determina, para um valor arbitrrio de sua entrada x, se x A ou se x A. Embora
isso no seja estritamente necessrio, podemos, para fixar as idias, especificar que o
algoritmo deve parar e dizer "sim" ou "no", respondendo pergunta "x A?".
Exemplo: O conjunto dos naturais pares recursivo. Basta examinar o algoritmo a

seguir, cuja entrada um natural i:
1. Se i = 0, pare e diga "Sim".

2. Se i = 1, pare e diga "No".
3. faa i := i - 2.
4. v para 1.
o
Fato: Todo conjunto recursivo recursivamente enumervel.
Dem.: Se o conjunto A Nat recursivo, existe um algoritmo que, para cada entrada
i determina se i A. Considere o procedimento a seguir:
1. i := 0.
2. execute com entrada i.
3. se respondeu "Sim", emita i.
4. i := i + 1.
5. v para 2.
Note que:
i assume todos os valores naturais
sempre pra, qualquer que seja sua entrada i;
responde "Sim" exatamente para os valores de i que pertencem a A.
Portanto, os valores de i emitidos so exatamente aqueles pertencentes a A.
o

Fato: A classe dos conjuntos recursivos fechada para as operaes de unio, interseo
e complementao.
Dem.: (unio) Sejam A e B conjuntos recursivos. Sejam e algoritmos que
determinam pertinncia em A e em B, respectivamente. Podemos construir um algoritmo
que determina se x A B, da seguinte forma:
1. execute com entrada x.

2. se respondeu "Sim", responda "Sim" e pare.
4. pare e responda o que respondeu.
(interseo) Sejam A, B, , como acima. Construa um algoritmo que

determina se x A B da seguinte forma:

2. se respondeu "No", responda "No" e pare.
4. pare e responda o que respondeu.
(complemento) Sejam A e como acima. Construa um algoritmo que

determina se x A = Nat - A da seguinte forma:

2. se respondeu "Sim", responda "No" e pare.
3. se respondeu "No", responda "Sim" e pare.
o
Fato: Um conjunto A recursivamente enumervel se e somente se existe um
procedimento que, com entrada x, pra e diz "Sim", se x A, o que no acontece se
x A. Isto quer dizer que, se x , ou (1) o procedimento no pra, ou (2) pra, mas
no diz "Sim".
Dem.: () Se A r.e., existe um procedimento que enumera seus elementos. Construa

um procedimento que aceita um elemento x qualquer como entrada, modificando da
seguinte maneira: quando emite um valor y, testa se y = x. Se isso acontecer, pra
e diz "Sim". Portanto, dir "Sim" exatamente quando sua entrada for emitida por , ou
seja quando for um elemento de A.
() Seja um procedimento que pra e diz "Sim" quando sua entrada x A, e que ou
no pra, ou no diz "Sim", quando x A. Um procedimento que enumera os
elementos de A pode ser construdo usando , da seguinte maneira:
1. faa k = 0;
2. para cada x = 0, , k execute (2.1) e (2.2).
2.1. execute um passo (adicional) de com entrada x
2.2. se parou e disse "Sim", emita x.
3. faa k = k + 1.
4. v para 2.
Note que necessrio executar "em paralelo" com as vrias entradas x porque, se os
diversos valores de x fossem tentados sequencialmente, e no parasse para algum valor
de x, nunca chegaria a ser executado com os valores subsequentes de x.
o
Fato: A classe dos conjuntos recursivamente enumerveis fechada para as operaes
de unio e de interseo.
Dem.: (unio) Sejam A e B conjuntos r.e. e sejam e procedimentos que enumeram

os elementos de A e de B, respectivamente. Um procedimento que enumera os
elementos de A B executa e em paralelo :
1. execute um passo de .
2. se emitiu i, emita i.
4. se emitiu i, emita i.
5. v para 1.
Os elementos emitidos por so exatamente os elementos de A e os elementos de B, ou

seja, os elementos de A B.
(interseo) Sejam A, B, e como acima. O procedimento que enumera os

elementos de A B executa em paralelo e , guardando os elementos j emitidos por
e por nos conjuntos X e Y, respectivamente:
0. Faa X = e Y = .
2. se emitiu i, acrescente i ao conjunto X.
4. se emitiu i, acrescente i ao conjunto Y.
5. emita os elementos comuns a X e a Y.
6. v para 1.
Os elementos emitidos por so aqueles pertencentes aos conjuntos finitos X e Y, ou

sejam aqueles j emitidos por e por .
o
Fato: Se um conjunto A e seu complemento A so ambos recursivamente enumerveis,
ento A (e o complemento A ) so ambos recursivos.
Dem.: J vimos que se A r.e., existe um procedimento que pra e diz "Sim",
exclusivamente quando sua entrada x um elemento de A; como A tambm r.e., existe
um procedimento que pra e diz "Sim" exclusivamente quando sua entrada x um
elemento de A , ou seja, exatamente quando x no um elemento de A.
Podemos construir um algoritmo que executa os procedimentos e em paralelo,

com entrada x, para determinar se x pertence ou no a A. O procedimento a seguir um
algoritmo porque eventualmente um dos dois passos (2) ou (4) ser executado: ou x A
ou x A, no havendo terceira possibilidade.

1. execute um passo (adicional) de com entrada x.
2. se parou e disse "Sim", pare e diga "Sim".
3. execute um passo (adicional) de com entrada x.
4. se parou e disse "Sim", pare e diga "No".
5. v para 1.
o
(reviso de 27fev97)

Captulo 3: Gramticas
J vimos que procedimentos podem ser usados para definir linguagens de duas
maneiras essenciais: como geradores, procedimentos que enumeram os elementos da
linguagem, e como reconhecedores (ou aceitadores), procedimentos que indicam
quando uma sequncia faz parte da linguagem. O tipo mais comum de gerador a
gramtica. A idia original de gramtica vem do estudo de linguagens naturais, e as
definies que apresentaremos aqui so essencialmente devidas ao linguista Noam
Chomsky.
Fundamentalmente, uma gramtica composta por regras de produo, ou

regras de re-escrita, atravs das quais possvel obter todos os elementos da linguagem
a partir de um smbolo inicial, usando as regras para re-escrever (produzir) os elementos.
Formalmente, definimos uma gramtica G como sendo uma construo
<N, , P, S>, onde
N um alfabeto de smbolos auxiliares, chamados de smbolos no terminais, ou,

simplesmente, de noterminais.
o alfabeto no qual a linguagem definida, cujos elementos so os smbolos
terminais, ou, simplesmente, terminais.
P o conjunto de regras de re-escrita, chamadas simplesmente de regras ou
produes.
S o smbolo inicial.
Vamos definir o vocabulrio de G, como sendo V = N , o alfabeto composto

pelos smbolos terminais e no terminais. O conjunto de regras P uma relao binria
no conjunto V* de cadeias de smbolos quaisquer (terminais ou noterminais), isto ,
P V* V*, correspondendo cada regra individual a um par de cadeias (, ).
Entretanto, em vez de (, ) P, a notao habitual para a regra que permite a re-
escrita de como simplesmente . Alm disso, reunimos regras com o mesmo
lado esquerdo , tais como 1, 2, , n, na abreviao
1 | 2 | ... | n.
Nota: Em geral se procura usar as seguintes convenes:
letras representam
S, A, B, C, noterminais
a, b, c, terminais
X, Y, Z, smbolos quaisquer
, , , cadeias quaisquer
x, y, z, cadeias de terminais
V, N, , , , alfabetos
Como acontece com toda conveno, haver alguns casos em que esta no ser
seguida.
o

Nota: Alguns autores preferem definir P como um subconjunto de V* N V* V*, ou
seja, exigem que, numa regra , o lado esquerdo contenha pelo menos um
smbolo noterminal. A diferena entre as duas definies irrelevante.
Exemplo: Vamos definir uma gramtica
G = < N, , P, S > = < { S }, { 0, 1 }, { (S, 0 S 1), (S, ) }, S >
onde N = { S } o conjunto de noterminais, = { 0, 1 } o conjunto de terminais, e

P = { (S, 0 S 1), (S, ) } = { S 0S1, S } = { S 0S1 | } o conjunto de
regras.
Para mostrar que a cadeia 000111 faz parte da linguagem associada gramtica,
seguimos, a partir de S, os seguintes passos intermedirios:
S, 0S1, 00S11, 000S111, 000111.
Assim, por trs vezes S substitudo por 0S1, e finalmente, S substitudo pela
sequncia vazia . Como veremos a seguir, aplicar uma regra equivalente a
simplesmente remover .
o
Relao (deriva em um passo). Podemos definir a aplicao de uma regra atravs de
uma relao: dizemos que se e somente se . Caso seja necessrio
distinguir entre vrias gramticas, podemos usar o smbolo G para indicar
explicitamente qual a gramtica G utilizada.
Quando consideramos vrios passos de uma derivao, podemos usar as definies de

operaes com relaes vistas no captulo 0, e indicar i (deriva em i passos), *
(deriva em zero ou mais passos, ou, simplesmente, deriva), + (deriva em um ou mais
passos).
Uma sequncia derivvel de S, (tal que S * ) chamada uma forma sentencial da

gramtica considerada.
Exemplo: Em referncia gramtica do exemplo anterior, podemos escrever
S 0S1, 0S1 00S11, 00S11 000S111, 000S111 000111
ou, de forma mais compacta,
S 0S1 00S11 000S111 000111
Podemos tambm escrever S 4 000111, e S * 000111. As cadeias S, 0S1,

00S11, 000S111, e 000111 so formas sentenciais da gramtica. Dessas, a mais
importante 000111, composta exclusivamente por terminais, que far parte da
linguagem da gramtica, de acordo com a prxima definio.
Linguagem de uma gramtica. Definimos a linguagem da gramtica G = <N, , P, S>

por
L(G) = { x * | S * x }.
Ou seja, a linguagem da gramtica G constituda pelas sequncias x, que so compostas
apenas de smbolos terminais e que podem ser obtidas em um nmero arbitrrio de
passos de derivao a partir do smbolo inicial S, usando as regras de P.
Exemplo: Seja G a gramtica do exemplo anterior. Vamos mostrar que
L(G) = { 0i1i | i Nat }.
Para mostrar a igualdade dos dois conjuntos necessrio mostrar a "dupla incluso" ,
que no caso se reduz a mostrar (a) e (b) a seguir:
(a) cada sequncia da forma 0i1i pode ser derivada a partir de S, ou seja,
L(G) { 0i1i | i Nat }.
Basta observar que uma derivao a partir de S, em que se utiliza i vezes a regra
S 0S1 e uma vez a regra S , gera exatamente 0i 1i .
(b) uma sequncia de terminais derivada de S tem a forma 0i1i, ou seja,

L(G) { 0i1i | i Nat }.
Basta notar que a partir de S, usando as duas regras de todas as maneiras possveis, s
possvel gerar sequncias (formas sentenciais) da forma 0i1i , e da forma 0iS1i , e que
cadeias da segunda forma no podem fazer parte da linguagem, por conter um smbolo
no terminal.
o
Gramticas equivalentes. Duas gramticas G1 e G2 so chamadas de equivalentes, se
ambas definem a mesma linguagem: L(G1) = L(G2).
Exemplo: As duas gramticas abaixo so equivalentes:
G1 = < {S, T}, {a, b}, {S aTa | bTb, T aT | bT | }, S>
G2 = < {S, A, B}, {a, b}, {S aA | bB, A aA | bA | a, B aB | bB | b}, S>
Para mostrar a equivalncia destas duas gramticas, basta apenas mostrar que, de forma
diferente, ambas geram exatamente as cadeias cujo primeiro smbolo igual ao ltimo.
Isso pode ser feito observando que:
em G1, o primeiro e o ltimo smbolos so introduzidos na mesma regra;
em G2, os noterminais A e B "lembram" qual "foi" o primeiro smbolo, e

determinam qual deve ser o ltimo smbolo.
A demonstrao completa deve ser feita por induo, e fica como exerccio para o leitor
interessado mostrar que
L(G1) = L(G2) = { cxc | c {a,b} e x {a,b}* }.

Por exemplo, a cadeia aabba da linguagem, e pode ser derivada como a seguir:
em G1 : S aTa aaTa aabTa aabbTa aabba
em G2 : S aA aaA aabA aabbA aabba
o
A hierarquia das gramticas. Chomsky definiu quatro "tipos" de gramticas, 0, 1, 2 e 3,
que formam uma hierarquia: cada gramtica de um tipo tambm dos tipos menores.
Nossa definio no exatamente a mesma usada por Chomsky, mas praticamente
equivalente.
Gramticas tipo 0 (gramticas sem restrio). Exatamente as gramticas vistas na

definio anterior. As regras de uma gramtica tipo 0 so regras da forma , com
e quaisquer.
Gramticas tipo 1 (gramticas sensveis ao contexto, ou gsc). As gramticas tipo 1 so

as gramticas com regras da forma , em que se exige | | | |; entretanto
permitida uma regra que viola esta restrio: uma gramtica tipo 1 pode ter a regra
S , se S no aparece do lado direito de nenhuma regra.
Gramticas tipo 2 (gramticas livres de contexto, ou glc). As gramticas tipo 2 so as

gramticas com regras da forma A , onde A um smbolo no terminal, e uma
sequncia qualquer de V*, possivelmente vazia.
Gramticas tipo 3 (gramticas regulares). As gramticas tipo 3 s podem ter regras dos
trs tipos descritos a seguir:
A a B, onde A e B so noterminais, e a um terminal;

A a, onde A um noterminal, e a um terminal;
A , onde A um noterminal.
Se uma linguagem tem uma gramtica tipo 0, ela uma linguagem tipo 0; se tem
uma gramtica tipo 1, ela uma linguagem tipo 1, ou uma linguagem sensvel ao
contexto (lsc); se tem uma gramtica tipo 2, ela uma linguagem tipo 2, ou uma
linguagem livre de contexto (llc); se tem uma gramtica tipo 3, ela uma linguagem tipo
3, ou uma linguagem regular.
Observaes:
As gramticas tipo 3 so chamadas regulares pela simplicidade da estrutura de
suas linguagens, garantida pelos rgidos formatos de suas regras.
As gramticas tipo 2 so chamadas de livres de contexto porque uma regra
A indica que o noterminal A, independentemente do contexto em que
estiver inserido, pode ser substitudo por .
Finalmente, as gramticas tipo 1 so chamadas de sensveis ao contexto por
permitirem regras da forma A : A pode ser reescrito como ,
dependendo do contexto em que A aparece ( esquerda, direita).
O caso especial da regra S , nas gramticas sensveis ao contexto tem uma
nica finalidade: permitir que a cadeia vazia pertena a algumas linguagens
sensveis ao contexto. Com efeito, a aplicao de uma regra em que
| | | | no pode diminuir o comprimento da sequncia qual aplicada,
porque temos sempre | | | |. Como | S | = 1, e | | = 0, h
necessidade de alguma regra que permita a diminuio do comprimento, para que
uma derivao S* seja possvel, em algumas gramticas sensveis ao contexto.
As definies de gramticas acima no formam exatamente uma hierarquia.
Certamente, uma gramtica tipo 3 sempre tipo 2, e uma gramtica tipo 1
sempre tipo 0, mas nem todas as gramticas tipo 2 so tipo 1. Isso acontece
porque as regras da forma A no satisfazem a restrio de comprimento,
pois | A | > | |, j que 1 > 0. Na ltima seo deste captulo, entretanto,
mostraremos um resultado que suficiente para nossos propsitos: qualquer glc
pode ser transformada, atravs de um algoritmo relativamente simples, em uma
gramtica que satisfaz simultaneamente as definies de glc e de gsc, e que, alm
disso, equivalente gramtica original. Com esse resultado, vemos que, ao
contrrio das classes de gramticas, as classes de linguagens definidas acima
formam uma hierarquia. Ou seja, toda linguagem regular uma llc, toda llc uma
lsc, e toda lsc uma linguagem tipo 0.
Seguem-se alguns exemplos de gramticas e linguagens de diversas classes.

Naturalmente, mais fcil mostrar que uma gramtica pertence a uma certa classe, do
que mostrar o resultado oposto: num caso, basta exibir uma gramtica apropriada; no
outro, necessrio mostrar que nenhuma gramtica apropriada. Algumas tcnicas para
obter esses resultados negativos sero apresentadas posteriormente, durante o decorrer
do curso.
Exemplo: A linguagem L = { cxc | c {a, b} e x {a, b}* } do exemplo anterior livre

de contexto, uma vez que G1 uma glc. Por outro lado, como G2 uma gramtica
regular, L tambm regular. Como toda linguagem regular livre de contexto, em geral
no se faz referncia ao fato de que a linguagem livre de contexto.
o
Exemplo: A linguagem L = { xxR | x {0,1}* } livre de contexto. (A notao xR
indica a sequncia reversa ou refletida de x: se x = a1 a2 an , xR = an a2 a1.) Basta
considerar a gramtica com regras
S 0S0 | 1S1 |
onde S o nico noterminal, e portanto tambm o noterminal inicial. Para derivar

00100100, por exemplo, teramos:
S 0S0 00S00 001S100 0010S0100 00100100
A linguagem L no regular, mas ainda no dispomos dos mecanismos apropriados para
provar este fato.
o
Exemplo: A linguagem L = { x x | x {0,1} } sensvel ao contexto. Uma gramtica
para esta linguagem tem as regras indicadas a seguir:
1. S 0ZS 5. Z0 0Z 9. ZZ' Z'0 13. Z' 0

2. S 1US 6. Z1 1Z 10. ZU' Z'1 14. U' 1
3. S 0Z' 7. U0 0U 11. UZ' U'0
4. S 1U' 8. U1 1U 12. UU' U1
A utilizao das regras explicada a seguir, usando-se como exemplo a

derivao de 00100010, na qual as regras esto indicadas como ndices inferiores.
1 a 4: regras usadas para gerar os smbolos das duas metades de xx. Os smbolos
da segunda metade so indicados por Z (zero: 0) e U (um: 1). U' ou Z' indica o
ltimo smbolo da segunda metade.
S 1 0ZS 1 0Z0ZS 2 0Z0Z1US 3 0Z0Z1U0Z'
5 a 8: regras usadas para levar todos os smbolos da segunda metade para depois
dos smbolos da primeira metade:
0Z0Z1U0Z' 7 0Z0Z10UZ' 6 0Z01Z0UZ' 5 0Z010ZUZ' 5 00Z10ZUZ'
6 001Z0ZUZ' 5 0010ZZUZ'
9 a 12: regras usadas para converter os smbolos da segunda metade. O smbolo
Z' (ou U') indica o ltimo smbolo ainda no convertido.
0010ZZUZ' 11 0010ZZU'0 10 0010ZZ'10 9 0010Z'010
13 a 14: regras usadas para converter o primeiro smbolo da segunda metade
0010Z'010 13 00100010
Pela definio de linguagem de uma gramtica, s nos interessam as sequncias
de terminais que so obtidas a partir do smbolo inicial S, usando as regras de produo
da gramtica. Por essa razo, a ordem em que as regras so aplicadas no importante.
Uma outra derivao possvel para 00100010, em que as mesmas regras so usadas em
uma ordem diferente
S 1 0ZS 1 0Z0ZS5 00ZZS 2 00ZZ1US 6 00Z1ZUS 6 001ZZUS
3 001ZZU0Z' 7 001ZZ0UZ' 5 001Z0ZUZ' 5 0010ZZUZ'
11 0010ZZU'0 10 0010ZZ'10 9 0010Z'010 13 00100010
Outro fato sem importncia a existncia de "becos sem sada", isto ,
sequncias derivveis de S que no levam a nenhuma sequncia de terminais, no
contribuindo, portanto, para a linguagem. Por exemplo, considere a derivao:
S 1 0ZS 1 0Z0ZS 2 0Z0Z1US 3 0Z0Z1U0Z' 13 0Z0Z1U00
Note que a regra 13 foi aplicada "precocemente", de forma que as ocorrncias restantes
dos smbolos Z e U no podem mais ser convertidas em ocorrncias de 0 e 1.
Entretanto, como nenhuma sequncia de terminais pode ser obtida a partir de
0Z0Z1U00, o fato de que 0Z0Z1U00 pode ser derivada a partir de S no introduz na
linguagem nenhum elemento indevido. (0Z0Z1U00 apenas uma forma sentencial
intil da gramtica.)
A linguagem L no livre de contexto, mas ainda no dispomos dos mecanismos
para provar este fato.
o
Uma das principais motivaes da definio de gsc vem do teorema abaixo: a
restrio nos comprimentos dos lados esquerdo e direito das regras tem exatamente a
finalidade de garantir a recursividade das linguagens sensveis ao contexto. Entretanto,
observamos que a recproca do teorema no verdadeira, ou seja existem linguagens
recursivas que no so sensveis ao contexto. Este ltimo fato ser demonstrado
posteriormente.
Teorema: Toda lsc um conjunto recursivo.
Dem.: Sejam G = <N, , P, S> uma gsc, e L = L(G). Devemos, pela definio de
conjunto recursivo, mostrar que existe um algoritmo que, quando recebe como entrada

uma cadeia arbitrria x *, indica se ou no verdade que x L, parando e emitindo
respectivamente "sim" ou "no".
Sabemos que uma gsc pode ter uma regra S , se S no aparecer direita em
nenhuma regra. Para cada uma das outras regras, o comprimento do lado esquerdo no
pode ser maior que o do lado direito, e cada aplicao da regra pode manter ou aumentar
o comprimento, mas nunca diminu-lo. Portanto, para considerar todas as derivaes que
podem levar a uma sequncia x, basta considerar as formas sentenciais de comprimento
menor ou igual ao de x: se x , S * * x implica que 1 | | | x |. Esta idia est
aplicada no algoritmo a seguir:
1. Se x , v para 4.
2. Se P contm uma regra S , pare e diga "sim".
3. Pare e diga "no".
4. Faa X = { S }, e Y = .
5. Se x X, pare e diga "sim"
6. Se X = , pare e diga "no"
7. Escolha uma cadeia qualquer em X, retire de X, e acrescente a Y
8. Para cada tal que , se Y, e se | | | x |, acrescente a X.
9. v para 5
O tratamento da entrada x = se resume a verificar se existe a regra correspondente

S; para as demais entradas, todas as possibilidades so consideradas, e uma forma
sentencial s eliminada se j foi considerada antes (pertence a Y), ou se longa demais
(comprimento maior que o de x). Durante a execuo do algoritmo, X guarda as formas
sentenciais que ainda devem ser consideradas. Note que se trata de um algoritmo: em
cada execuo do passo 7, escolhida uma cadeia de comprimento menor ou igual ao
de x, e no so permitidas repeties.
o
Exemplo: Considere a gsc G com noterminais S e T, terminais a, b e c, smbolo inicial
S e regras
S aSa | bSb | T
T cT | c
(Note que G tambm uma glc.) Seja x = aabbb. Para determinar se x L(G), so
consideradas as formas sentenciais abaixo, que compem o conjunto Y, ao final da
execuo:
{ S, aSa, bSb, T, aaSaa, abSba, aTa, baSab, bbSbb, bTb, cT, c, aaTaa, abTba,
acTa, aca, baTab, bbTbb, bcTb, bcb, ccT, cc, aacaa, abcba, accTa, acca,
bacab, bbcbb, bccTb, bccb, cccT, ccc, accca, bcccb, ccccT, cccc, ccccc }
Fica como exerccio a execuo passo a passo do algoritmo, mostrando que x L(G).
o
Teorema: Toda linguagem tipo 0 um conjunto recursivamente enumervel.
Dem.: Seja G = <N, , P, S> uma gramtica (tipo 0). O procedimento abaixo enumera
os elementos de L(G).

1. Faa X = { S }
2. Emita todos os elementos X *.
3. Faa Y = { | X e }
4. Faa X = Y
5. v para 2.
A cada iterao do procedimento acima, X contm todas as sequncias derivveis de S

em um passo adicional. Assim, se S * x em n passos, em n passos o procedimento
emitir x.
o
Outros resultados sobre as classes de linguagens ainda dependem de resultados
que sero apresentados posteriormente. Em particular, mostraremos posteriormente que
todo conjunto r. e. uma linguagem tipo 0, e apresentaremos os exemplos que mostram
que as demais incluses entre as classes de linguagens so prprias.
Gramticas livres de contexto, gramticas sensveis ao contexto, e regras com lado

direito vazio. Retomamos aqui o problema das regras com lado direito vazio em glc's e
gsc's. Como j vimos anteriormente, a definio de glc permite indiscriminadamente a
presena de regras A, onde A um noterminal; essas regras podem violar a restrio
da definio de gsc, uma vez que a nica regra permitida com lado direito vazio uma
regra S, desde que o smbolo inicial S no aparea direita em nenhuma regra.
Dessa maneira, no imediato que toda llc uma lsc, uma vez que uma glc pode
no satisfazer a definio de gsc.
Esta seo tem como principal finalidade mostrar que cada glc pode ser
transformada em outra glc equivalente, que satisfaz a definio de gsc. Como corolrio
desse fato, temos que toda llc tambm uma lsc.
Noterminais anulveis. Dizemos que um noterminal A de uma glc G anulvel se

possvel derivar a cadeia vazia a partir de A, ou seja, se A * .
Lema: Dada uma gramtica livre de contexto G = <N, , P, S>, o algoritmo a seguir
determina quais so os noterminais anulveis de G, isto , quais so os noterminais A a
partir dos quais pode ser derivada a cadeia vazia .
Dem.: Considere o algoritmo:

1. Faa X = { A N | A P }
2. Repita o passo 3 at que nenhum elemento novo possa ser acrescentado a X:
3. Para cada regra BX1 X2 Xn, se todos os smbolos X1 , X2 , Xn
pertencem a X, acrescente B a X.
Claramente, ao final da execuo do algoritmo, X contm exatamente os noterminais

anulveis da gramtica considerada.
o
Teorema: Para qualquer gramtica livre de contexto G existe uma gramtica livre de
contexto G', equivalente a G, que satisfaz a definio de gramtica sensvel ao contexto.

Dem.: Seja G = <N, , P, S>. Execute o algoritmo anterior para determinar quais os
noterminais anulveis de G. Seja S' um smbolo novo, no pertencente a N ou a .
Defina a gramtica G' = <N {S'}, , P', S'>, sendo P' como obtido como
descrito a seguir:
1. Inicialmente, faa P' = P.

2. Repita o passo 3 enquanto for possvel acrescentar regras novas a P'.
3. Para cada regra A B de P', se B anulvel, acrescente A a P'.
4. Retire de P' todas as regras com lado direito vazio.
5. Acrescente a P' a regra S' S.
6. Se S anulvel, acrescente a P', alm da regra acima, a regra S' .
(Se acrescentada, esta ser a nica regra com lado direito vazio.)
Claramente, a gramtica G' satisfaz as definies vistas de glc e de gsc. Note que,
como S' um smbolo novo, no ocorre direita em nenhuma das regras de G'.
Resta assim provar que G e G' so equivalentes. Para isto, observamos que o uso
das regras- em G corresponde ao uso de regras mais curtas em G': em vez de usar uma
regra de G, que introduz (ocorrncias de) noterminais anulveis, e depois usar as regras
necessrias para a transformao desses noterminais anulveis em , usamos de sada
uma regra mais curta de G', em que as correspondentes ocorrncias desses noterminais
anulveis no aparecem (ver passo 3 do algoritmo acima). Na outra direo,
similarmente, o uso de uma regra mais curta pode ser substitudo pelo uso da regra mais
longa de que se originou, seguida pelo uso das regras necessrias para transformar os
noterminais que se deseja anular na sequncia vazia.
o
Exemplo: Considere a gramtica G, com o conjunto de regras P a seguir:
S ABC | ABD
A aA |
B Bb | AC
C CC | c |
Dd
Para a aplicao do algoritmo acima, temos sucessivamente os seguintes valores para o
conjunto X:
{ A, C } regras A e C
{ A, B, C } regra B AC
{ A, B, C, S } regra S ABC
at que X atinge seu valor final: X = { S, A, B, C }.
Na construo do conjunto P' de regras da gramtica G', temos inicialmente P' = P:

S ABC | ABD
A aA |
B Bb | AC
C CC | c |
Dd
Retirando as ocorrncias de noterminais anulveis, as seguintes regras so
acrescentadas:
S BC | AC | AB | BD | AD | C | B | A | D |
Aa
Bb
BA|C|
CC
As regras com lado direito vazio so ento retiradas, as regras S'S, e S' so
acrescentadas, j que S X. Ao final, temos as seguintes regras em P':
S' S |
S ABC | ABD | BC | AC | AB | BD | AD | C | B | A | D
A aA | a
B Bb | AC | b | A | C
C CC | c | C
Dd
(A regra C C obviamente intil.)
Podemos agora comparar uma derivao em G com a correspondente derivao
em G'. Considere a seguinte derivao em G:
S ABD aABD aBD aACD aCD aD ad
A aplicao de S ABD introduz uma ocorrncia de B que depois anulada; o
mesmo acontece com a aplicao da regra A aA. As regras correspondentes em G'
so, portanto, S AD e A a. As duas derivaes correspondentes, em G e G',
podem ser representadas pelas rvores de derivao a seguir.
S S
A B D A D
a A A C d a d
rvore de derivao em G rvore de derivao em G'

o
Corolrio: Toda glc cuja linguagem no contm a sequncia vazia pode ser
transformada em uma glc equivalente que no tem regras com lado direito vazio.
Dem.: Se o smbolo inicial da gramtica no anulvel, a construo vista na
demonstrao do teorema acima nos leva a uma gramtica sem nenhuma regra-.
o

Exemplo: Seja a gramtica G com regras
E T E'
T F T'
F(E)|a
E' + T E' |
T' * F T' |
De acordo com o algoritmo visto na demonstrao do teorema anterior, o conjunto dos
noterminais anulveis X = {E', T'}. Assim, a nova gramtica G' tem regras
S' E
E T E' | T
T F T' | F
F(E)|a
E' + T E' | + T
T' * F T' | * F
A converso de gramticas livres de contexto em gramticas sem regras vazias
perdeu parte de sua importncia, porque os algoritmos de anlise sinttica usados em
compiladores modernos (ao contrrio de algoritmos mais antigos) no fazem restries
ao uso de regras com lado direito vazio. Portanto, regras com lado direito vazio podem
ser usadas sem problemas nas gramticas de linguagens de programao, usadas para
projeto e implementao de compiladores.
(reviso de 27fev97)

Linguagens Formais
Captulo 4: Autmatos finitos e expresses regulares
com Luiz Carlos Castro Guedes
4.1 - Introduo
Neste captulo estudaremos uma mquina (um procedimento aceitador, ou

reconhecedor), chamada autmato finito (af). A palavra finito includa no nome para
ressaltar que um af s pode conter uma quantidade finita e limitada de informao, a
qualquer momento. Essa informao representada por um estado da mquina, e s
existe um nmero finito de estados.
Essa restrio faz com que o af seja severamente limitado na classe de linguagens
que pode reconhecer, composta apenas pelas linguagens regulares, como mostraremos
neste captulo.
Duas verses do af so estudadas aqui: o af determinstico (afd) e o af no

determinstico (afnd). Este captulo mostra que uma linguagem regular pode ser definida
de quatro formas:
atravs de uma gramtica regular (definio);
atravs de um afd que reconhece a linguagem;
idem, atravs de um afnd;
atravs de uma expresso regular, um mecanismo a ser introduzido com essa
expressa finalidade.
4.2 - Autmato finito determinstico
Como observado acima, a informao que um af guarda sobre a entrada (mais
precisamente sobre a parte da entrada j lida) representada por um estado, escolhido
em um conjunto finito de estados. A definio formal de automato finito, na sua verso
determinstica dada a seguir.
Definio. Um Autmato Finito Determinstico (afd) M, sobre um alfabeto um
sistema (K, , , i, F), onde
K um conjunto de estados finito, no vazio;
um alfabeto de entrada (finito)
: K K a funo de transio
iK o estado inicial
FK o conjunto de estados finais.
O nome determinstico faz referncia ao fato de que uma funo (tambm
chamada funo prximo-estado), que determina precisamente o prximo estado a ser
assumido quando a mquina M se encontra no estado q e l da entrada o smbolo a: o
estado (q, a).
J. L. Rangel, L. C. Guedes - Ling. Formais - 4-1

De forma simplificada, podemos dizer que um afd aceita uma cadeia se, partindo
do estado inicial, e mudando de estado de acordo com a funo de transio, o afd
atinge um estado final ao terminar de ler a cadeia. Uma das maneiras de visualizar o
funcionamento de um afd atravs de um controle finito que l smbolos de uma fita de
entrada (onde se encontra a cadeia de entrada), sequencialmente, da esquerda para a
direita. Os elementos do conjunto de estados K representam os estados possveis do
controle finito. A operao se inicia no estado inicial i, lendo o primeiro smbolo da fita
de entrada. Por convenincia, considera-se que a cabea de leitura se move sobre a fita,
ao contrrio do que seria de se esperar.
A Figura 4.1 representa um afd cujo controle est no estado q, e que est lendo o
quarto smbolo da cadeia de entrada, um b.
Fig. 4.1 - Autmato Finito

Exemplo 1: Considere o afd M = (K, , , i, F), onde temos
K = { q0, q1, q2, q3 }
= { a, b }
i = q0
F = { q3 }
e onde a funo de transio : { q0, q1, q2, q3 } { a, b } { q0, q1, q2, q3 } dada
pela tabela abaixo
a b
q0 q1 q2
q1 q0 q3
q2 q3 q0
q3 q2 q1
Alternativamente, podemos representar o afd M por um diagrama de transies,

ou diagrama de estados, como o da Fig. 4.2. Note que o diagrama de transies
determina completamente o automato M, atravs de algumas convenes:
os estados so os ns do grafo, ou seja, K = { q0, q1, q2, q3 };
o estado inicial indicado pela seta, ou seja, i = q0;
os estado finais so indicados pelo crculo duplo: q3 o nico estado final, ou
seja, F = { q3 };

as transies so as indicadas pelas arestas: (q0, a) = q1, (q0, b) = q2,
(q1, a) = q0, etc, ou seja, a mesma funo representada pela tabela acima.
Cada estado de um af corresponde a uma determinada informao sobre a parte da
cadeia de entrada j lida. No caso do exemplo, a informao pode ser descrita em frases
curtas, mas isso nem sempre acontece. Para o estado q2, por exemplo, podemos dizer
"se o estado atingido q2,
o nmero de smbolos a j lidos par, e
o nmero de smbolos b j lidos mpar".
(Note que 0 par.)
Fig. 4.2 - afd para o Exemplo 1
Em resumo, temos:
nmero de a's nmero de b's
q0 par par
q1 mpar par
q2 par mpar
q3 mpar mpar
A linguagem aceita ou reconhecida por M (ver definio abaixo) a linguagem formada
pelas cadeias em que os nmeros de a's e de b's so ambos mpares. Isso se deve ao fato
de que o nico estado final q3.
Por exemplo, a cadeia abaa da linguagem de M, porque, com essa cadeia, os seguintes
estados so atingidos: q0, q1, q3, q2, q3. Como o ltimo estado final, a cadeia aceita.
A linguagem de um afd. Para definir a linguagem L(M), a linguagem das cadeias aceitas
ou reconhecidas pelo afd M, podemos definir inicialmente uma configurao de M como
sendo um par (q, x) K *, composto pelo estado corrente (o estado atual da
mquina) e pela cadeia x, a parte da entrada que ainda no foi lida. Como observado, o

estado representa a parte j lida da cadeia de entrada. A configurao (i, x) a
configurao inicial de M para a cadeia x; qualquer configurao (q, ) uma
configurao final se q F. A mudana de configurao caracterizada pela relao
|, definida abaixo:
(q, ax) | (p, x) se e somente se (q, a) = p
ou seja, se tivermos (q, a) = p, e se M estiver no estado q, lendo um smbolo a da cadeia

de entrada, M mover a cabea de leitura uma posio para a direita e ir para o estado
p. O smbolo a, depois de lido, no precisa mais aparecer na configurao. Podemos
agora definir a linguagem L(M) por
L(M) = { x * | (i, x) |* (f, ), com f F }
Como em casos anteriores, |* indica o fechamento reflexivo-transitivo da

relao, no caso a relao | de mudana de configurao, indicando que a
configurao final pode ser atingida em zero ou mais passos.
Exemplo 1: (continuao) Para mostrar que abaa L(M), basta observar que
(q0, abaa) | (q1, baa) | (q3, aa) | (q2, a) | (q3, ),
porque q3 final. Por outro lado, como
(q0, abab) | (q1,bab) | (q3, ab) | (q2, b) | (q0, ),
abab no pertence a L(M).
Uma caracterizao alternativa de L(M) pode ser baseada em uma extenso $ da

funo , feita de forma a aceitar cadeias no segundo argumento, isto com domnio
K * em vez de K . Pode-se definir a nova funo $ : K * K por
$ (q, ) = q, q K
$ (q,ax) = $ ( (q,a), x), q K, x *, a .
Fato: A funo $ realmente uma extenso de , isto , sempre que definida, $

tambm , e tem o mesmo valor. Ou seja, se q K e a , $ (q, a) = (q, a).
Dem. Exerccio.
Fato: A funo $ e a relao | se relacionam por
$ (q, x) = p se e somente se (q, x) |* (p, )

Portanto, temos
L(M) = {x * | $ (q, x) F }
Demonstrao: Exerccio.

Exemplo 1: (continuao) Para mostrar que abaa L(M), basta ver que
$ (q0, abaa) = $ (q1, baa) = $ (q3, aa) = $ (q2, a) = $ (q3, ) = q3 F
Como $ (q0, abab) = q0 F, abab L(M).
Exerccio 1: Mostre que o afd M do Exemplo 1 aceita a linguagem
L(M) = { x {a, b}* | os nmeros de a's e de b's em x so mpares }
Sugesto: induo no comprimento de x.
Exerccio 2: Mostre que a definio anterior de $ pode ser substituda pela equivalente
$ (q, ) = q, q K
$ (q, xa) = ($ (q, x),a), q K, x *, a .
Exerccio 3: Modifique a definio do af M do Exemplo 1, fazendo F= { q1, q2 }

Descreva a linguagem aceita por M assim modificado.
Exerccio 4: Descreva a linguagem do afd M dado pelo diagrama de estados da Fig. 4.3.
Fig. 4.3 - afd para o Exerccio 4
Exerccio 5: Descreva a linguagem do afd M = (K, , , i, F), onde K={q0, q1, q2, q3},
= { a, b }, i = q0, F = { q2 }, e dada pela tabela abaixo:
a b
q0 q1 q3
q1 q2 q0
q2 q3 q1
q3 q4 q2

4.3 - Autmato finito no determinstico
Passaremos agora ao estudo do af no determinstico. Em oposio ao que
acontece com o afd, a funo de transio de um afnd no precisa determinar exatamente
qual deve ser o prximo estado. Em vez disso, a funo de transio fornece uma lista
(um conjunto) de estados para os quais a transio poderia ser feita. Essa lista pode ser
vazia, ou ter um nmero qualquer positivo de elementos.
Essa possibilidade de escolha entre vrios caminhos a serem seguidos nos leva a
modificar a definio de aceitao. Um afd aceita se "o ltimo estado atingido final";
mas um afnd aceita se "existe uma sequncia de escolhas tal que o ltimo estado
atingido final". Podemos alternativamente imaginar que o afnd "escolhe", "adivinha", o
caminho certo para a aceitao, uma vez que a existncia de escolhas erradas, que no
levam a um estado final, irrelevante.
Exemplo 2: Considere o afnd dado pelo diagrama da Fig. 4.4 e a cadeia de entrada
ababa.
Fig. 4.4 - afnd para o Exemplo 2
A cadeia ababa aceita, porque uma das possibilidades a sequncia de estados q0,
q1, q1, q1, q1, q2. Naturalmente, com a mesma cadeia, poderamos escolher a sequncia
q0, q1, q1, q1, q1, q1, que no leva a um estado final. Ou a sequncia q0, q1, q1, q2,
interrompida, porque q2 no prev uma transio com o segundo b. Mas estes casos em
que "o automato adivinhou errado" no criam problemas para a aceitao, porque "existe
um caminho certo".
Este afnd aceita a linguagem das cadeias (de comprimento maior ou igual a 2), cujo
primeiro e ltimo smbolos so a, sendo os restantes quaisquer. (Compare este afnd com
o afd de um dos exemplos anteriores, que aceita a mesma linguagem.)
Definio. Formalmente, um Autmato Finito no Determinstico (afnd) M, sobre um

alfabeto um sistema (K, , , i, F), onde
K um conjunto (finito, no vazio) de estados,
um alfabeto de entrada (finito),
: K( { }) P(K) a funo de transio,
iK o estado inicial,
FK o conjunto de estados finais.

A notao P(K) indica o conjunto "partes" de K (conjunto potncia de K, ou, ainda,
"powerset" de K), o conjunto de todos os subconjuntos de K.
Pela definio, portanto, uma funo que aceita como argumentos q e a, onde q
um estado e a pode ser um smbolo de ou a cadeia vazia . Em qualquer caso, (q, a)
sempre um conjunto de estados, ou seja, um subconjunto de K.
Se tivermos (q, a) = {p1, p2, ..., pk}, entendemos que o autmato M, a partir do estado
q, pode escolher um dos estados p1, p2, ..., pk para ser o prximo estado. Se a = ,
nenhum smbolo da entrada lido; se a , o smbolo a da entrada lido. Podemos
considerar o caso a= como correspondendo a transies espontneas: M muda de
estado sem estmulo da entrada. Se tivermos (q, a) = , no h transies possveis a
partir do estado q com o smbolo a.
Definimos configuraes para o caso do afnd da mesma forma que anteriormente. A

mudana de configurao dada pela relao |, definida abaixo:
(q, ax) | (p, x) se e somente se p (q, a)
Note que a pode ser a cadeia vazia, caso em que temos, particularizando,
(q, x) | (p, x) se e somente se p (q, )
Podemos agora definir a linguagem L(M) por
L(M) = { x * | (i, x) |* (f, ), com f F }
Exemplo 2: (continuao) Temos, para a mesma cadeia ababa de entrada,

(q0, ababa) | (q1, baba) | (q1, aba) | (q1, ba) | (q1, a) | (q2, )
e, portanto, ababa L(M). Temos tambm o "caminho errado"
que leva configurao no final (q1, ), e no permite nenhuma concluso.
Cadeias como bab e abab no levam a configuraes finais e no so aceitas. Da
configurao (q0, bab) nenhuma configurao atingvel; para abab temos:
(q0, abab) | (q1, bab) | (q1, ab) | (q1, b) | (q1, )

Adicionalmente, temos um outro caminho
(q0, abab) | (q1, bab) | (q1, ab) | (q2, b)
que tambm no atinge nenhuma configurao final. Assim, as cadeias bab e abab no
so aceitas e no fazem parte de L(M).
Exemplo 3: Considere o afnd M da Fig. 4.5. M aceita cadeias da forma c y c, onde c

pode ser a ou b e y pode ser qualquer cadeia de a's e b's.
A cadeia ababa = cyc = ababa aceita por M, atravs da sequncia de configuraes

abaixo, em que a primeira e a ltima transies so realizadas atravs de transies-.
(A, ababa) M l e adivinha que c=a
| (B, ababa) M l a e confere que c=a
| (C, baba) M l b
| (C, aba) M l a e adivinha que este a faz parte de y
| (C, ba) M l b
| (C, a) M l a e adivinha que este a o ltimo c
| (D, ) M l e adivinha que a cadeia acabou
| (I, ) M aceita
Fig. 4.5 - afnd para o Exemplo 3
Todas as configuraes atingveis (caminhos certos e errados) esto indicadas abaixo:

(A, ababa)
| (B, ababa)
. | (C, baba)
. | (C, aba)
. | (C, ba)
. . | (C, a)
. . | (C, ) -- no aceita
. . | (D, )
. . | (I, ) -- ok! aceita!
. | (D, ba)
. | (I, ba) -- bloqueado
| (F, ababa) -- bloqueado
Exerccio 6: Considere a linguagem composta pelas cadeias no alfabeto {a, b} que

contm a cadeia aaa ou a cadeia bb. Ou seja, a linguagem
L = { x y z | x, z {a, b}* e ( y=aaa ou y=bb ) }
Construa um afnd M que aceite L.

Sugesto: M adivinha se a cadeia de entrada contm aaa ou bb, e apenas verifica esse
fato.
4.4 - Equivalncia dos afd's e dos afnd's

Mostraremos nesta seo que uma linguagem aceita por um af determinstico se
e somente se ela aceita por um af no determinstico. A classe de linguagens
reconhecidas por afd's e afnd's a classe das linguagens regulares (ver seo 4.6).
Teorema: Toda linguagem reconhecida por um afd reconhecida por um afnd.

Demonstrao: Exerccio.
Sugesto: Basta definir um afnd em que a nica transio possvel em cada caso aquela
especificada no afd.
Teorema: Toda linguagem reconhecida por um afnd reconhecida por um afd.

Demonstrao: ver Lemas 1 e 2 abaixo.
Lema 1: Toda linguagem reconhecida por um afnd reconhecida por um afnd que no
tem transies com .
Demonstrao: Seja M = (K, , , i, F) um afnd qualquer. Vamos construir um afnd
M' = (K, , ', i, F') equivalente a M, isto L(M') = L(M). Para isso vamos "simular" o
efeito das transies com de duas maneiras:
se tivermos a , (p1, ) = p2, e (p2, a) = q, acrescentaremos a ' uma
transio de p1 para q com a, ou seja, acrescentaremos q ao conjunto '(p1, a);
se tivermos (p1, ) = p2, e p2 F, acrescentaremos p1 a F.
(ver figura abaixo)
Isso deve ser feito repetidamente enquanto novas transies forem acrescentadas a ', e
enquanto novos estados forem acrescentados a F. Aps isso, retiramos de as transies
com , e chamamos os resultados de ' e F'.
Exemplo 4: Considere o afnd M do Exemplo 3 (Fig. 4.5). A construo descrita na

prova do Lema 1 permite construir o afnd equivalente M' (Fig. 4.6), que no tem

transies com . Note que M' tem estados inteis: B, F e I passaram a ser inacessveis a
partir do estado inicial.
Para aceitar a cadeia ababa, as configuraes de M esto na tabela a seguir:
Configuraes de M Configuraes de M'

(A, ababa) (A, ababa)
(B, ababa) ---
(C, baba) (C, baba)
(C, aba) (C, aba)
(C, ba) (C, ba)
(C, a) (C, a)
(D, ) (D, ) --- final
(I, ) --- final ---
Fig. 4.6 - afnd sem transies-

Lema 2: Toda linguagem aceita por um afnd sem transies com aceita por um afd.
Demonstrao. Seja M = (K, , , i, F) um afnd sem transies com . Vamos construir

um afd M' = (K', , ', i', F'), equivalente a M, isto , M' tambm aceita L. A idia da
demonstrao que os estados de M' so conjuntos de estados de M: a cada momento o
estado de M' contm todos os estados em que M poderia se encontrar. Desta maneira,
M' pode seguir ao mesmo tempo todos os caminhos percorridos por M. Temos:
K'= P(K); estados de M' so conjuntos de estados de M
i' = { i } o estado inicial de M' contm apenas o estado inicial de M
F' = { Q K | Q F }
os estados finais de M' so os conjuntos de estados de M
que contm pelo menos um estado final de M
': K' K'
A funo ' deve cobrir todas as possibilidades: '(Q, a) deve incluir todos os estados em
todos os conjuntos (q, a), para cada q em Q, ou seja,
(Q,a) = U (q,a)
q Q
para cada a . A aceitao nas duas mquinas se d de forma paralela:

M aceita x, e temos em M (i, x) |* (f, ), com f F
M' aceita x, e temos em M' (i', x) |* (Q, ), com Q F
A ligao entre as duas sequncias de configuraes feita pelo estado f Q.
O restante da demonstrao consiste na prova de que dada uma das sequncias de

configuraes, possvel construir a outra, e vice-versa.
Observamos que em geral no necessrio levar em considerao todos os estados de

M', bastando apenas considerar aqueles que so acessveis a partir de i'. Se M tem n
estados, M' tem um mximo terico de 2n estados, mas em geral apenas uma frao
desses estados acessvel a partir do estado inicial i'.
Exemplo 4 (continuao): Podemos construir um afd M'' a partir de M', como descrito
na demonstrao do Lema 2. M'' ser equivalente a M (Exemplo 3) e a M'.
Temos: i'' = { A }. A tabela abaixo mostra a funo ''. Note que os 251 estados no
acessveis a partir de { A } foram ignorados. O afd pode ser visto tambm na Fig. 4.7.
'' a b
{A} {C} {G}
{C} { C, D } {C}
{G} {G} { G, H }
{ C, D } { C, D } {C}
{ G, H } {G} { G, H }
Os estados finais de M'' que precisam ser considerados so, portanto, {C, D} e {G, H},
que contm os estados finais D e H de M'. Para comparao, a tabela abaixo apresenta as
configuraes assumidas por M, M' e M'' na aceitao de ababa.
Fig. 4.7 - afd para o Exemplo 4
M M' M''
(A, ababa) (A, ababa) ({A}, ababa)
(B, ababa) --- ---
(C, baba) (C, baba) ({C}, baba)
(C, aba) (C, aba) ({C}, aba)
(C, ba) (C, ba) ({C, D}, ba)
(C, a) (C, a) ({C}, a)
(D, ) (D, ) ({C, D}, )
(I, ) --- ---
Exerccio 7: Construa um afd equivalente ao afnd do Exerccio 6.
4.5 - Minimizao de autmatos finitos

Para af determinsticos, possvel fazer uma minimizao: dado um afd M,
possvel construir um afd M', que equivalente a M, e que tem o menor nmero de
estados possvel para todos os afd's que aceitam L(M). (Esta construo no se aplica a
af no determinsticos.)
Uma propriedade adicional, que no demonstraremos aqui, que o afd mnimo

nico, exceto pelos nomes dos estados, que podem ser escolhidos arbitrariamente. Ou
seja, o mesmo afd mnimo obtido, a partir de qualquer afd que aceite a linguagem
considerada.

A maneira de construir o afd mnimo baseada na idia de estados equivalentes,
que podem ser reunidos em um s. Dois estados p e q so equivalentes quando as
mesmas cadeias levam dos dois estados at a aceitao (at um estado final). Temos:
p q se e somente se
para toda cadeia x *,
$ (p, x) F se e somente se $ (q, x) F
A ltima linha pode ser substituda por
ou $ (p, x) e $ (q, x) so ambos finais, ou so ambos no finais.
A relao uma relao de equivalncia. Portanto, trivialmente, para estados
p, q e r quaisquer, temos
pp (reflexividade)
se p q, ento q p (simetria)
se p q e q r, ento p r (transitividade)
(Demonstrao: exerccio.)
O algoritmo que vamos descrever aqui se baseia no fato de que mais fcil
provar que dois estados p e q no so equivalentes do que provar que so. Para mostrar
que p e q no so equivalentes, basta achar uma cadeia x tal que $ (p, x) final e
$ (q, x) no final, ou vice-versa. Dizemos que essa cadeia x distingue o estado p do
estado q, e que p e q so distinguveis.
As propriedades que vamos usar no algoritmo so:

Propriedade 1. (Equivalncia se propaga para a frente.) Se p q, ento para qualquer
a , os estados p' = (p, a) e q' = (q, a) so equivalentes.
Dem. Seja x * uma cadeia qualquer. Devemos mostrar que p'' = $ (p', x) e
q'' = $ (q', x) so ambos finais ou ambos no finais.
Seja y = ax. Temos

p'' = $ (p', x) = $ ((p, a), x) = $ (p, ax) = $ (p, y)
e
q'' = $ (q', x) = $ ((q, a), x) = $ (q, ax) = $ (q, y)
Como p q, p'' e q'' so ambos finais ou ambos no finais.
Propriedade 2. (Distinguibilidade se propaga para trs.) Para qualquer a ,
se p' = (p, a) e q' = (q, a) no so equivalentes, ento p e q tambm no so
equivalentes.
Dem. Se p'e q' no so equivalentes, existe uma cadeia x que distingue p' e q'. Ou seja,
chamando p'' = $ (p', x) e q'' = $ (q', x), temos que um deles final e o outro no.
Fazendo y = ax, temos
p'' = $ (p', x) = $ ((p, a), x) = $ (p, ax) = $ (p, y)
e
q'' = $ (q', x) = $ ((q, a), x) = $ (q, ax) = $ (q, y)

e vemos que y = ax distingue p e q.
Propriedade 3. (Iniciao) Um estado final e um estado no final no podem ser

equivalentes.
Demonstrao: Sejam p F, e q F. A cadeia vazia distingue p de q: p = $ (p, ) F,
e q = $ (q, ) F.
Para minimizar um afd M, comeamos por determinar quais so os pares de

estados de M que so equivalentes, isto , que podem ser reunidos em um nico estado.
Como mais fcil descobrir quais so os pares de estados no equivalentes,
consideramos que estados p e q so equivalentes se no conseguirmos mostrar que so
distinguveis (no equivalentes). As estruturas de dados usadas pelo algoritmo so:
para cada par (p, q) de estados distintos,

um valor booleano marca(p, q), inicialmente com o valor false.
Se marca(p,q) = true, p e q so distinguveis.
uma lista de pares de estados, inicialmente vazia.
Se (r, s) est na lista de (p, q), isto significa que r e s sero distinguveis, se p e
q forem distinguveis.
Se marca(p, q) = true, dizemos que o par (p, q) est marcado. Note que o par
identificado como (p, q) o mesmo par identificado como (q, p), e, portanto, tanto faz
marcar (p, q), como marcar (q, p).
Note que o algoritmo que determina os pares de estados equivalentes baseado

nas propriedades vistas acima. As listas so usadas para evitar a necessidade de passar
mais de uma vez por cada par de estados. Ao final da execuo do algoritmo, os pares de
estados equivalentes so os que no esto marcados. A prova de correo do algoritmo,
pode ser encontrada, por exemplo, em [HopUll79]1.
Algoritmo. Determinao dos estados equivalentes em um afd M.

procedimento mark(p, q);
se p q ento
marca(p, q) := true;
para cada par (r,s) na lista de (p, q)
execute mark( r, s);
1JohnE. Hopcroft, Jeffrey D. Ullman, Introduction to Automata Theory, Languages and

Computation, Addison-Wesley, 1979 - Sec. 3.4, p.68
{parte principal do algoritmo}
para cada p final,
para cada q no final,
marca(p, q):= true;
para cada par (p, q) no marcado,
se existe um smbolo a tal que o par ((p,a), (q,a)) est marcado,
execute mark(p, q)
seno, para cada smbolo a faa
p' := (p, a);
q' := (q, a);
se p' q' e (p, q) (p', q'),
acrescente (p, q) lista de (p', q').
O teste da penltima linha no realmente necessrio, e pode ser considerado

como uma otimizao.
Dado M = (K, , , i, F), usamos como estados as classes de equivalncia de ,

obtidas para M para a construo do afd mnimo M' = (K', , ', i', F'). Temos:
K' = K/ = { [q] | q K }
': K' K', dada por '([q], a) = [(q, a)]
i' = [ i ]
F' = { [ f ] | f F }
Deixamos como exerccio demonstrar a consistncia da definio de ', isto , a
demonstrao de que o resultado da aplicao de ' independe da escolha do
representante q da classe de equivalncia [q].
Exemplo 5: Seja M um afd com estados A, B, C, D, E e F, sendo A o estado inicial; C e

F so os estados finais. Os smbolos de entrada so a e b, e como na tabela abaixo. M
aceita as cadeias que tem um nmero de a's da forma 6n+2 ou 6n+5. Na realidade,
bastaria exigir que o nmero de a's fosse da forma 3n+2, o que corresponde a um afd
com apenas 3 estados, e, por essa razo, M no mnimo, e deve ter estados
equivalentes.
A tabela de transio de M
a b
A B A
B C B
C D C
D E D
E F E
F A F
Os pares de estados (representados em ordem alfabtica sem os parenteses) a

serem considerados so AB, AC, AD, AE, AF, BC, BD, BE, BF, CD, CE, CF, DE, DF,

e EF. No h necessidade de incluir pares como AA por causa da reflexividade, nem
pares como BA por causa da simetria: basta incluir AB.
Vamos aplicar o algoritmo acima para determinar os pares de estados

equivalentes.
(marcao dos pares final / no final)

marcamos AC, AF, BC, BF, CD, CE, DF e EF.
(exame de cada par no marcado)
AB: Temos (A, a)=B, (B, a)=C, e BC est marcado. Logo, marcamos AB.
AD: Temos (A, a)=B, (D, a)=E, e (A, b)=A, (D, b)=D. Como BE no est
marcado, inclumos AD na lista de BE. (Note que no h necessidade de
incluir AD na lista de AD.)
AE: Temos (A, a)=B, (E, a)=F, e BF est marcado. Logo, marcamos AE.
BD: Temos (B, a)=C, (D, a)=E e CE est marcado. Logo, marcamos BD.
BE: Temos (B, a)=C, (E, a)=F, e (B, b)=B, (E, b)=E. Como CF no est
marcado, inclumos BE na lista de CF.
CF: Temos (C, a)=D, (F, a)=A, e (C, b)=C, (F, b)=F. Como AD no est
marcado, inclumos CF na lista de AD.
DE: Temos (D, a)=E, (E, a)=F e EF est marcado. Logo, marcamos DE.
(os pares restantes so equivalentes)
Os pares marcados aparecem na tabela abaixo:

A
B X
C X X
D X X
E X X X
F X X X X
A B C D E F
Os pares restantes (no marcados) so AD, BE, CF. Logo, A D, B E e C F.
Naturalmente, alm disso, A A, D A, etc. Note que as cadeias que distinguem os
pares de estados no equivalentes podem ser deduzidas da ordem de marcao: para os
pares final/no final, a cadeia . Para os demais pares, neste exemplo, a cadeia a. Por
exemplo, marcamos AB porque BC estava marcado, e porque de A e B passamos com o
smbolo a para B e C. A cadeia correspondente a AB portanto a = a.
Podemos agora construir o afd mnimo: o conjunto de estados o das classes de

equivalncia. Como previsto, tem apenas 3 estados. Temos:
K' = { [A], [B], [C], [D], [E], [F] } = { {A, D}, {B, E}, {C, F} }
i' = [A] = {A, D}
F' = { [C], [F] }= {C, F}
Para calcular as transies, escolhemos representantes das classes. Por exemplo, como
[A] = [D] = {A, D}, '( {A, D}, a) pode ser calculada como '( [A], a ) = [(A, a)] = [B]
= {B, E} ou como '( [D], a ) = [(D, a)] = [E] = {B, E}. Qualquer que seja o
representante escolhido, o resultado ser o mesmo, porque, como vimos na propriedade
1, "a equivalncia se propaga para a frente".
A funo de transio pode ser vista na tabela abaixo:

' a b
{A, D} {B, E} {A, D}
{B, E} {C, F} {B, E}
{C, F} {A, D} {C, F}
Um resultado interessante, cuja demonstrao pode ser encontrada na referncia

citada, o de que o afd mnimo que aceita uma dada linguagem nico, exceto por
isomorfismo. Neste contexto, isomorfismo quer dizer simplesmente re-nomeao de
estados: dados dois afd's M1 e M2 que aceitam a mesma linguagem L, se construirmos os
afd's mnimos associados ao dois afd's, encontraremos dois afd's M1' e M2' que so, na
prtica, idnticos: M1' e M2' s se distinguem pelos nomes de seus estados. Ou seja, a
linguagem L que define o afd mnimo que a aceita, e o resultado sempre o mesmo,
independente do afd aceitador de L do qual partimos.
Isso pode ser usado para resolver dois problemas interessantes. Primeiro, se
quisermos determinar se dois afd's M1 e M2 so equivalentes, basta construir os afd's M1'
e M2' mnimos correspondentes. Se M1' e M2' forem isomorfos, M1 e M2 so
equivalentes. Segundo, se quisermos mostrar que um afd M dado mnimo, basta aplicar
a M o processo de minimizao, e verificar que o resultado M' isomorfo de M. Isto
feito no Exemplo 6, onde, adicionalmente, para cada par de estados (p, q) distintos de
M, deduzimos exemplos de cadeias que os distinguem.
Exemplo 6: Vamos verificar que um afd mnimo, aplicando a ele o processo de

minimizao, e mostrando que o resultado final isomorfo do afd inicial. Seja M o afd
com estados A, B, C, D, E e F, sendo A o estado inicial; e F o nico estado final. Os
smbolos de entrada so a e b. A tabela de transio de M
a b
A B A
B C B
C D C
D E D
E F E
F A F
Aplicando o processo de minimizao, temos:

(marcao dos pares final / no final)
marcamos AF, BF, CF, DF, EF.
(exame de cada par no marcado)
AB: inclumos AB na lista de BC;
AC: inclumos AC na lista de BD;
AD: inclumos AD na lista de BE;
AE: como BF est marcado, marcamos AE;
BC: inclumos BC na lista de CD;
BD: inclumos BD na lista de CE
BE: como CF est marcado, marcamos BE; portanto, marcamos AD
(da lista de BE);
CD: inclumos CD na lista de DE;
CE: como DF est marcado, marcamos CE; portanto, marcamos BD
(da lista de CE) e AC (da lista de BD);
DE: como EF est marcado, marcamos DE; portanto, marcamos CD
(da lista de DE), BC (da lista de CD) e AB (da lista de BC).
Os pares marcados aparecem na tabela abaixo:
A
B X
C X X
D X X X
E X X X X
F X X X X X
A B C D E F
(os pares restantes so equivalentes)
No h pares de estados distintos restantes. Ou seja, cada estado equivalente

apenas a ele mesmo. O afd mnimo idntico a M, apenas tem estados {A}, {B}, {C},
{D}, {E}, {F}. As cadeias d(XY) que distinguem os pares de estados XY so:
d(AF) = d(BF) = d(CF) = d(DF) = d(EF) = .
d(AE) = a d(BF) = a = a
d(BE) = a d(CF) = a = a
d(AD) = a d(BE) = a a = aa
d(CE) = a d(DF) = a = a
d(BD) = a d(CEF) = a a = aa
d(AC) = a d(BD) = a aa = aaa
d(DE) = a d(EF) = a = a
d(CD) = a d(DE) = a a = aa
d(BC) = a d(CD) = a aa = aaa
d(AB) = a d(BC) = a aaa = aaaa
Naturalmente, as cadeias d(XY) podem tambm ser obtidas por inspeo, sem executar o
algoritmo.
Exerccio 8: Construa um afd mnimo que aceite a linguagem L no alfabeto = {a, b},
com L ={ cdxcd | c, d , x * }
Exerccio 9: Construa um afd mnimo que aceite o complemento da linguagem L do

Exerccio 8.

4.6 - Equivalncia entre autmatos finitos e gramticas regulares
Um dos resultados que devemos estabelecer neste captulo que a classe de
linguagens reconhecidas por automatos finitos a classe das linguagens regulares. J
sabemos, da seo anterior, que a classe das linguagens aceitas por af determinsticos
exatamente a mesma classe das linguagens aceitas por af no determinsticos. Trata-se,
portanto de estabelecer dois resultados simples, expressos atravs dos Teoremas 4.6 e
4.7, a seguir.
Teorema 4.6: Toda linguagem regular aceita por um afnd.
Demonstrao: Seja L uma linguagem regular. Portanto, L = L(G), para alguma

gramtica regular G = ( N, , P, S ). Vamos construir um afnd M = ( K, , , i, F ) que
aceita a linguagem L(G). Temos: K = N U { f }, i = S, F = { f }. Ou seja, os estados de
M sero os no terminais de M, mais um estado f criado para ser o nico estado final. O
estado inicial o smbolo inicial de G. (Note que f deve ser um smbolo novo, para no
causar confuso.)
As transies de M so dadas pelas regras de G:
Inicialmente, faa (A, a)= , para todos os noterminais A e para todos os smbolos a,
e para a = . A seguir, para todas as regras de G,
se G tem uma regra A a B, acrescente uma transio de A para B com o
smbolo a, ou seja, acrescente B a (A, a).
se G tem uma regra A a, acrescente uma transio de A para f com o smbolo
a, ou seja, acrescente f a (A, a).
se G tem uma regra A , acrescente uma transio de A para f com , ou seja,
acrescente f a (A, ).
Devemos mostrar que, para qualquer x *, M aceita x sse x L(G). A demonstrao
se completa pela verificao de que a sequncia de configuraes (S, x) |* (f, ) em M
corresponde exatamente sequncia de passos da derivao S * x em G.
Exemplo 7: Seja a gramtica regular G, dada por suas regras:

SaA|bB
AaA|bA|a
BaB|bB|b
que gera a linguagem { c x c | c {a, b} e x {a, b}*}. O afnd descrito na prova do
teorema anterior M = ({ S, A, B, f }, { a, b }, , S, { f }), com dada pela tabela
abaixo.
a b
S {A} {B}
A { A, f } {A}
B {B} { B, f }
f

Seja a cadeia x=ababa. A cadeia x pertence linguagem, como se pode ver pela
derivao
S aA abA abaA ababA ababa.
A cadeia x tambm aceita por M, como se pode ver pela sequncia de configuraes
(S, ababa) | (A, baba) | (A, aba) | (A, ba) | (A, a) | (f, )
Note que os estados e os smbolos no terminais aparecem na mesma ordem, exceto por
f, que no aparece na derivao. Os smbolos terminais, entretanto, tem tratamento
diverso: so gerados na derivao, e aparecem desde sua introduo at a cadeia final, e
so consumidos nas transies do afnd, aparecendo desde a configurao inicial at o
momento de sua leitura.
Exemplo 8: Seja a gramtica regular G, dada por suas regras:

SaA|bA|
AaS|bS
Temos L(G) = { x {a, b}* | |x| par }. O afnd descrito na prova do teorema anterior
M = ({ S, A, f }, { a, b }, , S, { f }), com dada pela tabela abaixo.
a b
S {f} {A} {A}
A {S} {S}
f
Seja a cadeia x = abba, de comprimento par. Temos:
S aA abS abbA abbaS abba.
em G, e
(S, abba) | (A, bba) | (S, ba) | (A, a) | (S, ) | (f, )
em M.
Teorema 4.7: Se L aceita por um automato finito, ento L regular.
demonstrao: Podemos supor que L aceita por um afd M = (K, , , i, F). Vamos
construir uma gramtica regular G para L. A gramtica G = (K, , P, i) tem como
smbolos no terminais os estados de M, e como smbolo inicial o estado inicial i de M.
As regras de G so dadas pelas transies e pelos estados finais de M:
se p = (q, a) em M, G tem uma regra q ap em P.
se q final (q F), G tem uma regra q em P
A demonstrao semelhante a anterior: devemos mostrar que, para qualquer x *, M
aceita x sse x L(G).
Exemplo 9: Seja o afd M = ({q0, q1}, {a, b}, , q0, {q1}), com dada pela tabela
abaixo.
a b
q0 q1 q1
q1 q0 q0
M aceita as cadeias de {a, b}* que tem comprimento mpar.
A gramtica G correspondente, de acordo com o teroema acima,

q0 a q1 | b q1
q1 a q0 | b q0 |
Para a cadeia x= ababa, temos
e
q0 aq1 abq0 abaq1 ababq0 ababaq1 ababa
4.7 - Expresses regulares

Vamos agora definir expresso regular. A expresso regular a maneira mais
compacta e mais simples de descrever conjuntos regulares, e usada com essa finalidade
em construo de compiladores, editores, sistemas operacionais, protocolos, etc. A
definio abaixo uma definio recursiva, e ser usada como base para outras
definies, e para as demonstraes.
Definio. Definimos uma expresso regular (er) em um alfabeto atravs de ER1

ER6 abaixo:
ER1. uma er.
ER2. uma er.
ER3. para cada a , a uma er.
ER4. Se e so er's, ento ( ) uma er.
ER5. Se e so er's, ento ( ) uma er.
ER6. Se uma er, ento (*) uma er.
Naturalmente, uma er se e somente se isso pode ser provado a partir de ER1 ER6.
Usualmente, so omitidos os parenteses de er's, de acordo com a ordem de precedncia
*
e considerando os operadores como associativos esquerda. Alm disso, o smbolo

frequentemente omitido.
Exemplo 10: Seja = {a, b} e seja a expresso regular = (ab)* a b b, ou seja, com
todos os parnteses, = (((((ab)*)a)b)b). Mostramos que uma er, mostrando
sucessivamente que so er's as expresses a seguir:
1. a de ER3
2. b de ER3
3. (ab) de 1, 2 e ER4
4. (ab)* de 3 e ER6

5. (ab)*a de 4, 1 e ER5
6. (ab)*ab de 5, 2 e ER5
7. (ab)*abb de 6, 2 e ER5.
Definio. A linguagem L[] associada a uma er (ou denotada pela er) definida de
forma recursiva, seguindo a definio de er:
ER1. L[] = ;
ER2. L[] = {};
ER3. para cada a , L[a] = {a};
ER4. L[()] = L[] L[];
ER5. L[()] = L[] L[];
ER6. L[(*)] = (L[])*.
Exemplo 11: Seja = (ab)*abb, como acima. Podemos determinar a linguagem
L[] seguindo o mesmo caminho usado para provar que uma er.
1. L[a] = {a} de ER3
2. L[b] = {b} de ER3
3. L[ab] = L[a] L[b] = {a} {b} = {a, b} de 1, 2 e ER4
4. L[(ab)*] = (L[ab])* = {a, b}* de 3 e ER6
5. L[(ab)*a] = L[(ab)*] L[a] = {a, b}*{a} de 4, 1 e ER5
6. L[(ab)*ab] = L[(ab)*a] L[b] =
= {a, b}*{a}{b} = {a, b}*{ab} de 5, 2 e ER5
7. L[(ab)*abb] = L[(ab)*ab] L[b] =
= {a, b}*{ab}{b} = {a, b}*{abb} de 6, 2 e ER5
Assim, L[] a linguagem das cadeias que terminam em abb.
Uma outra forma de indicar as mesmas propriedades de pertinncia vistas acima,

mais adequada para provar a pertinncia em casos isolados :
ER1. No existe x tal que x L[].
ER2. Se x L[], ento x=
ER3. Se x L[a] (para a ), ento x=a.
ER4. Se x L[ ], ento ou x L[], ou x L[].
ER5. Se x L[ ], ento x=yz, com y L[] e z L[].
ER6. Se x L[*], ento ou x=, ou x=yz, com y L[] e z L[*].
Os casos 1..5 so autoexplicativos; para o caso 6, basta observar a propriedade
apresentada no Exerccio 10.
Exerccio 10: Mostrar que, para qualquer linguagem L , L* = {} (L L*).
Exemplo 12: Suponhamos que desejamos provar que x = abaabb L[], para a er
=(ab)*abb, usando as propriedades acima. Os passos intermedirios da prova esto
indicados abaixo:
1. a L[a]
2. a L[ab] de 1
3. b L[b]
4. b L[ab] de 3
5. L[(ab)*]
6. a L[(ab)*] de 2 e 5
7. ba L[(ab)*] de 4 e 6
8. aba L[(ab)*] de 2 e 7
9. abaa L[(ab)*a] de 8 e 1
10. abaab L[(ab)*ab] de 9 e 3
11. abaabb L[(ab)*abb] de 10 e 3
Note que cada ocorrncia de um smbolo (a ou b) em x fica associada a uma ocorrncia
do mesmo smbolo em . No fundo a construo da prova de que x L[] consiste
exatamente na descoberta de uma associao adequada. No exemplo acima, a nica
associao possvel est indicada abaixo, pela numerao das ocorrncias de smbolos, na
er e na cadeia considerada:
= (a1 b2 )* a3 b4 b5 , x = a1 b2 a1 a3 b4 b5
Em outros casos, podem ser possveis vrias associaes. Por exemplo, considere o
alfabeto = {a, b, c}, a er = (ab)* (bvc)* e a cadeia y = bb. Neste caso, temos
= (a1 b2)* (b3 c4)*
e podemos ter y = b2 b2, ou y =b2 b3, ou ainda, y =b3 b3 .
Definio. Dizemos que duas er's e so equivalentes se as linguagens a elas

associadas so iguais: L[] = L[]. A equivalncia indicada por .
Exerccio 11: Mostre que, dada uma er , sempre possvel construir uma er
equivalente a , de forma que ou = , ou no contm o smbolo .
Sugesto: considere as equivalncias

*
Exerccio 12: Mostre que, dada uma er , sempre possvel construir uma er
equivalente a , de forma que ou = , ou = , e no contm o smbolo .
Sugesto: considere as equivalncias

( )* *
( ) ( )
( ) ( )
Exerccio 13: Suponha a seguinte definio: uma er ambgua se para algum xL[],
existe mais de uma associao possvel entre as ocorrncias de smbolos em x e em .
Sejam as expresses
= (a b)* (b c)*
= (a b)* (aa bb) (a b)*

- Mostre que e so ambguas, de acordo com a definio dada.
- Construa er's equivalentes a e que no sejam ambguas.
Teorema 4.8: Toda linguagem denotada por uma expresso regular regular.
Demonstrao. Seja uma er qualquer. Vamos mostrar que L() regular construindo
um afnd M() que aceita L(), preparando para uma demonstrao por induo na
estrutura de .
Por simplicidade, vamos construir todos os afnd M() considerados nesta demonstrao
com exatamente um estado final, distinto do estado inicial. Para uma er no elementar,
o afnd M() ser construdo a partir dos afnd's das er's componentes. Para evitar a
necessidade de nomear cada estado de cada uma dessas mquinas, vamos indicar a forma
de composio graficamente. Por conveno, sempre representaremos o estado inicial
esquerda, e o estado final direita.
ER1. O afnd M() que aceita
ER2. O afnd M() que aceita L[]
ER3. O afnd M(a) que aceita L[a], a
ER4. Se e so er's, podemos supor (pela Hiptese de Induo) que j esto

construdos M() e M(). O afnd M( ) que aceita L[ ] obtido acrescentando
um estado inicial e um final novos a M() e M(). As novas transies so transies
com entrada do estado inicial novo para os antigos estados iniciais de M() e de M(),
e dos antigos estados finais de M() e de M() para o novo estado final. O resultado

ER5. Se e so er's, podemos supor (pela Hiptese de Induo) que j esto
construdos M() e M(). O afnd M( ) que aceita L[ ] obtido acrescentando
um estado inicial e um final novos a M() e M(). As novas transies so transies
com entrada do estado inicial novo para o antigo estado inicial de M(), do antigo
estado final de M() para o antigo estado inicial de M(), e do antigo estado final de
M() para o novo estado final. O resultado
ER6. Se uma er, podemos supor (pela Hiptese de Induo) que j est construdo
M(). O afnd M(*) que aceita * obtido acrescentando um estado inicial e um final
novos a M(). As novas transies so transies com entrada do estado inicial novo
para o antigo estado inicial de M() e para o novo estado final e do antigo estado final
de M() para o novo estado inicial.

O restante da demonstrao deixado como exerccio.
Exemplo 13: Seja a er = (a b)* a. Vamos construir um afnd que aceita L(),
seguindo a construo indicada na demonstrao acima. Os passos intermedirios e os
resultados esto indicados nas tabelas a seguir
M(a) a b
inicial: A {B}
final: B
M(b) a b
inicial: C {D}
final: D
M(a b) a b
inicial: E {A, C}
A {B}
B {F}
C {D}
D {F}
final: F

M((a b)*) a b
inicial: G {E, H}
E {A, C}
A {B}
B {F}
C {D}
D {F}
F {G}
final: H
M((a b)*a) a b
inicial: I {G}
G {E, H}
E {A, C}
A {B}
B {F}
C {D}
D {F}
F {G}
H {A'}
A' {B'}
B' {J}
final: J
Note que a sub-expresso a ocorre duas vezes em M(), e porisso foi necessrio incluir
duas vezes M(a); para a segunda vez renomeamos os estados, que passaram a ser A' e B'.
Exerccio 14: Construa um afd mnimo para a linguagem denotada pela er do Exemplo
13, a partir do afnd M() construdo no exemplo.
Exerccio 15: Construa afd's mnimos que aceitem as linguagens denotadas pelas
expresses regulares do Exerccio 13,
= (a b)* (b c)*
= (a b)* (aa bb) (a b)*
Teorema 4.9: Toda linguagem regular denotada por uma expresso regular.
Demonstrao: ver referncia citada.
A demonstrao do Teorema 4.9 constri a expresso regular que representa a

linguagem aceita por um afd examinando os caminhos entre o estado inicial e os estados
finais do afd. O operador usado para tratar caminhos alternativos, o operador para
tratar caminhos de comprimento maior que 1, e o operador * para tratar laos. Embora a
construo seja interessante, na prtica o uso normalmente feito de er's para

especificao de linguagens regulares, e muito mais frequente a construo de afd's a
partir de er's, do que a construo inversa.
4.8 - O Lema do Bombeamento para linguagens regulares

Como mencionado anteriormente, precisamos de um resultado que nos permita
demonstrar que algumas linguagens no so regulares. Este resultado o "Lema do
Bombeamento", ou "Pumping Lemma", que nos diz que qualquer cadeia suficientemente
longa z de uma linguagem regular pode ser decomposta em trs partes: z = uvw, de
maneira que podemos construir outras cadeias da linguagem pela repetio da parte
central v: todas as cadeias da forma u vi w so tambm da linguagem. Ou seja, podemos
acionar a bomba quantas vezes quisermos, para criar quantas sentenas novas da
linguagem desejarmos: uw, uvvw, uvvvw, ... .
Para mostrar que uma linguagem no regular, mostramos que no h como

decompor uma cadeia (qualquer, arbitrariamente longa) da linguagem de forma que seja
possvel bombear e continuar na linguagem.
Teorema 4.10: (Lema do Bombeamento) Seja L uma linguagem regular. Ento, existe
um natural n tal que qualquer cadeia z de L com comprimento maior ou igual a n pode
ser decomposta em trs cadeias u, v e w (z = uvw) de forma que
|uv| n
v
para qualquer i 0, u vi w L
Demonstrao: A demonstrao se baseia no fato de que para as cadeias longas z
necessrio usar pelo menos um loop de estados num afd que aceite a linguagem. Assim,
os smbolos de u so usados para chegarmos a um estado q do loop; os smbolos de v
so usados para dar a volta no loop, de volta ao estado q; os smbolos de w so usados
para ir de q at um estado final. Portanto, podemos dar quantas voltas no loop
quisermos, e repetir v um nmero qualquer i de vezes: u vi w.
As cadeias curtas (comprimento < n) devem ser excludas porque podem ser
aceitas sem passar por nenhum loop.
A demonstrao completa pode ser encontrada em [HopUll79].
Exemplo 14: Seja a linguagem regular L = L[] = L[], com = 1(01)* e = (10)*1.
Considere a cadeia z=10101, pertencente a L. Podemos decompor a cadeia, da forma
descrita no teorema acima, de diversas formas. Por exemplo:
u=1 v = 01 w = 01
u = 10 v = 10 w=1
u= v = 1010 w=1
Note que todas as cadeias das formas 1(01)i01, 10(10)i1, (1010)i1 pertencem a L.

Exerccio 16: (baseado no Exemplo 14)
Mostre que e so equivalentes.
Estime o valor de n (Teorema 4.10) para L.
Mostre todas as formas de decomposio de z que satisfazem o Teorema.
Exemplo 15: A linguagem L = { ai bi | i 0} no regular. (J vimos que L uma llc.)

Vamos mostrar aqui que L no regular. A demonstrao por contradio. Suponha
que L regular. Se L regular, o Teorema acima se aplica, e existe n tal que a
decomposio descrita pode ser realizada para qualquer cadeia de comprimento igual ou
maior que n.
Seja k=n+1. Considere a cadeia z=ak bk. Qualquer decomposio z=uvw deve ter em v o
mesmo nmero de a's e de b's, para que a propriedade de que o nmero de a's igual ao
de b's se mantenha nas cadeias u vi w. Se isso no acontecer, quando acrescentarmos
mais um v (aumentando i de 1), obteremos uma cadeia fora da linguagem. Portanto, v
deve ser da forma aj bj, com j>0, j que v no pode ser vazia. Mas nesse caso, u v2 w
conter a cadeia aj bj aj bj, com pelo menos um a depois de um b, o que no pode
acontecer na linguagem.
Ou seja, nenhuma decomposio possvel, contrariando o Teorema, e podemos

concluir que L no regular.
Exerccio 17: Mostre que a linguagem L = { x xR | x {0, 1}* } no regular.
4.9 - Propriedades de fechamento das linguagens regulares

Vamos ver agora algumas propriedades de fechamento da classe das linguagens
regulares. A maioria das provas pode ser feita usando mais de um dos formalismos
usados para definir linguagens regulares: gramticas regulares, afd's, afnd's e expresses
regulares veja o Exerccio 18.
Teorema 4.11: A classe das linguagens regulares no alfabeto fechada para as

operaes de (a) unio, (b) interseo, (c) complemento em relao a *, (d)
concatenao e (e) fechamento transitivo (estrela).
Demonstrao:
(a) Vamos mostrar que se L1 e L2 so linguagens regulares, ento L1L2 uma
linguagem regular. Sejam e er's tais que L()=L1 e L() = L2.
Portanto, L1 L2 = L( ) tambm regular.
(b) Vamos mostrar que se L1 e L2 so linguagens regulares, ento L1L2 uma
linguagem regular. Sejam M1 = (K1, , 1, i1, F1) e M2 = (K2, , 2, i2, F2), afd's tais
que L(M1)=L1 e L(M2) = L2.
Seja M = (K1 K2, , , (i1, i2), F1 F2), com definida por
( (q1, q2), a) = ( 1(q1, a), 2(q2, a) )
M aceita L1L2 , porque

( (i1, i2), x) |* ( (f1, f2), ) em M sse
( i1, x) |* ( f1, ) em M1
e ( i2, x) |* (f2, ) em M2,
e
(f1, f2) final em M sse
f1 final em M1
e f2 final em M2.
L aceita por M, e portanto, regular.
(c) Vamos mostrar que se L regular, o complemento L = * - L tambm regular.

Seja M =(K, , , i, F) um afd que aceita L. Ento M' = (K, , , i, K-F) aceita L.
Temos:
M' aceita x $ (i, x) K - F $ (i, x) F M no aceita x
x L x L.
(d) Vamos mostrar que, se L1 e L2 so regulares, L1 L2 regular. Sejam e er's tais
que L()=L1 e L() = L2. Portanto, L1 L2 = L( ) tambm regular.
(e) Vamos mostrar que se L regular, o fechamento L* tambm regular. Seja a uma er
tal que L() = L. Ento L(*)* = (L())* = L* tambm regular.
Exerccio 18: Considere o Teorema 4.11. Construa demonstraes alternativas para os

casos indicados:
(a) construindo uma gramtica regular para a unio de L1 e L2, a partir de
gramticas regulares de L1 e L2.
(b) usando (a), (c), e a propriedade de conjuntos (de Morgan) que diz que
X Y = X Y
(d) construindo uma gramtica regular para a concatenao de L1 e L2, a partir
de gramticas regulares de L1 e L2.
(e) construindo uma gramtica regular para o fechamento de L, a partir de uma
gramtica regular de L.
Exerccio 19: Mostre que, na construo usada na demonstrao do Teor. 4.11 parte
(c), no pode ser usado um afnd.
Sugesto: Considere o afnd
(reviso de 27fev97)

Linguagens Formais
Captulo 5: Linguagens e gramticas livres de contexto
Jos Lucas Rangel, maio 1999
5.1 - Introduo
Vimos no captulo 3 a definio de gramtica livre de contexto (glc) e de
linguagem livre de contexto (llc). As regras de uma glc so da forma A , onde
uma cadeia qualquer de terminais e noterminais, possivelmente vazia. Como vimos,
o que caracteriza a gramtica livre de contexto a propriedade de que o smbolo no
terminal A pode ser substitudo pela cadeia do lado direito da regra, onde quer que
A ocorra, independentemente do contexto, isto , do resto da cadeia que est sendo
derivada. Por essa razo, possvel representar derivaes em glc's atravs de rvores
de derivao: para usar a regra A , acrescentamos rvore, como filhos de A, ns
correspondentes aos smbolos de .
5.2 - rvores de derivao

Uma rvore de derivao uma rvore composta da seguinte maneira:
a raiz tem como rtulo o smbolo inicial S da gramtica.
a cada n rotulado por um noterminal A corresponde uma regra de A. Se a
regra for A X1X2 ... Xm, os filhos do n so rotulados, da esquerda para a
direita, por X1, X2, ..., Xm. (cada um dos Xi pode ser um terminal ou um
noterminal.)
um n rotulado por um terminal sempre uma folha da rvore, e no tem
filhos.
Os ns interiores da rvore so sempre (rotulados por) noterminais. Se a um n
rotulado pelo noterminal A for aplicada a regra A , considera-se o n como
interior, embora ele tenha zero filhos. Na representao grfica da rvore, costume
indicar, neste caso, os zero filhos atravs de um n , que no contribui para o
resultado da rvore.
Uma sub-rvore de uma rvore de derivao um n da rvore com todos seus
descendentes, as arestas que os conectam e seus rtulos. Uma sub-rvore sempre
corresponde a uma derivao parcial, a partir do smbolo que rotula a raiz da sub-
rvore. O resultado de uma rvore de derivao a cadeia formada pelos terminais
(que aparecem como folhas da rvore), lidos da esquerda para a direita. Note que a
ordenao dos filhos de cada n fundamental para que se possa definir a ordenao
das folhas da rvore.
Exemplo 5.1: Seja a gramtica G, dada por suas regras:
S AB
A aaA |
B Bbb |
A rvore de derivao para a sequncia aaaabb est representada na Fig. 1. O
resultado da rvore aaaabb, sendo as regras escolhidas de acordo com a derivao
S B aaAB aaaaAB aaaaB aaaaBbb aaaabb.
J. L. Rangel Linguagens Formais 5-1

S
A B
a a A B b b
a a A a

Fig. 1 - rvore de derivao de aaaabb
Teorema 5.1: Seja G = (N, , P, S) uma glc. Ento, para qualquer cadeia x *,
x L(G) se e somente se existe uma rvore de derivao A na gramtica G, cujo
resultado x.
Demonstrao: Basta observar a correspondncia entre a substituio de noterminais
pelos lados direitos de suas regras na derivao e a criao dos filhos correspondentes
na rvore. Usando essa correspondncia possvel construir uma rvore de derivao
cujo resultado x a partir de uma derivao S * x; possvel tambm construir uma
derivao S * x a partir de uma rvore de derivao cujo resultado x. Os detalhes
da demonstrao so deixados como exerccio.
Observao. A partir de uma derivao. s possvel construir uma rvore; entretanto,
na direo oposta, possvel construir vrias derivaes, dependendo da ordem em
que os ns so considerados. O Exemplo 5.2 mostra algumas das vrias derivaes
que correspondem mesma rvore.
Derivaes esquerdas e direitas.

Diz-se que uma derivao uma derivao esquerda (leftmost derivation) se a cada
passo da derivao o noterminal A escolhido para aplicao de uma regra A for
sempre aquele que fica mais esquerda. Simetricamente, fala-se em derivao direita
(rightmost derivation) se o noterminal escolhido sempre o que estiver mais
direita.
Exemplo 5.2: Seja a gramtica G0 abaixo, dada por suas regras. (Esta gramtica ser
usada em vrios exemplos, no que se segue.
E E + T | T
T T * F | F
F ( E ) | a
Considere a cadeia x = a*(a+a)+a. Temos abaixo trs derivaes de:
E E+T T+T T*F+T F*F+T a*F+T a*(E)+T
a*(E+T)+T a*(T+T)+T a*(F+T)+T a*(a+T)+T
a*(a+F)+T a*(a+a)+T a*(a+a)+F a*(a+a)+a
E E+T E+F E+a T+a T*F+a T*(E)+a
T*(E+T)+a T*(E+F)+a T*(E+a)+a T*(T+a)+a
T*(F+a)+a T*(a+a)+a F*(a+a)+a a*(a+a)+a
E E+T T+T T+F T*F+F T*F+a F*F+a
F*(E)+a a*(E)+a a*(E+T)+a a*(T+T)+a
a*(T+F)+a a*(F+F)+a a*(a+F)+a a*(a+a)+a

Note que a primeira derivao uma derivao esquerda, e a segunda uma
derivao direita. Todas as trs derivaes correspondem mesma rvore de
derivao, apresentada na Figura 2. Como se pode observar, em todas elas aparecem
as mesmas regras, aplicadas nos mesmos lugares, variando apenas a ordem em que as
regras so aplicadas.
E
E + T
T F
T * F a
F ( E )
a E + T
T F
F a
a
Fig. 2- rvore de derivao de a*(a+a)+a
Como todas as derivaes correspondentes mesma rvore de derivao
descrevem a mesma forma de construo da cadeia derivada - as mesmas regras
aplicadas nos mesmos lugares - consideramos que a forma de construo da cadeia
pode ser representada pela rvore ou por uma derivao esquerda, ou por uma
derivao direita. Entretanto, se existem duas ou mais rvores de derivao (duas ou
mais derivaes esquerdas, duas ou mais derivaes direitas), para a mesma cadeia,
consideramos que a gramtica no define de forma nica a maneira pela qual a cadeia
derivada, e dizemos que a gramtica ambgua.
Exemplo 5.3: Seja a gramtica G1, dada por suas regras:
E E + E | E * E | ( E ) | a
Pode-se verificar que G1 equivalente a G0, vista no exemplo 5.2 acima. Entretanto,
diferentemente de G0, G1 uma gramtica ambgua. Considere, por exemplo a cadeia
a+a*a. As duas derivaes (esquerdas) abaixo correspondem a duas rvores de
derivao distintas.
E E+E a+E a+E*E a+a*E a+a*a
E E*E E+E*E a+E*E a+a*E a+a*a
A construo das duas rvores fica como exerccio.
Uma linguagem livre de contexto cujas gramticas so todas ambguas
chamada uma gramtica inerentemente ambgua.
Exemplo 5.4: Sejam L1 = {ai bj ck| i=j } e L2 = {ai bj ck| j=k }. A linguagem L
definida por L = L1 L2 inerentemente ambgua. As linguagens L1 e L2 no so
inerentemente ambguas, como se pode ver pelas suas respectivas gramticas G1 e G2.

G1: S1 T C G2: S2 A V
T a T b | A a A |
C c C | V b V c |
fcil construir um exemplo G de gramtica ambgua para L, a partir de G1 e G2:
G: S S1 | S2
S1 T C S2 A V
T a T b | A a A |
C c C | V b V c |
Para verificar que G ambgua, basta observar que todas as cadeias pertencentes
interseo M = L1 L2 = {ai bj ck | i=j=k } podem ser derivadas de duas formas
distintas, dependendo da regra inicial escolhida para a derivao. Por exemplo,
aabbcc pode ser obtida por uma das duas derivaes esquerdas abaixo:
S S1 TC aTbC aaTbbC aabbC aabbcC
aabbccC aabbcc
S S2 AV aAV aaAV aaV aabVc aabbVcc
aabbcc
Naturalmente, isto prova apenas que G ambgua, e no que todas as gramticas de L
so ambguas. Esta demonstrao no ser includa aqui.
Observamos tambm que M no uma llc. Isto ser visto no Exemplo 5.7.
5.3 - Simplificao de gramticas livres de contexto

No existe a possibilidade de simplificao de gramticas livres de contexto,
no mesmo sentido da minimizao de automatos finitos vista anteriormente. ,
entretanto possvel fazer uma simplificao que elimina todos os smbolos e regras
inteis da gramtica. Podemos dizer que um smbolo terminal intil quando no
aparece em alguma cadeia da linguagem; podemos dizer que um smbolo no terminal
intil quando no aparece em alguma derivao de alguma cadeia da linguagem.
Uma regra intil contm algum smbolo intil.
Em alguns casos, a gramtica ambgua, e algumas regras podem ser
removidas sem que a linguagem se altere, mas pode no ficar claro qual regra deve ser
considerada intil. Por exemplo, se tivermos
1, 2. S A X | Y C
3. X B C
4. Y A B
h duas maneiras de gerar ABC a partir de S. Quais as regras que devem ser retiradas?
1 e 3 ou 2 e 4? Tanto faz.
Todas as simplificaes que podem ser feitas, entretanto, no alteram a
essncia de uma gramtica: apenas a tornam mais limpa. Algumas transformaes de
gramticas visam obter uma gramtica equivalente inicial que tem alguma forma
particular, por exemplo, que simplifique a demonstrao de algum teorema. Para ver
alguns algoritmos para simplificao ou transformao de gramticas sugerimos a
mesma referncia citada anteriormente.

O exemplo a seguir procura esclarecer alguns dos conceitos mencionados.
Exemplo 5.5: Uma gramtica com regras e smbolos inteis. Seja a gramtica
1, 2, 3: S A B | A C | B D
4, 5: A a A | a
6, 7: B b B | b
8, 9: C c D | d C
10, 11: Y y | z Z
12, 13: Z z | y Y
Smbolos no terminais acessveis:
Em derivaes a partir de S podem aparecer S A B C D (regras 1, 2, 3).
Smbolos no terminais produtivos:
Derivaes que levam a cadeias de terminais: A (regra 5), B (regra 7), Y (regra
10), Z (regra 11), S (regra 1, j que A e B so produtivos.)
Logo, todos os noterminais, exceto S A B so inteis. Retirando todas as regras que
fazem referncia a noterminais inteis, temos:
1: S A B
4, 5: A a A | a
6, 7: B b B | b
Os smbolos restantes podem ser considerados inteis: C D Y Z c d y z.
5.4 - O lema do bombeamento para linguagens livres de contexto.

Vamos examinar agora um resultado que nos permitir provar que algumas
linguagens no so livres de contexto. O resultado conhecido como Lema do
Bombeamento, ou Pumping Lemma, e semelhante ao resultado correspondente visto
para linguagens regulares.
Teorema 5.2: Lema do Bombeamento. Seja L uma llc. Ento, existe um nmero n,
que s depende de L, tal que qualquer cadeia z de L com comprimento maior ou igual
a n pode ser decomposta de maneira que z = uvwxy e
|vx| 1
|vwx| n
para todo i 0, uviwxiy pertence a L.
Demonstrao (simplificada). Se L uma llc, existe uma glc G tal que L(G)=L. Se z
tem um comprimento suficientemente longo, no ser possvel gerar z sem que na
derivao de z ocorra um no terminal A repetido, de forma que a partir de A
derivada uma cadeia que contm outra ocorrncia de A. Para que isto ocorra, as duas
ocorrncias de A devem estar num mesmo caminho da raiz da rvore de derivao at
as folhas. (Cadeias mais curtas podem ser geradas sem que essa repetio acontea.)
Atravs (possivelmente) de uma rearrumao dos passos da derivao, temos
S * uAy * uvAxy * uvwxy
ou seja,

S * uAy,
A * vAx,
A * w
Portanto, podemos derivar
i=0: uwy S * uAy * uwy
i=1: uvwxy S * uAy * uvAxy * uvAxy * uvwxy
i=2: uvvwxxy S * uAy * uvAxy * uvvAxxy * uvvwxxy
i=3: uvvvwxxxy S * uAy * uvAxy * uvvAxxy
* uvvvAxxxy* uvvvwxxxy

Uma demonstrao completa do Lema do Bombeamento pode ser encontrada na

referncia citada.
Observao. A recproca do Lema do Bombeamento no verdadeira, isto , existem
linguagens que no so livres de contexto, mas que tem a propriedade da
decomposio.
Exemplo 5.6: Considere a gramtica G0, a cadeia z = a*(a+a)+a, e a rvore de
derivao correspondente a z (Exemplo 5.2), reproduzida na Figura 3. Podemos ver
que existem vrios casos de repetio de noterminais da forma indicada no teorema
acima. Por exemplo, vamos considerar as duas ocorrncias de T indicadas pelas setas:
E
E + T
T F
T * F a
F ( E )
a E + T
T F
F a
a
Fig. 3- rvore de derivao de a*(a+a)+a
Temos: E * T+a, T * a*(T+a), T * a. Ou seja, u = , v = a*(, w = a, x =
+a), y=+a. Ou seja, as seguintes cadeias devem ser da linguagem:

i=0: uwy a +a
i=1: uvwxy a*( a +a) +a
i=2: uv2wx2y a*( a*( a +a) +a) +a
i=3: uv3wx3y a*( a*( a*( a +a) +a) +a)+a

Exerccio 5.2: (Ver Exemplo 5.3)

1. Construa rvores de derivao para as cadeias uviwxiy, para i=0, 1, 2, 3,
observando que essas rvores so construdas de pedaos da rvore de derivao
de x. (Nem todos esses pedaos so sub-rvores.)
2. Verifique todas as combinaes de noterminais repetidos que satisfazem as
condies do teorema, e quais as decomposies possveis para a cadeia z.
3. Estime o valor de n para a linguagem considerada.
Exerccio 5.3: Considere a llc
L={ x xR | x {a, b}* } { aaaab }
e a cadeia z = aabaabaa. Estime n para essa linguagem. Determine todas as
decomposies possveis de z, de acordo com o teorema.
Exemplo 5.7: Vamos agora mostrar que L = { ambmcm | n0 } no livre de contexto,
usando o teorema acima. A demonstrao por contradio: suporemos que L livre
de contexto, e deduziremos um absurdo.
Se L llc, L satisfaz o teorema acima para algum n. Suponha que a cadeia z=akbkck
suficientemente longa: | z | n. Ento z pode ser decomposta, z = uvwxy, de forma
que para qualquer i, zi = uviwxiy pertence a L. A contradio est em que qualquer
decomposio, existem cadeias zi que no pertencem a L: ou tem o nmero errado de
a's, b's, e c's, ou aparecem smbolos fora da ordem a - b - c: as combinaes ba,
cb e ca no podem ocorrer em L.
Para eliminar todas as decomposies:
se v e x no tem o mesmo nmero de a's, b's e c's, algum zi ter nmeros
diferentes dos trs smbolos;
se v e x tem o mesmo nmero de a's, b's e c's, devemos ter v = aj e x = bjcj, ou v
= ajbj e x=cj . No primeiro caso, z2 contm x2 = bjcjbjcj, que contm a
combinao cb, que no ocorre em L; no segundo caso, de forma semelhante,
ocorre a combinao ba.
Logo, L no uma llc.
Exerccio 5.4: Mostre que a linguagem { x x | x {a, b}* } no uma llc.
Nota: a primeira verso deste captulo contou com a colaborao de Luiz Carlos Castro Guedes
(maio 1999)

Captulo 6:
Linguagens livres de contexto e autmatos de pilha

Jos Lucas Rangel, maio 1999
6.1 - Introduo.
Os aceitadores, ou reconhecedores, das linguagens livres de contexto so os
chamados autmatos de pilha ou ap's. Usaremos aqui o modelo mais geral de ap, o ap
no determinstico, ou apnd, que consiste basicamente de um autmato finito no
determinstico, com uma memria adicional, em forma de pilha. Numa pilha,
smbolos novos s podem ser acrescentados no topo da pilha; apenas o ltimo
smbolo armazenado, o smbolo que se encontra no topo da pilha pode ser consultado;
esse smbolo deve ser retirado para que os demais possam ser alcanados.
Neste captulo vamos provar que a classe de linguagens reconhecidas pelos
apnd's exatamente a classe das llc.
6.2 - Autmatos de pilha no determinsticos

Definio. Definimos um autmato de pilha no determinstico (apnd) como uma
construo (tupla) A = < K, , , , i, I, F >, formada pelos seguintes elementos:
K - conjunto (finito) de estados
- alfabeto de entrada
- alfabeto da pilha
- funo de transio
: K ( {}) P(K *)
i - estado inicial
iK
I - smbolo inicial da pilha
I
F - conjunto de estados finais
FK
O alfabeto contm os smbolos que podem ser armazenados na pilha, ou
seja, empilhados. Para simplificar a especificao da funo de transio ,
consideramos que a cada passo, um smbolo lido (e retirado) do topo da pilha, e, no
mesmo passo, uma seqncia de comprimento qualquer pode ser empilhada. Assim,
se queremos retirar um smbolo do topo da pilha, basta que a sequncia a ser
empilhada seja a seqncia vazia . Por outro lado, se quisermos manter o smbolo do
topo da pilha, ele deve ser re-empilhado.
Escolher de forma no determinstica, uma opo (p, ) (q, a, Z) quer dizer
que a partir do estado q, lendo a da entrada, e lendo Z do topo da pilha, uma transio
Linguagens Formais, J. L. Rangel, 6-1

possvel para A ter como prximo estado p, e a seqncia ser empilhada, depois
da remoo de Z da pilha.
Da mesma forma que num autmato finito no determinstico (afnd), temos a
possibilidade de executar uma transio sem avanar na leitura dos smbolos da
entrada, e essa ao representada pela leitura da cadeia vazia . Por essa razo, o
segundo argumento de pode ser , alm de poder ser um smbolo de .
Usamos P(K *) para representar o conjunto potncia de K *, ou seja o
conjunto de todos os subconjuntos de K *. Como se trata aqui de um conjunto
infinito, necessrio especificar que, em qualquer caso, (q, a, Z) ser sempre um
conjunto finito, de forma a manter finita a descrio do apnd A.
Para descrever os passos de uma computao realizada por um apnd,
utilizamos configuraes [q, y, ] K * *. Os trs elementos de uma
configurao so o estado corrente q K, a parte da entrada ainda a ser lida, y *,
e o contedo * da pilha. Por conveno, o topo da pilha fica esquerda, isto , o
primeiro smbolo de considerado como sendo o smbolo do topo da pilha. A
configurao inicial correspondente entrada x [i, x, I].
Vamos definir a relao mudana de configurao, representada por | ou
por |A, se quisermos explicitar o apnd A considerado. Para isso utilizamos a funo
de transio . Suponha uma configurao [q, ax, Z], com (p, ) (q, a, Z).
Escolhida esta opo, o prximo estado ser p, e a cadeia deve ser empilhada, aps
a leitura de Z. Assim, podemos passar da configurao [q, ax, Z]para a configurao
[p, x, ], em que o estado passou a ser p, o "smbolo" a da entrada e o smbolo Z da
pilha foram lidos, e a seqncia foi empilhada. Ou seja,
se (p, ) (q, a, Z)
ento [q, ax, Z] | [p, x, ]
Temos duas situaes em que se pode dizer que um apnd aceita sua entrada,
que correspondem a duas definies independentes do que se entende por linguagem
reconhecida por um apnd. A primeira semelhante usada nos afnd: o apnd aceita se,
aps ler sua entrada, o estado um estado final; a segunda mais caracterstica dos
apnd: o apnd aceita se, aps ler sua entrada, a pilha est vazia. Assim, podemos
definir a linguagem de um apnd A (a linguagem aceita, ou reconhecida por A) de duas
maneiras diferentes:
aceitao por estado final:
Lef (A) = { x * | [i, x, I] |* [f, , ], com fF e * qualquer }
aceitao por pilha vazia:
Lpv (A) = { x * | [i, x, I] |* [f, , ], com qK qualquer }
So, portanto, duas as definies de configurao final:
[q, , ] uma configurao final para aceitao por estado final se q F;
[q, , ] uma configurao final para aceitao por pilha vazia, se = .
No primeiro caso, o contedo da pilha irrelevante; no segundo caso, o
estado q irrelevante. Note-se que o conjunto de estados finais F de um apnd A no
utilizado na definio da linguagem que A aceita por pilha vazia. Por essa razo
costuma-se, neste caso, fazer F = , sem perda de generalidade.
Um ponto importante a observar que, no caso geral, as linguagens Lef(A) e
Lpv(A) podem ser distintas.
Exemplo 6.1: Seja o apnd A = < K, , , , i, I, F >, com
K = {0, 1, 2} i = 0
= {a, b} I=X
= {X, A} F = {2}
A funo :{0,1,2}{a,b,}{X,A} P({0,1,2}{X,A}*) dada por
(0, a, X) = {(0, AX)} (1, b, A) = {(1, )}
(0, a, A) = {(0, AA)} (1, , X) = {(2, X)}
(0, b, A) = {(1, )}
Convencionamos, neste exemplo, e nos seguintes, que o valor da funo , para as
combinaes de valores no especificadas, sempre o conjunto vazio . No caso
presente, portanto,
(0, b, X) = (0, , X) = (0, , A) = (1, a, X) = (1, a, A) = (1, b, X)
= (1, , A) = (2, a, X) = (2, a, A) = (2, b, X) = (2, b, A)
= (2, , X) = (2, , A) = .
Suponhamos agora que a entrada do apnd A x=aaabbb. A configurao inicial
correspondente [0, aaabbb, X]. A partir dessa configurao, os seguintes passos so
possveis:
[0, aaabbb, X] | [0, aabbb, AX] | [0, abbb, AAX] | [0, bbb, AAAX]
| [1, bb, AAX] | [1, b, AX] | [1, , X] | [2, , X]
A ltima configurao indica que o estado final 2 foi atingido e que toda a entrada foi
lida. Podemos assim dizer que aaabbb Lef(A).
Se examinarmos o funcionamento de A para a entrada acima, e, atravs da funo o
funcionamento para as demais sequncias em {a, b}*, podemos verificar:
o primeiro smbolo deve ser um a
o nmero de a's deve ser igual ao de b's.
aps o primeiro b, nenhum outro a pode ser aceito.
aps o ltimo b, uma transio- leva A para uma configurao em que o
estado 2, e nenhuma transio adicional possvel.
Portanto, Lef (A) = { aj bj | j1 }. Por outro lado, nenhuma das transies prev a
retirada de X do fundo da pilha, de forma que Lpv(A)=.

Exemplo 6.2: Seja o apnd A = < K, , , , i, I, F >, com
K = {0, 1} i=0
= {a, b} I=X
= {X, A} F=
sendo a funo :{0,1}{a,b,}{X,A} P({0,1}{X,A}*) dada por:
(0, a, X) = {(0, A)} (0, b, A) = {(1, )}
(0, a, A) = {(0, AA)} (1, b, A) = {(1, )}
Com entrada aaabbb, os seguintes so passos possveis:
[0, aaabbb, X] | [0, aabbb, A] | [0, abbb, AA] | [0, bbb, AAA]
| [1, bb, AA] | [1, b, A] | [1, , ]
Como toda a entrada foi lida e a pilha est vazia, temos aaabbb Lpv (A).
Examinando o funcionamento de A, podemos verificar que Lpv(A) = { aj bj | j1 }, ou
seja, que a linguagem aceita por pilha vazia por este autmato de pilha idntica
linguagem aceita por estado final pelo autmato do exemplo anterior. Por outro lado,
F= faz com que Lef(A)=.
Exerccio 6.1: Construa um autmato de pilha A que aceita a linguagem dos dois
exemplos anteriores, simultaneamente, por pilha vazia e por estado final, ou seja,
construa um apnd A tal que Lef(A) = Lpv(A) = { ai bi | i 1 }
Exemplo 6.3: Seja a glc G0 = <N, , P, S>, com N = <{E, T, F},
= {+, *, (, ), a}, P, E>, S=E e P composto pelas regras:
EE+T|T
TT*F|F
F(E)|a
O apnd A, a seguir, aceita L(G0), por pilha vazia:
A = < {q}, , N, , q, E, >,
sendo dada por:
(q, , E) = {(q, E+T), (q, T)}
(q, , T) = {(q, T*F), (q, F)}
(q, , F) = {(q, (E)), (q, a)}
(q, +, +) = (q, *, *) = (q, (, ( ) = (q, ), ) ) = (q, a, a) = {(q, )}
De acordo com a especificao da funo acima, vemos que h dois tipos de
transies possveis neste apnd, conforme o smbolo de N que aparece no topo da
pilha:

se o smbolo do topo da pilha um noterminal de G0, nenhum smbolo da entrada
lido, e h uma possibilidade para cada regra do noterminal.
O apnd A depende do no-determinismo para escolher entre as diversas
possibilidades aquela que corresponde regra de G0 usada no passo
correspondente numa derivao esquerda da entrada x.
se o smbolo do topo da pilha um terminal de G0, e o mesmo smbolo lido da
entrada.
Esta transio s pode ser feita se a escolha (no-determinstica) das transies do
primeiro tipo foi feita de forma correta para a entrada.
Por exemplo, para a entrada (a+a)*a, temos a derivao esquerda
E T T*F F*F (E)*F (E+T)*F (T+T)*F (F+T)*F
(a+T)*F (a+F)*F (a+a)*F (a+a)*a
A mesma seqncia de regras usada, e passos dos dois tipos so intercalados, de
acordo com a natureza do smbolo que aparece no topo da pilha:
[q, (a+a)*a, E] | [q, (a+a)*a, T] | [q, (a+a)*a, T*F] | [q, (a+a)*a, F*F]
| [q, (a+a)*a, (E)*F] | [q, a+a)*a, E)*F] | [q, a+a)*a, E+T)*F]
| [q, a+a)*a, T+T)*F] | [q, a+a)*a, F+T)*F]
| [q, a+a)*a, a+T)*F] | [q, +a)*a, +T)*F] | [q, a)*a, T)*F]
| [q, a)*a, F)*F] | [q, a)*a, a)*F] | [q, )*a, )*F] | [q, *a, *F]
| [q, a, F] | [q, a, a] | [q, , ]
(Usamos aqui colchetes para representar as configuraes, para evitar confuso com
os parnteses de .)
Veremos posteriormente que possvel construir, para qualquer glc G, de
forma semelhante utilizada neste ltimo exemplo, um apnd que aceita L(G) por
pilha vazia.
6.3 - Equivalncia das duas formas de aceitao

Mostraremos agora que as duas formas de aceitao so equivalentes, no
sentido de que definem a mesma classe de linguagens. Naturalmente, isto no quer
dizer que para o mesmo apnd A as linguagens Lef(A) e Lpv(A) so iguais. A idia aqui
que se L = Lef(A), ento existe um apnd B (possivelmente diferente de A) tal que
Lpv(B) = L, e vice-versa.
Teorema 6.1: Para qualquer apnd A, existe um apnd B tal que B aceita por estado
final a mesma linguagem que A aceita por pilha vazia.
Dem.: Seja o apnd A = <K, , , , i, I, F >.
Defina B = < K {i', f'}, , {I'}, ', i', I', {f'} >, com ' dada por
'(i', , I') = {(i, I I')}
para qK, a{}, Z, '(q, a, Z) = (q, a, Z)
para qK, '(q, , I') = {(f', )}
A idia fundamental da construo de B que, com entrada x,
B passa de sua configurao inicial [i', x, I'] para a configurao [i, x, I I'], idntica
configurao inicial de A, exceto pelo smbolo I' acrescentado no fundo da
pilha;
B simula todas as transies de A (exceto pela presena de I' no fundo da pilha), e
quando A atinge uma configurao [q, , ], indicando a aceitao de x, B atinge a
configurao [q, , I'], com apenas o smbolo I' na pilha;
B passa ento dessa configurao para a configurao [f', , ], que indica a
aceitao da entrada x.
Esquematicamente, temos:
configuraes de A configuraes de B
[i', x, I']
[i, x, I] [i, x, I I']
.... ....
[q, ?, ?] [q, ?, I']
[f', ?, ?]
Portanto, se A aceita x por pilha vazia, B aceita x por estado final. Para a
recproca, observamos que A pode esvaziar a pilha sem completar a leitura de sua
entrada x, atingindo uma configurao [q, y, ], com y, que no uma configurao
final. Simulando A, B pode atingir configuraes [q, y, I'] e [f', y, I'], mas esta ltima,
apesar do estado final, no uma configurao de aceitao, pela mesma razo
anterior.
Teorema 6.2: Para qualquer apnd A, existe um apnd B tal que B aceita por pilha vazia
a mesma linguagem que A aceita por estado final.
Dem.: Seja A = < K, , , , i, I, F >.
Defina B = < K {i', d'}, , {I'}, ', i', I', >, com ' dada por
'(i', , I') = {(i, I I')}
para qK, a {}, Z, '(q, a, Z) = (q, a, Z)
para fF, Z{I'}, '(f, , Z) = {(d', Z)}
para Z{I'}, '(d', , Z) = {(d', )}
A idia fundamental da construo de B que, com entrada x,
B passa de sua configurao inicial [i', x, I'] para a configurao [i, x, I I'], idntica
configurao inicial de A, exceto pelo smbolo I' acrescentado no fundo da
pilha;
B simula todas as transies de A (exceto pela presena de I' no fundo da pilha), e
quando A atinge uma configurao [f, , ], indicando a aceitao de x, B atinge a
configurao [f, , I'], com o smbolo I' acrescentado no fundo da pilha;

B passa ento dessa configurao para a configurao [d', , I'], preparando-se
para esvaziar a pilha, para indicar a aceitao da entrada x.
A nica ao possvel no estado d' a remoo do smbolo do topo da pilha, de
forma que B atinge finalmente a configurao de aceitao [d', , ].
Esquematicamente, temos
configuraes de A configuraes de B
[i', x, I']
[i, x, I] [i, x, I I']
.... ....
[f, , ] [f, , I']
[d', , I']
.
[d', , I']
[d', , ]
Portanto, se A aceita x por estado final, B aceita x por pilha vazia. Para a recproca,
observamos que A pode esvaziar a pilha sem aceitar sua entrada x, atingindo uma
configurao [q, y, ], com qF, que no uma configurao final. Simulando A, B
pode atingir a configurao [q, y, I'], mas, como q no final, o estado d' no pode ser
atingido, e I' no pode ser removido da pilha.
6.4 - Equivalncia das classes de linguagens definidas por apnd's e

glc's
Esta seo mostra que os apnd's reconhecem exatamente as llc's, isto , as
linguagens definidas por glc's. Devido aos resultados da seo anterior, basta
considerar aqui uma forma de aceitao, no caso, a aceitao por pilha vazia. O
primeiro resultado corresponde ao Teorema abaixo.
Teorema 6.3: Seja L uma llc. Ento existe um apnd que aceita L por pilha vazia.
Dem.: Se L uma llc, ento existe uma glc G = < N, , P, S > tal que L=L(G). A
demonstrao feita atravs da construo de um apnd A que aceita L por pilha vazia
a partir da gramtica G, de forma semelhante utilizada em um dos exemplos vistos
anteriormente.
O apnd em questo tem apenas um estado: A = < {q}, , N, , q, S >, com como
se segue:
para cada noterminal A, se as regras de A so A1, A2, An, temos
(q, , A) = { (q, 1), (q, 2), (q, n) }.
para cada terminal a, temos (q, a, a) = { (q, ) }.
A prova de que Lpv(A) = L(G) se baseia na relao entre uma computao de A (uma
seqncia de configuraes sucessivas de A) que aceita uma cadeia x, e uma
derivao esquerda da mesma cadeia x. Deixamos como exerccio completar os
detalhes da demonstrao. O Exemplo 6.3 permite ver, para um caso particular, a
correspondncia entre os passos da derivao de uma cadeia x em G e as
configuraes assumidas por A at a aceitao de x.
O segundo resultado corresponde ao Teorema 6.4. A demonstrao encontrada
na referncia citada anteriormente difere ligeiramente da apresentada aqui.
Teorema 6.4: Se L uma linguagem aceita por pilha vazia por um apnd A, ento L
uma llc.
Dem.: o teorema decorre dos Lemas 1 e 2 a seguir.
Lema 1: Para cada apnd A, existe um apnd B satisfazendo as duas condies:
Lpv (B) = Lpv (A).
B s tem um estado.
Dem.: Seja A = < K, , , i, I, >. Vamos construir o apnd equivalente
B = <{ u }, , ', ', u, X, >, com ' = { X } (KK).
Como o estado do apnd B no contm nenhuma informao ( sempre u), durante a
simulao de A por B, a informao sobre o estado de A deve ser anotada na pilha de
B. primeira vista, bastaria anotar o estado s1 de A no topo da pilha de B, no
momento do empilhamento de um smbolo Z, juntamente com esse smbolo: [s1, Z].
Entretanto, neste caso, quando Z fosse desempilhado, toda a informao sobre o
estado de A se perderia. Por essa razo, vamos anotar tambm, com cada smbolo Z, o
estado s2, o estado assumido por A quando esta particular instncia de Z for
desempilhada. Note que se Z substitudo por outro smbolo Z', o mesmo estado s2
ser descoberto quando Z' for retirado.
Os smbolos do alfabeto ' so triplas [s1, Z, s2 ], com um smbolo Z de e dois
estados s1 e s2. O smbolo X de B ser usado apenas como smbolo inicial, e no
precisa ser tratado da mesma forma.
Assim, a cada smbolo Z so acrescidos dois estados s1 e s2: s1 ser o estado de
A quando esta ocorrncia de Z aparecer no topo; s2 ser o estado de A quando o
smbolo do topo passar a ser aquele imediatamente abaixo de Z. Para garantir a
correo da simulao de A, dois smbolos [s1, Z1, s2 ] e [s3, Z2, s4 ], que apaream em
posies consecutivas na pilha de B, devem sempre satisfazer a propriedade s2 = s3.
Assim, quando Z2 se tornar o estado do topo, o estado ser s2, aquele estado previsto
(de forma no deterministica) por ocasio do empilhamento de Z1.
Adicionalmente, se a pilha s contem um smbolo [s1, Z, s2 ], s2 ser o estado de A em
que a pilha ficar vazia. A definio da funo de transio ' de B garante estas
propriedades:
transio geral:
Se (q1, Z1Z2 Zn) (q, a, Z),
ento (u, [q1, Z1, q2][q2, Z2, q3] [qn, Zn, qn+1]) '(u, a, [q, Z, qn+1]),
para quaisquer valores de q2, , qn escolhidos em K.
caso particular n = 0:
Se (q1, ) (q, a, Z), ento (u, ) '(u, a, [q, Z, q1]).
incio da simulao:
para cada q K, (u, [i, I, q]) '(u, , X).
Note que B prepara a simulao, colocando na pilha de B um smbolo [i, I, q], com a
seguinte informao: o estado inicial i de A, o smbolo inicial I de A, e a indicao de
que eventualmente, quando a pilha se tornar vazia, o estado ser o estado q. O estado
q escolhido de forma no determinstica, razo pela qual todas as possibilidades
esto previstas no caso do incio da simulao.
O restante da demonstrao consiste em mostrar que a cada computao de A
corresponde uma computao de B, e vice versa, de forma que A e B aceitam a
mesma linguagem por pilha vazia. Novamente, os detalhes so deixados como
exerccio.
Exemplo 6.4: Seja o apnd A = < K, , , , i, I, >, com K={0,1}, ={a, b} e
={I, a, b}, sendo dada pela tabela a seguir. Cada linha descreve um elemento (p, )
de (q, a, Z). As linhas esto numeradas para referncia posterior.
q a Z p
1 0 a I 0 a
2 0 b I 0 b
3 0 a a 0 aa
4 0 a b 0 ab
5 0 b a 0 ba
6 0 b b 0 bb
7 0 I 1
8 0 a 1 a
9 0 b 1 b
10 1 a a 1
11 1 b b 1
O apnd A essencialmente no determinstico, e aceita por pilha vazia a

linguagem { xxR | x {a, b}* }. Lembramos que xR indica a cadeia reversa ou
refletida de x: se tivermos x = x1x2xn, ento xR = xnx2x1.
Vamos construir o apnd B que deve aceitar por pilha vazia a mesma
linguagem. Temos B = <{ u }, , ', ', u, X, >, onde
' = { X, [0, I, 0], [0, I, 1], [1, I, 0], [1, I, 1], [0, a, 0], [0, a, 1],
[1, a, 0], [1, a, 1], [0, b, 0], [0, b, 1], [1, b, 0], [1, b, 1] },
e ' descrita pela tabela a seguir:
q a Z p comentrios
u X u [0, I, 0] iniciao
u [0, I, 1]
u a [0, I, 0] u [0, a, 0] 1
u a [0, I, 1] u [0, a, 1]
u b [0, I,0] u [0, b, 0] 2
u b [0, I, 1] u [0, b, 1]
q a Z p comentrios
u a [0, a, 0] u [0, a, 0] [0, a, 0] 3
u [0, a, 1] [1, a, 0]
[0, a, 1] u [0, a, 0] [0, a, 1]
u [0, a, 1] [1, a, 1]
u a [0, b, 0] u [0, a, 0] [0, b, 0] 4
u [0, a, 1] [1, b, 0]
u a [0, b, 1] u [0, a, 0] [0, b, 1]
u [0, a, 1] [1, b, 1]
u b [0, a, 0] u [0, b, 0] [0, a, 0] 5
u [0, b, 1] [1, a, 0]
u b [0, a, 1] u [0, b, 0] [0, a, 1]
u [0, b, 1] [1, a, 1]
u b [0, b, 0] u [0, b, 0] [0, b, 0] 6
u [0, b, 1] [1, b, 0]
u b [0, b, 1] u [0, b, 0] [0, b, 1]
u [0, b, 1] [1, b, 1]
u [0, I, 1] u 7
u [0, a, 0] u [1, a, 0] 8
u [0, a, 1] u [1, a, 1]
u [0, b, 0] u [1, b, 0] 9
u [0, b, 1] u [1, b, 1]
u a [1, a, 1] u 10
u a [1, b, 1] u 11
A ltima coluna indica a associao das linhas da tabela de ' com as linhas da tabela
de .
Suponhamos agora que as mquinas A e B recebem como entrada x = aabaabaa.
Vamos mostrar as configuraes assumidas pelas duas mquinas, durante a anlise de
x.
A B
[u, aabaabaa, X]
[0, aabaabaa, I] [u, aabaabaa, [0, I, 1]]
[0, abaabaa, a] [u, abaabaa, [0, a, 1]]
[0, baabaa, aa] [u, baabaa, [0, a, 1][1, a, 1]]
[0, aabaa, baa] [u, aabaa, [0, b, 1][1, a, 1][1, a, 1]]
[0, abaa, abaa] [u, abaa, [0, a, 1][1, b, 1][1, a, 1][1, a, 1]]
[1, abaa, abaa] [u, abaa, [1, a, 1][1, b, 1][1, a, 1][1, a, 1]]
[1, baa, baa] [u, baa, [1, b, 1][1, a, 1][1, a, 1]]
[1, aa, aa] [u, aa, [1, a, 1][1, a, 1]]
[1, a, a] [u, a, [1, a, 1]]
[1, , ] [u, , ]
Como se pode ver, cada terceira componente de smbolo da pilha de B

corresponde exatamente ao estado de A, no momento em que o smbolo (ou aquele
que o substituiu) retirado da pilha.

Lema 2: Se o apnd A tem apenas um estado, Lpv (A) uma llc.
Dem.: Seja A = < { u }, , , , u, I, > um apnd com apenas um estado u.
Construmos uma glc G tal que L(G) = Lpv(A):
G = < N, , P, I >
sendo as seguintes as regras de P:
se (u, ) (u, a, Z), ento P tem uma regra Z a.
A demonstrao consiste na verificao de que a cada computao (sequncia de
configuraes) de A, corresponde uma derivao (esquerda) de G.
Exemplo 6.5: Considere o apnd B do Exemplo 6.4. A gramtica G pode ser construda
como se segue:
X [0, I, 0] | [0, I, 1]
[0, I, 0] a [0, a, 0]
[0, I, 1] a [0, a, 1]
[0, I, 0] b [0, b, 0]
[0, I, 1] b [0, b, 1]
[0, a, 0] a [0, a, 0] [0, a, 0] | a [0, a, 1] [1, a, 0]
[0, a, 1] a [0, a, 0] [0, a, 1] | a [0, a, 1] [1, a, 1]
[0, b, 0] a [0, a, 0] [0, b, 0] | a [0, a, 1] [1, b, 0]
[0, b, 1] a [0, a, 0] [0, b, 1] | a [0, a, 1] [1, b, 1]
[0, a, 0] b [0, b, 0] [0, a, 0] | b [0, b, 1] [1, a, 0]
[0, a, 1] b [0, b, 0] [0, a, 1] | b [0, b, 1] [1, a, 1]
[0, b, 0] b [0, b, 0] [0, b, 0] | b [0, b, 1] [1, b, 0]
[0, b, 1] b [0, b, 0] [0, b, 1] | b [0, b, 1] [1, b, 1]
[0, I, 1]
[0, a, 0] [1, a, 0]
[0, a, 1] [1, a, 1]
[0, b, 0] [1, b, 0]
[0, b, 1] [1, b, 1]
[1, a, 1] a
[1, b, 1] b
Assim, podemos derivar x=aabaabaa, pela derivao correspondente s
computaes de A e de B vistas no exemplo anterior:
X [0, I, 1] a [0, a, 1] a a [0, a, 1] [1, a, 1]
a a b [0, b, 1] [1, a, 1] [1, a, 1]
a a b a [0, a, 1] [1, b, 1] [1, a, 1] [1, a, 1]
a a b a [1, a, 1] [1, b, 1] [1, a, 1] [1, a, 1]
a a b a a [1, b, 1] [1, a, 1] [1, a, 1]
a a b a a b [1, a, 1] [1, a, 1]
a a b a a b a [1, a, 1]
aabaabaa
Exerccio 6.3: Verificar se a gramtica acima tem regras inteis, isto , regras que
nunca so usadas na derivao de alguma sentena da linguagem.
Um assunto que no ser discutido neste captulo a definio de um
autmato de pilha determinstico (apd), a partir do qual so definidas as linguagens
determinsticas. Esta classe um subconjunto prprio da classe das (de todas as) llc's.
A importncia das linguagens determinsticas, pode ser deduzida do fato de que todas
as linguagens de programao so tratadas como linguagens determinsticas pelos
compiladores.
(maio 99)

Linguagens Formais
Captulo 7: Mquinas de Turing

Jos Lucas Rangel
7.1 - Introduo
Neste captulo vamos estudar a mquina de Turing (mT), introduzida por Alan
Turing como um modelo matemtico do processo de computao. Sua estrutura
simples proposital, uma vez que Turing pretendia, com sua definio, chegar a um
modelo que fosse universalmente aceito. A mquina que vamos apresentar aqui
apenas uma das diversas variantes encontradas na literatura, escolhida por ser
suficientemente prxima de um sistema de computao real, e por no oferecer
maiores dificuldades de definio.
A mT o principal modelo usado para o estudo do que ou no computvel.
De acordo com a tese de Church, todos os modelos razoveis de procedimento so
equivalentes, e a mT se revelou simples e flexvel o suficiente para permitir todas as
demonstraes dos resultados principais. Pode-se usar uma mT como aceitador ou
reconhecedor, ou ainda como a implementao de um procedimento mais geral, que
transforma uma cadeia de entrada em uma cadeia de sada. Neste captulo vamos
definir a mT e apresent-la como o reconhecedor das linguagens tipo 0, e procurar
mostrar, atravs de exemplos, sua universalidade. Demonstrar a tese de Church,
naturalmente, est fora de cogitao, de maneira que a universalidade da mquina de
Turing s pode ser confirmada pelo fato de que todos os procedimentos encontrados
na prtica podem ser implementados atravs de mquinas de Turing.
7.2 - A mquina de Turing

Vamos definir a mquina de Turing com um controle finito, como todas as
mquinas at aqui, e uma fita, que pode servir como dispositivo de entrada
(inicialmente a cadeia de entrada est escrita na fita), como rea de trabalho
(memria, ou rascunho) , ou como dispositivo de sada (possveis resultados estaro
escritos na fita ao final da computao).
O modelo aqui apresentado tem uma fita semi-infinita: considera-se a fita
arbitrariamente extensvel apenas para o lado direito. Por conveno, a fita finita,
mas pode ser aumentada sempre que houver necessidade de mais espao, com mais
uma clula em branco. A justificativa para isso que o que computvel no pode
depender do tamanho do bloco usado como rascunho pelo matemtico: sempre deve
ser possvel arranjar outro bloco e continuar escrevendo. O novo bloco do matemtico
estar em branco, como sempre estar em branco a parte da fita em que ainda nada foi
escrito.
Por conveno, um trecho da fita em branco ser representado por um ou mais
smbolos branco. Alm disso, vamos convencionar um branco no pode ser escrito,
ou seja um trecho de fita em que ocorre o smbolo branco um trecho onde nada foi
escrito at agora. Assim, a qualquer momento, valem as seguintes propriedades:
apenas um nmero finito de posies da fita pode conter um smbolo distinto
de branco;
Linguagens Formais - J. L. Rangel 7-1
aps o primeiro branco da fita, todos os smbolos so brancos.
Isto acontece porque a mquina avana ou recua na fita uma clula de cada vez e, em
um nmero finito de passos, apenas um nmero finito de posies da fita pode ter sido
alcanado.
Alguns autores preferem falar de uma fita infinita, cujo contedo de
smbolos branco, exceto nas posies que j foram visitadas; outros preferem dizer
que a fita potencialmente infinita e que estendida a cada vez que se tenta andar
para a direita a partir da ltima posio. O fato importante a ser considerado que, a
qualquer momento, a quantidade de informao contida na fita finita, embora no
haja um limite para a quantidade de informao que nela pode ser armazenada.
Essa informao pode ser representada por uma cadeia de caracteres composta
pelos smbolos gravados na fita, da primeira posio at o primeiro branco
(exclusive). Note que, ao contrrio do que ocorre em gravadores de fita, consideramos
que a cabea de leitura/gravao que se move, e no a fita.
Outros caractersticas poderiam ser acrescentadas ao nosso modelo, tais como:
vrias fitas;
fitas extensveis para ambos os lados;
fitas com finalidade especfica, por exemplo fitas para entrada e fitas para
sada
a mquina pode ter mais de uma cabea de leitura por fita;
em vez de fita, a mquina pode usar como memria um reticulado bi-
dimensional;
a mquina pode ser no determinstica.
De acordo com a tese de Church, entretanto, detalhes como estes no devem
influenciar a capacidade de computao da mT. O modelo que vamos utilizar um
modelo determinstico bastante simples, prximo do mnimo necessrio para uma
mquina razovel, de acordo com a tese de Church. Discutiremos mais tarde a
equivalncia entre este modelo e suas variantes que possuem caractersticas como as
mencionadas.
Definio. Uma mquina de Turing M uma tupla M = < K, , , , i, F >, onde K
um conjunto (finito, no vazio) de estados, o alfabeto (finito) de smbolos da fita,
o alfabeto de smbolos de entrada, a funo de transio, i K o estado
inicial, e F K o conjunto de estados finais.
O smbolo branco ser representado aqui por . Este smbolo um smbolo de
que no pode ser escrito, nem pode fazer parte da entrada. Assim, temos - .
A funo de transio um mapeamento : K K {L, R}.
Quando tivermos (q, a) = (p, b, R), a mT M, quando est no estado q, e l o smbolo
a na fita, escreve o smbolo b na mesma posio em que a estava escrito, move-se
para a direita uma clula, e passa para o estado p. (Idem, para a esquerda no caso de
(q, a) = (p, b, L) ). Por simplicidade, podemos deixar alguns valores de indefinidos,
de maneira que deve ser entendida como uma funo parcial.
Atingida uma situao em que o estado q, o smbolo lido a, e (q, a)
indefinido, dizemos que a mquina pra. Poderamos, se desejado, definir mquinas
de Turing que sempre param quando atingem um estado final, e que nunca param em
um estado no final. Mas sempre que esta propriedade for desejada, podemos alterar
uma mT introduzindo um estado adicional, no final, do qual a mquina nunca mais
sai.
Configurao. Para representar uma configurao (ou s vezes uma descrio
instantnea) de uma mT usaremos uma cadeia xqy * K *, em que xy *
o contedo da fita, sem incluir nenhum dos brancos que existem direita, e q K o
estado corrente. Para que esta notao seja usada, necessrio que os smbolos de
sejam distintos dos smbolos usados para representar os estados de K, tornando
impossvel a confuso entre as partes constituintes da configurao, que so o estado
q e o contedo xy da fita.
Esta notao tem a vantagem de dispensar a necessidade de indicar
separadamente a posio da cabea da mquina, uma vez que o prprio estado usado
para indicar essa posio. Assim, em uma configurao xqy, a posio onde a leitura e
a escrita se realizam o primeiro smbolo de y. Se y a cadeia vazia, ou seja, se a
configurao da forma xq, a mquina l um branco, direita da parte escrita x da
fita.
Configuraes inicial e final. Para iniciar a computao, a configurao inicial para a
entrada x ix, composta pelo estado inicial i e pela cadeia de entrada x. O smbolo
lido na configurao inicial o primeiro smbolo de x, exceto no caso x=, em que o
smbolo lido um branco. Uma configurao xfy final se o estado f final. Como
veremos a seguir, a mT pode, se for conveniente, aceitar sua entrada sem l-la at o
final.
Mudana de configurao. A definio da relao mudana de configurao, |,
no oferece surpresas:
movimento para a direita:
se (q, a) = (p, b, R), ento xqay | xbpy
(no estado q, lendo a, escreve b, anda para a direita e muda para o estado p)
movimento para a direita, lendo um branco:
se (q, ) = (p, b, R), ento xq | xbp
(caso particular do movimento para a direita: no estado q, lendo um branco,
escreve b, anda para a direita e muda para o estado p)
movimento para a esquerda:
se (q, a) = (p, b, L), ento xcqay | xpcby
(no estado q, lendo a, escreve b, anda para a esquerda e muda para o estado p)
movimento para a esquerda, lendo um branco:
se (q, ) = (p, b, L), ento xcq | xpcb
(caso particular do movimento para a esquerda: no estado q, lendo um branco,
escreve b, anda para a esquerda e muda para o estado p)
Naturalmente, se o valor de (q, a) indefinido, nenhuma configurao pode
ser alcanada a partir de uma configurao xqay, e a mquina pra. No caso particular
a=, se a configurao for xq, a mquina pra quando (q, ) indefinido.
As assimetrias que podem ser notadas na definio da relao mudana de
configurao | so devidas s assimetrias na definio de configurao e na
definio da prpria mquina de Turing: (1) na configurao xqy o smbolo lido o

primeiro de y, e (2) a fita semi-infinita para a esquerda. Note que esta definio
impede a passagem da cabea para a esquerda do primeiro smbolo.
Notamos, para uso futuro, que a mudana de configurao pode ser descrita
atravs da substituio de cadeias que envolvem no mximo trs smbolos:
qa bp, q bp, cqa pcb ou cq pcb,
O restante da configurao no se altera.
Linguagem reconhecida por uma mT. A linguagem aceita, ou reconhecida por uma
mT M definida por
L(M) = { x * | ix |* yfz, onde f F }
ou seja, L(M) o conjunto das cadeias x, compostas de smbolos do alfabeto de
entrada, que levam M da configurao inicial ix (correspondente entrada x) para
alguma configurao final yfz (em que o estado f final).
A aceitao se d quando o estado final atingido, no interessando em que
ponto da fita est a cabea, ou se h possibilidade de continuar a partir desse ponto. Se
possvel atingir uma configurao cujo estado final, a cadeia de entrada j est
aceita. Caso contrrio, a cadeia no ser aceita. No sequer necessrio que a entrada
seja inteiramente lida.
Para no aceitar uma cadeia x (x no pertence linguagem), a mquina pode
parar em algum estado no final, ou pode simplesmente no parar, e continuar se
movendo indefinidamente sem nunca aceitar.
Exemplo 7.1: Considere a mT M = ( K, , , , i, F ), onde
K = { q0, q1, q2, q3, q4 }
= { a, b }
= { a, b, X, Y, }
i = q0
F = { q4 },
e dada pela tabela abaixo, onde a notao foi simplificada, e cada valor da funo
em algum ponto representado por uma quntupla. Assim, se (q, a)=(p, b, D),
representaremos este fato pela quntupla qapbD. Quando nenhuma quntupla iniciada
por qa aparece, o valor de (q, a) indefinido. (Como estamos considerando apenas o
caso determinstico, no mximo pode ocorrer uma quntupla para cada par (q, a).
q0aq1XR q0Yq3YR q0q4XR
q1aq1aR q1bq2YL q1Yq1YR
q2aq2aL q2Xq0XR q2Yq2YL
q3Yq3YR q3Yq4XR q3q4XR
Considere a cadeia de entrada x = aaabbb. A seqncia de configuraes
assumida por M com entrada x :
q0aaabbb | Xq1aabbb | Xaq1abbb | Xaaq1 bbb | Xaq2aYbb
| Xq2aaYbb | q2XaaYbb | Xq0aaYbb | XXq1aYbb | XXaq1Ybb
| XXaYq1bb | XXaq2YYb | XXq2aYYb | Xq2XaYYb | XXq0aYYb
| XXXq1YYb | XXXYq1Yb | XXXYYq1b | XXXYq2YY
| XXXq2YYY | XXq2XYY | XXXq0YYY | XXXYq3YY
| XXXYYq3Y | XXXYYYq3 | XXXYYYXq4
A mT M acima aceita a linguagem { an bn | n 0 ). Podemos observar as aes
correspondentes a cada um dos estados:
q0 o primeiro a marcado com um X, passa para q1;

se no houver mais nenhum a, passa para q3;
q1 procura o primeiro b, que marcado com Y, passa para q2;
q2 volta at o X, e passa para q0 ;
q3 verifica que todos os smbolos j esto marcados:
vai para a direita at encontrar um , e passa para q4;
q4 aceita.
Outros exemplos de computaes:

q0 | Xq4 (aceita)
q0ab | Xq1b | q2XY | Xq0Y | XYq3 | XYXq4 (aceita)
q0ba (para sem aceitar)
q0aab | Xq1ab | Xaq1b | Xq2aY | q2XaY | Xq0aY | XXq1Y
| XXYq1 (para sem aceitar)
mostrando que e ab pertencem linguagem, mas isso no acontece com ba e aab.
Exerccio 7.1: Construa uma MT que aceite a linguagem L = { an bn cn | n 0 }.
7.3 - A mquina de Turing como modelo geral de procedimento.

A mquina de Turing , como j foi observado anteriormente, o modelo
formal mais usado de procedimento. Pela tese de Church, todos os modelos razoveis
do processo de computao, definidos e por definir, so equivalentes. Por essa razo
podemos usar a mquina de Turing como sendo nosso modelo formal de
procedimento. Lembramos que, por sua natureza, a tese de Church no admite prova
formal.
A definio da linguagem aceita por uma mT caracteriza o uso de uma mT
como procedimento aceitador, de forma que (via tese de Church) a classe das
linguagens aceitas por mquinas de Turing e a classe dos conjuntos recursivamente
enumerveis se identificam. Semelhantemente, identificamos algoritmo com mT que
sempre pra - ou seja, para qualquer entrada sempre atinge uma configurao a partir
da qual no h nenhuma outra configurao acessvel. Um conjunto recursivo ,
ento, a linguagem aceita por uma mT que sempre pra. Fazemos assim a
correspondncia entre dizer Sim e estar num estado final, e dizer No e estar em
um estado no final.
Exemplo 7.2. Seja construir uma mquina de Turing para converter um inteiro dado
em notao unria, para a notao binria. (Em notao unria, o natural i
representado pela cadeia 1i, obtida pela concatenao de i instncias do smbolo i.)
Suporemos que entrada e sada da mquina estaro delimitadas entre dois $. Por
exemplo, se a entrada $1111$, a sada deve ser $100$, sendo permitida a presena
adicional de algum lixo na fita.

A idia usada para a construo da mT a seguinte: se um nmero mpar, o ltimo
bit de sua representao binria 1; se par, 0. Para obter os demais bits, o nmero
dividido por 2. Na fita da mT, dividir por 2 cancelar um smbolo sim, um no. Isto
combina com a determinao da paridade do nmero: se no sobrar nenhum, o
nmero par.
Podemos usar a seguinte mquina, descrita atravs de quntuplas:
A$B$R A1A1L AxAxL

B$H$R B1CxR BxBxR
C$E$R C1D1R CxCxR
D$F$R D1CxR
E0E0R E1E1R E1GL
F0F0R F1F1R F0GL
G$A$L G0G0L G1G1L
H0H0R H1H1R HI$L
I$M$R I0JxR I1KxR IxIxL
J$J$R J0J0R J1J1R JxJxR JL0L
K$K$R K0K0R K1K1R KxKxR KL1R
L$I$L L0L0L L1L1L
M$M$R M0M0R M1M1R MxMxR MN$R
Nesta mT, o estado inicial A, e o final N. A computao abaixo corresponde
entrada $1111$. A ltima parte da computao corresponde inverso da
representao binria, que necessria porque os bits do resultado so gerados a partir
do menos significativo. No nosso caso, 4 = 11111 = 1002 aparece como 001, e precisa
ser invertido.
A$1111$ $B1111$ $xC111$

$x1D11$ $x1xC1$ $x1x1D$
$x1x1$F $x1x1G$0 $x1xA1$0
$x1Ax1$0 $xA1x1$0 $Ax1x1$0
A$x1x1$0 $Bx1x1$0 $xB1x1$0
$xCxx1$0 $xxCx1$0 $xxxC1$0
$xxx1D$0 $xxx1$F0 $xxx1$0F
$xxx1$G00 $xxx1G$00 $xxxA1$00
$xxAx1$00 $xAxx1$00 $Axxx1$00
A$xxx1$00 $Bxxx1$00 $xBxx1$00
$xxBx1$00 $xxxB1$00 $xxxxC$00
$xxxx$E00 $xxxx$0E0 $xxxx$00E
$xxxx$0G01 $xxxx$G001 $xxxxG$001
$xxxAx$001 $xxAxx$001 $xAxxx$001
$Axxxx$001 A$xxxx$001 $Bxxxx$001
$xBxxx$001 $xxBxx$001 $xxxBx$001
$xxxxB$001 $xxxx$H001 $xxxx$0H01
$xxxx$00H1 $xxxx$001H $xxxx$00I1$
$xxxx$00xK$ $xxxx$00x$K $xxxx$00xL$1
$xxxx$00Ix$1 $xxxx$0I0x$1 $xxxx$0xJx$1
$xxxx$0xxJ$1 $xxxx$0xx$J1 $xxxx$0xx$1J

$xxxx$0xx$L10 $xxxx$0xxL$10 $xxxx$0xIx$10
$xxxx$0Ixx$10 $xxxx$I0xx$10 $xxxx$xJxx$10
$xxxx$xxJx$10 $xxxx$xxxJ$10 $xxxx$xxx$J10
$xxxx$xxx$1J0 $xxxx$xxx$10J $xxxx$xxx$1L00
$xxxx$xxx$L100 $xxxx$xxxL$100 $xxxx$xxIx$100
$xxxx$xIxx$100 $xxxx$Ixxx$100 $xxxxI$xxx$100
$xxxx$Mxxx$100 $xxxx$xMxx$100 $xxxx$xxMx$100
$xxxx$xxxM$100 $xxxx$xxx$M100 $xxxx$xxx$1M00
$xxxx$xxx$10M0 $xxxx$xxx$100M $xxxx$xxx$100$N
Exerccio 7.2. Construa uma mquina de Turing que faa a converso inversa, isto ,
recebendo como entrada a representao binria de um nmero natural, constri sua
representao unria.
Sugesto: A sada desejada pode ser construda usando o seguinte ciclo: se o bit for 1,
acrescente um 1 sada; dobre o nmero de 1s para todos os bits exceto o mais
significativo. Por exemplo, para converter 1101 (13) podemos fazer:
para o bit 1, acrescenta 1 (1);
para o bit 1, dobra (11) e acrescenta 1 (111)
para o bit 0, dobra (111111)
para o bit 1, dobra (111111111111) e acrescenta 1 (1111111111111)
Como a mquina de Turing s trabalha com smbolos e cadeias, para que uma
mquina de Turing possa trabalhar com conjuntos que no so linguagens,
necessrio usar uma codificao, usando cadeias de smbolos para representar os
elementos do conjunto. Na nossa definio informal de procedimento, no foi feita
nenhuma restrio sobre os valores aceitveis como entradas para procedimentos, mas
esta restrio existe para a mT: apenas cadeias de smbolos podem ser usadas como
entradas ou sadas. Conjuntos que no so linguagens s podem ser tratados por um
procedimento atravs de alguma codificao de seus elementos em cadeias de alguma
linguagem. Por exemplo: podemos dizer que o conjunto Nat2 de pares de naturais
r.e., e justificar esta afirmativa apresentando o procedimento enumerador (ou gerador)
abaixo.
1. Faa i=0.
2. Para j=0, ..., i, emita (i-j, j).
3. Incremente i de 1.
4. V para 2.
Neste procedimento, no foi especificada a forma de representao dos nmeros
naturais, ou de seus pares, de forma que qualquer representao pode ser usada.
Entretanto, usando mquinas de Turing como reconhecedores, s podemos
mostrar que Nat2 r.e. descrevendo uma linguagem cujos elementos representam os
elementos de Nat2, e uma mT que reconhece esta linguagem. As linguagens L1, L2 e
L3 abaixo so exemplos de linguagens que podem ser usadas com essa finalidade.
L1 = { ai bj | i, j Nat }
L2 = { $ 1i $ 1j $ | i, j Nat }
L3 = { $ x $ y $ | x, y Z}, onde Z = { 0 } {1}{ 0, 1 }*

Nas duas primeiras codificaes, o par (2, 3) representado respectivamente por
aabbb ou por $11$111$. No terceiro caso, usamos a representao binria dos dois
elementos do par, de forma que (2, 3) corresponde a $10$11$.
A nica propriedade exigida de uma codificao, que deve ser definida por
uma bijeo. Tomando L1 como exemplo, a cada elemento de Nat2 corresponde
exatamente um elemento de L1=L[a*b*], e vice-versa. J que existe a codificao,
para mostrar que Nat2 r.e., basta mostrar que L1 r.e., o que pode ser feito neste
caso observando que L1 regular.
Exerccio 7.3: Construa mquinas de Turing que aceitem as linguagens L1, L2 e L3.
Sugesto: Como as linguagens so regulares, construa afds, que podem ento ser
transformados em mTs que nunca se movem para a esquerda.
Para representar um procedimento qualquer com uma mT precisamos permitir
a gerao de cadeias de sada, uma vez que a fita da mT funciona como memria e
como dispositivo de entrada/sada. As cadeias geradas como sada de um
procedimento devem ser escritas na fita. Isto vale para o caso de um procedimento
gerador, que enumera uma linguagem infinita, e que portanto no pode parar (veja
Exemplo 7.3), ou para um procedimento que calcula uma funo que transforma
cadeias de entrada em cadeias de sada (veja Exemplo 7.2).
Exemplo 7.3: Vamos descrever a mT M que enumera os elementos de Nat2,
codificados usando elementos de L1. Note que M no recebe nenhuma entrada. As
diversas cadeias geradas estaro separadas por $'s.
1. Inicialmente, M escreve $$ na fita, enumerando o par (0, 0).
2. Para cada cadeia x=aibj no considerada na fita,
M acrescenta no fim da fita a cadeia ax$xb$ = ai+1bj$aibj+1$,
correspondente enumerao de (i+1, j) e de (i, j+1).
Em seguida M marca a cadeia aibj como j considerada.
O contedo da fita de M, aps alguns passos, seria
$$a$b$aa$ab$ab$bb$aaa$aab$
onde $ marca a separao entre as cadeias j consideradas e as ainda no
consideradas. O processo se repete indefinidamente. Observe que necessrio
conhecer a codificao, para identificar quais os elementos de Nat2 que foram
enumerados.
A construo da mquina completa fica como exerccio.
Exerccio 7.4: Descreva mT's que enumeram Nat2 de acordo com as outras duas
codificaes consideradas.
Exemplo 7.4: Vamos construir M, uma mT que soma dois nmeros em unrio, ou seja
um procedimento que implementa a soma unria. M recebe como entrada uma cadeia
A da forma $x$y$, em que x e y so cadeias de 1s, representando dois naturais i e j
em unrio. Ao final o resultado z (a cadeia de 1s que representa i+j) deve ficar na
fita, delimitado por $s; para remover quaisquer caracteres que no faam parte de
z, usaremos o smbolo X.
A idia a seguinte:
substitumos o segundo $ por 1;
substitumos o ltimo 1 por $;
substitumos o terceiro $ por X.
Assim, com entrada $11$111$, representando as parcelas 2 e 3, teremos
$11$111$ |* $111111$ |* $11$11$$ |* $11111$X

Ignorando o X, esta ltima cadeia a representao do resultado 5. Outro exemplo
seria 0+0=0, em que a entrada $$$ deveria ser transformada em $$X.
A mquina de Turing pode ter estados { A, F } sendo A inicial e F final, com as
seguintes transies:
A$B$R
B1B1R B$C1R
C1C1R C$D$L
D1E$R
E$FXR
de maneira que para a entrada $11$111$ teramos a seguinte computao:
A$11$111$ | $B11$111$ | $1B1$111$ | $11B$111$ | $111C111$
| $1111C11$ | $11111C1$ | $111111C$ | $11111D1$ | $11111$E$
| $11111$XF
ou seja, 2+3=5. Semelhantemente, para a entrada $$$ teramos
A$$$ | $B$$ | $1C$ | $D1$ | $$E$ | $$XF
ou seja, 0+0=0.
Exemplo 7.5: Seja descrever uma mT M, que soma dois nmeros em binrio, ou seja
mais uma mT que implementa o procedimento soma. M recebe como entrada uma
cadeia A da forma $x$y$, em que x e y so cadeias de 0's e 1's, representando dois
naturais i e j em binrio. Vamos supor que o resultado z (a cadeia que representa i+j)
deve ficar no fim da parte escrita, com delimitadores especiais: $$z$$. (Antes do
primeiro $$ fica o "lixo" resultante das computaes.)
O plano de execuo de M o seguinte:
M decora um bit de x, soma com o bit correspondente de y e escreve no fim
da fita o bit correspondente de z. Se houver um carry (vai-um), este deve ser
considerado da prxima vez. Este processo repetido at que os bits de x ou de y
estejam todos marcados. A partir deste ponto, s os bits da outra cadeia so levados
em considerao, at serem todos marcados. Note que os bits de z esto sendo gerados
na ordem invertida, de forma que a sentena no fim da fita efetivamente zR. Para
terminar, os bits de z so copiados um a um, a partir do ltimo, para o fim da fita,
onde a cadeia z construda.
Note que os bits decorados e o carry devem ser anotados em estados especiais
para cada combinao de valores. Os contedos da fita em alguns pontos da
computao esto mostrados a seguir, para a soma 3+7=10.
$11$111$
$1x$11x$0
$xx$1xx$01
$xx$xxx$010
$xx$xxx$0101
$xx$xxx$010x$$1
$xx$xxx$01xx$$10

$xx$xxx$0xxx$$101
$xx$xxx$xxxx$$1010
$xx$xxx$xxxx$$1010$$
Outra possibilidade a seguinte: usamos tcnicas semelhantes s do Exemplo 7.2 e do
Exerccio 7.2, para as converses de binrio para unrio e vice-versa; a soma pode ser
feita em unrio. Neste caso, podemos ter contedos de fita, em alguns instantes da
computao, como os seguintes:
$11$111$ 3 = 112; 7=1112
$xx$111$111$ 3= 1111
$xx$xxx$111$1111111$ 7 = 11111111
$xx$xxx$1111111111$x 10 = 11111111111
$xx$xxx$xxxxxxxxxx$x$1010$ 10 = 10102
A efetiva construo da mquina, por uma das duas maneiras mencionadas, fica como
um exerccio.
7.4 - Tcnicas para a construo de mquinas de Turing

Vamos apresentar a seguir algumas tcnicas de construo de mT's. Em
virtude do interesse apenas terico das mT's, apenas algumas mquinas muito
pequenas so efetivamente construdas. Isso se deve ao fato de que a construo de
uma mT pode ser extremamente trabalhosa. Assim, normalmente feita apenas uma
descrio da mquina, como fizemos nos exemplos 7.3 e 7.5. Vamos examinar aqui
algumas tcnicas, que podem ser usadas para efetivamente construir mT's, mas que
so mais frequentemente usadas em descries de mT's. Vamos apresentar tambm
algumas modificaes do modelo bsico, que no alteram a capacidade de
computao da mT.
1. anotao de informaes no controle finito. A mT pode mudar de estado para
guardar uma informao adicional. Por exemplo, a mT pode decorar o smbolo
que encontrou em uma posio, para mov-lo para outra, ou para compar-lo com
outro smbolo em outra posio.
2. cpia e verificao de smbolos, possvelmente em ordem inversa. Uma mT pode
decorar e marcar smbolos em uma parte A (devidamente demarcada) da fita, para
alguma ao em outra parte B (tambm devidamente demarcada) da fita. O
smbolo decorado em A pode ser copiado em B, ou pode ser comparado com
outro smbolo em B para verificar se duas cadeias so iguais. Se em A comeamos
pelo ltimo smbolo, e em B pelo primeiro, a operao se d na ordem inversa.
3. Mltiplas trilhas. Podemos incluir no alfabeto smbolos que sejam tuplas de
outros smbolos. Por exemplo, pode conter pares de elementos de . Esta
construo permite simular a existncia de vrias trilhas na fita. Por exemplo,
usando triplas como smbolos, (a1, b1, c1) (a2, b2, c2) ... (an, bn, cn) pode ser vista
como uma cadeia de n smbolos (que so triplas) ou pode ser vista como a
combinao de trs cadeias, uma em cada trilha: a1a2...an, b1b2...bn, e c1c2...cn.
A situao est representada na figura abaixo, onde podemos ver a cadeia de triplas,
(a1, b1, c1) (a2, b2, c2) (an, bn, cn)

ou, alternativamente, trs trilhas separadas.
a1 a2 an
b1 b2 bn
c1 c2 cn
Em alguns casos, queremos verificar alguma condio sobre uma cadeia x, o que
usualmente destri a cadeia, mas, para alguma finalidade, a cadeia deve ser
preservada. Podemos construir uma cpia de x na outra trilha, simplesmente
trocando cada smbolo ai de x por (ai, ai). Se x = a1a2...an, ento x pode ser substitudo
por (a1, a1) (a2, a2) ... (an, an). Uma das cpias pode ser destruda no processamento, e
ao final x reconstitudo a partir da cpia salva na outra trilha.
4. Subrotinas. Podemos considerar que qualquer ao para a qual uma mT foi
construda (ou descrita) pode ser usada na construo de outra mT, em que a ao
desejada como parte do processamento. Basta para isso incluir uma cpia dos
estados e transies da subrotina. Se quisermos fazer vrias chamadas, entretanto,
ser necessrio dar novos nomes aos estados, para isolar uma chamada da sub-
rotina das demais.
5. Fita infinita nos dois sentidos. Se for interessante, podemos considerar que a fita
da mT se estende de forma ilimitada tambm para a esquerda da posio inicial.
Para a simulao de uma mT com fita infinita nos dois sentidos, bastaria
considerar uma fita semi-infinita com duas trilhas, cada qual representando uma
das "metades". Podemos anotar no controle finito em qual das duas metades da
fita a mT est no momento, e ignorar a outra metade.
Por exemplo, se o contedo da fita infinita
a-3 a-2 a-1 a0 a1 a2 a3

podemos usar uma fita semi-infinita para representar o mesmo contedo:
a0 a1 a2 a3
a-1 a-2 a-3 a-4
ou seja, por
(a0, a-1) (a1, a-2) (a2,a-3) (a3, a-4)
6. Vrias fitas. Podemos considerar uma mT com vrias fitas, a que podem ser
atribudas funes diferentes, caso desejado. Por exemplo, podemos considerar
que a mquina tem uma fita de entrada, uma fita de sada, e uma ou mais fitas de
memria. A simulao de uma mT com n fitas pode ser feita em uma mT com um
fita s, cujos smbolos so tuplas, que contm todos os smbolos de todas as fitas,
e marcas com as posies de todas as cabeas.
7. Mquinas de Turing no determinsticas. Para definir uma mquina no
determinstica, devemos considerar uma funo que pode oferecer mais de uma
possibilidade de transio, a partir de cada configurao. Uma mT no
determinstica pode ser simulada por uma mt determinstica. Isto ser descrito a
seguir.
Definio. Uma mquina de Turing no determinstica M pode ser definida por uma
tupla M = < K, , , , i, F >, onde K um conjunto (finito, no vazio) de estados,
o alfabeto (finito) de smbolos da fita, o alfabeto de smbolos de entrada, a
funo de transio, i K o estado inicial, e F K o conjunto de estados finais.
A funo de transio um mapeamento : K P(K {L, R}). Todos os
valores de so conjunto finitos.
Configurao. Da mesma maneira que para uma mT determinstica, uma
configurao de uma mT uma cadeia xqy, em que xy * o contedo da fita, sem
incluir nenhum dos brancos que existem direita, e qK o estado corrente.
Semelhantemente, a configurao inicial para a entrada x ix, e uma configurao xfy
final se o estado f final.
Mudana de configurao. A definio da relao mudana de configurao, |,
no oferece surpresas:
movimento para a direita:
se (p, b, R)(q, a), ento xqay | xbpy
caso particular: se (p, b, R)(q, ), ento xq | xbp
movimento para a esquerda:
se (p, b, L)(q, a), ento xcqay | xpcby
caso particular: se (p, b, L)(q, ), ento xcq | xpcb
Naturalmente, se (q, a)=, nenhuma configurao pode ser alcanada a partir
de uma configurao xqay, e a mquina pra. Caso particular: se a configurao for
xq, a mquina pra quando (q, )=.
Linguagem reconhecida por uma mT no determinstica. A linguagem aceita, ou
reconhecida por uma mT M definida por
L(M) = { x * | ix |* yfz, onde f F }
A aceitao se d quando o estado final atingido, no interessando em que
ponto da fita est a cabea, se h possibilidade de continuar a partir desse ponto, ou se
h outras configuraes no finais atingveis com a mesma entrada. Como nos outros
casos em que definimos mquinas no determinsticas, s nos interessa saber se existe
ou no a possibilidade de atingir um estado final.
Exemplo 7.6. A mT a seguir no determinstica. A linguagem aceita por essa
mquina { xx | x{0,1}* }.
A0BxR A1CxR AKxR

B0B0R B0DyL B1B1R
C0C0R C1C1R C1DyL
D0D0L D1D1L DxExR DyDyL
E0FxR E1GxR EyJyR
F0F0R F1F1R FyHyR
G0G0R G1G1R GyIyR
H0DyL HyHyR
I1DyL IyIyR
JyJyR JKxR
A escolha no determinstica feita em dois estados, B e C. Em ambos os casos, trata-
se de adivinhar qual o primeiro smbolo da segunda metade da cadeia xx. No caso do
estado B este smbolo um 0; no caso do estado C, trata-se de um 1. Os demais
smbolos so apenas conferidos nos estados H e I. Abaixo, um exemplo de
computao:
A11011101 xC1011101 x1C011101 x10C11101 x101C1101

x10D1y101 x1D01y101 xD101y101 Dx101y101 xE101y101
xxG01y101 xx0G1y101 xx01Gy101 xx01yI101 xx01Dyy01
xx0D1yy01 xxD01yy01 xDx01yy01 xxE01yy01 xxxF1yy01
xxx1Fyy01 xxx1yHy01 xxx1yyH01 xxx1yDyy1 xxx1Dyyy1
xxxD1yyy1 xxDx1yyy1 xxxE1yyy1 xxxxGyyy1 xxxxyIyy1
xxxxyyIy1 xxxxyyyI1 xxxxyyDyy xxxxyDyyy xxxxDyyyy
xxxDxyyyy xxxxEyyyy xxxxyJyyy xxxxyyJyy xxxxyyyJy
xxxxyyyyJ xxxxyyyyxK
Teorema 7.1. Os modelos determinstico e no determinstico da mquina de Turing

so equivalentes.
Dem. Basta mostrar como simular uma mT no determinstica M em uma mT
determinstica M. A fita de M conter diversas configuraes de M. Se alguma delas
for final, M aceitar sua entrada. O smbolo $ ser usado como separador de
configuraes.
1. Inicialmente, M encontra na sua fita a entrada x de M. Acrescentando marcas e o
estado inicial i de M, M' escreve na fita a configurao inicial de M para x, C0=ix, de
forma que a fita de M contm $C0$.
2. Para cada configurao C no considerada na fita, M' constri no fim da fita, as
configuraes atingveis a partir de C, separadas por $. Se M tem m opes de
escolha, e as configuraes atingveis so C1, C2, ... Cm, neste passo a cadeia
$C1$C2$$Cm$ acrescentada no final da fita.
3. Se alguma das configuraes de M construdas por M' for final, M' pra e aceita a
entrada.
Para construir as configuraes, observamos que no mximo trs smbolos so
alterados, quando se passa de uma configurao C para uma configurao C' em um
passo. Ou seja, boa parte do trabalho de construo de C' simplesmente um trabalho
de cpia.
Exerccio 7.5. Construa uma mquina determinstica que aceite a linguagem do
Exemplo 7.6, sem usar a construo sugerida no Teorema 7.1.
7.5 - Linguagens tipo 0 e conjuntos recursivamente enumerveis

Vamos agora caracterizar a classe de linguagens aceitas por mT's, mostrando
que se trata da mesma classe de linguagens geradas por gramticas (tipo 0), ou seja,
via tese de Church, que a classe dos conjuntos recursivamente enumerveis idntica
classe das linguagens tipo 0. Este resultado ser objeto dos dois teoremas a seguir.
Teorema 7.2: Toda linguagem tipo 0 recursivamente enumervel.
Demonstrao. Seja L uma linguagem tipo 0. Seja G uma gramtica tal que L = L(G).
Vamos descrever a construo de uma mt M, no determinstica, que aceita L(G).

M ignora sua entrada, e escreve $S$ no fim da fita. Em seguida, M simula uma
derivao em G escolhendo e aplicando no-deterministicamente uma regra em cada
passo. Para isso, escolhida a regra , M encontra (no-deterministicamente) uma
ocorrncia de e substitui esta ocorrncia por . Quando esta derivao tiver como
resultado a cadeia x, M ter em sua fita duas cpias de x que devem ser comparadas.
Neste ponto M passa para um estado final.
Uma outra possibilidade de construo de M atravs de uma mT determinstica, que
em vez de "adivinhar" as regras a serem usadas, testa todas, sucessivamente.
O prximo resultado a recproca do teorema acima.
Teorema 7.3. Toda linguagem recursivamente enumervel tipo 0.
Demonstrao. Seja L uma linguagem r.e. Portanto, L aceita por alguma mT
(determinstica) M. Vamos mostrar que L tipo 0, construindo uma gramtica (tipo 0)
G que aceita L. Uma derivao em G simula uma computao de M, e tem o seguinte
aspecto:
S * ix$x * yfz$x * x
A partir do smbolo inicial S, derivamos uma cadeia da forma ix$x, onde i o estado
inicial de M, de forma que ix a configurao inicial de M com entrada x. A
simulao da computao de M ser feita a partir dessa configurao inicial. A
segunda cpia de x fica inalterada at o final. A cadeia x contm apenas smbolos do
alfabeto de entrada de M, que so os terminais de M; o separador $ e os smbolos de
estados de M so noterminais de G. Para esta fase as regras de G podem ser obtidas
adaptando as regras de uma gramtica sensvel ao contexto de { xx | x*},
acrescentando os smbolos noterminais i e $.
A segunda parte,
ix$x * yfz$x
simula a computao de M com entrada x. Para isto, as regras de G so construdas a
partir das transies de M. Para cada valor (q, a), G tem uma ou mais regras que
simulam a mudana de configurao. Se (q, a) = (p, b, R), basta uma regra qabp.
Se (q, a) = (p, b, L), h necessidade de uma regra cqa pcb para cada smbolo c do
alfabeto da fita. O fim da fita de M identificado pela presena do separador $.
Portanto, quando M l um branco, o separador $ alcanado, e transies em que um
envolvido tem regras correspondentes das formas q$ pb$ e cq$ pcb$.
Supondo que x pertence a L(M), uma configurao final yfz ser eventualmente
alcanada, com ix |* yfz. Portanto, em G, ser possvel a derivao ix$x * yfz$x,
onde f um estado final.
Na ltima fase, os restos da computao de M so removidos, restando apenas a cpia
no usada da cadeia x. Para obter yfz$x * x, G tem regras fX para cada estado
final f. O noterminal X pode ser visto como um apagador usando regras cX X e
Xc X para cada smbolo c do alfabeto da fita, e X$ , podemos eliminar todos
os vestgios da simulao, e ficar apenas com a cadeia x.
Por construo, G gera x se e somente se M aceita x. Para a construo da primeira
parte de G, veja o exerccio abaixo.

Exerccio 7.6: Seja um alfabeto qualquer, e seja ' = { i, $ }. Considere a
linguagem L' no alfabeto ', dada por L' = { ix$x | x * }. Mostre que L' sensvel
ao contexto, construindo uma gsc para L'.
Nota: na demonstrao do teorema anterior, i e $ so noterminais.
Este captulo foi escrito a partir de uma verso inicial escrita com a colaborao de Luiz Carlos
Castro Guedes
2jul99

Captulo 8: O problema da parada.
Decidibilidade e computabilidade.
Jos Lucas Rangel
8.1 - Introduo.
Como observado no captulo anterior, podemos substituir a definio informal

de procedimento pela definio formal de mquina de Turing (mT). J vimos que,
dependendo da forma como a mT construda, ela pode ser um procedimento gerador
ou um procedimento reconhecedor; por outro lado, uma mT que sempre pra,
qualquer que seja a sua entrada, um algoritmo. Portanto, um conjunto
recursivamente enumervel (r.e.) uma linguagem reconhecida por uma mT; e um
conjunto recursivo uma linguagem aceita por uma mT que sempre pra.
Devemos, neste captulo, apresentar exemplos de linguagens que mostrem que
as definies de conjunto recursivamente enumervel e de conjunto recursivo so no
triviais. Uma vez que j foi provada a incluso da segunda classe na primeira, basta
apresentar exemplos de conjuntos r.e. que no so recursivos, e de conjuntos
enumerveis que no so r.e. Efetivamente, o reconhecimento de um conjunto no
recursivamente enumervel , ento, uma tarefa que no pode ser realizada por
nenhuma mquina de Turing, por nenhum procedimento, ou seja, uma tarefa
incomputvel.
Para que esses exemplos sejam apresentados, precisamos de alguns conceitos
auxiliares.
8.2 - Enumerao de Mquinas de Turing.

Para definir uma enumerao (e uma numerao) de todas as mquinas de
Turing (mT) vamos introduzir uma codificao, que vai representar cada mT
M = <K, , , , i, F> atravs de uma cadeia em um alfabeto adequado ; a
enumerao das mT, determinsticas e no determinsticas, ser baseada em uma
enumerao de *. Para isso conveniente fazer algumas suposies:
Os estados de K esto ordenados: q0, q1, q2, , de tal forma que i = q0.
De forma semelhante, os smbolos de , s0, s1, s2, esto ordenados, de
forma que s0 o smbolo especial branco .
Assim, para representar M, usaremos um alfabeto = {q, s, |, #, L, R} de
forma que o estado qi representado por q|i, e o smbolo si representado por s|i. A
representao ento usa as cadeias q, q|, q||, q|||, , s, s|, s||, s|||, para os estados e
smbolos; note, em particular, que q o estado inicial, e s o smbolo branco.
Os smbolos #, L, e R de so usados respectivamente como separador e
como indicadores de movimento para a esquerda, e para a direita.
Para representar a funo , devemos representar todos os valores de (q, s).
Isso pode ser feito atravs de uma sequncia de quntuplas (qi, sj, qk, sl, r), com r{L,
R}, que indicam que (qk, sl, r) (qi, sj).
Linguagens Formais J.L.Rangel 8-1
A cadeia correspondente tupla (qi, sj, qk, sl, r) em * q|i s|j q|k s|l r. Se M
uma mT no determinstica, podemos ter vrias tuplas com os mesmos valores nos
dois primeiros elementos.
Por exemplo, se tivermos a tupla (q1, s2, q3, s4, L), indicando que (q3, s4, L)
(q1, s2), a cadeia correspondente em * ser q|s||q|||s||||L. Para representar a funo ,
concatenamos as representaes das quntuplas correspondentes a , separadas por #.
Para representar F, basta concatenar, sem separao, as cadeias que
representam os estados. Por exemplo, F = {q1, q3, q5 } representado por q|q|||q|||||. A
representao de M se reduz apenas representao de F e de , que podem ser
separadas por ##.
Exemplo: Seja M = <K, , , , i, F>, onde
K = { p, q, r }
= { a, b }
= { , a, b, X }
i=q
F = { r },
sendo dada por
(p, a) = {(q, a, R)}
(q, a) = {(q, X, R)}
(q, b) = {(r, a, L)}
(q, ) = {(r, X, L)}
Fazendo q0 = q, q1 = p, q2 = r, s0 = , s1 = a, s2 = b, s3 = X, temos a seguinte
representao de M:
q||##q|s|qs|R#qs|qs|||R#qs||q||s|L#qsq||s|||L
Uma entrada aaab de M ser codificada em * como s|s|s|s||.
Com essa codificao (ou alguma outra codificao semelhante), possvel
representar as mT's e suas entradas atravs de cadeias em *, onde um alfabeto
apropriado. Sabemos que * enumervel, e que podemos atribuir um natural a cada
cadeia de *, e fazer referncia s cadeias de * como x0, x1, x2, . Assim, podemos
atribuir mT representada por xi o nmero i, e fazer a referncia a ela como a i-sima
mquina de Turing Mi.
Entretanto, para que a notao Mi sempre represente uma mT, uma conveno
adicional necessria. Observe que nem todas as cadeias xi de * correspondem a
mT's. Por exemplo, a cadeia LLL no descreve nenhuma mT. Para que a cada natural
i corresponda uma mT Mi, vamos associar a cada i tal que xi no descreve nenhuma
mquina a mquina vazia ##, que no tem nenhum estado final, e nenhuma transio
possvel. Incidentalmente, ## aceita a linguagem vazia .
Assim, podemos falar em Mi, para qualquer i: ou M a mquina representada por xi,
ou xi no representa nenhuma mquina, e Mi a mquina representada por ##. Note
que fcil distinguir as cadeias de * que representam mT's das demais, uma vez que
elas formam um conjunto regular.
Semelhantemente, podemos enumerar as cadeias que representam entradas:
x0, x1, x2 ...,
de forma que poderemos falar na i-sima cadeia de entrada xi.
Exerccio: Escolha uma enumerao de *. Para essa enumerao, descreva
algoritmos que permitam
dado um natural i, determinar a cadeia xi de * correspondente.
dada uma cadeia x em ?*, determinar o natural i tal que x = xi.
dada uma cadeia xi em *, determinar se xi ou no a representao de uma
mT.
Exerccio: Para uma enumerao determinada de *,
(a) determine o nmero da sequncia ##.
(b) determine qual a mquina M23.
Suporemos daqui para a frente que est fixada uma enumerao de todas as
mquinas de Turing, em algum alfabeto fixo.
M0, M1, M2, M3,
e de suas entradas,
x0, x1, x2, x3,
Codificao e decodificao. Podemos sempre supor que existem algoritmos com as
seguintes finalidades:
dado um natural i, determinar a cadeia xi.
dado um natural i, determinar a representao de Mi.
dada uma cadeia x, determinar i tal que x = xi.
dada uma mT M, determinar i tal que M = Mi.
Faremos referncia a esses algoritmos como algoritmos de codificao ou de
decodificao. Como se trata de algoritmos, podemos supor que podem ser simulados
por uma mT, ou usados por mT's como subrotinas.
8.3 - Mquina de Turing Universal.

Vamos agora mostrar como pode ser construda uma mT universal U, que tem
a propriedade de poder simular qualquer outra mT. Por simplicidade, vamos descrever
uma mT universal U no determinstica. Para simular a computao de uma mT M
qualquer, quando recebe como entrada a cadeia x, a idia a seguinte:
U recebe uma entrada $, onde e so as representaes de M e x em
algum alfabeto ;
U simula M com entrada x;
U aceita $ se M aceita x.
Para a simulao, U constri uma representao de uma configurao de M
em sua fita, e faz a simulao alterando essa configurao. A simulao parte da
configurao inicial q Para cada mudana de configurao Ci | Ci+1, U deve
identificar o estado e o smbolo lido em Ci, escolher uma entre as diversas transies
previstas na funo de transio que faz parte de e construir a nova configurao
Ci+1.
Como U no determinstica, pode decidir "no-deterministicamente" quando
uma configurao final Cf de M foi atingida, e apenas verificar que o estado contido
em Cf um dos estados finais listados em .

Todas as operaes envolvidas so operaes de cpia e de comparao de
cadeias, e no oferecem nenhum problema maior. Naturalmente, a simulao de um
passo da mquina M corresponde a um nmero considervel de passos de U, mas isto
no um problema.
Assim, a construo de U possvel. Frequentemente, conveniente supor que
a mT U recebe como entrada i$j, para indicar que deve simular Mi com entrada xj,
sendo i e j representados em alguma base adequada. Os passos adicionais necessrios
so de codificao e decodificao, e podem, como j vimos, ser realizados por uma
mT.
A mT U frequentemente usada como uma subrotina, na construo de outras
mT's, em geral atravs de frases como
"ento, M simula Mi com entrada xj e se M parar, ...".
Uma comparao que se faz frequentemente a da mquina de Turing
universal U com o modelo de von Neumann, em que se baseiam os computadores
comuns. O modelo de von Neumann se caracteriza justamente por ter o programa
armazenado na memria, juntamente com os dados, durante a execuo.
Note que U uma mquina de Turing, e, portanto, faz parte da enumerao M0, M1,
M2, M3, sendo, para algum natural u, a mquina Mu.
8.4 - Uma linguagem no recursivamente enumervel.

Vamos agora apresentar um exemplo de linguagem no recursivamente
enumervel. Considere a linguagem L abaixo:
L = { xi | xi no aceita por Mi }
Fato: L no recursivamente enumervel.
Dem.: Vamos mostrar, por contradio, que L no aceita por nenhuma mquina de
Turing. Para isso, suponha que L aceita pela mT M.
Como toda mT, M faz parte da enumerao das mT's, ou seja, para algum i, M = Mi,
de forma que L = L(Mi). Vamos verificar se xi L.
se tivermos xi L, como L = L(Mi), temos que Mi aceita x, e portanto
xiL.
se, alternativamente, tivermos xiL, ou seja, xiL(Mi), naturalmente, M
no aceita xi, e portanto xiL.
Estabelecida a contradio, conclumos que L no aceita por nenhuma mT M, e que
L no recursivamente enumervel.
Para a linguagem L, portanto, no existem
um procedimento reconhecedor de L
um procedimento enumerador de L
uma gramtica, tipo 0 ou no, que gere L.
Fato: , o complemento de L, uma linguagem recursivamente enumervel.
Dem.: Temos = { xi | xi aceita por Mi }. Podemos descrever uma mT M que aceita
L, da seguinte forma:
a partir de xi, M obtm a representao de Mi.
como foi descrito para a mquina universal U, M simula Mi com entrada xi.
se Mi parar e aceitar xi, M tambm pra e aceita xi.
Note que se Mi no pra, com entrada xi, ento M tambm no pra, com a mesma
entrada
Fato: A linguagem L no recursiva.
Dem.: J vimos anteriormente que o complemento de uma linguagem recursiva
tambm uma linguagem recursiva. Como o complemento de L L, que no r.e., e
portanto, tambm no recursiva, L no pode ser recursiva.
A linguagem L , portanto, tem uma gramtica tipo 0, mas no sendo recursiva,
tambm no pode ser sensvel ao contexto, e no pode ter nenhuma gramtica tipo 1.
8.5 - Problemas decidveis e indecidveis.
Para qualquer conjunto X no recursivo, a pergunta "x X?" no admite

soluo atravs de um algoritmo que aceite x como entrada e responda SIM ou NO
corretamente pergunta. Mas, do ponto de vista prtico, a diferena entre um
conjunto no recursivamente enumervel, e um conjunto recursivamente enumervel
que no recursivo pode ser considerada pequena. Com efeito, suponha que um
conjunto L recursivamente enumervel mas no recursivo, e que dispomos de uma
mT M que reconhece L, mas, no pra quando sua entrada no pertence a L. Suponha
que, com entrada x, M foi executada por, digamos, mil passos, e que no parou. Nada
podemos responder pergunta "x L ?". Ser que M vai parar nos prximos mil
passos?
Uma das maneiras de dizer que uma linguagem L no recursiva dizer que o
problema "x L ?" no decidvel. De uma forma geral, um problema indecidvel
um conjunto de questes que pode ser reduzido por codificao ao problema da
pertinncia em uma linguagem no recursiva, e, assim, no pode ser respondido por
uma mT que sempre pra; se um problema pode ser reduzido por codificao ao
problema de pertinncia em uma linguagem recursiva, dizemos que decidvel.
Um ponto importante que um problema indecidvel sempre envolve uma famlia de
questes, ou questes em que aparece um parmetro. O problema P(i) - "Mi aceita
xi?" pode ser indecidvel, mas o problema P(23) - "M23 aceita x23?" decidvel. Como
prova disso, oferecemos duas mTs: Msim e Mno. Msim sempre pra e aceita qualquer
entrada (sempre responde SIM); Mno sempre pra, mas nunca aceita qualquer de suas
entradas (sempre responde NO). irrelevante o fato de ser difcil ou trabalhoso
descobrir qual das duas mquinas corresponde resposta correta da pergunta "M23
aceita x23?", mas certamente uma das duas resolve corretamente o problema. De fato,
o que indecidvel em "Mi aceita xi ?" exatamente qual das duas respostas
corresponde a um valor de i arbitrrio, ou seja, qual das duas mquinas consideradas
deve ser usada em cada caso.
Reduo. Uma das tcnicas mais comuns de estabelecer se um problema decidvel
ou indecidvel atravs de reduo desse problema a outro problema cuja resposta
conhecida.
Dizemos que P1 se reduz a P2 se a resposta a qualquer consulta a P1 pode ser
deduzida da resposta a uma consulta apropriada a P2.
Se P1 se reduz a P2, podemos dizer que, de certa forma, P2 mais geral que P1.

Supondo que P2 indecidvel, e que P2 se reduz a P1, podemos concluir que P1
tambm indecidvel; por outro lado, se P1 decidvel, e P2 se reduz a P1, podemos
concluir que P2 tambm decidvel.
O problema da parada. Como exemplo da tcnica de reduo, vamos mostrar que o
problema da parada das mquinas de Turing (halting problem) indecidvel. Este
problema pode ser formulado como "Mi pra com entrada xj?", embora algumas vezes
seja confundido o problema da aceitao "Mi aceita xj?".
Como fcil reduzir qualquer um dos problemas ao outro, os dois problemas
podem ser considerados equivalentes, e a confuso de certa forma justificada. Para
verificar a equivalncia, basta verificar que sempre possvel alterar uma mT M,
construindo outra mT M que aceita a mesma linguagem, de maneira tal que M tem
as propriedades de parar sempre que atinge um estado final, e de nunca parar em um
estado que no seja final. Isso quer dizer que M pra se e somente se aceita sua
entrada. Vamos representar o problema da parada por Q(i,j) = Mi aceita xj?
Como sabemos que P(i) = "Mi aceita xi?" indecidvel (veja a linguagem L
acima), e sabemos que podemos reduzir P a Q, porque P(i) equivalente a Q(i, i),
conclumos que o problema da parada Q indecidvel.
Usualmente, a demonstrao de que um problema indecidvel , feita atravs
de reduo, a partir do problema da parada, diretamente, ou ento, de forma indireta, a
partir de problemas cuja indecidibilidade j foi provada anteriormente.
(junho 99)

Captulo 9: Linguagens sensveis ao contexto e autmatos
linearmente limitados.
Jos Lucas Rangel
9.1 - Introduo.
Como j vimos anteriormente, a classe das linguagens sensveis ao contexto
(lsc) uma classe intermediria entre a classe das linguagens recursivas e a classe das
linguagens livres de contexto (llc). J vimos anteriormente que a classe das llc est
propriamente contida na classe das lsc's: como aplicao do Lema do Bombeamento,
provamos que alguns exemplos de linguagens geradas por gramticas sensveis ao
contexto no so llc's.
Neste captulo, queremos apresentar os autmatos linearmente limitados, uma
classe de mquinas de Turing cuja operao restringida, de forma a aceitar apenas as
lsc's. Adicionalmente, queremos mostrar que a incluso da classe das lsc's na classe
das linguagens recursivas prpria, atravs de um exemplo de linguagem recursiva
que no uma lsc.
9.2 - Autmatos linearmente limitados.

Um autmato linearmente limitado (all) uma mquina de Turing no
determinstica A = <K, , , , i, F>, que satisfaz certas restries:
dois smbolos especiais, um marcador esquerdo [ e um marcador direito ],
so includos em ;
quando [ lido, a mquina no pode se mover para a esquerda, nem
escrever um smbolo distinto de [;
quando ] lido, a mquina no pode se mover para a direita, nem escrever
um smbolo distinto de ].
[ e ] no podem ser escritos em nenhuma outra situao.
Supondo que a fita de um all contm inicialmente uma sequncia da forma
[ x ], estas restries fazem com que o all no possa abandonar a regio entre os dois
marcadores [ e ], nem apag-los ou mov-los. Portanto, todas as computaes de um
all devem ser feitas no espao que originalmente contm sua entrada x.
Como j vimos anteriormente, possvel definir uma fita com k trilhas, e, num
trecho da fita de comprimento n, podemos armazenar kn smbolos. Esta a origem do
nome "linearmente limitado": o all pode manipular em sua fita informao com
tamanho limitado por uma funo linear do tamanho de sua entrada.
Definimos configuraes e transies para um all da mesma forma que para
uma mT. Entretanto, a configurao inicial associada entrada x * i [ x ].
Definimos a linguagem de um all A, por
L(A) = { x* | i [ x ] |* [ f ], com fF }
Exemplo: Vamos descrever informalmente um all A que aceita a lsc { x x | x* },
sendo = { a, b }.
Inicialmente, a fita de A contm [ y ]. Em seguida, A marca o primeiro
smbolo de y, e o primeiro smbolo da segunda metade de y, que verifica ser igual ao
Jos Lucas Rangel Linguagens Formais 9-1

primeiro. (A posio inicial da segunda metade escolhida de forma no
determinstica.) A seguir, o processo se repete com os demais smbolos das duas
metades, marcando o primeiro smbolo no marcado da primeira metade e o primeiro
smbolo no marcado (igual) da segunda metade, at que nenhum smbolo no
marcado reste na fita.
Atingido este ponto, A verificou que o ponto escolhido como incio da
segunda metade era o correto, porque havia um nmero igual de smbolos nas duas
metades, e alm disso, que os smbolos correspondentes das duas metades eram iguais
em todos os casos. Portanto, a cadeia de entrada y pertence linguagem, e pode ser
aceita por A, que passa para um estado final, onde pra.
Exerccio: Construa um all que aceite a linguagem {x x | x*}, onde = {a, b}, em
todos os detalhes.
9.3 - All's e lsc's

Vamos agora provar dois teoremas que mostram que a classe das linguagens
aceitas por all's no determinsticos e a classe das linguagens sensveis ao contexto
(lsc's) so idnticas.
Teorema 9.1: Toda lsc reconhecida por um all no determinstico.
Dem.: Seja L uma lsc, e G uma gsc que gera L. Vamos mostrar como construir um all
A, que aceita L(G). Para verificar que xL(G), A simula uma derivao S*x em
sua fita.
Primeiro, observamos que, se G tem uma regra S , A deve aceitar a entrada vazia,
identificada pelo contedo de fita []. Este caso deve ser tratado especialmente, porque
a derivao S no pode ser simulada sem um espao de comprimento pelo menos
|S| = 1.
Para considerar as demais entradas x = x1 x2 xn, A inicialmente divide sua fita em
duas trilhas, copiando x na primeira trilha, e preparando a segunda para simular uma
derivao de x. Para representar as duas trilhas, vamos usar pares de smbolos, de
forma que
(a1, b1) (a2, b2) (an, bn)
representa uma fita com duas trilhas, que contm, respectivamente, a1a2an e
b1b2bn.
Inicialmente, a fita de A contm
[ x1 x2 xn ].
Dividindo a fita em duas trilhas, temos
[ (x1, S) (x2, ) (xn, ) ]
Na segunda trilha, que contm inicialmente S, A simula uma derivao em G,
sem alterar o contedo da primeira trilha, escolhendo as regras de forma no
determinstica. Supondo-se, naturalmente, que xL, uma derivao de x pode ser
simulada, e ao final da simulao, a fita conter duas cpias de x, uma em cada trilha:
[ (x1, x1) (x2, x2) (xn, xn) ]
Neste ponto, A verifica que o contedo da primeira trilha idntico ao da segunda, e
passa para um estado final.

A idia central da demonstrao a de que, como G uma gsc, as formas sentenciais
intermedirias entre S e x, na derivao S * x, tem todas comprimento menor ou
igual ao de x, e podem portanto ser escritas na segunda trilha.
Nota: a demonstrao acima usa o fato de que o all A no-determinstico de forma
essencial, e essa hiptese no pode ser retirada, pelo menos de forma simples. Na
demonstrao, apenas uma forma sentencial construda a cada vez, sendo a escolha
da regra e da maneira de sua aplicao feita de forma no-determinstica. A
verificao final de que a cadeia x foi obtida, verifica a correo da escolha. (Escolhas
erradas no poderiam derivar x, e portanto no levariam aceitao.)
No caso de um all determinstico, entretanto, isto no seria possvel, e seria
necessrio, em princpio, examinar todas as formas sentenciais possveis, at o
comprimento n da entrada, como foi feito no algoritmo usado para demonstrar que
todas as linguagens sensveis ao contexto so conjuntos recursivos. No possvel,
entretanto, considerar todas as formas sentenciais simultaneamente por causa da
restrio de espao, porque o nmero de formas sentenciais de comprimento menor
ou igual a n pode ser exponencial em n. Uma outra alternativa seria tratar uma forma
sentencial por vez, e anotar apenas o caminho percorrido durante a derivao da
forma sentencial corrente (que regras foram aplicadas em que pontos, por exemplo),
de forma a recuar (backtrack) posteriormente, se a cadeia x no for atingida, para
voltar e considerar as alternativas restantes. Isto tambm no possvel, pois o
comprimento do caminho tambm pode ser exponencial em n.
Como esta demonstrao no pode ser adaptada para o caso determinstico,
pelo menos de forma simples, e nenhuma outra demonstrao alternativa foi
descoberta, o problema da equivalncia das classes das linguagens aceitas por all's
determinsticos e all's no determinsticos um problema ainda em aberto.
Teorema 9.2: Toda linguagem aceita por um all uma lsc.

Dem.: Seja A um all (no determinstico). Para aceitar uma entrada x, A realiza uma
computao
i [ x ] |* f
onde i o estado inicial, e f um dos estado finais de A. Vamos construir uma gsc G
que simula esta computao em cada derivao. Note, entretanto, que uma derivao
de x em G deve partir do smbolo inicial S, e terminar com x, e que a computao
acima s pode ser iniciada aps a definio de x. Usando smbolos no terminais da
forma (a, b, c, d), podemos simular quatro "trilhas":
a primeira trilha guarda uma cpia de x, que no ser alterada;
a segunda guarda outra cpia, que ser usada na simulao;
a terceira guarda o estado corrente e a posio da cabea, durante a
simulao;
a quarta tem as marcas que indicam as extremidades da fita.
A derivao se d em vrias fases:
fase 1: S * (x1, x1, i, [) (x2, x2, , ) ... (xn, xn, , ])

Nesta primeira fase, so geradas as duas cpias de x=x1x2xn, e preparada a
configurao inicial, com o estado i na primeira posio.

fase 2: (x1, x1, i, [) (x2, x2, , ) ... (xn, xn, , ])
* (x1, z1, , [) (x2, z2, , ) (xm, zm, f, ) (xn, zn, , ])
Na segunda fase, feita a simulao de A at que uma configurao final f seja
obtida, com = z1z2zm-1 e = zmzm+1zn.
fase 3: (x1, z1, , [) (x2, z2, , ) (xm, zm, f, ) (xn, zn, , ]) * x1x2xn
Na ltima fase, a partir dos smbolos em que o estado (a terceira componente) final,
feita a substituio, de forma a deixar apenas os smbolos da primeira "trilha".
Os detalhes da construo da gramtica ficam como exerccio para o leitor.
9.4 - Uma linguagem recursiva que no sensvel ao contexto.

Vamos agora apresentar uma linguagem L, definida a seguir, que recursiva,
mas no uma lsc. Para definir L, vamos inicialmente supor uma enumerao das
gsc's, G0, G1, G2, , limitadas ao caso em que o alfabeto dos terminais contm
apenas 0 e 1. Como feito anteriormente com mquinas de Turing, essa enumerao
pode ser baseada na codificao das gramticas em cadeias em um alfabeto adequado.
Apenas para fixar as idias, podemos supor que os smbolos noterminais so
codificados como n, n|, n||, , sendo o noterminal inicial indicado apenas por n.
Dessa forma, para codificar uma gramtica G = < N, , P, S >, no h necessidade de
incluir na codificao de uma gramtica o conjunto de seus terminais (0 e 1 podem
ser representados simplesmente por 0 e 1), o conjunto de noterminais N (sempre
representados por n, n|, n||, , ou o smbolo inicial S (codificado como n). Basta
assim apenas codificar as regras da gramtica, que podem ser separadas por #.
Com isso, o alfabeto pode ser = {0, 1, n, |, , #}. Como fizemos na
enumerao das mquinas de Turing, a enumerao deve eliminar as cadeias de *
que no correspondem a gsc's, e substitu-las por alguma gsc, por exemplo , que
representa a gsc "vazia", que no tem nenhuma regra, e que gera a linguagem vazia
.
Para cada gramtica Gi, possvel construir uma mT que sempre pra e que
reconhece a linguagem de Gi. Seja Mi a mT construda a partir de Gi. Portanto, a
enumerao M0, M1, M2, inclui mT's que aceitam todas as lsc's.
Defina a linguagem L por
L = { xi | Mi no aceita xi }
Fato: L recursiva.
Dem.: Note que, por construo, todas as mquinas Mi aceitam conjuntos recursivos,
e param para todas suas entradas. L aceita por uma mT M que
a partir de sua entrada x, M determina i tal que x=xi, e constri uma
representao de Mi.
simula Mi com entrada xi.
M aceita x=xi se e somente se Mi no aceita xi, ou seja, se Mi, com entrada
xi, pra em um estado que no final.
Fato: L no uma lsc.
Dem.: Por contradio. Suponha que L uma lsc. Neste caso, L tem uma gsc G=Gi, e
aceita pela mquina Mi: L = L(Gi) = L(Mi). Mas ento
xiL Mi no aceita xi xiL(Mi) xiL,
estabelecendo uma contradio. Conclumos, portanto, que L no uma lsc.
As duas propriedades acima estabelecem que a classe das linguagens sensveis
ao contexto est propriamente contida na classe das linguagens recursivas.
(julho 99)

Captulo 10: Linguagens determinsticas e seus aceitadores
Jos Lucas Rangel
10.1 - Introduo.
Nos captulos relativos s linguagens livres de contexto, observamos que as

classes de linguagens aceitas por autmatos de pilha determinsticos (apd) e no
determinsticos (apnd) no so as mesmas, ao contrrio do que acontece, por exemplo,
com os autmatos finitos. Neste captulo, vamos apresentar exemplos e algumas
propriedades das linguagens determinsticas, isto , das linguagens aceitas por apd's.
10.2 - Autmatos de pilha determinsticos.

Como observado anteriormente, um apd um caso particular de apnd, em que,
a partir de qualquer configurao existe, no mximo, uma configurao acessvel. Em
termos da definio de um apd A = <K, , , , i, I, F>, isto significa:
para quaisquer qK, a{}, Z, (q, a, Z) tem, no mximo, um
elemento;
se, para algum qK e algum Z, (q, , Z) no vazio, ento para todos
os smbolos a, (q, a, Z) deve ser vazio.
A primeira condio impede a possibilidade de escolha entre duas transies com um
smbolo; a segunda condio evita a possibilidade de escolha entre a leitura de um
smbolo de , e a leitura de um , ou seja, a escolha entre ler e no ler um smbolo da
entrada.
Note, entretanto, que, ao contrrio do que acontece com os autmatos finitos
determinsticos, pode no existir nenhuma configurao alcanvel a partir de uma
dada configurao, mesmo que a entrada ainda no tenha sido completamente lida.
Por exemplo, a pilha pode ficar vazia. Assim, uma entrada x pode ser deixar de ser
aceita por um apd sem ter sido completamente lida.
Definimos uma linguagem determinstica como sendo uma linguagem aceita
por estado final por um apd. A razo para essa escolha est nas propriedades a seguir,
que limitam o interesse das linguagens aceitas por apd's por pilha vazia.
Dizemos que uma cadeia y um prefixo de outra cadeia x se x = y z para
algum z; dizemos que y um prefixo prprio de x se y um prefixo de x, e y x.
Dizemos que uma linguagem L tem a propriedade dos prefixos se nenhuma
cadeia de L tem um prefixo prprio que tambm pertence a L, ou seja, se dadas duas
cadeias x, y pertencentes a L,
x = yz implica z = .
Fato: Se L = Lpv(M), para algum apd M, ento L tem a propriedade dos prefixos.
Dem.: Suponha que xL. Isto significa que a partir da configurao inicial [i, x, I],
correspondente a x, pode ser alcanada uma configurao final (para aceitao por
pilha vazia) [q, , ]. Considere uma cadeia y=xz, com z. A partir da configurao
inicial correspondente a y, [i, y, I] = [i, xz, I] pode ser alcanada a configurao
[q, z, ], sem que a parte z da entrada seja lida. Como a partir desta ltima
Linguagens Formais Jos Lucas Rangel 10-1
configurao nenhuma outra pode ser atingida, nenhum smbolo de z ser lido, e a
cadeia y no ser aceita.
Exerccio: Seja L uma linguagem qualquer num alfabeto , e seja $ um smbolo novo,
no pertencente a .
(a) Mostre que a linguagem L{$} = { x$ | x(L} tem a propriedade dos prefixos;
(b) Mostre tambm que se L uma linguagem determinstica, ou seja, se L aceita
por estado final por um apd, L{$} aceita por um apd por pilha vazia.
Exerccio: Mostre que as linguagens { ai bj | i=j }, { ai bj | i>j }, { ai bj | i<j } e
{ ai bj | ij }, so determinsticas.
10.3 Propriedades de fechamento da classe das linguagens

determinsticas
Para as linguagens determinsticas, no existe um correspondente do Lema do
Bombeamento (pumping lemma), de forma que a principal maneira de provar que
uma linguagem livre de contexto no determinstica atravs do uso de
propriedades de fechamento. Por exemplo, veremos posteriormente que a classe das
linguagens determinsticas fechada para a operao de complemento. Assim, uma
llc cujo complemento no uma llc no pode ser determinstica.
Vamos comear pela propriedade do fechamento com o complemento.
Teorema: A classe das linguagens determinsticas fechada para o complemento.
Dem.: Seja M um apd que aceita uma linguagem L, por estado final.
Vamos mostrar como construir um apd M' que aceita o complemento de L. A idia
central semelhante da prova do fechamento da classe das linguagens regulares
para o complemento: vamos trocar os estados finais pelos no finais. Assim, pelo
menos em princpio, se L a linguagem aceita por M = < K, , , , i, I, F>, o apd
M' = < K, , , , i, I, K-F> deve aceitar o complemento de L.
Entretanto, algumas possibilidades devem ser consideradas:
1. M no aceita uma entrada x porque M pra sem que a entrada x tenha sido toda
lida. Se construirmos M' apenas pela troca dos estados finais e no finais de M, x
continuaria no sendo aceita, o que seria incorreto.
2. M l toda a entrada x, mas aps isso, M executa uma infinidade de passos com
entrada , sem retirar smbolos da pilha, e, nessa fase, passa por estados finais e
no finais. Note que M aceita x, mas se construirmos M' apenas pela troca dos
estados finais e no finais, x continuaria sendo aceita, o que seria incorreto.
Para resolver esses problemas, necessrio fazer vrias transformaes em M antes
de trocar os estados finais e no finais. Os detalhes da efetiva construo de M' a
partir de M podem ser vistos no livro de Hopcroft e Ullman.
A partir deste resultado, podemos mostrar que a classe das linguagens
determinsticas contida propriamente na classe das llc.
Fato: A llc L = { ai bj ck | ou ij ou jk } no determinstica.
Dem. Basta mostrar que o complemento no uma livre de contexto.

Intuitivamente, L "no pode" ser determinstica porque comparar i e j envolve
um tratamento da pilha (empilhar i smbolos, desempilhar j smbolos) completamente
diferente do necessrio para comparar j e k (empilhar j smbolos, desempilhar k
smbolos).
Fato: A classe das linguagens determinsticas no fechada para as operaes de
unio e interseo.
Dem.: Para a unio, note que a linguagem L do exemplo anterior pode ser vista como
a unio de duas llc determinsticas:
L = { ai bj ck | ou ij ou jk } = L1 L2,
sendo
L1 = { ai bj ck | ij }
L2 = { ai bj ck | jk }
Para mostrar que a classe das linguagens determinsticas no fechada para a
interseo, podemos usar os fatos de que a classe no fechada para a unio, mas
fechada para o complemento. Uma das relaes de de Morgan
L1 L2 = L1 L2
Assim, se a classe das linguagens determinsticas fosse fechada para a interseo,
tambm seria fechada para a unio. Pela contradio, vemos que a classe no pode ser
fechada para interseo.
Exercicio: Mostrar que L = { ai bj | i=j ou i=2j } uma linguagem no determinstica,
que pode ser escrita como a unio de duas linguagens determinsticas.
10.4 Concluso
Com os exemplos e as propriedades estabelecidas neste captulo e nos
anteriores, a hierarquia das classes de linguagens definidas aqui pode ser representada
pela figura abaixo, em que todas as incluses indicadas so prprias.
linguagens

linguagens recursivamente enumerveis (tipo 0)

linguagens recursivas

linguagens sensveis ao contexto (tipo 1)

linguagens livres de contexto (tipo 2)

linguagens determinsticas

linguagens regulares (tipo 3)
(julho 99)

Exemplo 1:
mT M: aceita L={ 0w0 | w{0,1}* }
K = { A, B, C, D }
entrada: 0, 1
fita: , 0, 1, x
inicial: A
final: D
transies:
A0BxR B0B0R B1B1R BCxL C0DxR
aceitao de 01100
A01100 xB1100 x1B100 x11B00 x110B0
x1100B x110C0x x110xDx
Exemplo 2:
(ver Ex.1) Gramtica que gera L, simulando M
terminais: 0, 1
noterminais: S, T, X, Y, Z, W, $, A, B, C, D
inicial: S
regras:
fase 1: (prepara para simular M, salvando uma cpia de x)

S*$Ax$x
S $AT
T 0XT | 1YT | Z
X0 0X Y0 0Y
X1 1X Y1 1Y
XZ Z0 YZ Z1
Z $
fase 2: (simula M)
$Ax$x*$D$x
(D o nico estado final)
A0 xB
B0 0B B1 1B
0B$ C0x$ 1B$ C1x$ xB$ Cxx$
(isto , aB$ Cax$, para a-{})
C0 0D
fase 3: (limpa)
D W
0W W 1W W xW W
W0 W W1 W Wx W
$W$
Para gerar 01100, temos a derivao:
(fase 1)
S $AT $A0XT $A0X1YT $A0X1Y1YT $A0X1Y1Y0XT
$A0X1Y1Y0X0XT $A0X1Y1Y0X0XT $A0X1Y1Y0X0XZ
$A0X1Y1Y0X0XZ $A01XY1Y0X0XZ $A01X1YY0X0XZ
$A011XYY0X0XZ $A011XY0YX0XZ $A011X0YYX0XZ
$A0110XYYX0XZ $A0110XYY0XXZ $A0110XY0YXXZ
$A0110X0YYXXZ $A01100XYYXXZ $A01100XYYXZ0
$A01100XYYZ00 $A01100XYZ100 $A01100XZ1100
$A01100Z01100 $A01100$01100
(fase 2)
$A01100$01100 $xB1100$01100 $x1B100$01100
$x11B00$01100 $x110B0$01100 $x1100B$01100
$x110C0x$01100 $x110xDx$01100
(fase 2)
$x110xDx$01100 $x110xWx$01100 $x110Wx$01100
$x11Wx$01100 $x1Wx$01100 $xWx$01100
$Wx$01100 $W$01100 01100
Exemplo 3:
(ver Exemplo 1)
all M: aceita L={ 0w0 | w{0,1}* }
K = { I, A, B, C, D }
entrada: 0, 1
fita: , 0, 1, x, [, ]
inicial: A
final: D
transies:
I[A[R
A0BxR B0B0R B1B1R B]C]L C0DxR
aceitao de 01100
I[01100] [A01100] [xB1100] [x1B100] [x11B00]
[x110B0] [x1100B] [x110C0x] [x110xDx]
Exemplo 4:
(ver Ex.3) Gramtica que gera L, simulando M
terminais: 0, 1
noterminais:
Temos:
a{0, 1, x}
b{0, 1}
q{I, A, B, C, D}
os no terminais so:
S
(ab) (duas trilhas, com a e b)
([ab) (no incio da fita)
(ab]) (no fim da fita)
(qab) (q l a)
(q[ab) (no incio da fita, q l [)
([qab) (no incio da fita, q l a)
(qab]) (no fim da fita, q l a)
(abq]) (no fim da fita, q l ])
(q[ab]) (caso de um smbolo, q l [)
([qab]) (caso de um smbolo, q l a)
([abq]) (caso de um smbolo, q l ])
inicial: S
regras:
(pode esquecer caso particular : L)
fase 1: (prepara para simular M, salvando uma cpia de x)
S (I[00]) | (I[11]) | (I[00) T | (I[11) T

T (00) T | (11) T | (00]) | (11])
fase 2: (simula M)
Temos:
a, c {0, 1, x}
b, d {0, 1}
passo de M regras correspondentes

I[A[R (I[ab]) ([Aab])
(I[ab) ([Aab)
A0BxR (A0b)(cd) (xb)(Bcd)
([A0b)(cd) ([xb)(Bcd)
(A0b)(cd]) (xb)(Bcd])
([A0b)(cd]) ([xb)(Bcd])
([A0b]) ([xbB]
BaBaR (Bab)(cd) (ab)(Bcd)
([Bab)(cd) ([ab)(Bcd)
(Bab)(cd]) (ab)(Bcd])
([Bab)(cd]) ([ab)(Bcd])
(Bab]) (abB])
([Bab]) ([abB])
B]C]L (abB]) (Cab])
([abB]) ([Cab])
C0DxR (C0b)(cd) (xb)(Dcd)
([C0b)(cd) ([xb)(Dcd)
(C0b)(cd]) (xb)(Dcd])
([C0b]) ([xbD])
fase 3: (limpa)
(Dab) b
([Dab) b (D[ab) b
(Dab]) b (abD]) b
(D[ab]) b ([Dab]) b ([abD]) b
b(cd) bc (cd)b cb
([cd)b cb b(cd]) bc
Para gerar 01100, temos a derivao:

(fase 1)
S (I[00)T (I[00)(11)T (I[00)(11)(11)T
(I[00)(11)(11)(00)T (I[00)(11)(11)(00)(00])
(I[00)(11)(11)(00)(00])
(fase 2)
(I[00)(11)(11)(00)(00]) ([A00)(11)(11)(00)(00])
([x0)(B11)(11)(00)(00]) ([x0)(11)(B11)(00)(00])
([x0)(11)(11)(B00)(00]) ([x0)(11)(11)(00)(B00])
([x0)(11)(11)(00)(00B]) ([x0)(11)(11)(00)(B00])
([x0)(11)(11)(00)(C00]) ([x0)(11)(11)(00)(x0D])
(fase 3)
([x0)(11)(11)(00)(x0D]) ([x0)(11)(11)(00)0
([x0)(11)(11)00 ([x0)(11)100 ([x0)1100 01100

Introdução a Conjuntos, Funções e Relações

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Introdução a Conjuntos, Funções e Relações

Uploaded by

Copyright:

Available Formats

Captulo 0: Conjuntos, funes, relaes

[n] = { i Nat | 0 < i n }.

Este conjunto [n] s vezes representado por {1, 2, , n}, convencionando-se

Produto Cartesiano. O produto cartesiano de dois conjuntos A e B o conjunto A B

A1 A2 An = { (x1, x2, xn ) | para cada i [n], xi Ai }

Podemos definir potncias de um conjunto, a partir da definio de produto

An = A A A (n vezes) = { (x1, x2, xn) | para i [n], xi A}.

Exemplo: Sejam A = { a, b, c }, B = { d, e }. Ento,

J.L.Rangel - Ling. Formais - 0-1

(x, y) f e (x, z) f implicam em y = z.

Naturalmente, esse valor nico de y que f faz corresponder a x indicado pela

Definimos o contradomnio de f: A B como sendo o conjunto

Exemplo: Se considerarmos o conjunto Int dos nmeros inteiros, e a funo suc:

para cada i Int, suc(i) = i + 1,

suc = { , (-2, -1), (-1, 0), (0, 1), (1, 2), }

No caso de sobrejees (e bijees), codomnio e contradomnio so iguais.

Alternativamente, podemos falar em funes injetoras, sobrejetoras ou "sobre",

Conjuntos enumerveis. Um conjunto A enumervel se vazio, ou se existe uma

O nome enumervel se deve ao fato de que, se A no vazio, a sequncia

Fato: Todos os conjunto finitos so enumerveis.

J.L.Rangel - Ling. Formais - 0-2

Fato: Um conjunto infinito enumervel, se e somente se existe uma funo injetora

a, se existir um a tal que g(a) = i

Podemos fazer a caracterizao de diversas maneiras:

J.L.Rangel - Ling. Formais - 0-3

Dem.: por "diagonalizao".

Uma vez que a definio de conjunto enumervel se baseia na existncia de uma

Vamos considerar o conjunto X definido a seguir:

Como X um conjunto de naturais, X P(Nat). Entretanto, veremos que X no faz

ou k f(k), e neste caso k X,

ou k f(k), e neste caso k X.

Em qualquer das possibilidades, portanto, os conjuntos X e f(k) diferem em pelo menos

J.L.Rangel - Ling. Formais - 0-4

"todo conjunto enumervel tem o mesmo nmero de elementos que Nat."

Fato: Se um conjunto A enumervel, e se B um subconjunto de A, B tambm

n( (a, b) ) = g(nA (a), nB (b)).

(a, b, c) = (d, e, f) se e somente se (a=d) e (b=e) e (d=f).

Vamos a seguir introduzir algumas propriedades de relaes binrias. Seja R uma

R reflexiva se para qualquer x A, x R x;

Exemplos: As relaes <, , =, so relaes binrias definidas no conjunto Nat, e tem

reflexiva simtrica transitiva

Exemplo: A relao = no conjunto Nat uma relao de equivalncia; outros exemplos

Composio de relaes: definimos a composio de relaes da forma a seguir:

RS = { (x, z) A C | y B, (x, y) R e (y, z) S }.

Se as relaes R e S so funes, a composio RS se reduz exatamente

Exemplo: Sejam as relaes

Ri+1 = Ri R, para i Nat

No caso do exemplo, podemos provar que (x, y) R se y-x 1. Assim, em

x R* y se e somente se para algum i Nat, x Ri y,

Exemplo: Seja a relao R, no conjunto Nat definida por

Temos x Ri y se e somente se y = x + i, de forma que x R* y se e somente y x.

(1) que satisfaa x R y implica x S y (isto , S R) e

ou seja, x R+ y se e somente se para algum i>0, x Ri y.

Exemplo: Seja a mesma relao R do exemplo anterior. Neste caso, temos

(1) para cada i I, Bi . nenhum bloco vazio

(2) U = U Bi = A a unio dos blocos A

(3) se ij, Bi I Bj = . blocos so disjuntos dois a dois

Dessa maneira, cada elemento a de A pertence a exatamente um bloco da partio P.

Observao: Na maioria das vezes o conjunto I usado para indexar os elementos da

Exemplo: Seja o conjunto A = { a, b, c, d, e }. Temos a seguir alguns exemplos de

Exemplo: Seja a equivalncia R em A = {a, b, c, d, e, f}, dada pelas seguintes

(1) R uma equivalncia