Você está na página 1de 38

I NTRODUÇÃO À L INGUAGEM

% distribui(L,A,B) : distribui itens de L entre A e B


distribui([],[],[]).
A
distribui([X],[X],[]). B
distribui([X,Y|Z],[X|A],[Y|B]) :- distribui(Z,A,B).
E
% intercala(A,B,L) : intercala A e B gerando L
C
intercala([],B,B).
intercala(A,[],A).
intercala([X|A],[Y|B],[X|C]) :-
D F
X =< Y,
intercala(A,[Y|B],C).
intercala([X|A],[Y|B],[Y|C]) :-
X > Y,
Sumário
1. Elementos Básicos ................................................................................ 03
1.1. Fatos................................................................................................... 03
1.2. Consultas ........................................................................................... 03
1.2.1. Variáveis compartilhadas ...................................................... 04
1.2.2. Variáveis Anônimas ............................................................... 05
1.3. Regras ................................................................................................ 05
1.3.1. Grafos de relacionamentos..................................................... 05
1.4. Exercícios ............................................................................................06
2. Banco de Dados Dedutivos ................................................................. 08
2.1. Aritmética .......................................................................................... 08
2.2. Comparação ....................................................................................... 09
2.3. Relacionamento entre tabelas .......................................................... 09
2.4. O modelo relacional........................................................................... 11
2.4. Exercícios ............................................................................................11
3. Controle Procedimental ..................................................................... 13
3.1. Retrocesso .......................................................................................... 13
3.2. Cortes ................................................................................................. 14
3.2.1. Evitando retrocesso desnecessário ........................................ 15
3.2.2. Estrutura condicional............................................................. 16
3.3. Falhas ................................................................................................ 17
3.4. Exercícios ............................................................................................17
4. Programação Recursiva ..................................................................... 19
4.1. Recursividade .................................................................................... 19
4.2. Predicados recursivos........................................................................ 19
4.3. Relações transitivas .......................................................................... 21
4.4. Exercícios ............................................................................................23
5. Listas e Estruturas................................................................................ 24
5.1. Listas.................................................................................................. 24
5.1.1. Tratamento recursivo de listas.............................................. 25
5.1.2. Ordenação de listas ................................................................ 26
5.2. Estruturas ......................................................................................... 28
5.2.1. Representando objetos geométricos....................................... 28
5.3. Exercícios ............................................................................................29
6. Base de Dados Dinâmica ..................................................................... 31
6.1. Manipulação da base de dados dinâmica......................................... 31
6.2. Aprendizagem por memorização ...................................................... 32
6.3. Atualização da base de dados em disco............................................ 33
6.4. Um exemplo completo: memorização de capitais ............................ 33
6.5. Exercícios ............................................................................................35
Capítulo 1
Elementos Básicos
Os elem en t os bá sicos da lin gu a gem P r olog sã o h er da dos da lógica de pr edi-
cados. Esses elementos são fatos, regras e consultas.

1.1 Fatos
Fatos ser vem pa r a est a belecer u m r ela cion a m en t o exist en t e en t r e objet os de
um determinado contexto de discurso. Por exemplo, num contexto bíblico,
pai(adão,cain).
é u m fa t o qu e est a belece qu e Adã o é pa i de Ca in , ou seja , qu e a r ela çã o pai
exist e en t r e os objet os den om in a dos adão e cain. E m P r olog, iden t ifica dor es
de r ela cion a m en t os sã o den om in a dos predicados e iden t ifica dor es de objet os
são denominados átomos. Tanto predicados quanto átomos devem iniciar com
letra minúscula.

Programa 1.1: Uma árvore genealógica.


pai(adão,cain).
pai(adão,abel).
pai(adão,seth).
pai(seth,enos).

1.2 Consultas
P a r a r ecu per a r in for m a ções de u m pr ogr a m a lógico, u sa m os consultas. Um a
con su lt a per gu n t a se u m a det er m in a do r ela cion a m en t o exist e en t r e objet os.
Por exemplo, a consulta
?- pai(adão,cain).
per gu n t a se a r ela çã o pai va le pa r a os objet os adão e cain ou , em ou t r a s
palavras, pergunta se Adão é pai de Cain. Então, dados os fatos estabelecidos
n o P r ogr a m a 1.1, a r espost a a essa con su lt a ser á yes. Sin t a t ica m en t e, fa t os
e con su lt a s sã o m u it o sim ila r es. A difer en ça é qu e fa t os sã o a gr u pa dos n o
a r qu ivo qu e con st it u i o pr ogr a m a , en qu a n t o con su lt a s sã o sen t en ça s digit a-
das no prompt (?-) do interpretador Prolog.
Respon der u m a con su lt a com r ela çã o a u m det er m in a do pr ogr a m a cor r es-
pon de a det er m in a r se a con su lt a é con seqü ên cia lógica desse pr ogr a m a , ou
seja, se a consulta pode ser deduzida dos fatos expressos no programa.

Linguagem Prolog 3
Outra consulta que poderíamos fazer com relação ao Programa 1.1 é
?- pai(adão,enos).
Nesse caso, porém, o sistema responderia no.
As con su lt a s t or n a m -se a in da m a is in t er essa n t es qu a n do em pr ega m os vari-
áveis, ou seja, identificadores para objetos não especificados. Por exem plo,
?- pai(X,abel).
pergunta qu em é o pai d e Abel ou , t ecn ica m en t e, qu e va lor de X t or n a a con-
su lt a u m a con seqü ên cia lógica do pr ogr a m a . A essa per gu n t a o sist em a r es-
ponderá X = adão. Note que variáveis devem iniciar com maiúscula.
Um a con su lt a com va r iá veis pode t er m a is de u m a r espost a . Nesse ca so, o
sist em a a pr esen t a r á a pr im eir a r espost a e fica r á a gu a r da n do a t é qu e seja
pressionado enter, qu e t er m in a a con su lt a , ou ponto-e-vírgula, qu e fa z com
que a próxima resposta possível, se houver, seja apresentada.
?- pai(adão,X).
X = cain ;
X = abel ;
X = seth ;
no

1.2.1 Variável compartilhada


Su pon h a qu e desejá ssem os con su lt a r o P r ogr a m a 1.1 pa r a descobr ir qu em é
o a vô de E n os. Nesse ca so, com o a r ela çã o avô n ã o foi dir et a m en t e defin ida
nesse programa, teríamos que fazer a seguinte pergunta:
Quem é o pai do pai de Enos?
E n t ã o, com o o pa i de E n os n ã o é con h ecido a priori, a con su lt a cor r espon den-
te a essa pergunta tem dois objetivos:
primeiro, descobrir quem é o pai de Enos, digamos que seja Y;
depois, descobrir quem é o pai de Y.
?- pai(Y,enos), pai(X,Y).
Y = seth
X = adão
yes
P a r a r espon der essa con su lt a , pr im eir o o sist em a r esolve pai(Y,enos),
obt en do a r espost a Y = seth. E m segu ida , su bst it u in do Y por seth n o se-
gundo objetivo, o sistema resolve pai(X,seth), obtendo X = adão.

Linguagem Prolog 4
Nessa con su lt a , dizem os qu e a va r iá vel Y é compartilhada pelos objet ivos
pai(Y,enos) e pai(X,Y). Va r iá veis com pa r t ilh a da s sã o ú t eis por qu e n os
permitem estabelecer restrições entre objetivos distintos.

1.2.2 Variável anônima


Ou t r o t ipo de va r iá vel im por t a n t e é a va r iá vel anônima. Um a va r iá vel a n ô-
n im a deve ser u sa da qu a n do seu va lor específico for ir r eleva n t e n u m a de-
terminada consulta. Por exemplo, considerando o Programa 1.1, suponha que
desejá ssem os sa ber qu em já pr ocr iou , ou seja , qu em t em filh os. E n t ã o, com o
o nome dos filhos é uma informação irrelevante, poderíamos digitar:
?- pai(X,_).
A essa consulta o sistema responderia X = adão e X = seth.

