Fundamentos de Prolog: uma breve

introduo programao em lgica

Jacques Robin, DI-UFPE
jr@di.ufpe.br, www.di.ufpe.br/~jr
O que Prolog?
Primeiro e mais usado linguagem do paradigma da
Programao em Lgica (PL)
Operacionalizao simples, prtica e eficiente da
PL
PL unifica:
Engenharia de Software (especificao formal, linguagens
de programao)
IA (raciocino e Representao do Conhecimento (RC))
Banco de Dados -- Dedutivos (BDDs)
Teoria Lgica (TL) das provas
Metfora da programao em lgica
Teoria Lgica = Programa = BD dedutivo = BC
Programar = apenas declarar axiomas e regras
Axiomas da TL:
fatos da BC
parte extensional do BDD
dados explcitos de um BD tradicional
Regras da TL (e da BC):
parte intencional do BDD
Teoremas da TL:
deduzidos a partir dos axiomas e das regras
dados implcitos do BDD
Linguagens de PL
Interpretadas (interatividade) e compiladas
(eficincia)
Interpretadores-Compiladores (IC) de PL:
SGBD dedutivos (em geral em memria central)
Motores de inferncia
Provadores de teoremas para lgicas com grande interseo com
a Lgica da 1a ordem (L1)
Interao:
Declarar o que verdadeiro (axiomas e regras do PL/BDD)
Chamar o IC e carregar o PL/BDD
Perguntar o que verdadeiro (tentar provar teoremas =
executar o PL = consultar o BDD)
PL x resto do mundo
PL x programao imperativa, funcional e 00:
mais declarativa, mais alto-nvel
mais verstil -- linguagem nica para:
especificar formalmente e implementar
programar aplicaes, scripts e consultas em BD
PL x outros formalismos de RC:
melhor fundamentao terica
melhor integrao com o resto da cincia computao
PL = base interessante para integrao de
paradigmas
PL = caso particular de programao por restries
Clusulas de Horn
Formulas de L1:
em forma normal implicativa (todas as variveis
implicitamente universalmente quantificadas)
com premissas todas positivas
e uma concluso nica e positiva.
Padro: P1 & ... & Pn => C
Muitas mas nem todas as formulas de L1 tem
conjunto equivalente de clusulas de Horn, cex:
V X,Y animal_lover(X) & animal(Y) & kills(X,Y) => F
Programa Prolog = conjunto (implicitamente
conjuntivo) de clusulas de Horn
Programa Prolog e clusulas de Horn
Fatos Prolog:
clusulas de Horn com premissa nica T implcita
ex: C. <=> T => C
Regras Prolog:
outras clusulas de Horn
ex: C :- P1, ... ,Pn. <=> P1 & ... & Pn => C
Premissas de clusulas com a mesma concluso so
implicitamente disjuntivas:
ex: {C :- P1, ... ,Pn., C :- Q1, ... ,Qm}
<=> (P1& ... & Pn) v (Q1 & ... & Qm) => C
Escopo das variveis = uma clusula
Interpretador Prolog: controle e busca
Aplica regra de resoluo:
com estratgia linear (sempre tenta unificar ultimo fato a
provar com a concluso de uma clusula do programa),
na ordem de escritura das clusulas no programa,
com encadeamento de regras para trs,
busca em profundidade e
da esquerda para direita das premissas das clusulas,
e com backtracking sistemtico e linear quando a
unificao falha,
e sem occur-check na unificao.
Estratgia eficiente mas incompleta.
Verificao de ocorrncia
Ao contrario da unificao da resoluo:
unificao de Prolog sem occur-check,
quando chamado com uma varivel X e um literal l,
instncia X com l, sem verificar antes se X ocorre em l.
Junto com a busca em profundidade:
faz que Prolog pode entrar em loop com regras recursivas,
ex: c(X) :- c(p(X)). gera lista infinita de objetivos:
c(p(U)), c(p(p(U))), c(p(p(p(U)))), ...
cabe ao programador de no escrever tais regras,
torna a unificao linear no lugar de quadrtica
no tamanho dos termos a unificar
West criminoso? em L1
V P,W,N american(P) &
weapon(W) & nation(N) &
hostile(N) & sells(P,N,W) =>
criminal(P)
E W owns(nono,W) & missile(W)
V W owns(nono,W) & missile(W)
=> sells(west,nono,W)
V X missile(W) => weapon(W)
V X enemy(N,america) =>
hostile(N)
american(west)
nation(nono)
enemy(nono,america)
nation(america)
american(P) & weapon(W) &
nation(N) & hostile(N) &
sells(P,N,W) => criminal(P)
owns(nono,m1)
missile(m1)
owns(nono,W) & missile(W) =>
sells(west,nono,W)
missile(W) => weapon(W)
enemy(N,america) => hostile(N)
american(west)
nation(nono)
enemy(nono,america)
nation(america)
West criminoso? em Prolog
american(P) & weapon(W) &
nation(N) & hostile(N) &
sells(P,N,W) => criminal(P)
owns(nono,m1)
missile(m1)
owns(nono,W) & missile(W) =>
sells(west,nono,W)
missile(W) => weapon(W)
enemy(N,america) => hostile(N)
american(west)
nation(nono)
enemy(nono,america)
nation(america)
criminal(P) :- american(P),
weapon(W), nation(N),
hostile(N), sells(P,N,W).
owns(nono,m1).
missile(m1).
sells(west,nono,W) :-
owns(nono,W), missile(W).
weapon(W) :- missile(W).
hostile(N) :- enemy(N,america).
american(west).
nation(nono).
enemy(nono,america).
nation(america).
West criminoso? busca
criminal(P) :- american(P),
weapon(W), nation(N),
hostile(N), sells(P,N,W).
owns(nono,m1).
missile(m1).
sells(west,nono,W) :-
owns(nono,W), missile(W).
weapon(W) :- missile(W).
hostile(N) :- enemy(N,america).
american(west).
nation(nono).
enemy(nono,america).
nation(america).
criminal(west)? <- yes.
american(west)? -> yes.
weapon(W)? <- W = m1.
missile(W)? -> W = m1.
nation(N)? -> N = nono.
hostile(nono)? <- yes.
enemy(nono,america)? -> yes.
sells(west,nono,m1)? <- yes.
owns(nono,m1)? -> yes.
missile(m1)? -> yes.
Ordem influencia a eficincia
criminal(P) :- american(P),
weapon(W), nation(N),
hostile(N), sells(P,N,W).
owns(nono,m1).
missile(m1).
sells(west,nono,W) :-
owns(nono,W), missile(W).
weapon(W) :- missile(W).
hostile(N) :- enemy(N,america).
american(west).
nation(america).
enemy(nono,america).
nation(nono).
criminal(west)? <- yes.
american(west)? -> yes.
weapon(W)? <- W = m1.
missile(W)? -> W = m1.
nation(N)? -> N = america.
hostile(america)? <- no.
enemy(america,america)? -> no.
backtrack: nation(N),
N \ {america}? -> N = nono.
hostile(nono)? <- yes.
enemy(nono,america)? -> yes.
sells(west,nono,m1)? <- yes.
owns(nono,m1)? -> yes.
missile(nono,m1)? -> yes.
Prolog devolve a primeira resposta
g1(a).
g21(a).
g3(a).
g4(a).
g1(b).
g21(b).
g22(b).
g3(b).
g(X) :- g1(X), g2(X).
g1(X) :- g3(X), g4(X).
g2(X) :- g21(X), g22(X).
$ prolog
?- consult(g.pl).
yes
?- g(U).
U = b
?- ;
U = a
?- ;
no
?- halt.
$


