Você está na página 1de 157

.

1/157

Inteligncia Computacional

Fundamentos de Prolog e ECLi P S e


(Joinville, 20 de agosto de 2009)
Claudio Cesar de S
Departamento de Cincia da Computao
Bloco F - 2o. Piso - F-209 - Sala 13
Joinville - SC
email: claudio@joinville.udesc.br

JJ
II
J
I
Back
Close

Sumrio
1

Introduo

Proposta destes Slides

Requisitos

10

Index of Distribution

11

Implementaes e Ambientes

12

Caractersticas

13

Resolvendo um Problema

14

Explicando o Fluxo da Mquina Prologuiana

21

2/157

JJ
II
J
I
Back
Close

Um Predicado Composto

10 Implementando em

22

ECLiP S e

11 Ambiente de Programao:

ECLiP S e

25
console

27

12 Ambiente de Programao: TKECLi P S e

28

13 Um Outro Exemplo: Os Trs Msicos

29

14 Apresentao do Prolog

31

15 Quanto ao Eclipse

37

16 Ambiente Grco de Programao: TKECLi P S e

39

17 O Tracer para Auto-aprendizagem

40

18 Sintaxe do Prolog

41

19 Resumindo Via Exemplo

60

3/157

JJ
II
J
I
Back
Close

20 Exerccios de Warmup

63

21 Semntica Operacional

66

22 Recursividade

71

23 Iterao Clssica

72

24 Recurso Ilustrada

73

25 Recurso Ilustrada 2

74

26 Quase Tudo So Flores

75

27 Um Outro Clssico: Os Ancestrais

82

28 Seu Processamento

85

29 Functores

95

30 Denies dos Functores

96

4/157

JJ
II
J
I
Back
Close

31 Listas

102

32 Resumindo o Fluxo do Clculo Recursivo

103

33 O Fluxo Operacional das Listas Anlogo

104

34 Uma Lista Genrica

105

35 A Sintaxe das Listas

106

36 Denies sobre Listas

107

37 Listas: Uma Auto-Denio

112

38 Problemas de Buscas em IA

135

39 Dicas de Programao

139

40 Predicados Mo-na-roda

141

41 Predicados Baixaria

142

5/157

JJ
II
J
I
Back
Close

42 Gerando Programas Executveis (ou quase com o SWIProlog)


43 Operaes Especiais

143
148
6/157

44 Programando com  Elegncia

152

45 Sites Interessantes

154

46 Alguns Bons Livros

156

47 Sugestes

157

JJ
II
J
I
Back
Close

Introduo
Histrico

7/157

A linguagem Prolog:

X As bases na lgica clssica


X Incio da dcada de 70 sua primeira implementao
X Foi evoluindo, e continua at hoje ativo.
X Os fundamentos da LPO (Lgica de Primeira Ordem), seguindo

para uma notao em clusulas (forma clausal), e numa notao


restrita em clusulas de Horn.

Depois tem mais, ...

JJ
II
J
I
Back
Close

Proposta destes Slides


A proposta tornar este texto acessvel a todas as pessoas sem
base em lgica, e at mesmo aquelas que nunca tenham utilizado
nenhuma outra linguagem de programao.

8/157

Lembrar que: apenas fazendo/praticando o verdadeiro aprendizado ocorre. Escutar e ver, trazem apenas lembranas.
Assim, ao nal das partes, faas os exerccios propostos.
Estes slides foram feitos h uns 10 anos atrs e abandonados e
ainda esto com alguns erros. O abuso (exagero) das aspas o
principal deles.
Agora retomado devido o ECLi P S e e a Programao em Lgica
com Restries  PLR (CLP  Constraint Logic Programming) e
as pesquisas em torno da PLR.
A segunda parte deste material, tem o foco na PLR.

JJ
II
J
I
Back
Close

Assim, esta atualizao ainda est incompleta.


with suggestions.

Please, react me

9/157

JJ
II
J
I
Back
Close

Requisitos
Novamente: apenas fazendo/praticando o verdadeiro aprendizado
ocorre. Escutar e ver, trazem apenas lembranas.

10/157

Assim, tenha em mos um dos dois programas instalados.


Prolog sugerido: http://www.swi-prolog.org/, v na aba de
download.
Quanto ao ECLi P S e : http://www.eclipse-clp.org ou http:
//87.230.22.228/, mais especicamente
http://www.eclipse-clp.org/Distribution/, escolha uma verso e a plataforma (linux, sun, mac, ..., windows) que lhe convier.

JJ
II
J
I
Back
Close

Index of Distribution
11/157

Index of /Distribution/6.0_96
22-Jul-2009 07:26
Icon
[DIR]
[ ]
[DIR]
[DIR]
[DIR]
[DIR]
[DIR]

Name
RPMS/
This is ECLiPSe 6.0#96
common/
i386_linux/
i386_nt/
sparc_sunos5/
src/

Slides de: 20 de agosto de 2009

===> aqui tem os manuais ...

JJ
II
J
I
Back
Close

Implementaes e Ambientes
X H vrios Prolog disponveis na WEB, um dos mais utilizados o

12/157

SWI-Prolog http://www.swi-prolog.org/,

X Multiplataforma: Windows (95, 98 ou NT), Linux ( Unix-like),


Mac.

X Tem-se Prolog bem-pagos e gratuitos;


X Interfaces grcas ou texto;
X E o ECLiP S e, objeto de investigao da segunda parte deste
curso.

JJ
II
J
I
Back
Close

Caractersticas
X Um programa em Prolog rompe com o conceito de sequencialidade

13/157

e uxo de programas, a exemplo de outras linguagens tradicionais


de programao.

JJ
II
J
I
Back
Close

Resolvendo um Problema
X Esse exemplo instigante e contm

conceitos iniciais do
Prolog, acompanhe com ateno a discusso em sala de aula.
todos

14/157

X A proposta resolver de imediato um problema interessante, antes


de entrar nos detalhes da linguagem.

Fui h uma festa e apresentado h trs casais. Os maridos


tinham prosses e esposas distintas. Aps alguns

goles

me

confundi quem era casado com quem, e as prosses. Apenas


lembro de alguns fatos, ento me ajude descobrir quem so
estes casais, com base nos seguintes dados:

1.
2.
3.
4.

O mdico casado com a Maria;


O Paulo advogado;
Patrcia no casada com Paulo;
Carlos no mdico.

(Retirado da revista Coquetel:

Problemas de Lgica)

JJ
II
J
I
Back
Close

Modelagem

Os demais nomes de nossos personagens so (sim, estavam faltando


mesmo no enunciado):
1. H = { carlos (c) , luiz (l) , paulo (p) }

15/157

2. M = { maria, lucia, patricia }


3. P = { advogado (a), medico (m), engenheiro (e) }
Em resumo, um tupla-3 do tipo (H,M,P)
O problema se resume em encontrar: ((H1,M1,P1), (H2,M2,P2),

(H3,M3,P3))

Codicando a Descrio Acima


1
2
3
4
5
6

/
Os demais nomes de nosso personagens sao :
H = { carlos ( c ) , l u i z ( l ) , paulo (p) }
M = { maria , lucia , p a t r i c i a }
P = { advogado (a ) , medico (m) , engenheiro ( e ) }

JJ
II
J
I
Back
Close

7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

Modelagem : (H,M,P) logo ((H1,M1, P1) , (H2,M2, P2) , (H3,M3, P3))


/
/ aqui comeca o codigo /
p r o f ( advogado ) .
p r o f ( medico ) .
prof ( engenheiro ) .
esposa ( p a t r i c i a ) .
esposa ( l u c i a ) .
e s p o s a ( maria ) .

16/157

write

nl write

nl write

x : deduz (X, Y, Z ) ,
(X) ,
,
(Y) ,
,
(Z) ,
deduz ( ( c a r l o s , M1, P1 ) , ( l u i s , M2, P2 ) , ( paulo , M3, advogado ) ) :
e s p o s a (M1) ,
e s p o s a (M2) ,
e s p o s a (M3) ,
p r o f ( P1 ) ,
p r o f ( P2 ) ,
M3 \== p a t r i c i a ,
P1 \== medico ,
P1 \== advogado ,
P2 \== advogado ,
P1 \== P2 ,
M1 \== M2,
M1 \== M3,
M2 \== M3.

nl .

JJ
II
J
I
Back
Close

35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

/ A r e s t r i c a o a) nao f o i atendida :
%% O medico eh casado com a Maria
logo o programa acima deve s o f r e r uma modificacao :
basta r e l e r as hipoteses e voce vai concluir que o
programa se reduz a :
/
y : deduz2 (X, Y, Z ) ,

17/157

write (X) , nl , write (Y) , nl , write ( Z ) , nl .

deduz2 ( ( c a r l o s , M1, P1 ) , ( l u i s , maria , medico ) , ( paulo , M3, advogado ) ) :


e s p o s a (M1) ,
e s p o s a (M3) ,
p r o f ( P1 ) ,
M3 \== p a t r i c i a ,
P1 \== medico ,
P1 \== advogado .

/ ? [ ' casais . pl ' ] .


% casais . pl compiled 0.00 sec , 0 bytes
Yes
? x .
carlos , patricia , engenheiro
luis , lucia , medico
paulo , maria , advogado

JJ
II
J
I
Back
Close

63
64
65
66
67
68
69
70
71

Yes
? y .
carlos , patricia , engenheiro
luis , maria , medico
paulo , lucia , advogado
Yes
?
/

18/157

Listing 1: 3 casais e prosses dos maridos


Ao longo deste texto, este exemplo ser detalhado, bem como o
estudante vai estar apto em resolv-lo de outras maneiras.

JJ
II
J
I
Back
Close

Exerccios

1. Execute este programa no Tkeclipse explorando Tracer. Utilize


a opo Creep para avanar passo-a-passo.
2. Assegure o entendimento do Tracer pois vai favorecer a sua autoaprendizagem.

19/157

3. No SWI-Prolog, Execute este programa ativando o trace grco,


guitracer; e analise porque alguns resultados foram duplicados.
Ou seja:

?- guitracer.
....

/* ativa o trace grfico */

4. Faa as seguintes experimentaes na console do interpretador:


(a) ?- prof(X).
(b) ?- esposa(Y).
(c) ?- prof(X) , X =
medico.
5. Altere e/ou inclua algumas regras, am de restringir a quantidade
de respostas.

JJ
II
J
I
Back
Close

Avance ao exerccio seguinte, caso tenhas entendido a Mquina


Prolog, deduzir tais respostas. Caso tenhas dvida, habilite o trace
(?- trace, ...) no prexo das questes acima.
20/157