1.3 Regras
Regras n os per m it em defin ir n ova s r ela ções em t er m os de ou t r a s r ela ções já
existentes. Por exemplo, a regra
avô(X,Y) :- pai(X,Z), pai(Z,Y).
defin e a r ela çã o avô em t er m os da r ela çã o pai, ou seja , est a belece qu e X é
a vô de Y se X t em u m filh o Z qu e é pa i de Y. Com essa r egr a , podem os a gor a
realizar consultas tais como
?- avô(X,enos).
X = adão
F a t os e r egr a s sã o t ipos de cláusulas e u m con ju n t o de clá u su la s con st it u i
um programa lógico.

1.3.1 Grafos de rela cionamentos


Regr a s podem ser for m u la da s m a is fa cilm en t e se desen h a r m os a n t es u m
grafo d e relacion am en tos. Nesse t ipo de gr a fo, objet os sã o r epr esen t a dos por
nós e r ela cion a m en t os sã o r epr esen t a dos por arcos. Além disso, o a r co qu e
r epr esen t a a r ela çã o qu e est á sen do defin ida deve ser pon t ilh a do. P or exem-
plo, o grafo a seguir define a relação avô.

X avô Y

pai pai

Linguagem Prolog 5
A va n t a gem em se em pr ega r os gr a fos de r ela cion a m en t os é qu e eles n os
per m it em visu a liza r m elh or os r ela cion a m en t os exist en t es en t r e a s va r iá veis
usadas numa regra.
Com o m a is u m exem plo, va m os defin ir a r ela çã o irmão em t er m os da r ela-
ção pai, já exist en t e. P odem os dizer qu e du a s pessoa s dist in t a s sã o ir m ã s se
ambas têm o mesmo pai. Essa regra é representada pelo seguinte grafo:

X irmão Y

pai pai

Em Prolog, essa regra é escrita como:


irmão(X,Y) :- pai(Z,X), pai(Z,Y), X\=Y.
E viden t em en t e, poder ía m os defin ir a r ela çã o irmão sim plesm en t e list a n do
todas as suas instâncias. Veja:
irmão(cain,abel).
irmão(cain,seth).
irmão(abel,cain).
irmão(abel,seth).
irmão(seth,cain).
irmão(seth,abel).
E n t r et a n t o, u sa r r egr a s, a lém de m u it o m a is elega n t e e con ciso, t a m bém é
muito mais consistente. Por exemplo, se o fato pai(adão,eloi) fosse acres-
cen t a do a o P r ogr a m a 1.1, u sa n do a defin içã o por r egr a , n a da m a is pr ecisa r ia
ser a lt er a do. P or ou t r o la do, u sa n do a defin içã o por fa t os, t er ía m os qu e a-
crescentar ao programa mais seis novas instâncias da relação irmão.

1.4 Exercícios
1.1. Digite o Programa 1.1, incluindo as regras que definem as relações avô e
irmão, e realize as seguintes consultas:
a) Quem são os filhos de Adão?
b) Quem são os netos de Adão?
c) Quem são os tios de Enos?

Linguagem Prolog 6
1.2. Considere a árvore genealógica a seguir:

+ +
Ana Ivo Bia Gil

Eva + Raí Clô Ary


+ Lia

Noé Gal

a ) Usa n do fatos, defin a a s r ela ções pai e mãe. E m segu ida , con su lt e o
sistema para ver se suas definições estão corretas.
b) Acr escen t e a o pr ogr a m a os fa t os n ecessá r ios pa r a defin ir a s r ela ções
homem e mulher. P or exem plo, pa r a est a belecer qu e An a é m u lh er e
Ivo é homem, acrescente os fatos mulher(ana) e homem(ivo).
c) Usa n do du a s r egr a s, defin a a r ela çã o gerou(X,Y) t a l qu e X ger ou Y
se X é pa i ou m ã e de Y. F a ça con su lt a s pa r a ver ifica r se su a defin içã o
est á cor r et a . P or exem plo, pa r a a con su lt a gerou(X,eva) o sist em a
deverá apresentar as respostas X = ana e X = ivo.
d) Usando relações já existentes, crie regras para definir as relações fi-
lho, filha, tio, tia, primo, prima, avô e avó. P a r a ca da r ela-
çã o, desen h e o gr a fo de r ela cion a m en t os, codifiqu e a r egr a cor r espon-
dente e faça consultas para verificar a corretude.

1.3. Codifique as regras equivalentes às seguintes sentenças:


a) Todo mundo que tem filhos é feliz.
b) Um casal é formado por duas pessoas que têm filhos em comum.

Linguagem Prolog 7
Capítulo 2
Banco de Dados Dedutivo
Um con ju n t o de fa t os e r egr a s defin em u m ba n co de da dos dedu t ivo, com a
mesma funcionalidade de um banco de dados relacional.

2.1 Aritmética
P r olog ofer ece u m pr edica do especia l is, bem com o u m con ju n t o operadores,
através dos quais podemos efetuar operações aritméticas.
?- X is 2+3.
X = 5
Os oper a dor es a r it m ét icos sã o + (adição), - (subtração), * (multiplicação),
mod (resto), / (divisão real), // (divisão inteira) e ^ (potenciação).

Programa 2.1: Área e população dos países.


% país(Nome, Área, População)
país(brasil, 9, 130).
país(china, 12, 1800).
país(eua, 9, 230).
país(índia, 3, 450).

O P r ogr a m a 2.1 r epr esen t a u m a t a bela qu e r ela cion a a ca da pa ís su a á r ea


em Km 2 e su a popu la çã o em m ilh ões de h a bit a n t es. Not e qu e a lin h a in icia n-
do com % é u m com en t á r io e ser ve a pen a s pa r a fin s de docu m en t a çã o. Com
ba se n esse pr ogr a m a , por exem plo, podem os det er m in a r a den sida de dem o-
gráfica do Brasil, através da seguinte consulta:
?- país(brasil,A,P), D is P/A.
A = 9
P = 130
D = 14.4444

Um a ou t r a con su lt a qu e poder ia ser feit a é a segu in t e: "Qu al a diferença


entre a população da China e da Índia?".
?- país(china,_,X), país(índia,_,Y), Z is X-Y.
X = 1800
Y = 450
Z = 1350

Linguagem Prolog 8
2.2 Comparação
P a r a r ea liza r com pa r a ções n u m ér ica s podem os u sa r os segu in t es pr edica dos
primitivos: =:= (igual) , =\= (diferente), > (maior), >= (m aior ou igu al), <
(menor) e =< (m en or ou igu al). P or exem plo, com esses pr edica dos, podem os
realizar consultas tais como:
A área do Brasil é igual à área dos Estados Unidos?
?- país(brasil,X,_), país(eua,Y,_), X =:= Y.
X = 9
Y = 9
Yes
A população dos Estados Unidos é maior que a população da Índia?
?- país(eua,_,X), país(índia,_,Y), X > Y.
No

2.3 Relacionamentos entre tabelas


O qu a dr o a segu ir r ela cion a a ca da fu n cion á r io de u m a em pr esa seu código,
seu salário e os seus dependentes.

Código Nome Salário Dependen tes


1 Ana R$ 1000,90 Ary
2 Bia R$ 1200,00 ------
3 Ivo R$ 903,50 Raí, Eva

Usa n do os pr in cípios de m odela gem lógica de da dos (1F N), podem os r epr e-
sentar as informações desse quadro através do uso de duas tabelas: a primei-
r a con t en do in for m a ções sobr e os fu n cion á r ios e a segu n da con t en do in for-
m a ções sobr e os depen den t es. E m P r olog, essa s t a bela s podem ser r epr esen-
tadas por meio de dois predicados distintos: func e dep.

Programa 2.2: Funcionários e dependentes.


% func(Código, Nome, Salário)
func(1, ana, 1000.90).
func(2, bia, 1200.00).
func(3, ivo, 903.50).
% dep(Código, Nome)
dep(1, ary).
dep(3, raí).
dep(3, eva).

Linguagem Prolog 9
Agora, com base no Programa 2.2, podemos, por exemplo, consultar o sistema
para recuperar os dependentes de Ivo, veja:
?- func(C,ivo,_), dep(C,N).
C = 3
N = raí ;
C = 3
N = eva
Obser ve qu e n essa con su lt a , o ca m po chave C é u m a va r iá vel com pa r t ilh a da .
É gr a ça s a essa va r iá vel qu e o r ela cion a m en t o en t r e fu n cion á r io e depen den-
tes, existente na tabela original, é restabelecido.