Forar o backtracking para obter todas
as respostas
g1(a).
g21(a).
g3(a).
g4(a).
g1(b).
g21(b).
g22(b).
g3(b).
g(X) :- g1(X), g2(X).
g(X) :- g3(X), g4(X).
g2(X) :- g21(X), g22(X).
g(U)? <- U = b.
g1(U)? -> U = a.
g2(a)? <- no.
g21(a)? -> yes.
g22(a)? -> no.
g1(U), U \ {a}? -> U = b.
g2(b)? <- yes.
g21(b)? -> yes.
g22(b)? -> yes.
;
g1(U), U \ {a,b} ? -> no.
Backtracking em cascadas
g1(a).
g21(a).
g3(a).
g4(a).
g1(b).
g21(b).
g22(b).
g3(b).
g(X) :- g1(X), g2(X).
g(X) :- g3(X), g4(X).
g2(X) :- g21(X), g22(X).
g(U), g \ {g1,g2}? <- U = a.
g3(U)? -> U = a.
g4(a)? -> yes.
;
g3(U), U \ {a}? -> U = b.
g4(b)? -> no.
g3(U), U \ {a,b}? -> no.
g(U), g \ {g1,g2 ; g3,g4}? -> no.
Sintaxe 1
fato -> fa. (abrev. para Formula Atmica)
regra -> fa0 :- fa1, ... , faN.
consulta -> fa1, ... , faN.
fa -> pred(termo1, ... , termoN) | preop termo1
termo2
| termo1 inop termo2 | termo1 termo2
postop
termo -> constante | varivel | fa
constante -> tomos | numeros
pred -> tomo
Ao invs de L1: nenhuma distino entre
predicados e funes
Sintaxe 2
varivel ex: G, Glr, geber-ramalho, 1geber, _glr, _
tomo ex: g, glr, =>, geber_ramalho, geber1, geber
ramalho
nmero ex: 23
termos, fatos, regras e consultas sem variveis:
instanciadas (ground)
termos, fatos e regras com variveis: universais
consultas com variveis: existenciais
Predicados built-in
op de unificao = e lista .
teste e converso de tipos: atom, integer, real, var,
name, list, etc.
controle de busca: !, fail, true, repeat
negao por falha: not
op aritmticos: is, +, -, *, /, mod, =:=, >, <, etc.
entrada/sada: read, write, nl, consult, reconsult, etc.
inspeo de cdigo: functor, arg, =.., listing, clause
meta-programao: assert, retract, call
manipulao de conjuntos: bagof, setof
Semntica
Programa Prolog P possui 2 semnticas:
semntica declarativa =
semntica das formulas de L1 correspondendo as
clusulas de P
em geral:
conjunto mnimo de termos instanciados verificando P
extenso de P como BDD
modelo de Herbrand
semntica procedimental =
execuo do algoritmo de resoluo sobre P
Maioria dos predicados built-in:
funcionam por efeitos colaterais
no possuem semntica declarativa em L1
Listas
[ e ]: incio e fim de lista
, separao entre eltos
|: separao entre 1o elto e resto da lista
?- [a,b,X,p(Y,C)] = [Head|Tail]
Head = a, Tail = [b,X,p(Y,C)]
?- [[p(X),[a]],q([b,c])] = [[H|T1]|T2]
H = p(X), T1 = [[a]], T2 = [q([b,c])]
member(X,[X|_]).
member(X,[Y|Z]) :- member(X,Z).
?- member(b,[a,b,c]) -> yes.
?- member(X,[a,b,c]) -> X = a ; X = b ; X = c ; no.
Igualdade x unificao
Ao invs de L1, Prolog no inclui operador de
igualdade semntica.
= operador de unificao sinttica:
no declara nada, apenas teste se 2 termos podem se
tornar igual por unificao das suas variveis
falha com termos ground sintaticamente diferentes
== operador de igualdade sinttica:
tambm apenas teste igualdade de 2 termos, sem tentar
unificar as suas variveis
falha com termos sintaticamente diferentes, mesmo
universais
Igualdade x unificao: exemplos
?- geber = senior -> no.
?- prof(X,disc(Y,dept(di,ufpe))) = prof(geber,disc(ia,Z)).
-> X = geber, Y = ia, Z = dept(di,ufpe).
?- prof(X,disc(Y,dept(di,ufpe))) == prof(geber,disc(ia,Z). -> no.
?- prof(X,disc(Y,dept(di,ufpe))) == prof(U,disc(V,dept(di,ufpe))). -> no.
?- prof(X,disc(Y,dept(di,ufpe))) == prof(X,disc(Y,dept(di,ufpe))). -> yes.
prof(ia,di,ufpe,geber).
musico(senior).
?- geber = senior, prof(X,ia,di,ufpe), musico(X). -> no.
e no: X = geber = senior.
prof(ia,di,ufpe,pessoa(geber,_).
musico(pessoa(_,senior)).
pessoa(geber, senior).
?- prof(X,ia,di,ufpe), musico(X). -> X = pessoa(geber,senior).
Evitar backtracking intil: ! (o cut)
op built-in de pruning, logicalmente sempre
verificado
com efeito colateral de impedir backtracking:
na sua esquerda na clusula que ocorre
em outras clusulas com a mesma concluso
ex: A :- B, C, D.
C :- M, N, !, P, Q.
C :- R.
impede backtracking P -> N
permite backtracking N -> M, Q -> P,
D -> (R xor Q), (P xor R) -> B
R tentado:
unicamente se M ou N falha
nunca se P ou Q falha
Cut: exemplo
f1(X,0) :- X < 3.
f1(X,2) :- 3 =< X, X < 6.
f1(X,4) :- 6 =< X.

f1(1,Y), 2 < Y? <- no
f1(1,Y)? -> X = 1, Y = 0
1 < 3? -> yes
2 < 0? -> no
f1(1,Y)? -> X = 1, Y = 2
3 =< 1? -> no
f1(1,Y)? -> X = 1, Y = 4
6 =< 1? -> no
f2(X,0) :- X < 3, !.
f2(X,2) :- 3 =< X, < 6, !.
f2(X,4) :- 6 <= X, !.

f2(1,Y), 2 < Y? <- no
f2(1,Y)? -> X = 1, Y = 0
1 < 3? -> yes
2 < 0? -> no
Cut: exemplo (cont.)
f3(X,0) :- X < 3, !.
f3(X,2) :- X < 6, !.
f3(X,4).
?- f3(1,Y).
Y = 0
?- ;
no.
?-
Esses cuts modificam at a
semntica declarativa do
programa
f4(X,0) :- X < 3.
f4(X,2) :- X < 6.
f4(X,4).
?- f4(1,Y).
Y = 0
?- ;
Y = 2.
?-


Hiptese do mundo fechado
Ao invs de L1, Prolog no permite nem fatos, nem
concluses de regras negativos, cex:
~animal_lover(geber).
~kill(X,Y) :- animal_lover(X), animal(Y).
Princpio de economia:
declarar e deduzir apenas o que verdadeiro,
supor que tudo que no mencionado nem deduzvel
falso (hiptese do mundo fechado)
Operador de negao por falha em premissas:
not p(X) verificado sse p(X) falha
=/= de ~p(X) verificado sse ~p(X) no BDE ou na concluso
de uma regra com premissas verificadas
Negao por Falha (NF) 1
Permite raciocnio no montono, ex:
ave(piupiu).
road_runner(bipbip).
ave(X) :- road_runner(X).
voa1(X) :- ave(X), not road_runner(X).
voa1(X)? -> X = piupiu ; no.
Sem semntica declarativa em L1
Depende da ordem, ex:
voa2(X) :- not road_runner(X), ave(X).
voa2(X)? -> no.
Negao por Falha 2
NF pode ser implementado apenas com ! e fail, ex:
voa3(X) :- road_runner(X), !, fail.
voa3(X) :- ave(X).
no(X) :- X, !, fail ; true.
NF torna resoluo de Prolog (Select Depth-1st
Linearly w/ Negation as Failure (SDLNF))
inconsistente
ex: edge(a,b).
sink(X) :- not edge(X,Y).
sink(a)? -> no.
sink(b)? -> yes.
sink(X)? -> no.
Prolog x sistemas de produo: controle
Raciocino dirigido pelo objetivo (e no pelos dados)
Regras encadeada para trs (e no para frente)
Busca em de cima para baixo e em profundidade na
rvore de prova (e no de baixo para cima e em
largura)
Sempre dispara 1a regra aplicvel encontrada (ie,
sem resoluo de conflitos)
Backtracking quando 1a regra leva a uma falha
Prolog x sistemas de produo:
poder expressivo
Fatos universais (e no apenas instanciados):
ex: ancestral(X,ado).
Unificao (e no apenas matching):
bidirecional
variveis lgicas podem ser instanciadas com termos
compostos (e no apenas atmicos)
ex: ?- prof(X,disc(ia,dept(di,ufpe)))
= prof(pessoa(geber,Y),disc(ia,Z))
-> X = pessoa(geber,Y), Z = dept(di,ufpe).

Prolog x resoluo em L1
Restries de Prolog com respeito a L1:
apenas clusulas de Horn
sem igualdade semntica
unificao sem verificao de ocorrncia
Extenses de Prolog com respeito a L1:
predicados (e no apenas funes) como construtores de
termos
predicados built-in de segunda ordem
Outras diferencias com respeito a L1:
negao por falha (limitada mas no montona)
Outras linguagens de PL
PL com semntica declarativa estendida:
negao explcita
concluses disjuntivas
igualdade semntica (Eqlog)
PL com semntica procedimental estendida:
backtracking inteligente
controle de busca por meta-regras (MRS, Metalog)
PL para SGBD dedutivo (Datalog):
encadeamento para frente
busca em aprofundamento iterativo
otimizao de acesso memria segundaria
resoluo completa e correta
Prolog x programao imperativa 1
Interativo:
compilao transparente integrada na interpretao
rodar programa = consultar um BD
Gerenciamento automtico da memria
Mecanismo nico de manipulao de dados --
unificao de termos lgicos -- implementando:
atribuio de valor
passagem de parmetros
alocao de estruturas
leitura e escritura em campos de estruturas
Prolog x programao imperativa 2
Estrutura de dados nica: termo Prolog
variveis lgicas sem tipo esttico
Controle implcito built-in na estrategia de
resoluo, ex: Em programao imperativa
procedure c(E)
const e0:tipoE0;
var E:tipoE, S0:tipoS0, l1:tipo-I1, S1:tipoS1;
do if E = e0 then do S0 := call p0(e0); return S0; end;
else do I1 := call p1(E); S1 := call p2(E,l1); return S1; end;
end;
Em Prolog
c(e0,S0) :- p0(e0,S0).
c(E,S1) :- p1(E,I1), p2(E,I1,S1).
Prolog x programao funcional 1
Matematicamente, predicado = relao:
no-determinismo:
respostas mltiplas (disponveis por backtracking),
unificao e busca built-in,
livra o programador da implementao do controle;
bi-direcionalidade:
cada argumento pode ser entrada ou sada, dependendo
do contexto de chamada,
nica definio para usos diferentes: verificador,
instanciador, resolvedor de restries, enumerador.
integrao imediata com BD relacional
Prolog x programao funcional 2
Append em Lisp:
(defun append(L1,L2)
(cond ((null L1) L2))
(T (cons (first L1) (append (rest L1) L2))))))
?- append([a,b],[c,d])
[a,b,c,d]
Append em Prolog:
append([],L,L).
append([H|T1],L,[H|T2]) :- append(T1,L,T2).
?- append([a,b],[c,d],R).
R = [a,b,c,d].
Append relacional codifica 8 funes
Vrios usos do mesmo predicado
verificador:
?- append([a,b],[c],[a,b,c]). -> yes.
?- append([a,b],[c],[a]). -> no.
instanciador:
?- append([a,b],[c],R). -> R = [a,b,c].
?- append(H,[c],[a,b,c]). -> H = [a,b].
resolvedor de restries:
?- append(X,Y,[a,b,c]). -> X = [], Y = [a,b,c]
; -> X = [a], Y = [b,c] ...
enumerador:
?- append(X,Y,Z). -> X = [], Y =[], Z = []
; -> X = [_], Y = [], Z = [_] ...
Prolog x programao OO
Funcionalidades built-in:
+ unificao e busca
- tipos, herna e encapsulao
Ontologicalmente:
Entidade Atmica (EA): em OO, valor de tipo built-in
em Prolog, tomo (argumento ou predicado)
Entidade Composta (EC): em OO, objeto
em Prolog, fato
Relao simples entre EC e EA: em OO, atributo de tipo built-in
em Prolog, posio em um predicado
Relao simples entre ECs: em OO, atributo de tipo objeto
em Prolog, predicado
Relao complexa entre entidades: em OO, mtodo
em Prolog, conjunto de regras
Prolog x programao OO: exemplo
Em OO:
pt[subclass_of planobj;
attrs[X inst_of int, Y inst_of int];
mets[right(Pt inst_of pt) {return self.X >= Pt.X}]]
pt1[inst_of pt; attrs[X = 0, Y = 0]]
pt2[inst_of pt; attrs[X = 1, Y =1]]
?- pt1.above(pt2) -> no.
Em Prolog:
pt(0,0).
pt(1,1).
planobj(pt(_,_)).
right(pt(X1,_),pt(X2,_) :- X1 >= X2.
?- above(pt(0,0),pt(1,1)). -> no.
Programao por restries
Programar = declarar restries sobre os valores
v1, ... vn, de um conjunto de variveis V1, ..., Vn:
o dominio Di associado a cada varivel Vi
equaes e inequaes Pj(Vp, ..., Vq) ligando-as
Executar programa:
fazer uma consulta sobre a compatibilidade de restries
de entrada Pk(Vr, ..., Vs) com as restries do programa
recuperar em sada todos os valores (v11, ... , vn1) ... (v1l,
..., vnl) de (V1, ... , Vn) que satisfazem ambos
Pj(Vp, ... , Vq) e Pk(Vr, ..., Vs).
Programao por restries: exemplo
integer(N).
integer(S).
sumto(0,0).
sumto(N,S) :- 1 =< N, N =< S, sumto(N - 1, S - N).
?- S =< 3, sumto(N,S).
(N = 0, S = 0), (N = 1, S = 1), (N = 2, S = 3).
Propagao recursiva de restries:
1: 1 =< N1 = N =< S1 = S =< 3
(N1,S1) in {(1,1),(1,2),(1,3),(2,1),(2,2),(2,3),(3,1),(3,2),(3,3)}
2: 1 =< N2 = N1 - 1 =< S2 = S1 - N1 =< 2
(N2,S2) in {(1,1),(1,2),(2,1),(2,2)} => (N1,S1) in {(2,3),(2,4),(3,4),(3,5)}
N1 = 2, S1 = 3 => N2 = 1, S2 = 1
Programao por restries: exemplo
integer(N).
integer(S).
sumto(0,0).
sumto(N,S) :- 1 =< N, N =< S,
sumto(N - 1, S - N).
?- S =< 3, sumto(N,S).
(N = 0, S = 0), (N = 1, S = 1),
(N = 2, S = 3).

restries usadas no
programa, na entrada, na sada
e para o controle
1: 1=<N1=N=<S1=S=< 3
(N1,S1) in {(1,1),(1,2),(1,3), (2,1),
(2,2),(2,3),(3,1),(3,2),(3,3)}
2: 1=<N2=N1-1=<S2=S1-N1=<2
(N2,S2) in {(1,1),(1,2),(2,1),(2,2)}
(N1,S1) in {(2,3),(2,4),(3,4),(3,5)}
N1=2, S1=3 => N2=1, S2=1
3: 1=<N3=N2-1=<S3=S2-N2=<0
contradio, no h mais solues
devolve:
(0,0) regra 1
(1,1) e (2,3) regra 2, 2a iterao
Prolog x programao por restries
Em Prolog:
predicados aritmticos no podem ser chamados como
resolvedores de restries
mas apenas como verificadores
a consulta S =< 3, sumto(N,S) gera erro por chamar
predicados aritmticos com termos no instanciados
Prolog pode ser visto como:
uma linguagem de programao por restrio
cujo nico operador a unificao
cujo domnio o conjunto de arvores finitas que
representam os termos Prolog
Prolog como restries: exemplo
prof(X,disc(ia,dept(di,ufpe)))
?- prof(pessoa(geber,Y),disc(ia,Z))
1: prof = prof, 2 = 2
2: X = pessoa(geber,Y), disc = disc, 2 = 2,
3: ia = ia, dept(di,ufpe) = Z
4: fundo das arvores atingindas
devolve as equaes no trivais:
X = pessoa(geber,Y),
Z = dept(di,ufpe).

Linguagens de PL multiparadigma
PL concorrente, paralela (Concurrent Prolog,
Parlog)
PL funcional (Lambda-Prolog, LeFun)
PL OO (Logtalk, Objlog, Login, F-Logic)
PL por restries, ie, Prolog + (in)equaes:
aritmticas (CLP(R), CHIP, Prolog3)
de tipos (Login)
buleanas (CHIP, Prolog3)
PL para Internet, predicados built-in para:
protocolos http, ftp, mail, news, etc.
parsing de pginas HTML para termos Prolog
PiLLoW, Logicweb
Ficou curioso? Tem mais!
Disciplina de Programao em Lgica:
Prolog
LIFE: PL funcional, OO e por restries de tipos, e com
interface para BD relacional
Florid: PL OO com igualdade semntica e sintaxe de ordem
superior, para BD dedutivo e Internet
projeto: implementar agentes inteligentes para a RoboCup
Projetos de pesquisa:
CRUIJFF: ambiente de programao de agentes inteligentes
integrando os paradigmas lgica, funcional, e por restries
sobre uma base Java.
Web SKWASH: agentes inteligentes de data mining de Web log
file e gerao de resumos hipertextuais