JJ
II
J
I
Back
Close

Explicando o Fluxo da Mquina Prologui21/157

ana

? p(X).

p(a).
p(b).
p(c).
........
........
p(a)

p(b)

p(c)

X=b

X=c

....

? p(X).
X=a;
......

X=a

Figura 1: Fluxo bsico de um predicado em Prolog

JJ
II
J
I
Back
Close

Um Predicado Composto
22/157
p(X,Y,Z)

r(a).
r(b).
r(c)
s(1).
s(2).
t(d).
t(e).

r(X)
a

s(Y)
1

p(X,Y,Z) : r(X), s(Y), t(Z).


1

t(Z)
d

? p(X,Y,Z).
X=a
Y=1
Z=d

Figura 2: Fluxo bsico de um predicado composto em Prolog

JJ
II
J
I
Back
Close

Implementando estas Figuras


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

r (a ).
r (b ) .
r(c ).
s (1).
s (2).
t (d ) .
t(e ).
p (X, Y, Z ) : r (X) , s (Y) , t ( Z ) .
s a i d a : p (X, Y, Z ) ,
format ( 'X : ~w \ t Y : ~ w \ t Z : ~ w ' , [ X, Y, Z ] ) .
/
? s a i d a .
X: a
Y: 1
Z: d
true ;
X: a
Y: 1
Z: e
......................
X: c
Y: 2
Z: d
true ;
X: c
Y: 2
Z: e
true .
/

Listing 2: Semntica operacional do Prolog

23/157

JJ
II
J
I
Back
Close

Observaes:

Estes ltimos slides devem ser acompanhados com a explicao em

sala de aula.

Nestes dois slides se encontram vrias pginas de texto.

24/157

Muita calma nesta hora com as guras 8 e 9.


Como exerccio explique o que dizem estas guras, bem como a
numerao indicada nas echas.
Feito? Agora avance!

JJ
II
J
I
Back
Close

Implementando em

ECLiP S e

O exemplo dos trs casais em ECLi P S e (ao interessado apenas


em Prolog, salte este exemplo):
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

25/157

/ : l i b ( i c _ s y m b o l i c ) . /
: l i b ( i c ) .
p r o f ( 1 , medico ) .
p r o f ( 3 , advogado ) .
prof (2 , engenheiro ) .
m( 1 , p a t r i c i a ) .
m( 2 , l u c i a ) .
m( 3 , maria ) .
x : deduz ( ( c a r l o s , M1, P1 ) , ( l u i s , M2, P2 ) , ( paulo , M3, advogado ) ) ,
m(M1, E1 ) , m(M2, E2 ) , m(M3, E3 ) ,
p r o f ( P1 , P1_out ) , p r o f ( P2 , P2_out ) ,
w r i t e l n ( " A saida e dada por : " ) ,
w r i t e l n ( ( c a r l o s , E1 , P1_out ) ) ,
w r i t e l n ( ( l u i s , E2 , P2_out ) ) ,
w r i t e l n ( ( paulo , E3 , advogado ) ) .
deduz ( ( c a r l o s , M1, P1 ) , ( l u i s , M2, P2 ) , ( paulo , M3, advogado ) ) :

JJ
II
J
I
Back
Close

20
21
22
23
24
25
26
27

[ M1, M2,M3] : : 1 . . 3 ,
[ P1 , P2 ] : : 1 . . 2 ,
P2 #= 1 ,
M2 #= 3 ,
M3 #\= 1 ,
P1 #\= 1 ,
P1 #\= P2 ,
a l l d i f f e r e n t ( [ M1, M2,M3 ] ) .

26/157

Listing 3: 3 casais e prosses dos maridos

JJ
II
J
I
Back
Close

Ambiente de Programao:

ECLiP S e

con27/157

sole

Figura 3: A console bsica do ECL P S (anloga aos Prologs)


i

JJ
II
J
I
Back
Close

Ambiente de Programao: TKECL

iP S e
28/157

Figura 4: O ECLi P S e com a bilioteca TK

JJ
II
J
I
Back
Close

Um Outro Exemplo: Os Trs Msicos


 Trs

msicos, Joo, Antnio e Francisco, tocam harpa,

29/157

violoncelo e piano. Contudo, no se sabe quem toca o qu.


Sabe-se que o Antnio no o pianista. Mas o pianista ensaia sozinho Tera. O Joo ensaia com o Violoncelista s
Quintas. Quem toca o qu ?

O texto acima, muma verso em Prolog representado por:


1
2
3
4
5
6

i n s t r u m e n t o ( harpa ) .
instrumento ( v i o l o n c e l o ) .
instrumento ( piano ) .
dia ( 3 ) .
dia ( 5 ) .

7
8

m u s i c os ( m( joao , X1 , 5 ) , m( a n t o n i o , X2 , D2 ) , m( x i c o , X3 , D3) ) :

9
10
11
12

i n s t r u m e n t o (X1 ) ,
i n s t r u m e n t o (X2 ) ,
i n s t r u m e n t o (X3 ) ,

JJ
II
J
I
Back
Close

13
14
15
16
17
18

(X2 \== p i a n o ) ,
(X1 \== X2 , X3 \== X2 , X1 \== X3 ) ,
d i a (D3 ) ,
d i a (D2 ) ,
( ( D2 == 3 , D3 == 5 ) ; ( D2 == 5 , D3 == 3 ) ) ,
(X1 \== v i o l o n c e l o , X3 == p i a n o , D3 == 3 ) .

30/157

Fcil, certo? Veja a execuo:


1
2
3
4
5
6
7
8
9

consult

16 ?
( 'c:/ publico/musicos.txt ' ) .
% c : / p u b l i c o / m u s i c o s . t x t c o m p i l e d 0 . 0 0 s e c , 64 b y t e s
Yes
17 ? m u s i c os (X, Y, Z ) .
X = m( joao , harpa , 5 ) ,
Y = m( a n t o n i o , v i o l o n c e l o , 5 ) ,
Z = m( x i c o , piano , 3 ) ;
No
18 ?

Este exemplo ser melhorado ....... e como o anterior refeito com


recursos da PLR.

JJ
II
J
I
Back
Close

Apresentao do Prolog
Prolog uma linguagem de programao implementada sobre
um paradigma lgico (Lgica de 1a . Ordem (LPO)). Logo, a con-

31/157

cepo da linguagem apresenta uma terminologia prpria, mas


fundamentada sobre a LPO.

As restries da completude e corretude da LPO so contornadas

com um mtodo de prova sistemtico e completo, chamado de


SLD. Detalhes: Logic, Programming and Prolog, de Ulf Nilsson e
Jan Maluszyns, editado pela by John Wiley & Sons, 2000.

JJ
II
J
I
Back
Close

Caractersticas

Manipula smbolos (objetos) por natureza, logo 7 + 13 tem vrias