Outra coisa que podemos fazer é descobrir de quem Ary é depen dente:
?- dep(C,ary), func(C,N,_).
C = 1
N = ana

Ou, descobrir quem depende de funcionário com salário inferior a R$ 950,00:


?- func(C,_,S), dep(C,N), S<950.
C = 3
S = 903.5
N = raí ;
C = 3
S = 903.5
N = eva

F in a lm en t e, poder ía m os t a m bém con su lt a r o sist em a pa r a en con t r a r fu n cio-


nários que não têm dependentes:
?- func(C,N,_), not dep(C,_).
C = 2
N = bia

Nessa ú lt im a con su lt a , not é u m pr edica do pr im it ivo do sist em a P r olog qu e


serve com o u m t ipo especia l de n ega çã o, den om in a da n egação por falh a, qu e
será estudada mais adiante. Por enquanto, é suficiente saber que o predicado
not só fu n cion a a pr opr ia da m en t e qu a n do a s va r iá veis exist en t es n o objet ivo
n ega do já se en con t r a m in st a n cia da s n o m om en t o em qu e o pr edica do é a va-
lia do. P or exem plo, n a con su lt a a cim a , pa r a ch ega r a o objet ivo not
dep(C,_), pr im eir o o sist em a pr ecisa r esolver o objet ivo func(C,N,_);
m a s, n esse ca so, a o a t in gir o segu n do objet ivo, a va r iá vel C já foi su bst it u ída
por uma constante (no caso, o número 2).

Linguagem Prolog 10
2.4 O modelo de dados relacional

Programas lógicos são uma poderosa extensão do modelo de dados relacional.


Con ju n t os de fa t os cor r espon dem à s t a bela s do m odelo r ela cion a l e a s oper a-
ções bá sica s da á lgebr a r ela cion a l (seleção, projeção, u n ião, d iferen ça sim étri-
ca e prod u to cartesian o) podem ser fa cilm en t e im plem en t a da s a t r a vés de
regras. Como exemplo, considere o Programa 2.3.

Programa 2.3: Uma tabela de filmes.


% filme(Título, Gênero, Ano, Duração)
filme('Uma linda mulher', romance, 1990, 119).
filme('Sexto sentido', suspense, 2001, 108).
filme('A cor púrpura', drama, 1985, 152).
filme('Copacabana', comédia, 2001, 92).
filme('E o vento levou', drama, 1939, 233).
filme('Carrington', romance, 1995, 130).

Su pon h a qu e u m a loca dor a pr ecisa sse de u m a t a bela con t en do a pen a s film es


clá ssicos (i.e. la n ça dos a t é 1985), pa r a u m a det er m in a da pr om oçã o. E n t ã o,
teríamos que realizar uma seleção na tabela de filmes:
clássico(T,G,A,D) :- filme(T,G,A,D), A =< 1985.
Su pon h a a in da qu e a loca dor a deseja sse a pen a s os n om es e os gên er os dos
filmes clássicos. Nesse caso, teríamos que usar também projeção:
clássico(T,G) :- filme(T,G,A,_), A =< 1985.
Agora, fazendo uma consulta com esse novo predicado clássico, obteríamos
as seguintes respostas:
?- clássico(T,G).
T = 'A cor púrpura'
G = drama ;
T = 'E o vento levou'
G = drama

2.5 Exercícios
2.1. In clu a n o P r ogr a m a 2.1 u m a r egr a pa r a o pr edica do dens(P,D), qu e
r ela cion a ca da pa ís P à su a den sida de dem ogr á fica cor r espon den t e D.
Em seguida, faça consultas para descobrir:
a) qual a densidade demográfica de cada um dos países;
b) se a Índia é mais populosa que a China.

Linguagem Prolog 11
2.2. In clu a n o P r ogr a m a 2.2 a s in for m a ções da t a bela a ba ixo e fa ça a s con-
sultas indicadas a seguir:

Código Nome Salário Dependen tes


4 Leo R$ 2500,35 Lia, Noé
5 Clô R$ 1800,00 Eli
6 Gil R$ 1100,00 ------

a) Quem tem salário entre R$ 1500,00 e R$ 3000,00?


b) Quem não tem dependentes e ganha menos de R$ 1200,00?
c) Quem depende de funcionário que ganha mais de R$ 1700,00?

2.3. Inclua no Programa 2.3 as seguintes regras:


a) Um filme é longo se tem duração superior a 150 minutos.
b) Um filme é lançamento se foi lançado a menos de 1 ano.

2.4. Codifiqu e u m pr ogr a m a con t en do a s in for m a ções da t a bela a ba ixo e fa ça


as consultas indicadas a seguir:

Nome Sexo Idade Altura Peso


Ana fem 23 1.55 56.0
Bia fem 19 1.71 61.3
Ivo masc 22 1.80 70.5
Lia fem 17 1.85 57.3
Eva fem 28 1.75 68.7
Ary masc 25 1.72 68.9

a) Quais são as mulheres com mais de 20 anos de idade?


b) Quem tem pelo menos 1.70m de altura e menos de 65kg?
c) Quais são os possíveis casais onde o homem é mais alto que a mulher?

2.5. O peso idea l pa r a u m a m odelo é n o m á xim o 62.1*Altura–44.7 . Além


disso, pa r a ser m odelo, u m a m u lh er pr ecisa t er m a is qu e 1.70m de a lt u-
ra e menos de 25 anos de idade. Com base nessas informações, e conside-
r a n do a t a bela do exer cício a n t er ior , defin a u m pr edica do ca pa z de r ecu-
perar apenas os nomes das mulheres que podem ser modelos.

Linguagem Prolog 12
Capítulo 3
Controle Procedimental
E m bor a P r olog seja u m a lin gu a gem essen cia lm en t e decla r a t iva , ela pr ovê
recursos que nos permitem interferir no comportamento dos programas.

3.1 Retrocesso
O n ú cleo do P r olog, den om in a do m otor d e in ferên cia, é a pa r t e do sist em a
qu e im plem en t a a est r a t égia de bu sca de solu ções. Ao sa t isfa zer u m objet ivo,
ger a lm en t e h á m a is de u m a clá u su la n o pr ogr a m a qu e pode ser em pr ega da ;
com o a pen a s u m a dela s pode ser u sa da de ca da vez, o m ot or de in fer ên cia
seleciona a primeira delas e reserva as demais para uso futuro.

Programa 3.1: Números binários de três dígitos.


d(0). % cláusula 1
d(1). % cláusula 2
b([A,B,C]) :- d(A), d(B), d(C). % cláusula 3

Por exemplo, para satisfazer o objetivo


?- b(N).
a ú n ica opçã o qu e o m ot or de in fer ên cia t em é selecion a r a t er ceir a clá u su la
do P r ogr a m a 3.1. E n t ã o, u sa n do u m m eca n ism o den om in a do resolução, o
sistema fará N=[A,B,C] e reduzirá1 a consulta inicial a uma nova consulta:
?- d(A), d(B), d(C).
Qu a n do u m a con su lt a con t ém vá r ios objet ivos, o sist em a selecion a sem pr e
a qu ele m a is à esqu er da e, por t a n t o, o pr óxim o objet ivo a ser r esolvido ser á
d(A). P a r a r esolver d(A), h á du a s opções: clá u su la s 1 e 2. O sist em a sele-
cion a r á a pr im eir a dela s, deixa n do a ou t r a pa r a depois. Usa n do a clá u su la 1,
ficaremos, então, com A=0, N=[0,B,C] e a consulta será reduzida a:
?- d(B), d(C).
A pa r t ir da í, os pr óxim os dois objet ivos ser ã o r esolvidos a n a loga m en t e a
d(A) e a r espost a N=[0,0,0] ser á exibida n o vídeo. Nesse pon t o, se a t ecla
ponto-e-vírgula for pr ession a da , o m eca n ism o de retrocesso ser á a cion a do e o
sist em a t en t a r á en con t r a r u m a r espost a a lt er n a t iva . P a r a t a n t o, o m ot or de
in fer ên cia r et r oceder á n a ú lt im a escolh a feit a e selecion a r á a pr óxim a a lt er-

1 Reduzir significa que um objetivo complexo é substituído por objetivos mais sim ples.

