Banco de Dados com Regras: Ativos e Dedutivos Jacques Robin & Frederico Fernandes CIn-UFPE.
Introdução a programação em lógica Jacques Robin, DI-UFPE jr.
-
Upload
manuela-de-freitas -
Category
Documents
-
view
213 -
download
0
Transcript of Introdução a programação em lógica Jacques Robin, DI-UFPE jr.
Introdução a programação em lógicaIntrodução a programação em lógica
Jacques Robin, DI-UFPEwww.di.ufpe.br/~jr
Metáfora da programação em lógicaMetáfora da programação em lógica
Teoria Lógica = Programa = BD dedutivo = Base de Conhecimento (BC)
Programar = apenas declarar axiomas e regras Axiomas da TL:
• fatos da BC • parte extensional do BDD• dados explícitos 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 implícitos do BDD
Linguagens de PLLinguagens de PL
Interpretadas (interatividade) e compiladas (eficiência)
Interpretadores-Compiladores (IC) de PL: • SGBD dedutivos (em geral em memória central)• Motores de inferência• Provadores de teoremas para lógicas com grande interseção com a
Lógica da 1a ordem (L1) Interação:
• 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)
Programação procedimental Programação procedimental x programação declarativax programação declarativa
1. Escolher linguagem de especificação formal (LE)
2. Especificar formalmente os requisitos na LE
3. Escolher linguagem de programação (LP)
4. Codificar estruturas de dados na LP
5. Codificar passo a passo estruturas de controle na LP
6. Escolher/escrever compilador da LP
7. Executar programa
Escolher FRC (1,3) Declarar estruturas de
conhecimento no FRC (2,4) Escolher/escrever motor de
inferência para FRC (6) Consultar base de
conhecimento sobre verdade de um fato (7)• foi declarado? • pode ser deduzido?• reposta:
booleana (L0, L1) instanciação de variáveis
(L1)
Ciclo de desenvolvimento de um Ciclo de desenvolvimento de um software baseado em conhecimentosoftware baseado em conhecimento
AQUISIÇÃO
FORMALIZAÇÃO
IMPLEMENTAÇÃO
MANUTENÇÃO
Nível de Conhecimento
Nível Lógico
Ontologia
Raciocínio
Nível de Implementação BASE
Igualdade x unificaçãoIgualdade x unificação
Ao invés de L1, Prolog não inclui operador de igualdade semântica.
= operador de unificação sintática:• não declara nada, apenas teste se 2 termos podem se
tornar igual por unificação das suas variáveis• falha com termos ground sintaticamente diferentes
== operador de igualdade sintática:• também apenas teste igualdade de 2 termos, sem tentar
unificar as suas variáveis• falha com termos sintaticamente diferentes, mesmo
universais
Igualdade x unificação: exemplosIgualdade x unificação: 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(ia,di,ufpe,X), musico(X). -> no. e não: X = geber = senior. prof(ia,di,ufpe,pessoa(geber,_). musico(pessoa(_,senior)). pessoa(geber, senior). ?- prof(ia,di,ufpe,X), musico(X). -> X = pessoa(geber,senior).
Cláusulas de HornCláusulas de Horn Formulas de L1:
• em forma normal implicativa • com uma conclusão única e positiva• ie, da forma:
Muitas mas nem todas as formulas de L1 tem conjunto equivalente de cláusulas de Horn, cex:
Lógica de Horn: nnH hhfHorndeclaúsulashhLfL 1111 ,,/
CPP n 1
FYXkillsYanimalXranimalLoveYX ),()()(,
Cláusulas Prolog e cláusulas de HornCláusulas Prolog e cláusulas de Horn
Fatos Prolog:• cláusulas de Horn com premissa única T implícita• ex: C. <=> T => C
Regras Prolog:• outras cláusulas de Horn • ex: C :- P1, ... ,Pn. <=> P1 & ... & Pn => C
Premissas de cláusulas com a mesma conclusão são implicitamente disjuntivas:• ex: {C :- P1, ... ,Pn., C :- Q1, ... ,Qm} <=> (P1& ... & Pn) v (Q1 & ... & Qm) => C
Escopo das variáveis = uma cláusula
West é criminoso?West é criminoso? : em L1 : em L1
Requisitos em inglês1. It is crimimal for an American to
sell weapons to an hostile country
2. Nono owns missiles3. Nono acquires all its missiles
from West4. West is American5. Nono is a nation6. Nono is an enemy of the USA0. Is West a crimimal?
Em L11. P,W,N american(P) & weapon(W) &
nation(N) & hostile(N) & sells(P,N,W) => criminal(P)
2. W owns(nono,W) & missile(W)3. W owns(nono,W) & missile(W) =>
sells(west,nono,W)7. X missile(W) => weapon(W)8. X enemy(N,america) => hostile(N)4. american(west)5. nation(nono)6. enemy(nono,america)9. nation(america)
West é criminoso?West é criminoso? em formal normalem formal normal
Em L1: P,W,N american(P) & weapon(W)
& nation(N) & hostile(N) & sells(P,N,W) => criminal(P)
2. W owns(nono,W) & missile(W)3. W owns(nono,W) & missile(W)
=> sells(west,nono,W)7. X missile(W) => weapon(W)8. X enemy(N,america) =>
hostile(N)4. american(west)5. nation(nono)6. enemy(nono,america)9. nation(america)
Em formal normalamerican(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?West é criminoso? em Prolog em Prolog
Em lógica de Horn: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)
Em Prolog: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?West é criminoso? busca 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.
West é criminoso?West é criminoso? backtracking backtracking
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 respostaProlog 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).g(X) :- g3(X), g4(X).g2(X) :- g21(X), g22(X).
$ prolog?- consult(“g.pl”).yes?- g(U).U = b?- ;U = a ?- ;no?- halt.$
Forçar o backtracking para obter todas Forçar o backtracking para obter todas as respostasas 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 cascatasBacktracking em cascatas
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.
Interpretador Prolog: controle e buscaInterpretador Prolog: controle e busca
Aplica regra de resolução:• com estratégia linear (sempre tenta unificar ultimo fato a
provar com a conclusão de uma cláusula do programa),• na ordem de escritura das cláusulas no programa, • com encadeamento de regras para trás, • busca em profundidade e• da esquerda para direita das premissas das cláusulas,• e com backtracking sistemático e linear quando a unificação
falha,• e sem occur-check na unificação.
Estratégia eficiente mas incompleta.
Evitar backtracking inútil: Evitar backtracking inútil: !! (o cut) (o cut)
op built-in de pruning, logicalmente sempre verificado com efeito colateral de impedir backtracking:
• na sua esquerda na cláusula que ocorre• em outras cláusulas com a mesma conclusão
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: exemploCut: 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.)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
semântica declarativa do programa
f4(X,0) :- X < 3.f4(X,2) :- X < 6.f4(X,4).?- f4(1,Y).Y = 0?- ;Y = 2.?-
Hipótese do mundo fechadoHipótese do mundo fechado
Ao invés de L1, Prolog não permite nem fatos, nem conclusões de regras negativos, cex: ~animal_lover(geber).~kill(X,Y) :- animal_lover(X), animal(Y).
Princípio de economia: • declarar e deduzir apenas o que é verdadeiro, • supor que tudo que não é mencionado nem deduzível é
falso (hipótese do mundo fechado) Operador de negação por falha em premissas:
• not p(X) verificado sse p(X) falha• =/= de ~p(X) verificado sse ~p(X) no BDE ou na conclusão
de uma regra com premissas verificadas
Negação por Falha (NF) 1Negação por Falha (NF) 1
Permite raciocínio não monótono, ex:ave(piupiu).papa_leguas(bipbip).ave(X) :- papa_leguas(X).voa1(X) :- ave(X), not papa_leguas(X).voa1(X)? -> X = piupiu ; no. Sem semântica declarativa em L1 Depende da ordem, ex:voa2(X) :- not papa_leguas(X), ave(X).voa2(X)? -> no.
Negação por Falha 2Negação por Falha 2
NF pode ser implementado apenas com !, fail (nunca verificado) e true (sempre verificado), ex:• voa3(X) :- papa_leguas(X), !, fail. voa3(X) :- ave(X).• não(X) :- X, !, fail ; true.
NF torna resolução 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.
Predicados built-inPredicados built-in
op de unificação = e lista. op aritméticos: is, +, -, *, /, mod, =:=, >, <, etc. teste e conversão de tipos: atom, integer, real, var,
name, list, =... controle de busca: !, fail, true, repeat negação por falha: not entrada/saída: read, write, nl, consult, reconsult, etc. meta-programação: assert, retract, call manipulação de conjuntos: bagof, setofMaioria funcionam por efeitos colaterais sem semântica
declarativa em L1
Prolog: listasProlog: listas
[ e ]: início e fim de lista , separação entre eltos |: separação entre 1o elto e resto da lista
açúcar sintático para predicado .(Head,Tail)ex.: [a,[b,c],d] açúcar sintático para .(a,.(.(b,.(c,[])),.(d,[])))
?- [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.
Prolog: aritméticaProlog: aritmética
3 tipos de operadores built-in aritméticos:• calculadores (n-ários infixos): +, -, *, /, mod • comparadores (binários infixos): =:=, =\=, <, >, =<, >• o atribuídor is: Variável is ExpressãoAritmética
Expressão aritmética:• fórmula atômica contendo apenas números e calculadores
aritméticos• todos os argumentos dos calculadores e comparadores
devem ser instanciados com expressões aritméticas
Prolog: exemplos de aritmética 2Prolog: exemplos de aritmética 2
fac(0,1) :- !.fac(I,O) :- I1 is I - 1, fac(I1,O1), O is I * O1.?- fac(1,X).X = 1?- fac(3,X).X = 6?- fac(5,X).X = 120
sum([],0).sum([H|T],N) :- sum(T,M), N is H + M.?- sum([2,1,3,1],S).S = 7?- sum([2,10,1],S).S = 13
Prolog: teste de tipos Prolog: teste de tipos
semântica declarativa de var fora de L1
Prolog: entrada/saídaProlog: entrada/saída
Ler/escrever estrutura de dados dificilmente pode ser visto como resultando de uma dedução:• E/S não se integre naturalmente no paradigma de PL• requer predicados extra-lógicos sem semântica declarativa
em L1 Predicados built-in de Prolog para E/S:
• sempre verificados• cumprem sua tarefa por efeitos colaterais• não podem ser re-satisfeitos por backtracking
Prolog: failure-driven loopProlog: failure-driven loop
Loop gerada por backtracking forçado com fail e repeat.
repeat sempre verificado e re-verificado no backtracking (true sempre verificado mas falha no backtracking)
consult(File) :- see(File), consult-loop, seen.consult-loop :- repeat, read(Clause), process(Clause), !.process(X) :- end_of_file(X), !.process(Clause) :- assert(Clause), fail.
Prolog x programação imperativa 1Prolog x programação imperativa 1
Interativo: • compilação transparente integrada na interpretação• rodar programa = consultar um BD
Gerenciamento automático da memória Mecanismo único de manipulação de dados --
unificação de termos lógicos -- implementando:• atribuição de valor• passagem de parâmetros• alocação de estruturas• leitura e escritura em campos de estruturas
Prolog x programação imperativa 2Prolog x programação imperativa 2
Estrutura de dados única: termo Prolog variáveis lógicas sem tipo estático
Controle implícito built-in na estrategia de resolução, ex: Em programação 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 programação funcional 1Prolog x programação funcional 1
Matematicamente, predicado = relação: não-determinismo:
• respostas múltiplas (disponíveis por backtracking),• unificação e busca built-in, • livra o programador da implementação do controle;
bi-direcionalidade: • cada argumento pode ser entrada ou saída, dependendo do
contexto de chamada,• única definição para usos diferentes: verificador,
instanciador, resolvedor de restrições, enumerador. integração imediata com BD relacional
Prolog x programação funcional 2Prolog x programação funcional 2
Append em Haskell: append [] l = l append head1:tail1 l2 = head1:(append tail1 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 funções
Vários usos do mesmo predicadoVários 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 restrições:?- 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 programação OOProlog x programação OO
Funcionalidades built-in: • + unificação e busca• - tipos, herânça e encapsulação
Ontologicalmente:• Entidade Atómica (EA): em OO, valor de tipo built-in
em Prolog, átomo (argumento ou predicado)• Entidade Composta (EC): em OO, objeto
em Prolog, fato• Relação simples entre EC e EA: em OO, atributo de tipo built-in
em Prolog, posição em um predicado• Relação simples entre ECs: em OO, atributo de tipo objeto
em Prolog, predicado• Relação complexa entre entidades: em OO, método
em Prolog, conjunto de regras
Prolog x programação OO: exemploProlog x programação 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.right(pt2) -> no.
Em Prolog:pt(0,0).pt(1,1).planobj(pt(_,_)).right(pt(X1,_),pt(X2,_) :- X1 >= X2.?- right(pt(0,0),pt(1,1)). -> no.
Prolog x sistemas de produção:Prolog x sistemas de produção:poder expressivopoder expressivo
Fatos universais (e não apenas instanciados):• ex: ancestral(X,adão).
Unificação (e não apenas matching):• bidirecional• variáveis lógicas podem ser instanciadas com termos
compostos (e não apenas atómicos)• 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 sistemas de produção: controleProlog x sistemas de produção: controle
Raciocino dirigido pelo objetivo (e não pelos dados) Regras encadeada para trás (e não para frente) Busca em de cima para baixo e em profundidade na
árvore de prova (e não de baixo para cima e em largura)
Sempre dispara 1a regra aplicável encontrada (ie, sem resolução de conflitos)
Backtracking quando 1a regra leva a uma falha
Estudo de caso: Estudo de caso: A curiosidade matou o gato? A curiosidade matou o gato?
Requisitos em inglês
1. Jack owns a dog.2. Every dog owner is an animal
lover.3. No animal lover kills an animal.4. Either Jack or curiosity killed
Tuna5. Tuna is a catQ1. Did curiosity kill the cat?Q2. Quem matou o gato?
Em L1 1. x Dog(x) Owns(Jack,x)2. x (y Dog(y) Owns(x,y))
AnimalLover(x)3. x AnimalLover(x) (y
Animal(y) Kills(x,y))4. Kills(Jack, Tuna) Kills(Curiosity,
Tuna)5. Cat(Tuna)6. x Cat(x) Animal(x)
Q1. Kills(Curiosity,Tuna)Q2. X, Kills(X,Tuna)
Exercício 1:Exercício 1: A curiosidade matou o gato? A curiosidade matou o gato? em Prologem Prolog
Estudo de caso: Estudo de caso: a terrível novelaa terrível novelarequisitos em Inglêsrequisitos em Inglês
1. A soap opera is a TV show whose characters include a husband, a wife and a mailman such that:
2. the wife and the mailman blackmail each other 3. everybody is either alcoholic, drug addict or gay 4. Dick is gay, Jane is alcoholic and Harry is a drug addict 5. the wife is always an alcoholic and the long-lost sister of her
husband 6. the husband is always called Dick and the lover of the mailman 7. the long-lost sister of any gay is called either Jane or Cleopatra 8. Harry is the lover of every gay 9. Jane blackmails every drug addicted lover of Dick 10. soap operas are invariably terrible! 0. Who are the characters of a terrible TV show?
Exercício 2:Exercício 2:A terrível novelaA terrível novela em Prolog em Prolog
Estudo de caso: Estudo de caso: o banco de dados o banco de dados acadêmicoacadêmico
requisitos em Inglêsrequisitos em Inglês1. Bob is 40 and the manager of the CS
department. 2. His assistants are John and Sally. 3. Mary’s highest degree is an MS and she
works at the CS department. 4. She co-authored with her boss and her
friends, John and Sally, a paper published in the Journal of the ACM.
5. Phil is a faculty, who published a paper on F-Logic at a Conference of the ACM, jointly with Mary and Bob.
6. Every faculty is a midaged person who writes article, makes in the average $50,000 a year and owns a degree of some kind, typically a PhD.
7. One is considered midage if one is between 30 and 50 years old.
8. A faculty’s boss is both a faculty and a manager.
9. Friends and children of a person are also persons.
10. Every department has a manager who is an employee and assistants who are both employees and students
11. A boss is an employee who is the manager of another employee of the same department.
12. A joint work is a paper that is written by two faculties
13. There are three types of papers: technical reports, journal papers and conference papers
0a: Who are the midaged employees of the CS department and who are their boss?
0b: Who published jointly with Mary in the Journal of the ACM?
0c: Where did Mary published joint work with Phil?
Exercício 3:Exercício 3:O banco de dados acadêmicoO banco de dados acadêmico
em Prologem Prolog