conotaes;
Um tomo, literal ou um objeto dado por: `a', 77, "aa", '7' ,
"777". . .

32/157

Seu princpio inferencial o  backward chaining (encadeamento


regressivo), ou seja, para encontrar algum smbolo como verdade,
devemos demonstrar que suas premissas eram tambm verdadeiras;
Apresenta um propsito geral como Linguagem de Programao,
bem como tem interface com linguagens como Delphi, C, Visual
Basic, e outras;
Portabilidade entre plataformas para o Prolog padro. Logo, Prolog uma linguagem livre;
Fcil aprendizado;
reas de aplicaes: problemas de IA, provadores de teoremas,

JJ
II
J
I
Back
Close

sistemas especialistas, pesquisa operacional, construo de compiladores, etc.


33/157

JJ
II
J
I
Back
Close

Mquina Prologuiana

X Uma arquitetura clssica para essa linguagem de programao,

encontra-se na gura 14. Sua fundamentao terica encontra-se


no processo de raciocnio tpico do backward chaining.

34/157

X A operacionalidade anlogo a esse esquema de raciocnio.


Conhecimento
Embutido
(ULA de predicados)

Base de
Conhecimenbto
(programa usuario)

Maquina
Inferencial
(raciocinio)

Memoria
de
Trabalho
Maquina
Prologuiana

Interface com Usurio


(tipo console)

Figura 5: Arquitetura Tpica de uma Mquina

Prologuiana

JJ
II
J
I
Back
Close

Exemplos e Como Trabalhar

X Alm do Prolog ou do Eclipse instalado, necessrio ter um editor


de texto padro ASCII. Aquele de sua preferncia.

X Qualquer um desde que apresente o nmero das linhas no texto.

35/157

X Caso a escolha seja um Prolog com interface grca tipo XPCE

(http://www.swi-prolog.org/), o qual funciona muito bem sob o


Linux, tal editor acionado pelo comando:
?- edit(le('nome do pgm.pl')).

O ambiente do SWI-Prolog inicialmente interpretado, e apresenta um prompt default ao ser executado: ?-

X
Veja os exemplos iniciais:

?- 2 > 3.
No
?- 2 == 2.
Yes
?- mae(eva, abel).

JJ
II
J
I
Back
Close

No
?- 3 > 2.
Yes
Para carregar um programa usurio, previamente editado e salvo
no padro ASCII, para ser usado no SWI-Prolog, ento:

36/157

?- consult('c:/temp/teste.pl'). /* ou */
?- ['c:/temp/teste.pl'].
% teste.pl compiled 0.00 sec, 560 bytes
Yes
?- homem( X ). /* X maisculo */
X = joao
Yes
?- homem( x ). /* x minsculo */
No
As letras maisculas so as variveis da linguagem Prolog, isto
, aceitam qualquer objeto.

JJ
II
J
I
Back
Close

Quanto ao Eclipse
Como todo ambiente com algum requinte de interfaces, exige acertos iniciais para dar produtividade. O Eclipse tem no modo console,
mas aconselho o modo com janelas, mais confortvel para quem est
comeando. Ento vamos l:

37/157

X Veja a janela grca inicial. H apenas File, Query, e Tools.


Apenas as duas abas iniciais nos interessam de momento.

X V a File e acerte suas preferncias como Editor, cores, fontes,


etc.

X Em seguida acerte o seu diretrio de trabalho.


Algo como meus_programas\
X Ou selecione um arquivo novo para digitares, ou carregue um arquivo para execuo na opo Compile File.
X Veja na janela de Output. Se nenhum erro, estamos indo bem.

JJ
II
J
I
Back
Close

X V para linha de Query e teste seus predicados.


?- dia(X). /* digistaste no Query */
X = 3
Yes (0.00s cpu, solution 1, maybe more) /* apertei o more */
X = 5
Yes (0.03s cpu, solution 2)

38/157

X Se compararmos com outras interfaces de desenvolvimento esta


minimalista.

JJ
II
J
I
Back
Close

Ambiente Grco de Programao: TKECL

iP S e
39/157

Figura 6: O ECLi P S e grco  a aba File

JJ
II
J
I
Back
Close

O Tracer para Auto-aprendizagem


40/157

Figura 7: O depurador grco do ECLi P S e

JJ
II
J
I
Back
Close

Sintaxe do Prolog
X A sintaxe Prologuiana construda a partir de formulaes com

41/157

os predicados lgicos

X o conceito de predicado reete o esprito do Prolog.


X Inclua um cdigo exemplo aqui....
As construes (linhas de cdigo em Prolog) seguem uma sintaxe
de trs tipos, que podem ser identicada novamente no programa
inicial.
so as questes ou
uma base de conhecimento

1o. tipo:

goals

(query), isto , uma pergunta

. . . a idia a de um teorema a ser demonstrado . . . .

pergunta:

Seja uma

o nmero 3 maior que o 2?

?- >(3,2).
?Yes

/* ou ?-

3 > 2.

Ou seja,

JJ
II
J qu
maior
I
Back
Close

so os fatos ... algo sempre verdadeiro ou verdades


dicionais, encontrados na base de conhecimento.

2o. tipo:

incon-

?- listing(homem).
homem(joao).
homem(jose).
homem(jedro).
Yes

42/157

so as regras . . . que  aproximadamente so verdades ou


teoremas condicionais, isto : necessitam de uma prova lgica!

3o. tipo:

?- listing(mortal).
mortal(A) :- homem(A).
/* obs. o smbolo :- o implica ao contrrio <- */
/* homem --> mortal
leia-se ... para demonstrar que algum X
mortal, preciso demonstrar e provar que A
um homem */
Yes

JJ
II
J
I
Back
Close

Resumindo o Prolog

A construo de um programa em Prolog, feita de:

fatos, ques-

tes, regras e nada mais!

Logo, quanto a parte da lxica e sinttica, construda com poucos elementos.

43/157

JJ
II
J
I
Back
Close

Detalhando a Sintaxe

H alguns detalhes de como se montam esses predicados prologuianos, os mais trabalhosos so os das regras. Essa Receita de Bolo
segue abaixo:

Os predicados devem ser em letras minsculas:


AMENTE!

Os fatos, regras e questes terminam por


Seja uma regra, exemplo:

OBRIGATORI-

(ponto);

irmo(X,Y) :- pai(X,Z), pai(Y,Z), X \ == Y.


Os seguintes elementos so identicados:






44/157

 irmo/2,  pai/2 e  \ == /2, so predicados binrios (i.


. aridade igual a dois);
A vrgula (,) o  and lgico;
O  or lgico o ponto-e-vrgula ( ;) ;
O  :-  o  pescoo da regra;
O ponto no nal  . o  p da regra;

JJ
II
J
I
Back
Close




Logo a regra possui uma  cabea, que o predicado  irmo/2;


O corpo composto pelos predicados:  pai/2 e  \ == /2.

Os nomes que comeam por letras maisculas so variveis no

Prolog. As variveis podem receber nmeros, letras, frases, arquivos, regras, fatos, at mesmo outras variveis, mesmo sendo
desconhecidas !

A varivel annima _ ( o

45/157

underscore)

dispensa a necessidade
de ser instanciada, isto , sem restries quanto ao seu escopo;

Nomes que comeam por letras minsculas so smbolos no Prolog;

O escopo a validade da instncia de uma varivel na regra;


As variveis possuem o seu escopo apenas dentro de suas regras;
JJ
II
J
I
Back
Close

Outros Conceitos

Eventualmente vais encontrar os termos abaixo em livros de lgica,


de Prolog, do Eclipse, de IC, etc:

1. Aridade: Nmero de argumentos do predicado. Leia-se que


capital(paris, frana) um predicado de aridade dois;
2.

46/157

Matching:

Ao processar uma busca na Memria de Trabalho


(MT), a mquina inferncia do Prolog realiza vericaes do incio do programa para o nal. Encontrando um predicado de
mesmo nome, em seguida verica a sua aridade. Se nome e aridade casarem, o matching foi bem sucedido;

3. Instncia: Quando uma varivel de uma regra for substituda por


um objeto, esse dito ser uma instncia temporria regra;
4. Unicao: Quando uma regra for satisfeita por um conjunto
de objetos, se encontra um instncia bem sucedida para regra
inteira. Neste caso, as variveis foram unicados pelos objetos,
resultando em uma regra verdade e demonstrvel. Em resumo,
uma instncia que foi bem sucedida;

JJ
II
J
I
Back
Close

5.

Backtracking:

Esse conceito particular ao Prolog, e o diferencia das demais linguagens convencionais de computador. Basicamente, e no completamente, o conceito de backtracking o
mesmo da Engenharia de Software. Ou seja, na falha de uma
soluo proposta, o programa deve retroceder e recuperar pontos
e/ou estados anteriores j visitados, visando novas exploraes a
partir destes. Como exemplo ilustrativo, imaginemos uma estrutura em rvore qualquer, e em que um dos ns terminais (folhas)
exista uma ou mais sadas. Qual a heurstica de encontrar uma
das sadas ou o n desejado? Vrias abordagens podem ser feitas, algumas discutidas neste livro. O Prolog usa uma busca
em profundidade (depth-rst), cujo retrocesso ocorre ao n mais
recente, cuja visita foi bem sucedida. Esses ns referem aos predicados que formam um corpo da rvore corrente de busca. Logo,
vrias rvores so construdas, cada vez que uma nova regra
disparada. Mas o controle dessas rvores e seu objetivo corrente,
implementado como uma estrutura de pilha, em que ns no
solucionados so empilhados.

47/157

JJ
II
J
I
Back
Close

Os conceitos acima, fazem parte de uma tentativa de descrever


o funcionamento aa Mquina Prologuiana da gura 18, via um
uxograma, e este mostrado:
Avalie e verique a interpretao desse esquema da pilha abstrata de questes que o Prolog faz, representado na gura 18. Esta
gura efetivamente atende as queries do Prolog?

48/157

JJ
II
J
I
Back
Close

Operaes Bsicas do SWI-Prolog

Exceto o Visual Prolog (http://www.visual-prolog.com/), todos os


demais Prolog so basicamente idnticos. Atualmente deve existir
ter uns dez (10) fabricantes de Prolog comerciais e um outro tanto
oriundos da academia. Todos oferecem algo gratuito como chamariz
ao seu sistema. Logo, ao leitor sinta-se livre em experimentar outros
ambientes do Prolog.
Quanto ao SWI-Prolog, as suas caractersticas so: velocidade,
portabilidade (interoperacionabilidade), padro, robustez, facilidades de uso, interface com vrias outras linguagens de programao,
free-source, etc.
Os passos bsicos para se usar o SWI-Prolog em seu ambiente
interpretado so:
1. Editar o programa. Use o

edit

com numerao de linhas;

do DOS, ou outro editor ASCII

2. Carregar o programa usurio para o ambiente interpretado SWIProlog;


3. Executar os predicados;

49/157

JJ
II
J
I
Back
Close

4. Validar os resultados;
5. Voltar ao passo inicial, se for o caso.
50/157

JJ
II
J
I
Back
Close

Alguns comandos para usar no ECLi P S e e SWI-Prolog no padro


terminal:

Para carregar o programa:

pl

+ <Enter>

51/157
Welcome to SWI-Prolog (Version 3.2.3)
Copyright (c) 1993-1998 University of Amsterdam. All rights r
For help, use ?- help(Topic). or ?- apropos(Word).
Yes
?-

Idem ao

eclipse.

do Claudio.

Veja o passo-a-passo para instalao no Linux

Para sair desses ambientes:

?- halt.
Para carregar um programa na Memria de Trabalho (MT) (Working Memory-WM,

ou

base dinmica de conhecimento):

?- consult('d:/curso/udesc/autind/iia/ex1').
d:/curso/udesc/autind/iia/ex1 compiled, 0.00 sec, 52 bytes.

JJ
II
J
I
Back
Close

Yes
?ou
?- load_files('nomes','opcoes').
/* para conferir se est na ``{\em Working
?- ensure_loaded(rosa).
Yes
?-

Memory}'' */
52/157

Para eliminar um predicado da MT:

?- abolish(cor/1).
Yes
?- listing(cor/1).
[WARNING: No predicates for `cor/1']
No
? Para executar uma regra:

?- eh_maior_que_10.
DIGITE UM NUMERO:: 30
|
. < ......... faltou o ponto . >

JJ
II
J
I
Back
Close

numero maior que 10


Yes
? Para bisbilhotar o help, bem como inferir novas caractersticas do
Prolog:

?- help(nome_do_predicado).
ou
?- apropos(padro_desejado).
ou
?- explain(nome_do_predicado).
?- apropos(setenv).
setenv/2
Set shell environment variable
unsetenv/1
Delete shell environment variable
Yes
? As imperfeies:

no pode existir espao entre o nome do pre-

dicado e o incio dos argumentos, no caso o (...) .

Este erro

53/157

JJ
II
J
I
Back
Close

bastante comum entre os iniciantes do Prolog. Vejamos o exemplo abaixo no predicado  >:

?>
(9, 5).
[WARNING: Syntax error: Operator expected
> (9, 5
** here **
) . ]
?- >(9, 5).
Yes
?-

54/157

Para entrar no mdulo de depurao ou debugger:

?- trace, predicado.
ou
?- debug, predicado.
ou
?- spy(predicado_em_particular).
para desativar:
?- nospy(predicado_em_particular).

JJ
II
J
I
Back
Close

e
?- notrace.
e
?- nodebug. /* ou Crtl-C para sair do modo debug */
Apavoramentos com o modo

trace

na console:

===> <abort.> sai do debug/trace ou da pendencia...


ou <Crtl C> + <a> de abort
ou
?- abort.
Execution Aborted
Typing an 'h' gets us:
---a:
abort
b:
break
c:
continue e:
exit
g:
goals
t:
trace
h (?):
help
Action (h for help) ?
---`What does this mean?`, that's my first question.
'e'
exits the program immediately
'a'
aborts whatever you've type so far
'c'
continues where you left off
'h'
gets us the 'Action' help menu, again
So what does 'g', 't' and 'b' do?

55/157

JJ
II
J
I
Back
Close

I don't know yet, but I suspect:


