Inteligncia Artificial

PROLOG partes 1, 2 e 3

Rafael Rosario rafael.rosario@sociesc.org.br rafael.rosario@datasul.com.br

PROLOG (I)
Foi criada em meados de 1972 por Alain Colmerauer e Philippe Roussel, na Universidade de Marselha. O nome PROLOG foi escolhido por Philippe Roussel como uma abreviao de PROgrammation en LOGique. Propsito da criao: criar programas para traduo de linguagens faladas, como portugus ou ingls.

PROLOG (II)
Fundamentada na lgica simblica;

uma linguagem declarativa: em vez de o programa estipular a maneira de chegar soluo, passo a passo, limita-se a fornecer uma descrio do problema que se pretende computar.
Usa uma coleo de fatos e de relaes lgicas (regras) que exprimem o domnio relacional do problema.

PROLOG(III)
Outro fato que o difere das outras linguagens o fato de no possuir estruturas de controle (if-else, dowhile, for, switch). Para isso utilizamos mtodos lgicos para declarar como o programa dever atingir o seu objetivo. Um programa em PROLOG pode rodar em um modo interativo: o usurio poder formular queries utilizando fatos e regras para produzir a soluo atravs do mecanismo de unificao.

Fato (I)
Determina uma relao existente entre objetos conhecidos. Expressa uma verdade sobre um relacionamento: homem(jose). pai(jose,carina). homem / pai Predicado ou Relao. jose / jose,carina Argumento do Predicado ou Objeto

Fato (II)
Os nomes dos predicados e dos objetos devem comear com letra minscula. Os objetos so escritos dentro de parnteses. Todo fato terminado com um ponto final. A ordem dos objetos importante: pai (jose, carina). pai (carina, jose).

Fato (III)
Com fatos, podemos montar uma base de conhecimento:

pai(alfredo,moacyr). pai(alfredo,romeu). pai(moacyr,eduardo). pai(moacyr,rafael). pai(moacyr,vinicius). pai(romeu,cezar). pai(romeu,alfredinho).

Regra (I)
Expressa um relacionamento entre fatos. Um relacionamento em uma regra verdadeiro se os outros relacionamentos nessa regra tambm o so: luz(acesa) :- interruptor(ligado). O ":-" significa "se"; ou seja, essa regra significa que luz(acesa) verdadeiro se interruptor(ligado) verdadeiro.

Regra (II)
Regras podem tambm fazer uso de variveis: avo(X,Z) :- pai(X,Y), pai(Y,Z). Isso significa "se X pai de Y e Y pai de uma Z, ento X av de Z. X, Y e Z so variveis. No PROLOG,uma varivel no um continer cujo valor pode ser atribudo. Seu comportamento como de uma incgnita, cujo valor desconhecido a princpio e, aps descoberto, no sofre mais mudanas. Escritas sempre em Maisculo.

Consulta (I)
Quando de uma consulta, a mquina PROLOG pesquisa a base de dados procurando clusulas que se unifiquem com a consulta:

? pai(moacyr, rafael).
Responder true se localizar um fato que se unifique com a consulta; se o fato consultado no existir na base de dados, responder fail.

Consulta (II)
Quando uma consulta contm variveis, realizada uma pesquisa em todas as clusulas, localizado os objetos que essas representam: ?- avo(alfredo,N). N = eduardo ; N = rafael ; N = vinicius ; N = cezar ; N = alfredinho.

Regras Recursivas
Um predicado definido por uma regra recursiva deve ter, no mnimo uma definio no recursiva. Se isto no acontecer, a definio logicamente malformada e o programa ficaria em lao infinito.
ancestral(X,Y) :- mae(X,Y). ancestral(X,Y) :- pai(X,Y). ancestral(X,Y) :- mae(X,Z),ancestral(Z,Y). ancestral(X,Y) :- pai(X,Z),ancestral(Z,Y).