Linguagem Prolog 13
n a t iva . A figu r a a segu ir m ost r a a á r vor e de bu sca con st r u ída pelo m ot or de
inferência, até esse momento, bem como o resultado do retrocesso.

?- b(N).
3, N=[A,B,C]

?- d(A), d(B), d(C).

1, A=0 2

?- d(B), d(C). ...

1, B=0 2

?- d(C). ...

1, C=0 2, C=1

R=[0,0,0] R=[0,0,1]

3.2 Cortes
Nem sem pr e deseja m os qu e t oda s a s possíveis r espost a s a u m a con su lt a se-
ja m en con t r a da s. Nesse ca so, podem os in st r u ir o sist em a a podar os r a m os
indesejáveis da árvore de busca e ganhar eficiência.
Tom a n do com o exem plo o P r ogr a m a 3.1, pa r a desca r t a r os n ú m er os bin á r ios
in icia n do com o dígit o 1, ba st a r ia poda r o r a m o da á r vor e de bu sca qu e fa z
A=1. Isso pode ser feito do seguinte modo:
bin([A,B,C]) :- d(A), !, d(B), d(C).
A execu çã o do pr edica do ! (corte) poda t odos os r a m os a in da n ã o explor a dos,
a partir do ponto em que a cláusula com o corte foi selecionada.

?- bin(N).
3, N=[A,B,C]

?- d(A), !, d(B), d(C).

1, A=0 2

?- !, d(B), d(C). ...

?- d(B), d(C).

Linguagem Prolog 14
3.2.1 Evitando retrocesso desnecessário
Vamos a n a lisa r u m exem plo cu ja execu çã o en volve r et r ocesso desn ecessá r io
e veremos como evitar este problema com o uso de corte. Considere a função:

0 se x < 5
(x) = 1 se x 5 e x 9
2 se x 9

Essa função pode ser codificada em Prolog da seguinte maneira:

Programa 3.2: Uma função matemática.


f(X,0) :- X<5. % cláusula 1
f(X,1) :- X>=5, X=<9. % cláusula 2
f(X,2) :- X>9. % cláusula 3

Para enxergar onde há retrocesso desnecessário, considere a consulta


?- f(1,Y).
P a r a r esolver f(1,Y), pr im eir o selecion a m os a clá u su la 1. Com ela , obt em os
X=1, Y=0 e a con su lt a é r edu zida a o objet ivo 1<5. Com o esse objet ivo é ver-
da deir o, a r espost a Y=0 é exibida n o vídeo. E n t ã o, ca so o u su á r io pr ession e
ponto-e-vírgula, o r et r ocesso selecion a r á a clá u su la 2. Ist o r esu lt a r á em n o-
vos va lor es pa r a X e Y e a con su lt a ser á r edu zida a os objet ivos 1>=5 e 1=<9.
Com o esses objet ivos n ã o podem ser sa t isfeit os, o r et r ocesso ser á a cion a do
a u t om a t ica m en t e e a clá u su la 3 ser á selecion a da . Com essa ú lt im a clá u su la ,
a con su lt a ser á r edu zida a 1>5 e, com o esse objet ivo t a m bém n ã o pode ser
satisfeito, o sistema exibirá a resposta no.
De fa t o, a s t r ês r egr a s qu e defin em a fu n çã o f(x) sã o m u t u a m en t e exclu siva s
e, por t a n t o, a pen a s u m a dela s t er á su cesso pa r a ca da va lor de x. P a r a evit a r
qu e a pós o su cesso de u m a r egr a , ou t r a delt a s seja in u t ilm en t e selecion a da ,
podem os u sa r cor t es. Qu a n do o m ot or de in fer ên cia selecion a u m a clá u su la e
execu t a u m cor t e, a u t om a t ica m en t e, ele desca r t a t oda s a s dem a is clá u sulas
exist en t es pa r a o pr edica do em qu est ã o. Dessa for m a , evit a m os r et r ocesso
desnecessário e ganhamos velocidade de execução.

Programa 3.3: Uso de cortes para evitar retrocesso desnecessário.


f(X,0) :- X<5, !. % cláusula 1
f(X,1) :- X>=5, X=<9, !. % cláusula 2
f(X,2) :- X>9. % cláusula 3

Linguagem Prolog 15
3.2.2 Estrutura condicional
E m bor a n ã o seja con sider a do u m est ilo decla r a t ivo pu r o, é possível cr ia r em
Prolog um predicado para implementar a estrutura condicional if-then-else.

Programa 3.4: Comando if-then-else.


if(Condition,Then,Else) :- Condition, !, Then.
if(_,_,Else) :- Else.

Para entender como esse predicado funciona, considere a consulta a seguir:


?- if(8 mod 2 =:= 0, write(par), write(ímpar)).
Usando a primeira cláusula do Programa 3.4, obtemos
Condition = 8 mod 2 =:= 0
Then = write(par)
Else = write(ímpar)
e a consulta é reduzida a três objetivos:
?- 8 mod 2 =:= 0, !, write(par).
Com o a con diçã o expr essa pelo pr im eir o objet ivo é ver da deir a , m a is u m a
redução é feita pelo sistema e obtemos
?- !, write(par).
Agor a o cor t e é execu t a do, fa zen do com qu e a segu n da clá u su la do pr ogr a m a
seja descartada, e a consulta tor na-se
?- write(par).
Finalmente, execu t a n do-se write, a pa la vr a par é exibida n o vídeo e o pr o-
cesso termina.

Considere agora essa outra consulta:


?- if(5 mod 2 =:= 0, write(par), write(ímpar)).
Novamente a primeira cláusula é selecionada e obtemos
?- 8 mod 2 =:= 0, !, write(par).
Nesse ca so, por ém , com o a con diçã o expr essa pelo pr im eir o objet ivo é fa lsa , o
cor t e n ã o ch ega a ser execu t a do e a segu n da clá u su la do pr ogr a m a é, en t ã o,
selecion a da pelo r et r ocesso. Com o r esu lt a do da seleçã o dessa segu n da clá u-
sula, a palavra ímpar é exibida no vídeo e o processo termina.

Linguagem Prolog 16
3.3 Falhas
Vamos retomar o Programa 3.1 como exemplo:
?- b(N).
N = [0,0,0] ;
N = [0,0,1] ;
N = [0,1,0] ;
...
P odem os obser va r n a con su lt a a cim a qu e, a ca da r espost a exibida , o sist em a
fica aguardando o usuário pressionar a tecla ';' para buscar outra solução.
Uma forma de forçar o retrocesso em busca de soluções alternativas, sem que
o u su á r io t en h a qu e solicit a r , é fa zer com qu e a pós ca da r espost a obt ida o
sist em a en con t r e u m objet ivo insatisfatível. E m P r olog, esse objet ivo é repre-
sentado pelo predicado fail, cuja execução sempre provoca uma falha.

Programa 3.5: Uso de falhas para recuperar respostas alternativas.


d(0).
d(1).
bin :- d(A), d(B), d(C), write([A,B,C]), nl, fail.

O P r ogr a m a 3.5 m ost r a com o podem os u sa r o pr edica do fail. A execu çã o


dessa ver sã o m odifica da do P r ogr a m a 3.1 exibir á t oda s a s r espost a s, sem
interrupção, da primeira até a última:
?- bin.
[0,0,0]
[0,0,1]
[0,1,0]
...

3.4 Exercícios
3.1. O programa a seguir associa a cada pessoa seu esporte preferido.
joga(ana,volei).
joga(bia,tenis).
joga(ivo,basquete).
joga(eva,volei).
joga(leo,tenis).

Linguagem Prolog 17
Su pon h a qu e deseja m os con su lt a r esse pr ogr a m a pa r a en con t r a r u m
parceiro P pa r a joga r com Leo. E n t ã o, podem os r ea liza r essa con su lt a de
duas formas:
a) ?- joga(P,X), joga(leo,X), P\=leo.
b) ?- joga(leo,X), joga(P,X), P\=leo.
Desenhe as árvores de busca construídas pelo sistema ao responder cada
uma dessas consultas. Qual consulta é mais eficiente, por quê?

3.2. O pr edica do num cla ssifica n ú m er os em t r ês ca t egor ia s: positivos, nulo e