'g'
lists possible goals ===> os pendentes
't'
traces the program, a debugging tool
'b'
breaks the current script (whatever your working on)
and give a new shell.

No esquea que:

56/157

?- trace, t.
e
?- spy(t), t.
so equivalentes !

JJ
II
J
I
Back
Close

Outros Detalhes

Correes automticas:
?- patos(X,Y).
Correct to: `pratos(X, Y)'? yes
X = alho
Y = peixe ;
/* ; ^ */
/* ; para forar uma nova resposta manualmente */
X = cebola
Y = peixe ;
X = tomate
Y = peixe ;
No
?-

57/157

Forando todas as respostas, com o uso do predicado interno fail:


?- prato(X, Y),
alho
cebola
tomate
No
?-

write(X), nl, fail.

Logo o  fail um predicado que provoca uma falha na regra, ou

JJ
II
J
I
Back
Close

seja, torna-a sempre falsa; esse  fail fora o mecanismo  backtracking.


58/157

JJ
II
J
I
Back
Close

59/157

Figura 8: Fluxo

Aproximado

de Inferncias em Prolog

JJ
II
J
I
Back
Close

Resumindo Via Exemplo


Antes da prxima seo, necessrio compreender o que faz o
programa abaixo. Caso tenhas diculdade, execute-o com auxlio do
tracer.
1
2
3

60/157

x(7).
x(5).
x(3).

4
5
6
7
8
9
10
11

par ( Xpar ) : x (N1 ) , x (N2 ) , N1 =\= N2 ,


Xpar
(N1+N2 ) ,
(N1) ,
( ' .... ' ) ,
(N2) ,
( ' .... ' ) ,
( Xpar ) ,
,
.

write
write
write
nl
fail

12
13

is

write
write

? par (N ) .

Cuja rvore de busca dada pela gura 19:

JJ
II
J
I
Back
Close

61/157

Figura 9: rvore de busca para regra par


Aconselho estudar cada ponto deste exemplo, pois o mesmo
sumariza todo conhecimento at o momento sobre Prolog. Avance

JJ
II
J
I
Back
Close

prxima seo, apenas se este exerccio for dominado em detalhes.

62/157

JJ
II
J
I
Back
Close

Exerccios de Warmup
1. Construa a rvore geneolgica de sua famlia, tendo as relaes
(predicados): filho e pai;

63/157

2. A partir do programa anterior, construa as relaes: irmo, av,


tio, bisav, etc. Num prximo assunto, o conceito de ancestral
generaliza estes conceitos de pai, av, bisav, etc;
3. Quais dos predicados abaixo casam, e se a unicao ocorrer,
quais so os resutados? Escreva os seus signicados, tomando por
base os conceitos de termos ou tomos, matching (casamento), e
unicao:
1
2
3
4
5
6
7

?
?
?
?
?
?
?

2 > 3.
>(2 , 3 ) .
2 == 2 .
a ( 1 , 2 ) = a (X, X ) .
a (X, 3 ) = a ( 4 , Y ) .
a ( a ( 3 , X) ) = a (Y ) .
1+2 = 3 .

JJ
II
J
I
Back
Close

8
9
10
11
12
13
14
15
16
17

?
?
?
?
?
?
?
?
?
?

X = 1+2.
a (X, Y) = a ( 1 , X ) .
a (X, 2 ) = a ( 1 , X ) .
1+2 = 3
X + 2 = 3 Y.
X+Y = 1+2.
1+Y = X + 3 .
p a i (X, adao ) = p a i ( a b e l , Y ) .
X+Y = 1+5 , Z = X.
X+Y = 1+5 , X=Y.

64/157

4. Seja o programa abaixo:

b(1).
b(2).
d(3).
d(4).
c(5).
c(6).
a(W) :- b(X), c(Y), W is (X+Y), fail.
a(W) :- c(X), d(Y), W is (X+Y).
Encontre os valores para a(Y) e explique como foi o esquema de

JJ
II
J
I
Back
Close

busca. Onde e porqu ocorreu

backtraking ?

65/157

JJ
II
J
I
Back
Close

Semntica Operacional
Mais um resumo sobre a operacionalidade dos predicados.

66/157

Estas guras so difceis de serem encontradas, mas revelam a


essncia do Prolog

Figura 10: Um uxo operacional de um predicado tpico

JJ
II
J
I
Back
Close

Retirado de http:

//grack.com/downloads/school/enel553/report/prolog.html
Ainda da gura 21, temos:

o caminho de entrada do predicado, o qual chamado em sua


primeira vez, para aquela instncia.

call:

67/157

uma soluo encontrada, sua porta de sada para um retorno


com Yes.

exit:

a porta de entrada para o backtracking (caso ocorra uma


falha neste predicado, este ser exaustivamente inspecionado em
todas as suas possibilidades de solues).

redo:

a porta de sada no caso de no existirem mais nenhuma


alternativa a ser pesquisada. Retorno com o No.

fail:

JJ
II
J
I
Back
Close

Predicados de E/S

68/157

Figura 11: Um uxo operacional de um predicado de E/S - sem redo


Exemplo: o predicado write/1

JJ
II
J
I
Back
Close

Um predicado que sempre falhe

69/157

Figura 12: Um uxo operacional de um predicado com retorno em

fail

Exemplo: o predicado fail/0

JJ
II
J
I
Back
Close

Um uxo completo

70/157

Figura 13: Um uxo operacional completo


Faa uma reexo e veja se est tudo claro ....

JJ
II
J
I
Back
Close

Recursividade
X A recursividade em Prolog a sua prpria denio em lgica.

71/157

X Apesar da inecincia de solues recursivas, esta uma das elegncias do Prolog. Os exemplos se auto-descrevem.

X A exemplo das demais linguagens de programao, uma funo


recursiva aquela que busca em si prprio a soluo para uma
nova instncia, at que esta encontre uma instncia conhecida e
retorne um valor desejado.

Algumas ilustraes:

JJ
II
J
I
Back
Close

Iterao Clssica
72/157

Figura 14: Uma iterao ilustrada

JJ
II
J
I
Back
Close

Recurso Ilustrada
73/157

Figura 15: Recurso ilustrada

JJ
II
J
I
Back
Close

Recurso Ilustrada 2
74/157

Figura 16: Recurso ilustrada 2

JJ
II
J
I
Back
Close

Quase Tudo So Flores


75/157

Figura 17: Recurso ilustrada  ores

JJ
II
J
I
Back
Close

Exemplo:

Calcular a soma dos primeiros n-valores inteiros:

S(n) = 1 + 2 + 3 + 4 + ..... + (n 1) + n
Este problema pode ser reformulado sob uma viso matemtica,
mais especicamente, pela induo nita como:


S(n) =

76/157

1
para n = 1
S(n 1) + n para n > 2

O que um fato verdadeiro pois:

1 + 2 + 3 + ..... + (n 1) +n
{z
}
S(n) = |
S(n 1)
Como o procedimento recursivo, necessrio encontrar a denio para a  parada da recursividade. Como n no tem limite
superior, para qualquer n, inicia-se pelo que se conhece:

#1. A soma de 1 1, logo: soma(1,1).


#2. Para soma dos n-simos termos, necessrio a soma do (n 1)-simos termos,

logo:
soma(N,S) ... = ... Nant = (N-1), soma(Nant, S_Nant) e S = (N + S_Nant).

JJ
II
J
I
Back
Close

Notas:

A regra #1,  soma(1,1)., conhecida como condio ou


parada, ou ainda, regra de aterramento.

regra de

Pelo fato de que o Prolog inicia seu procedimento sequencial  de


cima para baixo , a condio #1 deve vir antes de #2.

77/157

Em alguns casos, a regra recusirva, regra #2, vem antes da regra


#1. Alguns desses exemplos so mostrados nestes slides.
Quando estiveres conante com o Prolog, estas condies de parada pode vir depois da regra geral. Mas para isto, outros mecanismos de controle de uxo de programa precisam serem
apresentados. de tais casos.

JJ
II
J
I
Back
Close

O exemplo acima reescrito em Prolog, dado por:


1
2
3
4
5
6
7
8
9
10
11

true

s ( 1 , 1 ) :
.
/ REGRA #1 /
s (N, S ) :
/ REGRA #2 /
N > 1,
Aux
(N 1) ,
format ( '\ n N : ~ w \ t AUX : ~ w \t PARCIAL : ~ w \ t S : ~ w ' ,
[ N, Aux , P a r c i a l , S ] ) ,
s (Aux , P a r c i a l ) ,
format ( '\ n == > Apos o casamento da REGRA #1: ' ) ,
S
(N + P a r c i a l ) ,
format ( '\ n N : ~ w \ t AUX : ~ w \t PARCIAL : ~ w \ t S : ~ w ' ,
[ N, Aux , P a r c i a l , S ] ) .

is

78/157

is

Listing 4: Soma dos nmeros de 1 a N


O procedimento recursivo tpico da movimentao da pilha intrnseca do Prolog. O quadro abaixo ilustra o exemplo de um  goal 
do tipo:

?-s(5,X).

JJ
II
J
I
Back
Close

Chamada Pendente Regra Casada N N1 Parcial


s(5,X)
s(4,X)
s(3,X)
s(2,X)
s(1,X)

#2
#2
#2
#2
#1 (aterrada)

5
4
3
2
1

4
3
2
1
-

?...<10>...
?...<6>...
?...<3>...
?...<1>...
-

...<15>...
-...<10>...
-...<6>...
-...<3>...
-1

79/157

JJ
II
J
I
Back
Close

A execuo na console:
1

? s ( 5 ,X ) .

2
3
4
5
6
7
8
9
10
11
12
13
14
15

N: 5
AUX: 4
N: 4
AUX: 3
N: 3
AUX: 2
N: 2
AUX: 1
==> Apos o casamento
N: 2
AUX: 1
==> Apos o casamento
N: 3
AUX: 2
==> Apos o casamento
N: 4
AUX: 3
==> Apos o casamento
N: 5
AUX: 4
X = 15

da
da
da
da

PARCIAL : _G254
PARCIAL : _G269
PARCIAL : _G284
PARCIAL : _G299
REGRA #1:
PARCIAL : 1
REGRA #1:
PARCIAL : 3
REGRA #1:
PARCIAL : 6
REGRA #1:
PARCIAL : 10

S:
S:
S:
S:

_G181
_G254
_G269
_G284

80/157

S: 3
S: 6
S : 10
S : 15

JJ
II
J
I
Back
Close

Observaes:
O predicado format funciona apenas no Prolog;
Acompanhe as explicaes em sala de aula;
Nem todo conjunto de regras recursivas so passveis de admitirem
tal quadro.

81/157

JJ
II
J
I
Back
Close

Um Outro Clssico: Os Ancestrais


O ancestral de X, no mnimo o pai de X. Logo, um av X tambm
seu ancestral. O pai deste av tambm antepassado de X, e assim
sucessivamente. Generalizando este conceito de ancestralidade, veja
gura 27, em termos da relao pai.
Escrevendo este conceito em Prolog, tem-se:

82/157

ancestral(X,Y) :- pai(X,Y).
ancestral(X,Y) :- pai(X,Z), ancestral(Z,Y).
Este conhecimento em LPO dado por:
xy((pai(x, y) ancestral(x, y))
xyz((pai(x, z) ancestral(z, y) ancestral(x, y))

JJ
II
J
I
Back
Close

83/157

Figura 18: Uma rvore que representa os descendentes de algum


Este cdigo em Prolog, agora em ingls:
1
2
3
4
5

p a r e n t ( john , p a u l ) .
/ p a u l i s john ' s p a r e n t
/
p a r e n t ( paul , tom ) .
/ tom i s p a u l ' s p a r e n t
/
p a r e n t ( tom , mary ) .
/ mary i s tom ' s p a r e n t
/
a n c e s t o r (X,Y) : p a r e n t (X,Y ) .
/ I f Y i s a p a r e n t o f X, then Y i s an a n c e s t o r o f X /

6
7

a n c e s t o r (X,Y) : p a r e n t (X, Z ) , a n c e s t o r ( Z ,Y ) .

JJ
II
J
I
Back
Close

8
9

/ i f Y i s an a n c e s t o r o f Z and Z i s a p a r e n t o f X,
then Y i s an a n c e s t o r o f X /

84/157

JJ
II
J
I
Back
Close

Seu Processamento
Calculando ?- ancestor(john,tom).
1
2
3
4
5
6
7
8
9
10
11

85/157

CALL a n c e s t o r ( john , tom ) .


CALL p a r e n t ( john , tom ) .
p a r e n t ( john , tom ) .
CALL p a r e n t ( john , Z ) .
TRY Z=p a u l
CALL a n c e s t o r ( paul , tom ) .
CALL p a r e n t ( paul , tom ) .
SUCCEEDS p a r e n t ( paul , tom ) .
SUCCEEDS a n c e s t o r ( paul , tom ) .
SUCCEEDS with Z=p a u l
SUCCEEDS a n c e s t o r ( john , tom ) .

FAIL

Repita o exemplo com nomes conhecidos de sua famlia.

JJ
II
J
I
Back
Close

Outros Exemplos de Recursividade

: alm do uso da recursividade,


este exemplo mostra o que fazer quando em aparentemente no
h predicados disponveis ao que se deseja; ou seja:  X <= 3
no existe, mas como opo equivalente tem-se:

Um simples sistema de menu

86/157

 X =< 3 ;
 \ + (X >= 3).
menu(0).
menu(_) :repeat,
write('......'), nl,
.......................
write('......'), nl,
write(' DIGITE A OPCAO: '),
read(X),
X >= 0,
\+(X >= 3), /* isto : X =< 3 */
/* X \== 0
equivalente a: \+(X == 3 ) */
acao(X),
menu(X).
%%%%%%%%%%%%%%%%%%%%%%%%%%%
acao(0).
/* continua acoes etc */

JJ
II
J
I
Back
Close

acao(1).
acao(2).
acao(3).

87/157

JJ
II
J
I
Back
Close

Clssico Scrates com


1
2
3
4
5
6
7

fail :

human ( s o c r a t e s ) .
% f a c t s about who i s human
human ( a r i s t o t l e ) .
human ( p l a t o ) .
god ( z e u s ) .
% and who i s a god
god ( a p o l l o ) .
m o r t a l (X) : human (X ) .
% a l o g i c a l a s s e r t i o n that X i s mortal i f X i s

88/157

8
9
10
11
12
13
14
15
16
17
18
19
20

Fazendo a s p e r g u n t a s :
? m o r t a l ( p l a t o ) .
yes
? m o r t a l ( a p o l l o ) .
no
? m o r t a l (X ) .
X = s o c r a t e s >;
X = a r i s t o t l e >;
X = p l a t o >;
no

% i s Plato mortal ?
% i s a p o l l o mortal ?
% f o r which X i s X m o r t a l ?

%human

Evitando e s t e l t i m o "no" , usando a r e c u r s i v i d a d e :

21
22
23
24

m o r t a l _ r e p o r t :
( 'Mostre todos mortais conhecidos:' ) ,
m o r t a l (X) ,

write

nl , nl ,

JJ
II
J
I
Back
Close

25
26
27

write (X) , nl ,
fail .

mortal_report .

/ ou : :

m o r t a l _ r e p o r t : t r u e . /

28
29
30
31
32
33
34
35

Ento :

? m o r t a l _ r e p o r t .
Mostre t o d o s m o r t a i s c o n h e c i d o s :
socrates
aristotle
plato
yes

89/157

Veja a seqncia dos fatos e da sada.

JJ
II
J
I
Back
Close

: Reformulando sob uma viso matemtica,


mais especicamente, pela induo nita tem-se:

Clculo do Fatorial


F at(n) =

1
para n = 0
F at(n 1) n para n > 1

90/157

O que um fato verdadeiro pois:

1 2 3 ..... (n 1) n
{z
}
F at(n) = |
F at(n 1)
Como o procedimento recursivo, deve-se encontrar a denio
para  parada da recursividade. Como n no tem limite superior, para qualquer n, ento inicia-se pelo que se conhece:
#1.

O fatorial de 0 1, logo: fatorial(0,1).


#2. O fatorial do n-simo termo, necessrio
o fatorial do (n 1)-simo termo, logo:
fatorial(N, Fat) :: Nant = (N-1), fatorial(Nant, Fat_Nant) e
Fat = (N Fat_Nant).

JJ
II
J
I
Back
Close

em termos de Prolog tem-se:


fatorial( 0, 1 ).
fatorial( X, Fat ) :-

X > 0,
Aux is (X - 1),
fatorial( Aux , Parcial ),
Fat is ( X
* Parcial ).

91/157

Complete a tabela abaixo, para descrio do fatorial:

Chamada Pendente Regra Casada X Aux Parcial Fat


fatorial(5,X)
fatorial(4,X)
fatorial(3,X)
fatorial(2,X)
fatorial(1,X)
fatorial(0,X)

#
#
#
#
#
#

......
......
......
......
......
......

......
......
......
......
......
......

?......
?......
?......
?......
?......
?......

......
-......
-......
-......
-......
-......

JJ
II
J
I
Back
Close

: A proposta do problema encontrar o custo entre dois vrtices quaisquer em um grafo orientado
dado pela gura 28. O nome do problema dene a proposta do
exerccio. Este grafo no apresenta ciclos, e nem bidirecional
entre os vrtices.

 O caminho do portugus

20

25

92/157

a
e

10

5
c

10

15

75

Figura 19: Um grafo que dene custos entres as cidades - unidirecional


Para expressar a idia da rota tem-se que:

Uma rota entre X e Y uma estrada que liga X e Y direta-

JJ
II
J
I
Back
Close

mente;
Uma rota entre X e Y uma estrada entre X e Z e e uma rota
entre Z e Y.
ligado(a,b,5).
ligado(c,d,10).
ligado(g,f,20).
ligado(b,e,5).

ligado(a,c,10).
ligado(d,g,15).
ligado(e,f,5).
ligado(b,f,25).

ligado(a,g,75).
ligado(d,e,5).
ligado(b,f,25).

93/157

rota(X,Y,C) :- ligado(X,Y,C).
rota(X,Y,C) :- ligado(X,Z,C1),
rota(Z,Y, C2),
C is (C1 + C2).
?- rota(a,g,X).
X = 75 ;
X = 35 ;
No
?-

JJ
II
J
I
Back
Close

Triangulo de Astericos

: ir para os exerccios ...

94/157

JJ
II
J
I
Back
Close

Functores
95/157

Figura 20: Um exemplo de functor  um termo composto

JJ
II
J
I
Back
Close

Denies dos Functores


Functores:

so funes lgicas, logo h uma equivalncia


entre um domnio e imagem.

96/157

Os functores permitem contornar o mapeamento tpico


sobre {V, F } (yes ou no)
Um domnio de objetos mapeados objetos.
Exemplo:

seja a descrio de uma classe de objetos do tipo carro


(ver gura 30):
carro(Nome, estilo(
esporte(Portas, opcionais(L1,L2)),
passeio(Portas),
off_road(L3, motor(Comb, outros(Turbo, L4)))
)
).

JJ
II
J
I
Back
Close

Carro

Estilo

#nome

Passeio

Esporte

#portas

Opcionais

#lista
(litens interno)

#lista
(itens externo)

#portas

Off-road

#lista
(opcionais)

97/157
Motor

#comb

#turbo

Outros

#lista

Figura 21: Representando o conceito hierrquico com um functor


Motivao

A principal observao do exemplo acima a hierarquia  natural e


estabelecida, para representar um conhecimento. Tal representao

JJ
II
J
I
Back
Close

conhecida por  frames, que incorpora a maioria dos conceitos da


programao orientada--objetos. Em resumo tem-se:
1. Construo de fatos genricos (prximo ao conceito de classes,
instncias, etc.);

98/157

2. Quantidade varivel de argumentos, leva h novos predicados. H


com isso um certo ganho de generalidade, pois um mesmo predicado pode ser utilizado para descrever vrios tipos de objetos,
buscas sobre padres so facilitadas;
3. Legibilidade dos dados, e consequentemente o entedimento do
problema;
4. Em resumo, os functores podem serem vistos como uma estruturao os dados sob formas dos  REGISTROS convencionais.
Exemplo

Seja o programa abaixo:


artista("Salvador Dali", dados(pintor(surrealista), regiao( "Catalunha" ),
86, espanhol)).

JJ
II
J
I
Back
Close

artista("Pablo Picasso", dados(pintor(cubista), 89, espanhol)).


artista("Jorge Amado", dados(escritor(contemporaneo), 86, brasileiro)).

Para vericar seu aprendizado, verique e entenda o porqu das perguntas e repostas abaixo:
1. Dentro do predicado  artista h outros predicados?
Resp: Errado. No so outros predicados e sim funes lgicas!
2. Quantos argumentos tem o predicado artista?
Resp: 02 argumentos, um campo o  `nome e o outro a funo
 dados !