Prtica 1
Crie a rvore genealgica da sua famlia, utilizando os predicados pai e mae, e verifique o que retorna cada consulta:
ancestral(fulano,ciclano). ancestral(X,ciclano). /*clique n a cada valor*/ ancestral(fulado,Y). /*clique n a cada valor*/ ancestral(fulado,_). /*clique n a cada valor*/ mae(X,_). /*clique n a cada valor*/ ancestral(X,_),pai(X,Y),pai(Y,_)

Prtica 1 - exemplo
mae(zilda,moacyr). mae(zilda,romeu). mae(maria,eduardo). mae(maria,rafael). mae(maria,vinicius). mae(norma,cezar). mae(norma,alfredinho). pai(alfredo,moacyr). pai(alfredo,romeu). pai(moacyr,rafael). pai(moacyr,eduardo). pai(moacyr,vinicius). pai(romeu,cezar). pai(romeu,alfredinho).

Outros conceitos (I)

Conjuno: (E Lgico) feita colocando-se uma vrgula entre os fatos: avo(X,Z) :- pai(X,Y) , pai(Y,Z).

Aridade: usado para a quantidade de objetos que o argumento de um predicado possui. gosta (maria, jos). /* aridade = 2 */
bebe (penlope, pinga, vodka, rum). /*4*/

Outros conceitos (II)

Negao: uma consulta avaliada como falsa no caso de no estar presente nenhuma regra positiva ou fato que d suporte ao termo proposto. Em outras palavras, se um fato no conhecido ser verdadeiro (ou falso), assume-se que ele falso. legal(X) :- \+ ilegal(X). Diferente: quando duas variveis no podem ter o mesmo valor: vizinho(X,Y) :- rua(X,Z), rua(Y,Z), X \== Y.

Outros conceitos (II)

Disjuno: (OU lgico), quando se declara mais de uma regra para determinar uma mesma relao: vizinho(X,Y) :- rua(X,Z), rua(Y,Z), X \== Y; rua(X,Z), rua (X,W), proximo(Z,W).

Prtica 2
A partir da rvore genealgica da sua famlia, crie as funes para:

irmo; meio-irmo; primo;

Resposta - Prtica 2 (I)

irmao(X,Y) :- pai(P,X), pai(P,Y), mae(M,X),mae(M,Y), X \== Y. meio-irmao(X,Y) :pai(P,X), pai(P,Y), X \== Y, \+ irmao(X,Y); mae(M,X),mae(M,Y), X \== Y, \+ irmao(X,Y).

Resposta - Prtica 2 (II)

genitor(X,Y) :- pai(X,Y); mae(X,Y). primo(X,Y) :- genitor(P,X), genitor(T,Y), P \== T, genitor(V,P), genitor(V,T).

Aplicaes (I)
Lgica matemtica, prova de teoremas e semntica; Soluo de equaes simblicas; Bancos de dados relacionais; Linguagem Natural;

Sistemas Especialistas;

Aplicaes (II)
Planejamento Automtico de Atividades; Aplicaes de General Problem Solving, como jogos (Xadrez, Damas, Jogo da Velha, etc.); Compiladores; Anlise Bioqumica e projetos de novas drogas.

Revisando 3 elementos Prolog (I)

Fatos: gosta(rafael,cachorro). valioso(ouro). pai(moacyr,rafael).

Revisando 3 elementos Prolog (II)

Regras: avo(X,Z) :- pai(X,Y), pai(Y,Z). filho(Y,X) :- pai(X,Y), homem(Y). aluno(X,ia) :- estuda(X,prolog).

Revisando 3 elementos Prolog (III)

Consultas (ou metas): ? avo (alfredo, rafael). ? primo (cezar, X). ? pai (moacyr,_). ? pai (X, eduardo).

Operadores de Controle
O Prolog utiliza de alguns operadores de controle para tratamento da recursividade: Backtracking; Cut; Fail.

