Introduo a Prolog Aula tericoprtica O que Prolog

Introdução a Prolog Aula “teórico-prática”

O que é Prolog? l l Linguagem mais divulgada do paradigma de Programação em Lógica Baseado em cláusulas de Horn l l l P 1 P 2 P 3 . . . Pn Q Operacionalização simples, prática e eficiente da metáfora da programação em lógica Metáfora da programação em lógica l l Programar = Declarar axiomas e regras Teoria Lógica x Prolog l l l Axiomas: Fatos prolog Regras: Regras prolog Teoremas: Deduzidos a partir dos fatos e regras

Exemplo - Fatos pam tom bob ann pat jim liz parent(pam, parent(tom, parent(bob, parent(pat, bob). liz). ann). pat). jim). female(pam). female(ann). female(pat). female(liz). male(bob). male(tom). male(jim).

Exemplo – Perguntas à base de fatos pam tom bob ann pat jim liz Bob é filho de Jim? - parent(jim, bob). false Bob é filho de quem? - parent(X, bob). X = pam ; X = tom ; Encontre X e Y tal que X é “progenitor” de Y. parent(X, Y). X = pam Y = bob ; . . .

Exemplo – Regras pam tom bob ann pat jim liz Quem é o pai de bob? - parent(X, bob), male(X). X = tom Definindo uma regra pai father(X, Y) : - parent(X, Y), male(X). Isto é a sintaxe em prolog para x, y parent(x, y) male(x) father(x, y) Agora podemos perguntar - father(X, bob). X = tom

Exercício 1 l Defina as regras: (arquivo family. P) l l mother(X, Y) sister(X, Y) grandparent(X, Y) Defina a regra: l aunt(X, Y) l Dica: você pode usar a regra sister(X, Y) definida anteriormente

Exemplo – Regras recursivas Quais são os ancestrais de jim? l Podemos expressar a relação ancestor(X, Y) por uma regra recursiva ancestor(X, Y) : father(X, Y). ancestor(X, Y) : father(X, Z), ancestor(Z, Y). l pam tom bob ann pat liz l Faça as perguntas l l jim Quem são os ancestrais de Jim? Bob é ancestral de quem? E Jim?

Sintaxe de Prolog l l l l fato -> fa. (abreviação para Formula Atômica) regra -> fa 0 : - fa 1, . . . , fa. N. consulta -> fa 1, . . . , fa. N. fa -> pred(termo 1, . . . , termo. N) | preop termo 1 termo 2 | termo 1 inop termo 2 | termo 1 termo 2 postop termo -> constante | variável | fa constante -> átomos | números pred -> átomo

Sintaxe de Prolog (2) l l variável ex: C, Chico, Francisco_carvalho, Chico 1, _fatc, _ átomo ex: c, fatc, =>, francisco_carvalho, chico 1, ‘chico ia’ número ex: 23 termos, fatos, regras e consultas sem variáveis: l l l termos, fatos e regras com variáveis: l l l instanciados (ground) ex. : person(bob, 40, cs). universais ex. : father(adao, X). father(X, Y) : - parent(X, Y), male(X). consultas com variáveis: l l existenciais ex. : - father(F, P).

Intepretação de um programa Prolog l P : - Q, R. l Interpretações declarativas l l l P é verdadeiro se Q e R forem verdadeiros. Q e R implica P. Interpretações procedurais l Para resolver o problema P: § § l Primeiro resolva o subproblema Q Depois resolva o subproblema R Para satisfazer P: § § Primeiro satisfaça Q E então satisfaça R

Interpretador Prolog: Controle e Busca (funcionamento procedural) l Aplica regra de resolução: l l l l com estratégia linear (sempre tenta unificar último fato a provar com a conclusão de uma cláusula do programa), na ordem escrita das cláusulas no programa, com encadeamento de regras regressivo (backward-chaining), 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.