3. Quantos argumentos tem a funo  dados?
Resp: 04 e 03 argumentos para o primeiro e segundo fato respectivamente. Logo, apesar de terem o mesmo nome, elas so
diferentes!
4. Quantos argumentos tem a funo pintor?
Resp: 01 argumento!
5. A funo  pintor equivalente a  escritor?
Resp: No, um objeto tem caractersticas da funo  pintor e
outro da  escritor;
6. Quanto ao valor de retorno dessas funes lgicas?

99/157

JJ
II
J
I
Back
Close

Resp: No existe,

ela por si s j mapeada num domnio

qualquer (nmeros, letras, objetos, etc.).

Concluindo Functores

100/157

Alguns de regras e questes que podem ser encontrados a partir do


exemplo acima:
/* qual o nome e os dados de cada artista ? */
?- artista(X,Y), write(X), nl, write(Y),nl, fail.
Do exemplo, deduz-se que functor ``\emph{casa}''
(``\emph{matching}'') com variveis (letras maisculas).
/* quem so os cubistas?*/
?- artista(X, dados(pintor(Y) ,_ ,_ )), Y == cubista, nl,
write(X), write('=====>'), write(Y), nl, fail.
/* quem tem mais de 80 anos? */
?- artista(X,dados(_ , Y _)), Y > 80, nl, write(X), write(Y),nl, fail.
/* no caso acima, nem todos resultados foram encontrados, porqu? */