Backtracking (I)
Backtracking (ou retrocesso): mecanismo usado pelo Prolog para encontrar fatos ou regras adicionais que satisfaam um objetivo; Quando a questo possui muitas sub-metas, a falha em uma busca pode acontecer. Neste momento, o Prolog precisa de uma maneira para lembrar os pontos de onde pode tentar procurar a soluo, para encontrar uma resposta certa.

Backtracking (II)
Considere a seguinte Base de Conhecimento: gosta (maria, pizza). gosta (maria, vinho). gosta (joo, vinho). gosta (joo, maria). realizada a questo: ? - gosta (maria, X), gosta (joo, X).

Backtracking (III)
? - gosta (maria, X) X = pizza ? - gosta (joao, comida) fail.. Neste ponto, o Prolog precisa ignorar esse valor para X e procurar de onde ele havia parado anteriormente: ? - gosta (maria, X). X = vinho. ? - gosta (joao, vinho) true

Cut (I)
O corte (cut) um usado para evitar o backtracking. O corte pode tornar um programa mais rpido, pois evita que o Prolog explore alternativas que, sabe-se de antemo, no iro contribuir para a soluo do problema, e ainda permite a economia de memria.

Cut (II)
f(X,0) :- X < 3. f(X,2) :- X >= 3, X < 6. f(X,4) :- X >= 6. Se infomar um valor > 3 -> retorna 0 Se informar um valor entre 3 e 6 -> retorna 2 Se informar um valor > ou igual a 6 ->retorna 4 Perguntamos: ? - f(1,Y).

Cut (II)
O Prolog usando backtracking trata 2 regras que sabemos que iro falhar... As 3 regras so mutuamente exclusivas: no momento em que uma funciona, no faz sentido tratar as outras 2. Para isso usamos o Cut (!): f(X,0) :- X < 3, !. f(X,2) :- X >= 3, X < 6, !. f(X,4) :- X >= 6.

Prtica 3
Utilizando o Cut (!), escreva uma regra para validar se algum tem um irmo, sem ter pesquisar toda a rvore: tem_irmao(X) :- ???

Prtica 3 - Resposta
Utilizando o Cut (!), escreva uma regra para validar se algum tem um irmo, sem ter pesquisar toda a rvore: tem_irmao(X) :- irmao(X,_), !.

Fail (I)
Inversamente ao comando cut, o predicado prdefinido fail sempre falha. O operador de corte (!) pode ser combinado com o predicado fail para produzir uma falha forada: gosta(maria,X) :- rato(X), !, fail. gosta(maria,X) :- animal(X).

Prtica 4
Podemos escrever a regra diferente de diversas formas: diferente1(X,Y) :- \+ X = Y. diferente2(X,Y) :- X\== Y. Escreva utilizando o cut (!) e fail:

Prtica 4 - Resposta
Podemos escrever a regra diferente de diversas formas: diferente1(X,Y) :- \+ X = Y. diferente2(X,Y) :- X\== Y. Escreva utilizando o cut (!) e fail: diferente1(X,X) :- !, fail. diferente1(X,Y).

Comando Is (I)
Avalia a expresso e unifica o resultado. Exemplos: ? X is 5 + 7 X = 12 ? 12.5 is 5 * 2.5. true

Comando Is (II)
Tambm pode ser usada para criar funes matemticas: divisao(X,Y,Z) :- Z is X / Y. ? divisao (10, 3, N). N = 3.33333

Fatorial
Fatorial usando comando is: fatorial (0,1). fatorial (N,F) :- N1 is N - 1, fatorial(N1,F1), F is N * F1.

fatorial(3,F) passo a passo (I)

fatorial (0,1). fatorial (N,F) :- N1 is N 1, fatorial(N1,F1), F is N * F1.

------------------------------------------------------fatorial(0,1). fail PILHA fatorial (3,F) => N=3, N1 =2;

3 * F1

fatorial(3,F) passo a passo (II)

fatorial (0,1). fatorial (N,F) :- N1 is N 1, fatorial(N1,F1), F is N * F1.

