exemplos prolog

Prévia do material em texto

--------------------------------------------------------------
Fatos:
gosta(pedro, maria).
gosta(maria, pedro).
mulher(maria).
homem(pedro).
pai(pedro, joão).
entrega(romeu, livro, maria).
--------------------------------------------------------------
Perguntas:
?- possui(maria, livro).
Exemplo:
Banco de dados ->
humano(socrates).
humano(aristoteles).
ateniense(socrates).
Pergunta ->
?- ateniense(aristoteles).
--------------------------------------------------------------
Variáveis:
Banco de dados ->
gosta(maria, flores).
gosta(maria, pedro).
gosta(paulo, maria).
Pergunta ->
?- gosta(maria, X).
Perguntamos do que Maria gosta?
X = flores
ENTER se estivermos satisfeitos.
; (ponto-e-vírgula) caso contrário. Prolog continua a busca por mais
respostas
Pergunta ->
?- gosta(X, paulo).
O que acontece?
--------------------------------------------------------------
Conjunções:
Banco de dados ->
gosta(maria, chocolate).
gosta(maria, vinho).
gosta(pedro, vinho).
gosta(pedro, maria).
Pergunta ->
?- gosta(pedro, maria), gosta(maria, pedro).
A vírgula em Prolog serve como uma conjunção ("and").
Também podemos fazer conjunções da forma:
?- gosta(maria, X), gosta(pedro, X).
X = vinho
--------------------------------------------------------------
Regras: afirmação geral sobre objetos e relacionamentos.
:- leia-se "se".
Exemplo 1:
Pedro gosta de X se X gosta de vinho.
gosta(pedro, X) :- gosta(X, vinho).
gosta(pedro, X) :- gosta(X, vinho), gosta(X, chocolate).
Exemplo 2:
gosta(pedro, X) :- mulher(X), gosta(X, vinho).
Exemplo 3:
Banco de dados ->
homem(alberto).
homem(eduardo).
mulher(alice).
mulher(vitoria).
pais(eduardo, vitoria, alberto).
pais(alice, vitoria, alberto).
Podemos definir o predicado irma_de, de tal forma que irma_de(X, Y) 
seja verdadeiro se X for irmã de Y. Portanto,
X deve ser mulher;
X tem pai P e mãe M;
Y tem os mesmos pais de X.
irma_de(X, Y) :- 
mulher(X),
pais(X, M, P),
pais(Y, M, P).
?- irma_de(alice, eduardo).
?- irma_de(alice, X).
X = eduardo
E se digitarmos ; ao invés de ENTER. O que acontece? 
O que podemos mudar para corrigir o problema?
--------------------------------------------------------------
Termo: 
Pode ser uma constante, uma variávei ou uma estrutura.
--------------------------------------------------------------
Constantes ->
Podem se átomos ou números.
Exemplos de átomos ->
maria, livro, ?-, :-, caracteres, etc.
Exemplos de números ->
Inteiros positivos e negativos, ponto flutuante, etc.
0, 1, -17, 3.53, 9e10, 6.07e-31, etc.
--------------------------------------------------------------
Variáveis ->
Tem nomes cujo primeiro caracter é uma letra maiúscula ou sinal
de sublinhado (underscore) "_".
"_" é usado para representar variáveis anônimas.
--------------------------------------------------------------
Estruturas ->
Formadas por um funtor, seguido de componentes separadas por vírgula
e colocadas entre parênteses.
Exemplo ->
livro(incidente_em_antares, verissimo).
Exemplo de estrutura aninhada ->
livro(incidente_em_antares, autor(erico, verissimo)).
Exemplo de argumentos de fatos em um BD ->
pertence(pedro, livro(incidente_em_antares, verissimo)).
--------------------------------------------------------------
Igualdade e Unificação: "="
Em Prolog, igualdade significa unificação.
Pode causar a instanciação de algumas variáveis.
Exemplo ->
pilotos(A, londres) = pilotos(londres, paris)
Unificam? Por que não? Onde está o problema?
ponto(X, Y, Z) = ponto(X1, Y1, Z1)
letra(c) = palavra(letra)
nome(alfa) = alfa
nome(alfa) = nome(alfa, beta)
f(X, X) = f(a, b)
f(X, a(b, c)) = f(Z, a(Z, c))
X = b
Z = b
irmaos(X, Y) :-
pai(X, PX),
pai(Y, PY),
PX = PY.
--------------------------------------------------------------
Aritmética:
Predicados pré-definidos em Prolog para comparação e 
cálculo:
=:= -> igualdade
=\= -> diferença
< -> menor
> -> maior
=< -> menor ou igual
>= -> maior ou igual
Exemplos ->
Considere um banco de dados contendo os príncipes de Gales
nos séculos 9 e 10, e os anos em que reinaram.
reinou(rhodri, 844, 878).
reinou(anarawd, 878, 916).
reinou(hywel_dda, 916, 950).
reinou(iago_ap_idwal, 950, 979).
reinou(hywal_ap_ieuaf, 979, 985).
reinou(cadwallon, 985, 986).
reinou(maredudd, 986, 999).
Quem foi o príncipe em um ano dado? 
principe(X, Y) :-
reinou(X, A, B),
Y >= A,
Y =< B.
?- principe(cadwallon, 986).
?- principe(X, 900).
?- principe(X, 979).
--------------------------------------------------------------
Predicado is:
Podemos usar o predicado is para cálculos aritméticos. É o único
que pode calcular resultados de operações aritméticas.
Exemplos ->
?- A is 3+5.
A = 8.
?- A = 3+5.
Unificação -> não realiza a conta.
A = +(3, 5)
?- 3 is 3 + 5.
No.
?- 3 is 2 + 1.
Yes.
?- X is 3 * 8 - 2.
X = 22.
?- X is 3 + 2.
X = 5.
?- X is Z + Y.
?- 6 is 2 * 4.
?- X = 5, Y is X // 2.
X = 5,
Y = 2.
?- Y is X // 2, X = 5.
Banco de dados contendo a população e a área de alguns países em 1976.
pop(eua, 203).
pop(india, 548).
pop(china, 800).
pop(brasil, 108).
area(eua, 8).
area(india, 3).
area(china, 10).
area(brasil, 8).
Para calcular a densidade populacional de uma país:
dens(X, Y) :-
pop(X, P),
area(X, A),
Y is P/A.
?- dens(china, X).
?- dens(turquia, X).
--------------------------------------------------------------
Operadores para cálculos aritméticos:
+ -> soma
- -> subtração
* -> multiplicação
/ -> divisão
// -> divisão inteira
mod -> resto da divisão
Exemplos:
Considere o banco de dados.
soma(5).
soma(2).
soma(2 + X).
soma(X + Y).
e a meta soma(2 + 3) unifica com quais fatos?
Com quais fatos essa meta unifica? Quais a instanciações
em cada caso?
?- soma(Y + 3).
?- soma(Y + Y).
Predicado para fatorial ->
?- fat(3, F).
F = 6.
No BD:
fat(0, 1).
fat(N, F) :-
N > 0, N1 is N - 1,
fat(N1, F1), 
F is N * F1.
--------------------------------------------------------------
Predicados:
true -> satisfeito sempre, somente uma vez
?- true, write('oi').
oi
true.
repeat -> satisfeito sempre, todas as ressatisfações.
?- repeat, write('oi').
oi
true ;
oi
true ;
oi
true .
var(X) -> satisfeito quando X é variável não instanciada.
nonvar(X) -> satisfeito quando X é termo ou variável instanciada.
atom(X) -> satisfeito se X é átomo.
number(X) - > satisfeito quando X é um número.
atomic(X) -> satisfeito quando X é átomo ou número.
Predicados para o Banco de Dados:
listing -> lista todas as cláusulas do banco de dados, incluindo fatos
e regras.
listing(P) -> lista todas as cláusulas do predicado P.
asserta(X) -> primeira cláusula do BD.
assertz(X) -> última cláusula do predicado, mas ambos satisfeitos uma
vez e adicionam a cláusula X ao BD.
retract(X) -> satisfeito se X é uma cláusula do BD. Como efeito colateral,
remove-a.
last(X, L) -> satisfeito quando X é o último elemento de L.
reverse(L, M) -> satisfeito quando L é a reversa de M.
delete(X, L, M) -> satisfeito quando a lista M é obtida de L pela remoção
de todas as ocorrências de X.
Predicados tratando listas como conjuntos:
subset(X, Y) -> satisfeito quando todos os elementos de X estão também em 
Y.
intersection(X, Y, Z) -> satisfeito quando Z = X intersecção Y.
union(X, Y, Z) -> satisfeito quando Z = X união Y.
X = .. L -> satisfeito quando X é termo e L é lista com funtor e 
argumentos de X.
Transformar termo em lista e lista em termo.
?- gosta(eu, tu) =.. L.
L = [gosta, eu, tu].
?- X =.. [a, b, c, d].
X = a(b, c, d).
random(N) -> pode ser usado numa expressão aritmética retorna um número 
aleatório 
entre 0 e N - 1.
?- X is random(4).
findall(X, M, L) -> instancia L a uma lista contendo todosos objetos X 
para os
quais M é verdadeiro.
Exemplo: achar todos que gostam de maria.
?- findall(X, gosta(X, maria), L).
L = [pedro, sergio, alan].
; -> operador "ou"
atomic(X) :- atom(X); number(X).
, -> operador "and"
--------------------------------------------------------------
Estruturas de dados:
Listas ->
Em Prolog, uma lista é:
ou uma lista vazia, [ ].
ou uma estrutura com dois componentes: a cabeça e a cauda.
Para representar uma lista, basta colocar os elementos entre colchetes,
separados por vírgulas: [a, b, c].
Exemplos:
[o, homem, [gosta, de, pescar]]
[a, V1, b, [X, Y]]
Listas são processadas dividindo-as em cabeça e cauda, como os predicados
car e cdr de Lisp. 
Operador "|".
p([1, 2, 3]).
p([o, gato, sentou, [no, capacho]]).
?- p([X|Y]).
X = 1, Y = [2, 3] ;
X = o, Y = [gato, sentou, [no, capacho]] ;
no
?- p([_, _, _, [_|X]]).
X = [capacho]
Predicado append:
?- append([alfa, beta], [gama, delta], X).
X = [alfa, beta], gama, delta]
?- append(X, [b, c, d], [a, b, c, d]).
--------------------------------------------------------------
Recursão:
Suponha a lista [azul, verde, amarelo, vermelho] e queiramos
saber uma cor arbitrária nesta lista. Devemos buscar primeiro na cabeça e
depois na cabeça da cauda, e assim por diante.
Predicado member(X, Y):
Que é verdadeiro quando X é um elemento da lista Y. Se X for a 
cabeça da lista.
member(X, Y) :- Y = [X|_].
Se X não for a cabeça da lista, mas pode ser parte da cauda:
member(X, Y) :- Y = [_|Z], member(X, Z).
?- member(d, [a, b, c, d, e, f, g]).
?- member(2, [3, a, d, 4]).