Prolog e aritmética l Operadores aritméticos l l l l + adição - subtração * multiplicação / divisão ** potenciação // divisão inteira mod módulo (resto da divisão inteira) O atribuidor is l Variável is Expr. Aritmética l Exemplos - X - X Y Z X = 1 + 2 X is 1 + 2 = 3 X is 5/2, Y is 5//2, Z is 5 mod 2. = 2. 5 = 2 = 1

Prolog e aritmética (2) l Operadores de comparação l l l > maior que < menor que >= maior ou igual =< menor ou igual =: = teste de igualdade aritmética == teste de diferença aritmética l Exemplos 1 + 2 =: = 2 + 1. yes - 1 + 2 = 2 + 1. no - 1 + A = B + 2. A = 2 B = 1 -

Exemplo Aritmético - Fatorial factorial(0, 1). factorial(N, Fn) : N > 0, M is N - 1, factorial(M, Fm), Fn is N * Fm. (arquivo fac. P) - factorial(10, X). X = 362880 - factorial(10, 362880). yes - factorial(10, 10000). no

Exercício 2 l l Defina uma regra fib(X, Y) que calcula o número de fibonacci de X, atribuindo-o a Y. A sequência de Fibonacci é definida matematicamente como l l l fib(1) = 1 fib(2) = 1 fib(n) = fib(n – 1) + fib(n – 2) Use seu programa para calcular o fib(5). O que acontece quando você calcula o fib(30)?

Adicionando e removendo cláusulas dinamicamente l Um programa prolog pode ser visto como um banco de dados l Relações l l l Predicados built-in permitem a atualização do programa em tempo de execução l Adicionar uma nova cláusula l l assert, asserta, assertz Remover uma cláusula l l Explícitas: fatos Implícitas: regras retract No XSB módulos com predicados dinâmicos devem ser carregados com o comando load_dyn/1

Usando assert para tornar o programa fib eficiente fib(1, 1). fib(2, 1). fib(N, Fn) : N > 2, M is N - 1, fib(M, Fm), O is N - 2, fib(O, Fo), Fn is Fm + Fo, asserta(fib(N, Fn)). l l Agora os resultados parciais são armazenados, não precisando serem recalculados. Teste fib(40, X).

Ferramentas de Debug l l trace/0 : ativa o modo de rastreamento. O sistema interage com o usuário cada vez que um predicado é: l l l Podem ser observados predicados específicos com o comando spy(predicado/aridade). Diferentes ações escolhidas na interação com o debugador: l l ativado inicialmente (call) retorna com sucesso (exit) vai fazer backtracking (redo) falhou completamente (fail) Creep (step), Leap (continuar até próximo spy), Skip (desabilita trace até o final desta execução), Abort (aborta a execução atual). notrace/0, nospy/1.

Mais um Exemplo Vamos definir a função l l Se X < 3 então Y = 0 Se 3 X e X < 6 então Y = 2 Se 6 X então Y = 4 Y 4 2 3 6 X (arquivo funct. P) f(X, 0) : - X < 3. f(X, 2) : - 3 =< X, X < 6. f(X, 4) : - 6 =< X.

Execução do exemplo l l Como prolog se comporta quando fazemos uma consulta? Vamos acompanhar a execução de uma consulta ativando o mecanismo de trace do xsb. - • trace. Agora façamos a consulta: f(1, Y), 2 < Y. f(X, 0) : - X < 3. f(X, 2) : - 3 =< X, X < 6. f(X, 4) : - 6 =< X. (0) (1) (0) (2) (0) (1) (3) (4) (0) Call: Exit: Call: Fail: Redo: Fail: Call: Fail: f(1, _h 454) ? c 1 < 3 ? c f(1, 0) ? c 2 < 0 ? c f(1, 0) ? c 1 < 3 ? c 3 =< 1 ? c 6 =< 1 ? c f(1, _h 454) ? c

Diagrama da execução do exemplo f(1, Y) 2<Y Regra 1 Y=0 1<3 2<0 CUT Regra 3 Y=4 Regra 2 Y=2 3≤ 1 1<6 2<2 6≤ 1 2<4 no no 2 < 0 no f(X, 0) : - X < 3. f(X, 2) : - 3 =< X, X < 6. f(X, 4) : - 6 =< X. Regras mutuamente exclusivas