--------------------------------------------------------fatorial(0,1). fail PILHA fatorial (3,F) => N=3, N1 =1; fatorial (2,F) => N=2, N1 =1;
F F 2 * F1 3 * F1

fatorial(3,F) passo a passo (III)

fatorial (0,1). fatorial (N,F) :- N1 is N 1, fatorial(N1,F1), F is N * F1.

--------------------------------------------------------fatorial(0,1). fail PILHA fatorial (3,F) => N=3, N1 =1; F 1 * F1 fatorial (2,F) => N=2, N1 =1; F 2 * F1 fatorial (1,F) => N=1, N1 =0;
F 3 * F1

fatorial(3,F) passo a passo (IV)

fatorial (0,1). fatorial (N,F) :- N1 is N 1, fatorial(N1,F1), F is N * F1.

--------------------------------------------------------fatorial(0,1). true PILHA fatorial (3,F) => N=3, N1 =1; F 1 fatorial (2,F) => N=2, N1 =1; F 1 * F1 F 2 * F1 fatorial (1,F) => N=1, N1 =0; F 3 * F1 fatorial(0,F) => F = 1

fatorial(3,F) passo a passo (V)

fatorial (0,1). fatorial (N,F) :- N1 is N 1, fatorial(N1,F1), F is N * F1.

--------------------------------------------------------fatorial (3,F) => N=3, N1 =1; PILHA fatorial (2,F) => N=2, N1 =1; fatorial (1,1) => N=1, N1 =0; F=1 1*1
F F 2 * F1 3 * F1

fatorial(3,F) passo a passo (VI)

fatorial (0,1). fatorial (N,F) :- N1 is N 1, fatorial(N1,F1), F is N * F1.

--------------------------------------------------------fatorial (3,F) => N=3, N1 =1; PILHA fatorial (2,2) => N=2, N1 =1;
F=2 F 2*1 3 * F1

fatorial(3,F) passo a passo (VII)

fatorial (0,1). fatorial (N,F) :- N1 is N 1, fatorial(N1,F1), F is N * F1.

--------------------------------------------------------fatorial (3,6) => N=3, N1 =1; PILHA F=6

F=6

3*2

Prtica 5
Teste o fatorial para outros nmeros:
fatorial (0,1). fatorial (N,F) :- N1 is N 1, fatorial(N1,F1), F is N * F1.

? fatorial (7,F). ? fatorial (100,F). E se mudarmos a seqncia das regras?

fatorial (N,F) :- N1 is N 1, fatorial(N1,F1), F is N * F1. fatorial (0,1).

Resposta - Prtica 5
E se mudarmos a seqncia das regras? fatorial (N,F) :- N1 is N 1, fatorial(N1,F1), F is N * F1. fatorial (0,1). ERROR: Unhandled exception: Out of local stack O Prolog entrou em loop e estourou a pilha (stack). Isso porque ele sempre executa as regras na ordem em que so colocadas.

Boas prticas (I)

De uma forma geral, uma boa idia colocar fatos antes de regras sempre que possvel: amigo(rafael,pedro). amigo(pedro,fernando). amigo(fernando,murilo). amigo(X,Y):-amigo(Y,X). O que acontece se colocarmos a ltima clusula por primeiro, e fizermos uma consulta: amigo (X,Y) ?

Boas prticas (II)

Regras no recursivas normalmente devem ser colocadas antes de regras recursivas: ancestral(X,Y) :- mae(X,Y). /*nao recursivo*/ ancestral(X,Y) :- pai(X,Y). /*nao recursivo*/ ancestral(X,Y) :- mae(X,Z),ancestral(Z,Y). ancestral(X,Y) :- pai(X,Z),ancestral(Z,Y).

Boas prticas (III)

Quando possvel, usar validaes que faam com que a ordem das regras no cause loop: fatorial(N,F) :- N > 0, N1 is N - 1, fatorial(N1,F1), F is N * F1. fatorial(0,1).