negativos. E sse pr edica do, da m a n eir a com o est á defin ido, r ea liza r et r o-
cesso desnecessário. Explique por que isso acontece e, em seguida, utilize
cortes para eliminar esse retrocesso.
num(N,positivo) :- N>0.
num(0,nulo).
num(N,negativo) :- N<0.

3.3. Su pon h a qu e o pr edica do fail n ã o exist isse em P r olog. Qu a l da s du a s


definições a seguir poderia ser corretamente usada para causar falhas?
a) falha :- (1=1).
b) falha :- (1=2).

3.4. Considere o programa a seguir:


animal(cão).
animal(canário).
animal(cobra).
animal(morcego).
animal(gaivota).
voa(canário).
voa(morcego).
voa(gaivota).
dif(X,X) :- !, fail.
dif(_,_).
pássaro(X) :- animal(X), voa(X), dif(X,morcego).

Desenhe a árvore de busca necessária para responder a con sulta


?- pássaro(X).
Em seguida, execute o programa para ver se as respostas do sistema cor-
respondem àquelas que você encontrou.

Linguagem Prolog 18
Capítulo 4
Programação Recursiva
Recu r sivida de é fu n da m en t a l em P r olog; gr a ça s a o seu u so, pr ogr a m a s r ea l-
mente práticos podem ser implementados.

4.1 Recursividade
A recursividade é um princípio que nos permite obter a solução de um proble-
m a a pa r t ir da solu çã o de u m a in st â n cia m en or dele m esm o. P a r a a plica r
esse pr in cípio, devem os a ssu m ir com o h ipót ese qu e a solu çã o da in st â n cia
m en or é con h ecida . P or exem plo, su pon h a qu e deseja m os ca lcu la r 2 11. Um a
in st â n cia m en or desse pr oblem a é 2 10 e, pa r a essa in st â n cia , "sa bem os" qu e a
solução é 1024. Então, como 2 210 2 11, concluímos que 2 11 2 1024 2048.

problema
solução
original
final

simplifica usa

instância obtemos solução


menor

A figu r a a cim a ilu st r a o pr in cípio de r ecu r sivida de. De m odo ger a l, pr ocede-
m os da segu in t e m a n eir a : sim plifica m os o problem a origin al t r a n sfor mando-
o n u ma instância m en or; en t ã o, obtemos a solução pa r a essa in st â n cia e a
usamos para construir a solução final, correspondente ao problema original.
O qu e é difícil de en t en der , a priori, é com o a solu çã o pa r a a in st â n cia m en or
é obt ida . P or ém , n ã o pr ecisa m os n os pr eocu pa r com essa pa r t e. A solu çã o da
in st â n cia m en or é ger a da pelo pr ópr io m eca n ism o da r ecu r sivida de. Sen do
a ssim , t u do o qu e pr ecisa m os fa zer é en con t r a r u m a sim plifica çã o a dequ a da
para o problema em questão e descobrir como a solução obtida recursivamen-
te pode ser usada para construir a solução final.

4.2 Predicados recursivos


A definição de um predicado recursivo é composta por duas partes:
1o base: resolve diretamente a instância mais simples do problema.
2o passo: resolve instâncias maiores, usando o princípio de recursividade.

Linguagem Prolog 19
Programa 4.1: Cálculo de potência.
% pot(Base,Expoente,Potência)
pot(_,0,1). % base
pot(B,N,P) :- % passo
N>0, % condição do passo
M is N-1, % simplifica o problema
pot(B,M,R), % obtém solução da instância menor
P is B*R. % constrói solução final

O P r ogr a m a 4.1 m ost r a a defin içã o de u m pr edica do pa r a ca lcu la r pot ên cia s.


A ba se pa r a esse pr oblem a ocor r e qu a n do o expoen t e é 0 , já qu e qu a lqu er
n ú m er o eleva do a 0 é igu a l a 1 . P or ou t r o la do, se o expoen t e é m a ior qu e 0 ,
então o pr oblem a deve ser sim plifica do, ou seja , t em os qu e ch ega r u m pou co
m a is per t o da ba se. A ch a m a da r ecursiva com M igu a l a N-1 ga r a n t e ju st a-
m en t e isso. P or t a n t o, a pós u m n ú m er o fin it o de pa ssos, a ba se do pr oblem a é
atingida e o resultado esperado é obtido.
Um m odo de en t en der o fu n cion a m en t o dos pr edica dos r ecu r sivos é desen h a r
o fluxo de execução.

pot(2,3,R) obtemos
R=8

3 1 2

pot(2,2,R) obtemos R=4

2 1 2

pot(2,1,R) obtemos R=2

1 1 2

pot(2,0,R) obtemos R=1

A ca da expa n sã o, deixa m os a ova l em br a n co e r ot u la m os a set a qu e sobr e


com a oper a çã o qu e fica pen den t e. Qu a n do a ba se é a t in gida , com eçam os a
preencher as ovais, propagando os resultados de baixo para cima e efetuando
a s oper a ções pen den t es. O ca m in h o segu ido é a qu ele in dica do pela s set a s
duplas. As setas pontilhadas representam a hipótese de recursividade.
Linguagem Prolog 20
Programa 4.2: Cálculo de fatorial.
% fat(Número,Fatorial)
fat(0,1). % base
fat(N,F) :- % passo
N>0, % condição do passo
M is N-1, % simplifica o problema
fat(M,R), % obtém solução da instância menor
F is N*R. % constrói solução final

O P r ogr a m a 4.2 m ost r a m a is u m exem plo de pr edica do r ecu r sivo e a figu r a a


seguir mostra o fluxo de execução para a consulta ?- fat(3,R).

fat(3,R) obtemos
R=6

3 1 3

fat(2,R) obtemos R=2

2 1 2

fat(1,R) obtemos R=1

1 1 1

fat(0,R) obtemos R=1

4.3 Relações transitivas


Se u m a r ela çã o r é transitiva, en t ã o r(x,y) e r(y,z) im plica m r(x,z). Um exem-
plo desse t ipo de r ela çã o é a r ela çã o ancestral: se Adã o é a n cest r a l de Set h e
Set h é a n cest r a l de E n os, en t ã o Adã o t a m bém é a n cest r a l de E n os. Um a r e-
la çã o t r a n sit iva é sem pr e defin ida em t er m os de u m a ou t r a r ela çã o, den om i-
n a da r ela çã o base. No ca so da r ela çã o ancestral, a r ela çã o ba se é a r ela çã o
pai. Assim , podem os dizer qu e se u m in divídu o x é pa i de u m in divídu o y,
então x é ancestral de y. Além disso, se x é pai de z e z é ancestral de y, então
x t a m bém é a n cest r a l de y. E ssa s r egr a s podem ser visu a liza da s n os gr a fos
de relacionamentos a seguir:

Linguagem Prolog 21
X ancestral Y

pai

X ancestral Y

pai ancestral

Programa 4.3: A relação transitiva ancestral.


pai(adão,cain).
pai(adão,abel).
pai(adão,seth).
pai(seth,enos).
ancestral(X,Y) :- pai(X,Y).
ancestral(X,Y) :- pai(X,Z), ancestral(Z,Y).

Veja uma consulta que poderia ser feita com o Programa 4.3:
?- ancestral(X,enos).
X = seth ;
X = adão

Ou t r o exem plo in t er essa n t e de r ela çã o t r a n sit iva é a r ela çã o acima, cu ja


relação base é a relação sobre. Os grafos a seguir descrevem essa relação:

X acima Y

sobre

X acima Y

sobre acima

Linguagem Prolog 22
D
B
C
A

Programa 4.4: A relação transitiva acima.


sobre(b,a).
sobre(d,b).
sobre(d,c).
acima(X,Y) :- sobre(X,Y).
acima(X,Y) :- sobre(X,Z), acima(Z,Y).

Veja uma consulta que poderia ser feita com o Programa 4.4:
?- acima(X,a).
X = b ;
X = d

4.4 Exercícios
4.1. Defin a u m pr edica do r ecu r sivo pa r a ca lcu la r o pr odu t o de dois n ú m er os
naturais usando apenas soma e subtração.
4.2. Defina um predicado recursivo exibir um número natural em binário.
4.3. O gr a fo a segu ir r epr esen t a u m m a pa , cu ja s cida des sã o r epr esen t a da s
por let r a s e cu ja s est r a da s (de sen t ido ú n ico) sã o r epr esen t a dos por n ú-
meros, que indicam sua extensão em km.