Evitar backtracking inútil: ! (o cut) l l op built-in de pruning, logicamente sempre verificado com efeito colateral de impedir backtracking: l l l 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. l l l impede backtracking P -> N permite backtracking N -> M, Q -> P, D -> (R xor Q), (P xor R) -> B R tentado: l l unicamente se M ou N falha nunca se P ou Q falha

Cut: exemplo l Otimizando o exemplo anterior: f(X, 0) : - X < 3, !. f(X, 2) : - 3 =< X, X < 6, !. f(X, 4) : - 6 =< X. l l l Nesse caso os cuts alteram apenas o comportamento procedural do programa. Se removermos os cuts o programa continuará produzindo os mesmos resultados. Green cuts

Cut: exemplo (2) l Podemos otimizar ainda mais o programa, pensando-o da seguinte forma: if (X < 3) then Y = 0 else if (X < 6) then Y = 2 else Y = 4 l Eliminamos assim 2 comparações desnecessárias. l Versão anterior: f(X, 0) : - X < 3, !. f(X, 2) : - 3 =< X, X < 6, !. f(X, 4) : - 6 =< X. l Reescrevemos para: f(X, 0) : - X < 3, !. f(X, 2) : - X < 6, !. f(X, 4).

Cut: exemplo(3) l O que acontece agora se os cuts forem removidos? f(X, 0) : - X < 3. f(X, 2) : - X < 6. f(X, 4). l f(1, Y). Y = 0; Y = 2; Y = 4; l l Neste caso os cuts afetam a semântica do programa Red cuts

Hipótese do mundo fechado l Ao contrário da Lógica de 1 a ordem, Prolog não permite nem fatos, nem conclusões de regras negativos: ~animal_lover(geber). ~kill(X, Y) : - animal_lover(X), animal(Y). l Princípio de economia: l l l declarar e deduzir apenas o que é verdadeiro, supor que tudo que não é mencionado nem dedutível é falso (hipótese do mundo fechado) Operador de negação por falha l Podemos usar o ! para implementar um operador de negação por falha, tal que: l not p(X) verificado sse p(X) falha

Negação por falha l Uma maneira de definir a negação por falha: not(P) : - P, !, fail ; true. l l fail é o objetivo que sempre falha, enquanto que true sempre tem sucesso. not já é pré-definido (built-in) no interpretador prolog, como um operador pré-fixo. - not true. no - not fail. yes

Voltando ao exemplo da família. . . l Definimos a relação sister(X, Y) como: l l l sister(X, Y) : - female(X), parent(Z, Y). Vimos que isso também deduz que uma mulher é irmã dela mesma: logicamente correto pela definição acima. Podemos usar a negação por falha para alcançar o resultado desejado. l sister(X, Y) : - female(X), parent(Z, Y), not(X = Y).

Exemplo da família pam - sister(X, pat). X = ann; no tom l bob liz l Conforme o comportamento esperado. Experimento: l ann pat l l jim Modifique a relação sister(X, Y) para sister(X, Y) : - not(X = Y), female(X), parent(Z, Y). Agora consulte: l - sister(X, pat).

O que aconteceu? l Afinal de contas de acordo com a lógica: l l l a b c d e é equivalente a d a b c e Negação por falha não tem a mesma semântica da negação da lógica. Vamos acompanhar o trace da consulta: - trace. - sister(X, pat). (0) Call: sister(_h 446, pat) (1) Call: not _h 446 = pat ? (1) Fail: not _h 446 = pat ? (0) Fail: sister(_h 446, pat) ? c c c ? c

O que aconteceu? (2) l Problema com objetivos não instanciados l l l Quantificação de variáveis diferente na negação por falha not(X = pat) não é interpretado como “existe X tal que not(X = pat)” A quantificação na negação por falha é universal l Para todo X: not(X = pat)? O que é claramente falso, pois X (não instanciado) unifica-se perfeitamente com pat Conclusão: cuidado ao usar cuts e negação por falha.