Prtica 6
1. Implemente: max(X, Y, Max) /*use max(4,5,Max) para testar*/ 2. A seguinte relao classifica nmeros em trs classes: positivo, nulo ou negativo. Defina este procedimento de forma mais eficiente usando cuts: classe(N, positivo) :- N > 0. classe(0, nulo). classe(N, negativo) :- N < 0.

Prtica 6 - Respostas
Implemente: max(X, Y, Max) max(X, Y, X) :- X >= Y. max(X, Y, Y) :- X < Y. max(X, Y, X) :- X >= Y, !. max(X, Y, Y).

Prtica 6 - Respostas
classe(N, positivo) :- N > 0, !. classe(N, negativo) :- N < 0, !. classe(0, nulo).

Operadores infixos (I)

E se eu quisessemos realizar consultas utilizando uma linguagem mais prxima da nossa? ? - Quem tem carro. ? joana faz Oque?

Operadores infixos (II)

O programador Prolog pode definir seus prprios operadores, como no exemplo: tem e faz. A definio de novos operadores realizada pela insero de um tipo especial de clusula chamada diretiva. As diretivas devem aparecer antes de qualquer expresso que contenha o operador criado.

Diretivas (I)
Exemplo de diretiva: :- op (500, xfx, tem). Onde: 500 indica a prioridade do operador; xfx indica que o operador (f) deve ser colocado entre dois argumentos (x); tem indica o nome do operador.

Diretivas (II)
Tendo a diretiva, criamos a base de conhecimento: pedro tem carro. joana tem dinheiro. joao tem problemas. joao tem dvidas. E fizemos as consultas: ?- Quem tem carro. Quem = pedro.

Diretivas (III)
Curiosidade: os comandos que usamos no Prolog, so diretivas pr-definidas na sua implementao: :- op (1200, xfx, :-); :- op (1200, fx *:-, ?-]). :- op (1100, xfx, ;) :- op (1000, xfx, ,) /* etc...*/ Note que alguns operadores (ex.: :-), possuem definio infixa (xfx) e prefixa (fx).

Prtica 7
1. Crie duas diretivas novas com operador infixo, e uma base de conhecimento usando estas diretivas. 2. Em seguida crie consultas que se assemelhem a linguagem humana. Exemplos: ? - fulado conhece Quem. ? - ciclano mora Onde.

Operadores de Comparao
Lista completa dos operadores de comparao:
OPERADOR > PRIORIDADE 700 TIPO xfx SIGNIFICADO maior que

< >= <= =:= ou == =\= ou \==

700 700 700 700 700

xfx xfx xfx xfx xfx

menor que maior ou igual a menor ou igual a valores iguais valores diferentes

Base de dados relacional (I)

Como criar uma base de dados relacional em Prolog? Como pesquisar resultados dentro dessa base? nasceu(pedroBarnack,joinville,1978). nasceu(muriloPereira,itajai,1980). nasceu(rafaelRosario,joinville,1980). nasceu(janineBoos,joinville,1985). nasceu(douglasSouza,curitiba, 1970).

Base de dados relacional (II)

Como perguntamos: Nome e ano de nascimento dos curitibanos? ?- nasceu(Quem,curitiba,Ano). Quem nasceu em joinville a partir de 1980? ?- nasceu(Quem,joinville,Ano),Ano >= 1980. Nome e ano de nascimento de quem nasceu antes de 1980 (sem trazer a cidade)? ?- nasceu(Quem,_,Ano), Ano < 1980.

Prtica 8
Crie um banco de dados que contenhas as seguintes informaes: Nome do Professor e disciplina que leciona; Disciplina e horrio (dia da semana, aula: primeiro ou segundo horrio); Construa as consultas para responder:
1. Qual o horrio do professor X (disciplina, dia e aula)? 2. Quais professores lecionam na tera-feira? 3. Quais matrias o professor X leciona no primeiro horrio?