25
A B
32
19
23 E
C
26
14 28

D 30 F

a ) Usa n do o pr edica do estrada(Origem,Destino,Km), cr ie u m pr o-


grama para representar esse mapa.
b) Defin a a r ela çã o t r a n sit iva dist(A,B,D), qu e det er m in a a dist â n cia
D entre duas cidades A e B.

Linguagem Prolog 23
Capítulo 5
Listas e Estruturas
List a s e est r u t u r a s sã o os dois m eca n ism os bá sicos exist en t es n a lin gu a gem
Prolog para criação de estruturas de dados mais complexas.

5.1 Listas
Uma lista é u m a seqü ên cia lin ea r de it en s, sepa r a dos por vír gu la s e delim i-
t a dos por colch et es. A list a vazia é r epr esen t a da por [] e u m a list a com pelo
m en os u m it em é r epr esen t a da por [X|Y], on de X é a cabeça (pr im eir o it em )
e Y é a cauda (demais itens) dessa lista.

?- [X|Y] = [terra, sol, lua].


X = terra
Y = [sol, lua]
Yes
?- [X|Y] = [estrela].
X = estrela
Y = []
Yes
?- [X|Y] = [].
No

A tabela a seguir lista alguns padrões úteis na manipulação de listas:

Padrão Quantidade de itens na lista


[] Nenhum
[X] um único item
[X|Y] pelo menos um item
[X, Y] exatamente dois itens
[X, Y|Z] pelo menos dois itens
[X, Y, Z] exatamente três itens

Por exemplo, para selecionar o terceiro item de uma lista podemos fazer:
?- [_,_,X|_] = [a,b,c,d,e].
X = c
Yes

Linguagem Prolog 24
5.1.1 Tratamento recursivo de listas
Usa n do o pr in cípio de r ecu r sivida de podem os per cor r er u m a list a a cessa n do
seus itens, um a um, seqüencialmente.

Programa 5.1: Exibição de listas.


% exibe(L) : exibe os elementos da lista L
exibe([]) :- nl.
exibe([X|Y]) :- write(X), exibe(Y).

O P r ogr a m a 5.1 m ost r a u m pr edica do pa r a exibiçã o de list a s. Qu a n do a list a


est á va zia , ele a pen a s m u da o cu r sor pa r a u m a n ova lin h a (nl). Qu a n do a
list a t em pelo m en os u m it em , ele exibe o pr im eir o deles u sa n do write e fa z
u m a ch a m a da r ecu r siva pa r a exibir os dem a is it en s. A ca da ch a m a da r ecu r-
siva a list a t er á u m it em a m en os. P or t a n t o, ch ega r á u m m om en t o em qu e a
lista ficará vazia e, então, o processo termina rá.

Programa 5.2: Verifica se um item é membro de uma lista.


% membro(X,L) : o item X é membro da lista L
membro(X,[X|_]).
membro(X,[_|Y]) :- membro(X,Y).

O P r ogr a m a 5.2 m ost r a u m ou t r o pr edica do cu ja fin a lida de pr in cipa l é de-


terminar se um item X consta numa lista L.
?- membro(c,[a,b,c,d]).
Yes
?- membro(e,[a,b,c,d]).
No
O in t er essa n t e é qu e esse pr edica do t a m bém ser u sa do pa r a a cessa r os it en s
existentes numa lista, veja:
?- membro(X,[a,b,c,d]).
X = a ;
X = b ;
X = c ;
X = d

Programa 5.3: Anexa duas listas.


% anexa(A,B,C): A anexado com B dá C
anexa([], B, B).
anexa([X|A], B, [X|C]) :- anexa(A, B, C).

Linguagem Prolog 25
Ou t r o pr edica do ba st a n t e ú t il é a qu ele a pr esen t a do n o P r ogr a m a 5.3. Con-
for m e a pr im eir a clá u su la est a belece, qu a n do u m a list a va zia é a n exa da a
u m a list a B, o r esu lt a do ser á a pr ópr ia list a B. Ca so con t r á r io, se a pr im eir a
list a n ã o for va zia , en t ã o podem os a n exa r a su a ca u da A com a segu n da list a
B e, depois, prefixar sua cabeça X ao resultado obtido C.
O pr edica do anexa t em com o fin a lida de bá sica a n exa r du a s list a s, m a s t a m-
bém pode ser usado de outras formas interessantes.

?- anexa([a,b],[c,d],L).
L = [a,b,c,d]
?- anexa([a,b],L, [a,b,c,d]).
L = [c,d]
?- anexa(X,Y,[a,b,c]).
X = []
Y = [a,b,c] ;
X = [a]
Y = [b,c] ;
X = [a, b]
Y = [c] ;
X = [a,b,c]
Y = []

5.1.2 Ordenação de listas


Va m os or den a r u m a list a L, u sa n do u m a lgor it m o con h ecido com o ordenação
por intercalação. Esse algoritmo consiste de três passos básicos:
distribuir os it en s da list a L en t r e du a s su blist a s A e B, de m odo qu e ela s
tenham tamanhos aproximadamen te iguais;
ordenar r ecu r siva m en t e a s su blist a s A e B, obt en do-se, r espect iva m en t e,
as sublistas As e Bs;
intercalar as sublistas As e Bs, obtendo-se a lista ordenada S.

Programa 5.4: Algoritmo Merge Sort.


% distribui(L,A,B) : distribui itens de L entre A e B
distribui([],[],[]).
distribui([X],[X],[]).
distribui([X,Y|Z],[X|A],[Y|B]) :- distribui(Z,A,B).

Linguagem Prolog 26
% intercala(A,B,L) : intercala A e B gerando L
intercala([],B,B).
intercala(A,[],A).
intercala([X|A],[Y|B],[X|C]) :-
X =< Y,
intercala(A,[Y|B],C).
intercala([X|A],[Y|B],[Y|C]) :-
X > Y,
intercala([X|A],B,C).

% ordena(L,S) : ordena a lista L obtendo S


ordena([],[]).
ordena([X],[X]).
ordena([X,Y|Z],S) :-
distribui([X,Y|Z],A,B),
ordena(A,As),
ordena(B,Bs),
intercala(As,Bs,S).

Usando o Programa 5.4 podemos fazer a seguinte consulta:


?- ordena([3,5,0,4,1,2],S).
S = [0,1,2,3,4,5]

P a r a or den a r a list a [3,5,0,4,1,2], pr im eir o o pr edica do dist r ibu i é ch a-


m a do. Com o a list a t em m a is de u m it em , a t er ceir a clá u su la do pr edica do
distribui é utilizada. Essa cláusula remove os dois primeiros itens da lista
e dist r ibu i os dem a is it en s en t r e A e B, r ecu r siva m en t e; em segu ida , a dicion a
u m dos it en s r em ovidos em A e o ou t r o em B. E ssa polít ica "u m pra m im , u m
pra você" é que garante que a distribuição será equilibrada.
?- distribui([3,5,0,4,1,2],A,B).
A = [3, 0, 1]
B = [5, 4, 2]
Depois qu e a dist r ibu içã o é feit a , a r ecu r sivida de se en ca r r ega de or den a r
ca da u m a da s su blist a s e pr odu zir As=[0,1,3] e Bs=[2,4,5], qu e sã o pa s-
sa da s com o en t r a da a o pr edica do intercala. E sse pr edica do, en t ã o, com pa-
r a o pr im eir o it em da list a As com o pr im eir o it em da list a Bs e selecion a o
menor deles. Após in t er ca la r r ecu r siva m en t e os it en s r est a n t es, o it em sele-
cionado é inserido no início da lista obtida pela intercalação recursiva.
?- intercala([0,1,3],[2,4,5],S).
S = [0,1,2,3,4,5]

Linguagem Prolog 27
5.2 Estruturas
Estruturas sã o objet os de da dos qu e possu em u m a qu a n t ida de fixa de com-
pon en t es, ca da u m deles poden do ser a cessa do in dividu a lm en t e. P or exem-
plo, data(6,agosto,2003) é u m a est r u t u r a cu jos com pon en t es sã o 6, a-
gosto e 2003. P a r a com bin a r os com pon en t es de u m a est r u t u r a u sa m os u m
functor. Nesse exem plo, o fu n ct or é a pa la vr a data. Um a est r u t u r a t em a
forma de um fato, mas pode ser usada como argumento de um predicado.