Prolog: listas [ e ]: início e fim de lista , separação entre elementos |: separação entre 1° elemento (cabeça) e resto da lista (calda) 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|T 1]|T 2] H = p(X), T 1 = [[a]], T 2 = [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. l

Exemplo: Append l l append(L 1, L 2, L 3): L 1 e L 2 são duas listas e L 3 é a sua concatenação. Append de uma lista vazia com uma segunda lista é a própria segunda lista: l l append([], L, L). Append de uma lista [X|L 1] com a lista L 2 é uma lista [X|L 3], onde L 3 é a concatenação da cauda da primeira (L 1) com L 2. l append([X|L 1], L 2, [X|L 3]) : append(L 1, L 2, L 3).

Exemplo: Append (2) l Exemplos do uso do append l Qual o resultado da concatenação das listas [a, b] e [c, d]? l l l - append([a, b], [c, d], X). X = [a, b, c, d] Que listas concatenadas resultam na lista [a, b, c, d]? l l l - append(X, Y, [a, b, c, d]). X = [] Y = [a, b, c, d]; X = [a] Y = [b, c, d]; …

Exercícios 3 l l Usando o append, escreva uma regra para apagar os três últimos elementos de uma lista L, produzindo uma lista L 1 (arquivo append. P) Defina a relação last(Item, List) de forma que Item é o último elemento de List de duas formas diferentes: l l usando append sem usar append

Prolog x prog. imperativa l Interativo: l l 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: l l atribuição de valor passagem de parâmetros alocação de estruturas leitura e escrita em campos de estruturas

Prolog x prog. imperativa (2) l Estrutura de dados única: termo Prolog þ l variáveis lógicas sem tipo estático (tipos dinâmicos) Controle implícito built-in na estratégia de resolução, ex: Em programação imperativa procedure c(E) const e 0: tipo. E 0; var E: tipo. E, S 0: tipo. S 0, l 1: tipo-I 1, S 1: tipo. S 1; do if E = e 0 then do S 0 : = call p 0(e 0); return S 0; end; else do I 1 : = call p 1(E); S 1 : = call p 2(E, l 1); return S 1; end; Em Prolog c(e 0, S 0) : - p 0(e 0, S 0). c(E, S 1) : - p 1(E, I 1), p 2(E, I 1, S 1).

Prolog x prog. funcional Matematicamente, predicado = relação: l não-determinismo: l l bi-direcionalidade: l l l respostas múltiplas (disponíveis por backtracking), unificação e busca built-in, livra o programador da implementação do controle; 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 prog. funcional (2) l Append em Haskell: append [] L = L append H: T L = H : append T L ? - append([a, b], [c, d]) [a, b, c, d] l Append em Prolog: append([], L, L). append([H|T 1], L, [H|T 2]) : - append(T 1, L, T 2). ? - append([a, b], [c, d], R). R = [a, b, c, d]. l Append relacional codifica várias funções

Vários usos do mesmo predicado l verificador: ? - append([a, b], [c], [a, b, c]). -> yes. ? - append([a, b], [c], [a]). -> no. l instanciador: ? - append([a, b], [c], R). -> R = [a, b, c]. ? - append(H, [c], [a, b, c]). -> H = [a, b]. l resolvedor de restrições: ? - append(X, Y, [a, b, c]). -> X = [], Y = [a, b, c] ; -> X = [a], Y = [b, c]. . . l enumerador: ? - append(X, Y, Z). -> X = [], Y =[], Z = [] ; -> X = [_], Y = [], Z = [_]. . .

Prolog x programação OO l Funcionalidades built-in: l l l + unificação e busca - tipos, herança e encapsulamento Ontologicamente: l l l 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: exemplo l 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}]] pt 1[inst_of pt; attrs[X = 0, Y = 0]] pt 2[inst_of pt; attrs[X = 1, Y =1]] ? - pt 1. right(pt 2) -> no. l Em Prolog: pt(0, 0). pt(1, 1). planobj(pt(_, _)). right(pt(X 1, _), pt(X 2, _)) : - X 1 >= X 2. ? - right(pt(0, 0), pt(1, 1)). -> no.