Prtica 8 - resposta
1. horario_prof(P,D,S,A) :- leciona(P,D), horario(D,S,A). ? - horario_prof(rafael,Disc,DiaSemana,Aula) . 2. ?- leciona(X,Disciplina) , horario(Disciplina,3,Aula). 3. ?- leciona(eduardo,Disc), horario(Disc,_,aula1).*/
Base de dados: leciona(rafael,ia). leciona(eduardo,redes). horario(ia,2,aula1). horario(ia,5,aula1). horario(redes,3,aula1). horario(redes,4,aula2).

Prtica 8 resposta 2 (I)

:- op(500, xfx, leciona). :- op(450, xfx, eh_lecionada_na). :- op(400, xfx, no_horario). :- op(300, fx, qual_o_horario_do_professor) qual_o_horario_do_professor(Prof, Materia, DiaSemana, SeqAula) :Prof leciona Materia, Materia eh_lecionada_na DiaSemana no_horario SeqAula.

Prtica 8 resposta 2 (II)

Base de dados: rafael leciona ia. eduardo leciona redes.
ia eh_lecionada_na segunda_feira no_horario primeira_aula. ia eh_lecionada_na quinta_feira no_horario primeira_aula. redes eh_lecionada_na terca_feira no_horario primeira_aula. redes eh_lecionada_na quarta_feira no_horario segunda_aula.

Prtica 8 resposta 2 (III)

1. ? - qual_o_horario_do_professor(eduardo, Materia, DiaSemana, SeqAula). 2. ?- Professor leciona Materia, Materia eh_lecionada_na terca_feira no_horario Qualquer. 3. ?- Professor leciona Materia, Materia eh_lecionada_na DiaSemana no_horario primeira_aula. /*ou _ no lugar de DiaSemana*/

Listas
Listas podem ser definidas e transformadas em Prolog de diversas maneiras diferentes. Listas so representadas por []: [a,e,i,o,u]; [1,2,3,5,7,11];

Composio de Lista
Listas so compostas por uma cabea e uma cauda: [H,T]; Na lista [1,2,3,5,7], podemos dizer que: 1 a cabea da lista [2,3,5,7] a cauda da lista; De maneira similar, 2 e [3,5,7] so respectivamente a cabea e a cauda da sub-lista [2,3,5,7] ;

Construindo uma Lista

Um lista construda a partir de seus elementos bsicos - uma cabea e um corpo (ou cauda): cons(X, Y, [X | Y]). ?-cons(a, b, Z). Z=[a | b]

Ocorrncia de elementos na Lista (I)

Para verificar se um elemento membro de uma lista, precisamos construir uma regra. Podemos definir que tal regra gere os resultados abaixo: ? - membro(a, [a,b,c,d]). true. ? - membro(c, [a,b,c,d]). true. ? - membro (j, [a,b,c,d]). fail

Ocorrncia de elementos na Lista (II)

Ou seja, dada uma lista L, X membro de L se: 1. X a cabea de L; ? - membro(a, [a,b,c,d]). 2. Ou X membro do corpo de L. ? - membro(c, [a,b,c,d]).

Ocorrncia de elementos na Lista (III)

A regra membro (X,L) ter duas clusulas: A primeira, um fato, estabelece a primeira condio: X membro de L, se X a cabea de L. A segunda, uma chamada recursiva que diz que X ainda pode ser membro de L, desde que seja membro do corpo de L: membro(X, [X | C]). membro(X, [Y | C]) :- membro(X, C).

Prtica 9
Dada a variante de implementao da regra membro: membro2(X, [H | T]) :- X == H. membro2(X, [H | T]) :- membro2(X, T).

1. Habilite o Debug grfico (menu Debug -> Graphical Debugger). Use o comando trace. Em seguida, execute membro(d,[a,b,c,d]) e veja passo a passo. 2. Execute membro(X,[a,b,c]) e membro2 (X,[a,b,c]). Qual das funes funciona? Por que?

Concatenao de listas (I)

Para a concatenao de duas listas quaisquer, resultando em uma terceira, se definir a relao: conc(L1, L3, L3).