Programa 5.6: Acontecimentos históricos.


hist(data(22,abril,1500), 'Descobrimento do Brasil').
hist(data(7,setembro,1822),'Declaração da independência').
hist(data(15,novembro,1888),'Proclamação da República').

As con su lt a s a segu ir , feit a s com ba se n o P r ogr a m a 5.6, m ost r a m o u so de


estruturas em Prolog:
?- hist(data(7,setembro,1822),F).
F = 'Declaração da independência'
?- hist(D,'Proclamação da República').
D = data(15, novembro, 1888)

5.1.2 Representando objetos geométricos


Ver em os a gor a com o est r u t u r a s podem ser em pr ega da s pa r a r epr esen t a r
a lgu n s objet os geom ét r icos sim ples: u m pon t o ser á r epr esen t a do por su a s
coor den a da s n o pla n o ca r t esia n o, u m a lin h a ser á defin ida por dois pon t os, e
um triângulo será definido por três pontos:
y

A B
5 C

0 3 7 13 x

Usa n do os fu n ct or es ponto, linha e triângulo, a lgu n s dos objet os da figu-


ra acima podem ser representados do seguinte modo:
A = ponto(3,5)
B = linha(ponto(7,9),ponto(13,2))
C = triângulo(ponto(3,5),ponto(7,9),ponto(13,2))

Linguagem Prolog 28
Programa 5.6: Verificando linhas verticais e horizontais.
vertical( linha(ponto(X,_), ponto(X,_)) ).
horizontal( linha(ponto(_,Y), ponto(_,Y)) ).

O Programa 5.6 mostra como podemos obter resultados interessantes usando


est r u t u r a s. E sse pr ogr a m a est a belece qu e u m a lin h a é ver t ica l se seu s ex-
t r em os t êm a m esm a or den a da e qu e ela é h or izon t a l se os seu s ext r em os
têm mesma abcissa. Com esse programa, podemos fazer consultas tais como:
?- vertical(linha(ponto(1,1),ponto(1,2))).
Yes
?- vertical(linha(ponto(1,1),ponto(2,Y))).
No
?- horizontal(linha(ponto(1,1),ponto(2,Y))).
Y = 1
Yes

Ou ainda a consulta: ‘Existe linha vertical com extremo em (2,3)?’


?- vertical( linha(ponto(2,3),P) ).
P = ponto(2,_0084)
Yes
Cu ja r espost a exibida pelo sist em a sign ifica : ‘sim , qu alqu er lin h a qu e com eça
no ponto (2,3) e termina no ponto (2,_) é uma resposta à questão’.

Ou t r a con su lt a in t er essa n t e ser ia : ‘E xiste u m a lin h a vertical e h orizon tal ao


mesmo tempo?’
?- vertical(L), horizontal(L).
L = linha(ponto(_0084,_0085),ponto(_0084,_0085))
Yes
E st a r espost a sign ifica : ‘sim , qu alqu er lin h a d egen erad a a u m pon to tem a
propriedade de ser vertical e horizontal ao mesmo tempo’.

5.3 Exercícios
5.1. Defin a o pr edicado último(L,U), qu e det er m in a o ú lt im o it em U n u m a
lista L. Por exemplo, último([a,b,c],U), resulta em U=c.
5.2. Defin a o pr edica do tam(L,N), qu e det er m in a o n ú m er o de it en s N exis-
tente numa lista L. Por exemplo, tam([a,b,c],N), resulta em N=3.

Linguagem Prolog 29
5.3. Defin a o pr edica do soma(L,S) qu e ca lcu la a som a S dos it en s da list a L.
Por exemplo, soma([4,9,1],S) resulta em S=14.
5.4. Defina o predicado máx(L,M) que determina o item máximo M na lista L.
Por exemplo, máx[4,9,1],M) resulta em M=9.
5.5. Usa n do o pr edica do anexa, defin a o pr edica do inv(L,R) qu e in ver t e a
lista L. Por exemplo, inv([b, c, a], R) resulta em R=[a,c,b].
5.6. Usa n do o pr edica do inv, defin a o pr edica do sim(L) qu e ver ifica se u m a
lista é simétrica. Por exemplo, sim([a,r,a,r,a]) resulta em yes.
5.7. Usa n do a t a bela d(0,zero), d(1,um), ..., d(9,nove), defin a o pr edi-
cado txt(D,P) qu e con ver t e u m a list a de dígit os n u m a list a de pa la-
vras. Por exemplo, txt([7,2,1],P) resulta em P=[sete,dois,um].
5.8. O gr a fo a segu ir r epr esen t a u m m a pa , cu ja s cida des sã o r epresentadas
por letras e cujas estradas são representados por nú meros.
1
A B
5
3
2 E
C
8
4 6

D 7 F

a ) Usa n do o pr edica do estrada(Número,Origem,Destino), cr ie u m


programa para representar esse mapa.
b) Defin a o pr edica do rota(A,B,R), qu e det er m in a u m a r ot a R (list a de
estradas) que leva da cidade A até a cidade B.
5.9. Um r et â n gu lo é r epr esen t a do pela est r u t u r a retângulo(A,B,C,D),
cujos vértices são A, B, C e D, nesta or dem.
a) Defin a o pr edica do regular(R) qu e r esu lt a em yes a pen a s se R for
um retângulo cujos lados sejam verticais e horizon tais.
b) Defin a o pr edica do quadrado(R) qu e r esu lt a em yes a pen a s se R for
um retângulo cujos lados têm as mesmas medidas.

Linguagem Prolog 30
Capítulo 6
Base de Dados Dinâmica
Ba se de da dos din â m ica é u m r ecu r so ba st a n t e ú t il pa r a im plem en t a r lógica
não-monotônica e programas que adquirem conhecimento dinamicamente.

6.1 Manipulação da base de dados dinâmica


De a cor do com o m odelo r ela cion a l, u m a base d e d ad os é a especifica çã o de
u m con ju n t o de r ela ções. Nest e sen t ido, u m pr ogr a m a em P r olog é u m a ba se
de da dos em qu e a especifica çã o da s r ela ções é pa r cia lm en t e explícit a (fa t os)
e parcialmente implícita (regras).

Programa 6.1: Jogadores e esportes.


joga(pelé,futebol).
joga(guga,tênis).
esporte(X) :- joga(_,X).

P a r a list a r a s clá u su la s da ba se de da dos, u sa m os o pr edica do listing. P or


exem plo, su pon do qu e o P r ogr a m a 6.1 t en h a sido ca r r ega do n a ba se, pode-
mos listar as cláusulas do predicado joga através da seguinte consulta:
?- listing(joga).
joga(pelé,futebol).
joga(guga,tênis).

P a r a a dicion a r u m a n ova clá u su la à ba se de da dos podem os u sa r o pr edica do


asserta ou assertz. A consulta a seguir mostra a diferença entre eles:
?- assertz(joga(oscar,basquete)).
Yes
?- asserta(joga(hortência,basquete)).
Yes

?- listing(joga).
joga(hortência,basquete).
joga(pelé,futebol).
joga(guga,tênis).
joga(oscar,basquete).
Yes

Linguagem Prolog 31
P a r a r em over u m a clá u su la da ba se de da dos, u sa m os o pr edica do retract.
Esse predicado recebe uma estrutura como argumento e remove da base uma
ou mais cláusulas (por retrocesso) que unificam com essa estrutu ra:
?- retract(joga(X,basquete)).
X = hortência ;
X = oscar ;
No
?- listing(joga).
joga(pelé, futebol).
joga(guga, tênis).
Yes

6.2 Aprendizagem por memorização


Gr a n de pa r t e do poder da lin gu a gem P r olog vem da h a bilida de qu e os pr o-
gr a m a s t êm de se m odifica r a si pr ópr ios. E st a h a bilida de possibilit a , por
exemplo, a criação de programas capazes de aprender por memorização.

Programa 6.2: Onde estou?


:- dynamic estou/1. % declara modificação dinâmica
estou(paulista).
ando(Destino) :-
retract(estou(Origem)),
asserta(estou(Destino)),
format('Ando da ~w até a ~w',[Origem,Destino]).