JJ
II
J
I
Back
Close

Resumindo: os functores organizam dados e visualizam regras recursivas de uma maneira mais simples e controlvel. Outro detalhe
que como objetos, functores respeitam todas as regras de  casamento vistas at o momento. Sem exceo !
101/157

JJ
II
J
I
Back
Close

Listas
Pr-requisito: conceitos de recursividade e functor dominados!

102/157

Seguem conceitos das LPs convencionais


Essencialmente vamos computar sob uma rvore binria
Ilustrando esta computao

JJ
II
J
I
Back
Close

Resumindo o Fluxo do Clculo Recursivo


103/157

Figura 22: Clculo Recursivo 1

JJ
II
J
I
Back
Close

O Fluxo Operacional das Listas Anlogo


104/157

Figura 23: Clculo Recursivo 2

JJ
II
J
I
Back
Close

Uma Lista Genrica


105/157

Figura 24: Uma lista em Prolog

JJ
II
J
I
Back
Close

A Sintaxe das Listas


106/157

Figura 25: Lista1 ilustrada


Aps as denies e exemplos volte a esta gura

JJ
II
J
I
Back
Close

Denies sobre Listas


Denies iniciais:

e recursivas ar

107/157

Uma lista uma estrutura de dados que representa uma cole-

o de objetos homogneos;
Uma lista uma seqncia de objetos;
Uma lista um tipo particular de functor1 (veja esta nota de
roda-p), pois apresenta uma hierarquia interna.
O smbolo [ usado para descrever o incio de uma lista,
e ] para o nal da mesma;

Notao:

Logo, a lista apresenta uma hierarquia natural, internamente.

JJ
II
J
I
Back
Close

[a, b, c, d ], logo um predicado cujo argumento seja


algumas letras, tem-se uma lista do tipo:

Exemplos:

letras( [ a, b, c, d ] ).
^
|
|
cabea da lista

108/157

Os elementos de uma lista so lidos da esquerda para direita, logo


a letra a o primeiro elemento ou  cabea da lista. Quanto ao
resto ou  cauda da lista, uma  sub-lista dada por: [b, c, d ].
Esta sub-lista, de acordo com uma outra denio complementar
apresentada na seo 37, tambm uma lista.
Operador  |:  Como vamos distinguir de onde se encontra a cabea da cauda da lista?

Como o conceito de listas introduziram


novos smbolos, isto , os seus delimitadores [. . . ], h um novo
operador que separa ou dene quem a cabea da cauda da
lista. Este operador o  pipe, simbolizado por  |, que distingue
a parte da esquerda da direita da lista. Isto necessrio para se

JJ
II
J
I
Back
Close

realizar os casamentos de padres com as variveis.

109/157

JJ
II
J
I
Back
Close

os exemplos abaixo denem como


ocorrem os casamentos entre variveis e listas. Portanto, preste
ateno em cada exemplo, bem como teste e faa suas prprias
concluses de como as listas operam.

Exemplos de  casamentos:

1
2
3
4
5
6
7
8
9
10
11
12
13

[ a , b , c , d ] == X
[ X | b , c , d ] == [ a , b , c , d ]
[ a | b , c , d ] == [ a , b , c , d ]
[ a , b | c , d ] == [ a , b , c , d ]
[ a , b , c | d ] == [ a , b , c , d ]
[ a , b , c , d | [ ] ] == [ a , b , c , d ]
[ ] == X
[ [ a | b , c , d ] ] == [ [ a , b , c , d ] ]
[ a | b , c , [ d ] ] == [ a , b , c , [ d ] ]
[ _ | b , c , [ d ] ] == [ a , b , c , [ d ] ]
[ a | Y ] == [ a , b , c , d ]
[ a | _ ] == [ a , b , c , d ]
[ a , b | c , d ] == [ X , Y | Z ]

110/157

JJ
II
J
I
Back
Close

Explique porque nos exemocorre o casamento de padres:

Contra-exemplos de  casamentos:

plos abaixo,

1
2
3
4

no

[ a , b | [ c , d ] ] \== [ a , b , c , d ]
[ [ a , b , c , d ] ] \== [ a , b , c , d ]
[ a , b , [ c ] , d , e ] \== [ a , b , c , d , e ]
[ [ [ a ] | b , c , d ] ] \== [ [ a , b , c , d ] ]

111/157

Enm, os tipos de casamentos de objetos de uma lista, segue o


mesmo padro dos  matching considerados at o momento em
Prolog.
Devido ao fato de listas modelarem qualquer estrutura
de dados, invariavelmente, seu uso extensivo em problemas de
IA, pois envolvem buscas sobre estas estruturas.

Aplicao:

JJ
II
J
I
Back
Close

Listas: Uma Auto-Denio


Retomando ao conceito de listas, se  auto-dene o conceito de
lista com os seguintes axiomas:
1.

Uma lista vazia uma lista;

2.

Uma sub-lista uma lista.

112/157

As denies acima so recorrentes, isto , uma depende da outra.


Em outras palavras, tem-se uma denio recursiva uma vez mais.
Sendo assim, reescrenvendo em Prolog tal denio dada por:

#1 _uma_lista( [ ] ).
/* 1a. premissa */
#2 _uma_lista( [X | T ] ) :- _uma_lista( T ).
?- _lista( [a,b,c] ).
yes
Um  mapa

de memria aproximado

dado por:

/* 2a. */

JJ
II
J
I
Back
Close

Regra
_uma_lista([a,b,c]) #2
_uma_lista([b,c])
#2
_uma_lista([c])
#2
_uma_lista([])
#1

X T
a [b,c]
b [c]
c
[]



113/157

Basicamente, quase todas operaes com listas possuem regras


anlogas a denio acima. O exemplo anterior serve apenas para
identicar que o objeto: [a,b,c,d ], uma lista.

JJ
II
J
I
Back
Close

Exemplos de Listas

As regras sobre listas so diversas e elegantes. Apenas exercitando


que se cria a destreza necessria para resolver qualquer desao
em Prolog. Alguns clssicos so mostrados nos exemplos que se
seguem. H alguns que so combinados com outros criando alguns
bem complexos.

114/157

O comprimento de uma lista o comprimento de sua sub-lista, mais um, sendo que o comprimento de
uma lista vazia zero. Em Prolog isto dado por:

Comprimento de uma lista:

#1 compto([ ], 0).
#2 compto([X | T], N):- compto(T, N1), N is N1+1.
? - compto([a, b, c, d], X).
X = 4
Um  mapa

de memria aproximado

dado por:

JJ
II
J
I
Back
Close

Regra
compto([a,b,c,d],N) #2
compto([b,c,d],N)
#2
compto([c,d],N)
#2
compto([d],N)
#2
compto([],N)
#1

X
T
N1 N is N+1
a [b,c,d] 3 3+1=4
b [c,d] 2 - 2+1
c
[d]
1 - 1+1
d
[]
0 - 0+1



-0

115/157

JJ
II
J
I
Back
Close

Em ingls este predicado2


conhecido como  append, e em alguns Prolog's pode estar embutido como predicado nativo:

Concatenar ou unio de duas listas:

#1 uniao([],X,X).
#2 uniao([X|L1],L2,[X|L3]) :- uniao( L1, L2, L3).

116/157

O ``goal'':
?- uniao([a,c,e],[b,d], W).
W=[a,c,e,b,d]
yes
Um  mapa

de memria aproximado

uniao([a,c,e],[b,d],L)
uniao([c,e],[b,d],L)
uniao([e],[b,d],L)
uniao([],[b,d],L)
2

Regra
#2
#2
#2
#1

X
a
c
e


L1
[c,e]
[e]
[]


dado por:
L2
[b,d]
[b,d]
[b,d]
[b,d]

L3

L[X | L3]

[c,e,b,d] [a,c,e,b,d]
[e,b,d] - [c,e,b,d]
[b,d] - [e,b,d]

- [b,d]

A palavra predicado, neste contexto, reete o conjunto de regras que denem as operaes
dos mesmos sobre listas.

JJ
II
J
I
Back
Close

Dividir uma lista em duas outras listas:

| L ], em uma lista