onde L1 e L2 so duas listas e L3 a concatenao resultante. Por exemplo: ? - conc([a, b], [c, d], L3) L3 = [a, b, c, d].

Concatenao de listas (II)

Novamente, dois casos devem ser considerados, dependendo do primeiro argumento L1: Se o primeiro argumento uma lista vazia, ento o segundo e o terceiro argumentos devem ser a mesma lista. Chamando tal lista de L, essa situao pode ser representada pelo seguinte fato Prolog: conc([], L, L).

Concatenao de listas (III)

Se o primeiro argumento for uma lista no-vazia, ento porque ela possui uma cabea e um corpo, e pode ser denotada por [X|L1]. A concatenao de [X|L1] com uma segunda lista L2, produzir uma terceira lista, com a mesma cabea X da primeira e um corpo (L3) que a concatenao do corpo da primeira lista (L1), com toda a segunda (L2). Isso se representa em Prolog por meio da regra: conc([X | L1], L2, [X | L3]) :- conc(L1, L2, L3).

Concatenao de listas (IV)

conc([1,2],[3,4]). conc([X | L1], L2, [X |L3]) :- conc (L1,L2,L3) ser: conc([1|[2]), [3,4], [1,L3]) :- conc ([2],[3,4], L3). conc ([2],[3,4], L3). conc(2, [], [3,4], [2,L3]) :- conc ([],[3,4], L3). conc ([],[3,4], L3). conc([],L,L). conc([], [3,4], [3,4])

Concatenao de listas (V)

conc([1,2],[3,4]). conc([X | L1], L2, [X |L3]) :- conc (L1,L2,L3) ser: conc([1|[2]), [3,4], [1,L3]) :- conc ([2],[3,4], L3). conc ([2],[3,4], L3). conc(2, [], [3,4], [2,L3]) :- conc ([],[3,4], L3). conc ([],[3,4], L3). L3 = [3,4] conc([],L,L). L = [3,4] conc([], [3,4], [3,4])

Concatenao de listas (VI)

conc([1,2],[3,4]). conc([X | L1], L2, [X |L3]) :- conc (L1,L2,L3) ser: conc([1|[2]), [3,4], [1,L3]) :- conc ([2],[3,4], L3). conc ([2],[3,4], L3). conc(2, [], [3,4], [2,L3]) :- conc ([],[3,4], L3). L3 = [3,4] [X,L3] = [2,3,4]

Concatenao de listas (VII)

conc([1,2],[3,4]). conc([X | L1], L2, [X |L3]) :- conc (L1,L2,L3) ser: conc([1|[2]), [3,4], [1,L3] :- conc ([2],[3,4], L3). conc ([2],[3,4], L3). L3 = [2,3,4], [X,L3] = [1,2,3,4]

Prtica 10
1) Utilize a regra conc/3 no sentido inverso ao que foi originalmente projetado, para decompor uma lista [a,b,c] em duas partes. 2) Podemos tambm usar o programa para procurar por um determinado padro em uma lista. Encontre os meses antes e depois de um determinado ms: ? - M=[jan, fev, mar, abr, mai, jun, jul, ago, set, out, nov, dez], <clusula usando conc/3>. Antes=[jan,fev,mar,abr] Depois=[jun,jul,ago,set,out,nov, dez]

Remover da lista (I)

A remoo de um elemento X de uma lista L pode ser programada atravs da relao: remover(X, L, L1).

onde L1 a mesma lista L com o elemento X removido.

Remover da lista (II)

A relao remover/3 definida de maneira similar relao de ocorrncia. So dois casos a estudar: Se X a cabea da lista L, ento L1 ser o seu corpo;

Se X est no corpo de L, ento L1 obtida removendo X desse corpo.

remover(X, [X | C], C). remover(X, [Y | C], [Y | D]) :-remover(X, C, D).

Remover da lista (III)