Programação em Lógica: Disciplina Eletiva de Graduação e Pós l l Prolog aprofundado Programação por resolução de restrições a base lógica (Constraint Logic Programming) l l l extensão de Prolog com resoluções de inequações e equações restrições quantitativas (N, Z, R, C) ou qualitativas (tipos, ontologias) Escalonamento, raciocínio espacial, otimização, automação industrial, CAD/CAM, música computacional Programação em lógica funcional Programação em lógica orientada a objetos Programação multiparadigma a base lógica: l l lógica + restrições + funcional + OO todo a IA e mais !

Programação em Lógica: Disciplina Eletiva de Graduação e Pós l Programação em lógica para engenharia de software l l l Programação em lógica probabilista e bayesiana l l raciocínio com incerteza Programação em lógica indutiva l l especificação formal prototipagem rápida aceleração do modelo de desenvolvimento em espiral aprendizagem de máquina, agentes adaptativos, mineração de dados, descoberta de conhecimento em BD, programação automática, bio-informática Programação em lógica multiagentes l l l sistemas inteligentes distribuídos comercio eletrônico jogos, competição de futebol de robôs

Programação em Lógica: Disciplina Eletiva de Graduação e Pós l Bancos de dados dedutivos: l l Bancos de dados dedutivos orientada a objetos Bancos de dados dedutivos temporais Bancos de dados de restrições: l l GIS, BD espaciais, BD espaço-temporais, integração de dados e interoperabilidade Bancos de dados de restrições orientada a objetos l l descoberta de conhecimento em BD, sistemas especialistas de grande porte, servidores de conhecimento ontológico toda a IA de grande escala e mais ! Bancos de dados probabilistas: l BD de sensores, data warehousing, integração de dados com fontes não confiáveis ou mutuamente inconsistentes,

Programação em Lógica: Disciplina Eletiva de Graduação e Pós l Gramáticas lógicas: l l l Parser e gerador de linguagem built-in em Prolog Basta desenvolver gramática (i. e. , como com lex e yacc) Mineração da web, extração de informação na Internet, compilação tradução automática, geração automática de resumos, chatterbots APIs Prolog/Java e Prolog/XML l sistemas de informação inteligentes distribuídos e heterogêneos a infraestrutura web l l l integração de dados, interoperabilidade entre sistemas, mediadores, data warehousing comercio eletrônico agentes inteligentes de recuperação, classificação, extração e notificação de informação na web, na Internet, em Intranet inteligência na computação pervasiva toda a IA embutida e mais !

Programação em Lógica: Disciplina Eletiva de Graduação e Pós-Graduação l Aplicação fio condutor para ilustração dos conceitos l “By the year 2050, develop a team of fully autonomous humanoid robots that can win against the human world soccer champion team. ” http: //www. robocup. org

Programação em Lógica: Disciplina Eletiva de Graduação e Pós

Introdução a Prolog FIM

Exercício 1 - Respostas mother(X, Y) : - parent(X, Y), female(X). sister(X, Y) : - female(X), parent(Z, Y). grandparent(X, Y) : - parent(X, Z), parent(Z, Y). aunt(X, Y) : - sister(X, Z), parent(Z, Y). l l l Quais são as respostas devolvidas para sister(X, pat). ? Por que isso ocorre? Como isso pode ser evitado? l Cenas dos próximos slides. . .

Exercício 2 - Resposta fib(1, 1). fib(2, 1). fib(N, Fn) : N > 2, M is N - 1, fib(M, Fm), O is N - 2, fib(O, Fo), Fn is Fm + Fo. l l O programa tem comportamento exponencial, para cada passo calculamos toda a seqüência de fibonacci. Os mesmos valores são calculados várias vezes. . .

Exercícios 3 - Resposta del 3(L, L 1) : - append(L 1, [_, _, _], L). last(Item, List) : - append(_, [Item], List). last 2(Item, [Item]). last 2(Item, [_|XL]) : - last 2(Item, XL).