Lista inicial em [X,Y

#1 divide([], [], []). % N par de objetos na lista


#2 divide([X], [], [X]). % N impar da lista L2
#3 divide([X,Y | L3] , [X | L1], [Y | L2] ):divide( L3, L1, L2).

117/157

Obs: Estes dois ltimos predicados apresentam uma particularidade interessante. Permitem que os predicados encontrem a lista
original. Exemplo:

?- divide([a,b,c,d,e],L1,L2).
L1=[a,c]
L2=[b,d,e]
?- divide(L , [ a , b ], [ c , d ]).
L=[a, c, b, d]
Um  mapa

de memria aproximado

divide([a,b,c,d,e],L1,L2)
divide([c,d,e],L1,L2)
divide([e],L1,L2)

Regra
#3
#3
#2

X
a
c
e

Y
b
d


dado por:
[X | L1]

[a,c]
[c]
[]

[Y | L2]

[b,d,e]
[d,e]
[e]

L3
[c,d,e]
[e]


JJ
II
J
I
Back
Close

observe o uso do predicado  put ao invs do


 write. Esta troca se deve a razo que o Prolog trata as listas
no cdigo original ASCII, ou seja fred = [102,101, 114, 100].

Imprimir uma lista:

escreve_lista( [ ] ).
escreve_lista( [ Head | Tail ] ) :write( ' : ' ),
put( Head ),
escreve_lista( Tail ).

118/157

Como uso simplicado tem-se:

Ao nal de qualquer exemplo que use listas, temos que imprimir....


assim, h muitos exemplos

JJ
II
J
I
Back
Close

: novamente,
em alguns Prolog's, este predicado pode estar embutido, conra.

Verica se um dado objeto pertence h uma lista

member( H, [ H | _ ] ).
member( H, [ _ | T ] ) :- member(H, T).

119/157

O interessante observar a versatilidade dos predicados. Explorando este tem-se:

?- member(3, [4,5,3]).
Yes
?- member(X, [4,5,3]).
X = 4 ;
X = 5 ;
X = 3 ;
No

JJ
II
J
I
Back
Close

?- member(3, X).
X = [3|_G231]
Yes
?- member(3, X).

120/157

X = [3|_G231] ;
X = [_G230, 3|_G234] ;
X = [_G230, _G233, 3|_G237]
.........................

Reita sobre a variedade de usos deste predicado

JJ
II
J
I
Back
Close

121/157

Figura 26: Um exemplo com member


Neste exemplo, um objeto
adicionado a lista sem repetio caso este j esteja contido na
lista:

Adiciona um objeto em uma lista:

add_to_set(X, [ ], [X]).

JJ
II
J
I
Back
Close

add_to_set(X, Y, Y) :- member(X, Y).


add_to_set(X, Y, [X | Y]).
122/157

JJ
II
J
I
Back
Close

O maior valor de uma lista:

uma lista.

1.
2.
3.
4.

max(
max(
max(
max(

Retorna o maior valor numrico de

[] ,0) :- !.
[M] , M ) :- !.
[M , K], M ) :- M >= K , !.
[M|R] ,N ) :- max( R , K ) ,
max( [K , M] , N).

123/157

Neste momento, o estudante deve ter percebido que a ordem


com que as regras se encontram dispostas na Memria de
Trabalho (MT) deve ser considerada. Pois o mecanismo de
backtracking do Prolog, fora uma ordem nica de como estas
regras so avaliadas.
Sendo assim, uma disciplina de programao em Prolog se faz
necessria algumas vezes! No caso das listas, as condies de paradas devem ocorrer antes da regra geral
recursiva.

A exceo a leitura de uma lista, este predicado


descrito mais adiante.
A regra geral aquela que contm uma recursividade, no exemplo anterior, a regra nmero 4. As demais regras, 1 a 3, so

JJ
II
J
I
Back
Close

regras destinadas parada da recurso. Logo, obrigatrias.


Estas regras de parada, tambm so chamadas de regras ou
clusulas aterradas (grounding), pois delimitam o nal da recurso.
Como exerccio, determine nos exemplos anteriores quem so
as regras gerais e as aterradas.

124/157

JJ
II
J
I
Back
Close

este mtodo ingnuo (primrio) na inverso


de uma lista, no sentido que faz n(n + 1)/2 chamadas recursivas
a uma lista de comprimento n.

Inverter uma lista:

naive_reverse( [ ] , [ ] ).
naive_reverse( [ H | T ], Reversed ) :naive_reverse( T , R ),
append( R , [ H ], Reversed ).

125/157

JJ
II
J
I
Back
Close

Inverso sosticada de uma lista:

lador, compare com o anterior.

usa como

truque

um acumu-

xinvertex(A, Z) :- reverse(A, [ ], Z).


reverse( [], Z, Z).
reverse( [A | X ],Acumulador, Z) :reverse(X, [A|Acumulador], Z).

126/157

JJ
II
J
I
Back
Close

usa uma tcnica simples de ir comparando sequencialmente. Caso ocorra um


erro, a substring procurada restaurada por meio de uma cpia,
presente no terceiro argumento.

Verica se uma lista est contida em outra lista:

subs(A,B) :- sub(A,B,A).
/* A lista A est contida em B ? */
sub([],_,_).
sub([A|B] , [C|D] , Lcopia) :- A == C,
sub( B, D, Lcopia).
sub([A|_] , [C|D] , Lcopia) :- A \== C,
sub(Lcopia,D, Lcopia).

127/157

Como exerccio, faa este predicado utilizando dois append.

JJ
II
J
I
Back
Close

observe que a clusula aterrada quase sempre se encontra antes da clusula geral. Contudo, a leitura de uma lista uma das raras excees em que o
aterramento vem depois da regra geral recursiva.

Leitura de uma lista via teclado:

le_lista( Lista ) :write('Digite <Enter> ou <Escape> para terminar: '),


write(' ===> '),
le_aux( Lista ).
le_aux( [Char | Resto ] ) :write(' '),
get0(Char),
testa(Char),
put(Char),
put(7), /* beep */
le_aux( Resto ).
/* Condio da Parada */
le_aux( [ ] ) :- !.
testa(13) :- !, fail.
/* Return */
testa(10) :- !, fail.
/* New line ===> UNIX */

128/157

JJ
II
J
I
Back
Close

testa(27) :- !, fail.
testa( _ ) :- true.

/* Escape */

H outros casos com o aterramento depois da regra geral.


129/157

JJ
II
J
I
Back
Close

Exlcui todas ocorrncias de um


termo na lista. Junto com o unio (append) este predicado tem
vrias utilidades. Observe os exemplos:

Removendo um item da lista:

1
2
3

del_X_all (X, [ ] , [ ] ) .
del_X_all (X, [X| L ] , L1 ) : del_X_all (X, L , L1 ) .
del_X_all (X, [Y| L1 ] , [Y| L2 ] ) : del_X_all (X, L1 , L2 ) .

130/157

4
5
6

? del_X_all ( 3 , [ 3 , 4 , 5 , 3 , 3 , 7 , 3 ] ,X ) .

7
8

X = [4 , 5 , 7]

9
10
11

Yes
? del_X_all ( 8 , [ 3 , 4 , 5 , 3 , 3 , 7 , 3 ] ,X ) .

12
13

X = [3 , 4 , 5 , 3 , 3 , 7 , 3]

14
15
16

Yes
? del_X_all ( 3 , [ 3 ] , X ) .

17
18

X = []

19
20
21
22

Yes
? del_X_all ( 3 , [ ] , X ) .

JJ
II
J
I
Back
Close

23

X = []

24
25
26

Yes
? del_X_all (X, [ 3 , 4 ] ,Y ) .

27
28
29

X = 3
Y = [4] ;

131/157

30
31
32

X = 4
Y = [3] ;

33
34
35

X = _G189
Y = [3 , 4] ;

36
37
38
39

No
?
? del_X_all (X, [ 3 , 4 ] , [ 3 ] ) .

40
41

X = 4

42
43

Yes

Observe que neste ltimo exemplo o predicado del_X_all deduziu o valor do termo X excludo no predicado. Ou seja, este um
dos muitos predicados que apresentam uma multi-funcionalidade.

JJ
II
J
I
Back
Close

Alguns predicados so difceis em qualquer linguagem de programao. Um destes a permutao a qual til
vrios problemas. O predicado exlclui_1a excluia a primeira
ocorrncia de um termo na lista, enquanto o del_X_all, visto
anteriormente, exclui todas ocorrncias.

Permutao:

132/157

1
2
3
4
5
6

/ Permutacao de e l e m e n t o s /
permutar ( [ ] , [ ] ) . / Condicao de parada /
permutar ( [ X| L ] , Lpermutada ):
permutar (L , L1 ) ,
e x c l u i _ 1 a (X, Lpermutada , L1 ) .

7
8
9
10

/ E x c l u i X apenas em sua p r i m e i r a o c o r r e n c i a /
e x c l u i _ 1 a (X, [X| L ] , L ) .
e x c l u i _ 1 a (X, [Y| L ] , [Y| L1 ] ) : e x c l u i _ 1 a (X, L , L1 ) .

11
12
13

/ executando /
i n i t : permutar ( [ 5 , 7 , 9 ] ,X) ,

14
15

? i n i t .

16
17
18
19

[5 , 7 , 9]
[7 , 5 , 9]
[7 , 9 , 5]

nl

write (X) , fail .

JJ
II
J
I
Back
Close

20
21
22

[5 , 9 , 7]
[9 , 5 , 7]
[9 , 7 , 5]

23
24
25

No
?

133/157

JJ
II
J
I
Back
Close

Partico:

134/157

JJ
II
J
I
Back
Close

Problemas de Buscas em IA
Faa muitos exerccios sobre listas e functores

135/157

Combinando os functores as listas, qual a sua utilidade?


Resgate o exemplo da Cruz ... xx aulas atrs
Os problemas de buscas em IA, basicamente se utilizam do ncleo
descrito abaixo, ou uma variao sobre o mesmo. Acompanhe a
discusso com o professor, e veja o link http://www.csupomona.
edu/~jrfisher/www/prolog_tutorial/. O ncleo abaixo retirei deste stio.
Retrata exatamente/precisamente os problemas de buscas em geral.

JJ
II
J
I
Back
Close

Ncleo Mgico

Reita sobre este cdigo, h muito conhecimento embutido.


136/157
1
2
3
4

s o l v e (P) :
start ( Start ) ,
s e a r c h ( S t a r t , [ S t a r t ] ,Q) ,
r e v e r s e (Q, P ) .

5
6
7
8
9
10
11

s e a r c h ( S , P , P) : g o a l ( S ) , ! .
s e a r c h ( S , V i s i t e d , P) :
n e x t _ s t a t e ( S , Nxt ) ,
s a f e _ s t a t e ( Nxt ) ,
no_loop ( Nxt , V i s i t e d ) ,
s e a r c h ( Nxt , [ Nxt | V i s i t e d ] , P ) .

/ done

/
/
/
/

/
/
/
/

g e n e r a t e next s t a t e
check s a f e t y
check f o r l o o p
continue searching . . .

12
13
14

no_loop ( Nxt , V i s i t e d ) :
\+member ( Nxt , V i s i t e d ) .

JJ
II
J
I
Back
Close

Continuando com o Ncleo Mgico


1
2
3
4
5
6

n e x t _ s t a t e ( S , Nxt ) : < f i l l i n h e r e >.


s a f e _ s t a t e ( Nxt ) : < f i l l i n h e r e >.
no_loop ( Nxt , V i s i t e d ) : < f i l l i n h e r e >.
/ i f d i f f e r e n t from d e f a u l t c l a u s e /
start ( . . . ) .
goal ( . . . ) .

137/157

Logo, voce tem um cdigo quase que padro para resolver qualquer
problema de buscas!
Basicamente tudo que z que problemas em IA envolve esta estrutura cannina de cdigo prologuiano

JJ
II
J
I
Back
Close

Resumindo esta Idia em uma Figura

138/157

Figura 27: Ns iniciais e nais do problema


Volte aos cdigos e reita mais uma vez!

JJ
II
J
I
Back
Close

Dicas de Programao
Tenha um editor sensvel a sintaxe do Prolog. Isto ajuda muito
aos iniciantes.

139/157

Ao carregar o programa no interpretador, certique-se que no


existam erros. Seno o cdigo com erro no carregado completamente.
Evite car pensando obstinadamente sobre um predicado que est
dando problema. Faa uma abordagem nova ou v andando.
Respire, saia de frente do computador, oxal!
Cuidado ao dar nomes de variveis. Use nomes signicativos e
curtos.
Cuidar nos predicados proibidos de backtraking. Exemplo o is.
Veja o que fazer para contornar, por exemplo:
cor(X) :- X is random(5),
X > 0, !.
cor(X) :- cor(X).

/* sem backtraking */

JJ
II
J
I
Back
Close

A cada predicado construdo, teste! Trabalhe com o conceito de


prototipao.
140/157

JJ
II
J
I
Back
Close

Predicados Mo-na-roda
findall e setof

141/157

format
var e nonvar
statistics para estatsticas do sistema, tempo de cpu, etc.
......................
statistics(cputime,T1),
/* seus calculos */ .........
statistics(cputime ,T2),
Temp is T2 - T1,
format('\n T1: ~f \t T2: ~f msec', [T1, T2]),
format('\n Tempo total: ~10f msec', Temp).

trace e notrace

JJ
II
spy e nospy faz uma depurao em um predicado em particular.
J
Os detalhes de uso deles voce descobre via ?- help(nome do predicado).I
e via

google.

Back
Close

Predicados Baixaria
if  then  else , at tu?

142/157

?- (23 > 45 -> write(23) ; write(45)).


45
true.

for
while

JJ
II
J
I
Back
Close

Gerando Programas Executveis (ou quase


com o SWI-Prolog)
O Prolog gera executveis com velocidades compatveis a linguagem C++, Delphi, e outras. Contudo, o SWI-Prolog pelo fato
de ser um  freeware (talvez), gera executveis que traz consigo o
seu interpretador. Ou seja, um executvel no SWI-Prolog funciona
como um Java, na base de um  bytecode.
Para desenvolver aplicaes comerciais ou de alto-desempenho,
interessante comprar um Prolog de algum dos muitos fabricantes.
O ECLi P S e mantido pela CISCO, explorado comercialmente
por esta, mas gratuito e livre.

143/157

JJ
II
J
I
Back
Close

A seguir mostrado como gerar um  executvel com o SWIProlog. Considere um programa exemplo, como este:

x(1).
x(5).
x(3).
par(PAR) :- x(N1),
x(N2),
N1 =\= N2,
is(PAR , (N1+N2)),
write(PAR), write(' .... '),
write(N1), write(' .... '),
write(N2), nl, fail.
/*, fail. */
par( 0 ) :- true.
inicio :- nl, par(_), halt.
Para o ambiente Linux, construa um dos dois scripts que se seguem:
#!/bin/sh

144/157

JJ
II
J
I
Back
Close

base=~/pesquisa/livro/pgms
PL=pl
exec $PL -f none -g "load_files(['$base/impares'],[silent(true)])" \
-t inicio -- $*

ou

145/157

#!/bin/sh
pl --goal=inicio --stand_alone=true -o saida.exe -c impares.pl

JJ
II
J
I
Back
Close

Execute um destes scripts na linha de comando do Linux, conforme


a ilustrao abaixo:
[claudio@goedel pgms]$ sh comp1.script
6
4
6
8
4
8

....
....
....
....
....
....

1
1
5
5
3
3

....
....
....
....
....
....

5
3
1
3
1
5

146/157

ou
[claudio@goedel pgms]$ sh comp2.script
% impares.pl compiled 0.00 sec, 1,524 bytes
[claudio@goedel pgms]$ ./saida.exe
6 .... 1 .... 5
4 .... 1 .... 3
6 .... 5 .... 1
8 .... 5 .... 3
4 .... 3 .... 1
8 .... 3 .... 5
[claudio@goedel pgms]$

Neste ltimo caso um executvel foi gerado chamado  saida.exe.

JJ
II
J
I
Back
Close

Estes dois scripts so equivalentes ao seguinte procedimento


dentro do ambiente interpretado. Logo, este vai funcionar para outros SO's:

?- consult('impares.pl').
% impares.pl compiled 0.00 sec, 1,556 bytes

147/157

Yes
?- qsave_program('nova_saida.exe',
[goal=inicio, stand_alone=true, toplevel=halt]).
Yes
Aqui, o predicado  qsave_program gerou um executvel chamado
de  nova_saida.exe. Leia com ateno o help deste predicado.
A interface com linguagens como C, Java e outros relativamente
fcil. Contudo, neste momento ser omitido.

JJ
II
J
I
Back
Close

Operaes Especiais
Alterando a memria de trabalho em tempo de execuo.

148/157

Alteraes de dados e linhas de cdigo de programa.


Ou seja, isto permite que um programa que se

auto-modique

Observe o exemplo que se segue:


?- dynamic(algo_novo/1).
Yes
??- assert(algo_novo( alo___mundo
Yes
??- algo_novo(X).
X = alo___mundo ;
Yes
?-

)).

JJ
II
J
I
Back
Close

Basicamente, o que se precisa fazer para remover ou adicionar um


fato ou regra MT, bastam dois passos:
1. Denir que este predicado dinmico na MT. Use o predicado:
dynamic(nome_do_novo/aridade) .
2. Pronto para usar, com o

assert

ou

149/157

retract.

JJ
II
J
I
Back
Close

Veja outros exemplos:


1. Removendo uma regra ou fato da Memria de Trabalho (MT):
?- retract(uniao([A|B], C, [A|D]) :- uniao(B, C, D)).

2. Adicionando

uma regra

ou

fato

da MT:

150/157

?- assertz(uniao(B, [A|C], [A|D]) :- uniao(B, C, D)).


Correct to: `assertz( (uniao(B, [A|C], [A|D]):-uniao(B, C, D)))'?
yes
B = _G519
A = _G513
C = _G514
D = _G517
Yes

3. Finalmente, reusando um fato j adicionado:


?- assert('uma_regra(X) :- algo_novo(X).').
Yes
/* usando a regra recm includa */
?- uma_regra(Y).
Y = alo___mundo ;
Yes
?-

JJ
II
J
I
Back
Close

Enm, avalie o impacto do que representa incluir ou excluir


uma regra durante a execuo de um programa. Ou seja, potencialmente se constri um programa que se  auto-modica durante a
sua execuo!
151/157

JJ
II
J
I
Back
Close

Programando com  Elegncia


H um estilo de como programar bem em Prolog? Claro, a resposta um sim. Contudo, esta elegncia ou estilo de programao
no trivialmente expresso sob a forma de regras. Algumas dicas
(experincias diversas) so:

Entenda

152/157

o problema que queres escrever em


Prolog. Um problema mal entendido, dicilmente ser bem implementado (se que for);
profundamente

Escreva da mesma maneira que o problema montado mentalmente. Assim como se fala, se escreve em Prolog.  Declare

problema, sem se preocupar como ele calculado passoa-passo

, esta uma das mximas do Prolog;

Evite o uso de operadores tradicionais como: >, <=, is . . . etc,

isto normalmente revela uma proximidade com a programao


procedural. O foco do Prolog  Casamento de Padres.

JJ
II
J
I
Back
Close

Pense que dois objetos podem ser equivalentes ou diferentes, apenas isto. Logo, eles casam ou no;

Quando uma implementao comea car complicada, porque

alguma premissa assumida previamente, est errada. Volte atrs,


e refaa tudo sob um outro enfoque. Refazer um novo programa
por inteiro, normalmente mais simples do que  forar um problema mal estruturado, convergir em uma soluo aceitvel;

Consulte os  grandes

153/157

mestres

em Prolog. Aprender Prolog com


programadores experientes uma boa dica. Alguns conhecidos
no Brasil: Pedro Porfrio (porrio@unifor.br), Edilson Ferneda
(ferneda@pos.ucb.br). Finalmente, a lista de discusso do SWIProlog tambm fcil encontrar muitos peritos em Prolog.

JJ
II
J
I
Back
Close

Sites Interessantes
http://www.cbl.leeds.ac.uk/~tamsin/Prologtutorial/

154/157

http://www.sju.edu/~jhodgson/ugai/
http://www.cee.hw.ac.uk/~alison/ai3notes/
http://dobrev.com/download.html
http://www.swi-prolog.org/
http://www.amzi.com (tem vrios artigos e tutoriais que ilus-

tram o uso e aprendizado do Prolog, respectivamente. Um site


fortemente recomendado, pois h um farto material gratuito, incluindo um ambiente de programao.)

http://www.arity.com tem um outro Prolog free


http://www.ida.liu.se/~ulfni/lpp/
Strawberry Prolog: http://www.dobrev.com/

JJ
II
J
I
Back
Close

http://www.cse.unsw.edu.au/~billw/cs9414/notes/prolog/
intro.html
http://www.mars-attacks.org/~boklm/prolog/
155/157

JJ
II
J
I
Back
Close

Alguns Bons Livros


Michael A. Convigton, Donald Nute, Andr Vellino; Prolog - Programming in Depth,

Ivan Bratko; Prolog,

Prentice-Hall, 1997;

Programming for Articial Intelligence,

edition (or later if there is one), Addison-Wesley;

W.F. Clocksin and C.S. Mellish;


edition, Springer-Verlag;

Leon Sterling and Ehud Shapiro;


Richard A. O'Keefe;

156/157

Programming in Prolog,

The Art of Prolog,

The Craft of Prolog,

2nd
3rd

MIT Press;

MIT Press 1990;

H um ttulo de um livro de IA, que  aproximadamente :


 Solving Complexs Problems with Articial Intelligence, cuja linguagem utilizada nas solues o Prolog.

JJ
II
J
I
Back
Close

Sugestes
Sugestes de exemplos so bem-vindos
Envie para: claudio@joinville.udesc.br

157/157

JJ
II
J
I
Back
Close

Você também pode gostar