Se h diversas ocorrncias de X em L, a relao remove/3 capaz de retirar cada uma delas atravs do mecanismo de backtracking do Prolog. Em cada execuo do programa remove/3 retiramos somente uma das ocorrncias de X, por exemplo: ?-remover(a, [a, b, a, a], L). L=[b, a, a]; L=[a, b, a]; L=[a, b, a];

Prtica 11
1) Utilize a regra remove/3 no sentido inverso, para inserir um novo item em qualquer lugar da lista. 2) Crie uma nova clusula para membro, utilizando a regra remover/3.

bagOf, setOf e findAll

Podemos gerar, atravs de backtracking, todos os objetos, um a um, que satisfazem algum objetivo (next, next, next). Porm, algumas vezes, deseja-se dispor de todas as respostas juntas, por exemplo, dentro de uma lista. Os predicados bagof/3, setof/3 e findall/3 servem exatamente para tal propsito.

bagOf (I)
bagof(X, P, L) Ir produzir uma lista L de todos os objetos X que satisfazem ao objetivo P. Exemplo - dada a base de conhecimento abaixo: classe(a, vog). classe(b, con). classe(c, con). /* continua d, e, f */

bagOf (II)
Podemos obter a lista de todas as consoantes nessa especificao atravs do objetivo: ?-bagof(Letra, classe(Letra, con), Consoantes). Consoantes=[b, c, d, ..., z]

bagOf (III)
Se a classe das letras no estivesse especificada, iramos obter por meio de backtracking, duas listas, uma correspondendo s vogais e outra s consoantes: ?-bagof(Letra, classe(Letra, Classe), Letras). Classe=vog Letras=[a, e, i, o, u]; Classe=con Letras=[b, c, d, f, ..., z].

bagOf Outro Exemplo

Dada a base de conhecimento:
leciona(rafael,progII). leciona(eduardo,redes). leciona(rafael,ia). leciona(eduardo,progI).

Qual seria o retorno da consulta: ?- bagof(Disc,leciona(rafael,Disc),Disciplinas).

E ?- bagof(Disc,leciona(Prof,Disc),Disciplinas).

setOf (I)
setof(X, P, L) Ir novamente produzir uma lista L dos objetos X que satisfazem a P, s que desta vez a lista L estar ordenada e itens duplicados, se houver, sero eliminados.

setOf (II)
Exemplo: ?- setof(Disc,eh_lecionada(Disc,Prof),Disciplinas). Prof = rafael Disciplinas = [ia, progII] Prof = eduardo Disciplinas = [progI, redes]

setOf (III)
No h restrio quanto ao tipo de objeto a ser coletado. Assim podemos, por exemplo, construir uma lista de pares da forma Classe/Letra de forma que as constantes apaream em primeiro lugar na lista ("con" antecede alfabeticamente "vog"): ?-setof(Classe/Letra, classe(Letra, Classe), Letras). Letras=[con/b, con/c, ..., con/z, vog/a, ..., vog/u]

findall (I)
Teste no Prolog e descubra o que faz o findall/3

What is next?
Apostila completa: aluno@net Prxima aula - DIA 14/04 AVALIAO EM DUPLAS

Referncias

http://pt.wikipedia.org/wiki/Prolog
http://pt.wikipedia.org/wiki/Alain_Colmerauer http://www.linhadecodigo.com.br/Artigo.aspx?id=1697 http://en.wikipedia.org/wiki/Prolog http://ccc.inaoep.mx/~emorales/Cursos/ProgSimb/node32.html www.fei.edu.br/eletrica/rbianchi/ia/Apostila-Prolog.doc http://www.swi-prolog.org/ http://www.sics.se/isl/sicstuswww/site/index.html http://gersonc.anahy.org/graduacao/paradigmas/prologsan.pdf http://ia.ucpel.tche.br/~lpalazzo/Aulas/PDEC/ http://gollem.science.uva.nl/SWI-Prolog/apps/view.html http://www.fdi.ucm.es/profesor/fernan/des/