Veja como o Programa 6.2 funciona:


?- estou(Onde).
Onde = paulista
Yes
?- ando(augusta).
Ando da paulista até a augusta
Yes
?- estou(Onde).
Onde = augusta
Yes
P a r a sa t isfa zer o objet ivo ando(augusta), o sist em a pr ecisa r em over o fa t o
estou(paulista) e a dicion a r o fa t o estou(augusta). Assim , qu a n do a
primeira consulta é feita novamente, o sistema encontra uma nova resposta.
Linguagem Prolog 32
6.3 Atualização da base de dados em disco
Como podem os obser va r , o P r ogr a m a 6.2 im plem en t a u m t ipo de r a ciocín io
não-monotônico; já qu e a s con clu sões obt ida s por ele m u da m à m edida qu e
n ovos fa t os sã o con h ecidos. P or ém , com o a s a lt er a ções ca u sa da s pela execu-
çã o dos pr edica dos asserta e retract sã o efet u a da s a pen a s n a m em ór ia ,
da pr óxim a vez qu e o pr ogr a m a for ca r r ega do, a ba se de da dos est a r á in a lt e-
rada e o programa terá "esquecido" que andou da Paulista até a Augusta.
P a r a sa lva r em disco a s a lt er a ções r ea liza da s n u m a ba se de da dos, podem os
usar os predicados tell e told.

Programa 6.3: Salvando uma base de dados em disco.


salva(Predicado,Arquivo) :-
tell(Arquivo),
listing(Predicado),
told.
Para recuperar uma base salva em disco, usamos o predicado consult.

6.4 Um exemplo completo: memorização de capitais


Com o exem plo de a pr en diza gem por m em or iza çã o, va m os a pr esen t a r u m
pr ogr a m a ca pa z de m em or iza r a s ca pit a is dos est a dos. E sse pr ogr a m a ser á
composto por dois arquivos:
geo.pl: contendo as cláusulas responsáveis pela iteração com o usuá rio;
geo.bd: contendo as cláusulas da base de dados dinâmica.
No in ício da execu çã o, o pr ogr a m a geo.pl ca r r ega r á n a m em ór ia a s clá u su-
la s exist en t es n o a r qu ivo geo.dat. No fin a l, essa s clá u su la s ser ã o sa lva s em
disco, de modo que ela sejam preservadas para a próxima execução.

Programa 6.4: Um programa que memoriza as capitais dos estados.


:- dynamic capital/2.
geo :- carrega('geo.bd'),
format('~n*** Memoriza capitais ***~n~n'),
repeat,
pergunta(E),
responde(E),
continua(R),
R = n,
!,
salva(capital,'geo.bd').

Linguagem Prolog 33
carrega(A) :-
exists_file(A),
consult(A)
;
true.
pergunta(E) :-
format('~nQual o estado cuja capital você quer saber? '),
gets(E).
responde(E) :-
capital(C, E),
!,
format('A capital de ~w é ~w.~n',[E,C]).
responde(E) :-
format('Também não sei. Qual é a capital de ~w? ',[E]),
gets(C),
asserta(capital(C,E)).
continua(R) :-
format('~nContinua? [s/n] '),
get_char(R),
get_char('\n').
gets(S) :-
read_line_to_codes(user,C),
name(S,C).
salva(P,A) :-
tell(A),
listing(P),
told.

Na pr im eir a vez qu e o P r ogr a m a 6.4 for execu t a do, a ba se de da dos geo.bd


a in da n ã o exist ir á e, por t a n t o, ele n ã o sa ber á n en h u m a ca pit a l. E n t r et a n t o,
à m edida qu e o u su á r io for in t er a gin do com o pr ogr a m a , o con h ecim en t o do
pr ogr a m a a r espeit o de ca pit a is va i a u m en t a do. Qu a n do a execu çã o t er m i-
n a r , a ba se de da dos ser á sa lva em disco e, por t a n t o, n a pr óxim a vez qu e o
programa for executado, ele se “lembrará” de todas as capitais que aprendeu.
O P r ogr a m a 6.4 fa z u so de u m a sér ie de pr edica dos ext r a -lógicos pr im it ivos
qu e sã o depen den t es do in t er pr et a dor . Ma ior es det a lh es sobr e esses pr edica-
dos podem ser obt ido n o m a n u a l on-line do SWI-P r olog. P or exem plo, pa r a
obter esclarecimentos sobre o predicado name, faça a seguinte consulta:
?- help(name).

Linguagem Prolog 34
6.5 Exercícios
6.1. Su pon do qu e a ba se de da dos est eja in icia lm en t e va zia , in diqu e qu a l
será o seu conteúdo após terem sido executadas as seguintes consultas.
?- asserta( metal(ferro) ).
?- assertz( metal(cobre) ).
?- asserta( metal(ouro) ).
?- assertz( metal(zinco) ).
?- retract( metal(X) ).
6.2. Im plem en t e os pr edica dos liga, desliga e lâmpada pa r a qu e eles fu n-
cionem conforme indicado pelos exemplos a seguir:
?- liga, lâmpada(X).
X = acessa
Yes
?- desliga, lâmpada(X).
X = apagada
Yes
6.3. O pr edica do asserta a dicion a u m fa t o à ba se de da dos, in con dicion a l-
m en t e, m esm o qu e ele já est eja lá . P a r a im pedir essa r edu n dâ n cia , defi-
n a o pr edica do memorize, t a l qu e ele seja sem elh a n t e a asserta, m a s
só adicione à base de dados fatos inéditos.
6.4. Su pon h a u m r obô ca pa z de andar a t é u m cer t o loca l e pegar ou soltar
objetos. Além disso, suponha que esse robô mantém numa base de dados
su a posiçã o cor r en t e e a s r espect iva s posições de u m a sér ie de objet os.
Implemente os predicados pos(Obj,Loc), ande(Dest), pegue(Obj) e
solte(Obj), de m odo qu e o com por t a m en t o desse r obô possa ser sim u-
lado, conforme exemplificado a seguir:
?- pos(O,L).
O = robô
L = garagem ;
O = tv
L = sala ;
No
?- pegue(tv), ande(quarto), solte(tv), ande(cozinha).
anda de garagem até sala
pega tv
anda de sala até quarto
solta tv
anda de quarto até cozinha
Yes

Linguagem Prolog 35
6.5. Modifiqu e o pr ogr a m a desen volvido n o exer cício a n t er ior de m odo qu e,
qu a n do for solicit a do a o r obô pega r u m objet o cu ja posiçã o é descon h eci-
da , ele per gu n t e a o u su á r io on de est á esse objet o e a t u a lize a su a ba se
de dados com a nova informação. Veja um exemplo:
?- pos(O,L).
O = robô
L = cozinha ;
O = tv
L = quarto ;
No
?- pegue(lixo), ande(rua), solte(lixo), ande(garagem).
Onde está lixo? quintal
anda de cozinha até quintal
pega lixo
anda de quintal até rua
solta lixo
anda de rua até garagem
Yes
?- pos(O,L).
O = robô
L = garagem ;
O = lixo
L = rua ;
O = tv
L = quarto ;
No
6.6. Acr escen t e t a m bém a o pr ogr a m a do r obô o pr edica do leve(Obj,Loc),
que leva um objeto até um determinado local. Por exemplo:
?- leve(tv,sala).
anda de garagem até quarto
pega tv
anda de quarto até sala
solta tv
Yes

Linguagem Prolog 36
Bibliografia
Ma is det a lh es sobr e a pr ogr a m a çã o em P r olog podem ser obt idos n a s segu in-
tes referências.

[1] B RATKO, I. Prolog Program m in g for Artificial In telligen ce, 2 nd E dit ion ,
Addison-Wesley, 1990.

[2] C OVINGTON, M. A., N UTE, D. a n d VELLINO, A. Prolog Program m in g in


Depth, 2nd Edition, Prentice-Hall, 1997.

[3] S TERLING, L . a n d S HAPIRO, E . T h e Art of Prolog - Ad van ced Program m in g


Techniques, MIT Press, 1986.

Linguagem Prolog 37
This document was created with Win2PDF available at http://www.win2pdf.com.
The unregistered version of Win2PDF is for evaluation or non-commercial use only.
This page will not be added after purchasing Win2PDF.

Você também pode gostar