Introdução a Programação em Lógica e Prolog

Introdução a Programação em Lógica e Prolog
Jacques Robin CIn-UFPE

O que é programação em lógica?
Para Inteligência Artificial: Uma linguagem de representação do conhecimento Uma máquina de inferência dedutiva Para Bancos de Dados: Linguagem de definição de dados Linguagem de consulta com inferência embutida Tamborete de dados dedutivo Para Ciência da Computação: Paradigma unificador trazendo insight entre áreas Para Teoria da Computação: Super conjunto não monotônico de um sub-conjunto da lógica dos predicados da 1a ordem Para Engenharia de Software: Uma linguagem de especificação formal Uma linguagem de programação de propósito geral

Aplicações da programação em lógica
Inteligência Artificial Representação do conhecimento Sistemas especialistas Planejamento Aprendizagem de máquina Processamento de linguagem natural Sistemas multi-agente Robótica Matemática computacional simbólica Sistemas Distribuídos e Internet Comércio eletrônico Recuperação, filtragem e extração de informação Engenharia de Software Prototipagem rápida de software complexos Especificações formais executáveis Programação por resolução de restrições Programação multi-paradigma de alto-nível Banco de Dados BD dedutivos e dedutivos OO Mineração de Dados e Descoberta de Conhecimento Integração de Dados e Interoperabilidade

O que é Prolog? Primeira e mais divulgada linguagem do paradigma da Programação em Lógica (PL) Operacionalização simples, prática e eficiente da metáfora da PL, embora teoricamente impura Padrão ISO Maioria das outras linguagens de PL: São extensões de Prolog Que superam as limitações de Prolog Surgiu na década de 70 Na moda na década de 80 (o Java da época ) Permanece a máquina de inferência dedutiva mais usada em IA Serve de base a várias outras máquinas de inferência: abdutiva, indutiva, resolução de restrições No entanto pouco divulgado e usado na indústria

Uso dual de Prolog para sistema inteligente
Como formalismo de representação do conhecimento Como linguagem de programação Maquina de Inferência implementando em Prolog raciocínio R em formalismo F Base de Conhecimento: Fatos e Regras Prolog Maquina de Inferência: Compilador/ Interpretador Prolog Base de Conhecimento: sentenças em formalismo F Ask Ask Tell Tell Retract Retract Maquina de Inferência: Compilador/ Interpretador Prolog

Revisão da Lógica de Horn
Para qualquer fórmula da lógica da 1a ordem, existe uma formula logicamente equivalente em forma normal conjuntiva: p1(...,X1i,...) ... c1(...,X1k,...) ... pn(...,Xnj,...) ...  cm(...,Xml,...) Lógica de Horn: sub-conjunto da lógica da 1a ordem restrita a conjunções de cláusulas de Horn Cláusula de Horn: disjunção de literais com ao máximo um literal positivo Dividas em 3 sub-categorias: Fatos: cláusulas de Horn com zero literal negativo c(...,Xk,...) Em forma normal implicativa: T  c(...,Xk,...) Regras definidas: cláusulas de Horn com exatamente um literal negativo e pelo menos um literal positivo: p1(...,X1i,...) ... pn(...,Xnj,...)  cm(...,Xml,...) Em forma normal implicativa: p1(...,X1i,...) ... pn(...,Xnj,...)  cm(...,Xml,...) Restrições de integridade: cláusulas de Horn com zero literal positivo p1(...,X1i,...) ... pn(...,Xnj,...) Em forma normal implicativa: p1(...,X1i,...) ... pn(...,Xnj,...)  F

Prolog como linguagem de representação do conhecimento para IA
Sentenças da base de conhecimento Prolog: Cláusula de Horn da 1a ordem excluindo: Restrições de integridade Predicado de igualdade Apenas: Fatos que representam o conhecimento em extensão Regras definidas que representam o conhecimento em intenção

Representação do conhecimento simbólico
Procedimentos Programação Imperativa Lógica Provadores de Teoremas Regras Shells de Sistemas Especialistas Classes/Objetos Redes Semânticas Classes/Objetos + Procedimentos Programação OO Frames Classes/Objetos + Lógica Lógicas descritivas Regras + Procedimentos Sistemas de Produção Regras + Classes/Objetos + Procedimentos Sistemas de Produção OO Regras + Lógica Programação em lógica Regras + Classes/Objetos + Lógica Programação em lógica OO

Prolog como máquina de inferência para IA
Provador de teorema para a sub-conjunto da Implementa: Raciocínio dedutivo dirigido pelo objetivo Não monotônico quando BC inclui regras usando com negação por falha nas premissas Usa: Hipótese do mundo fechado Hipótese da unicidade do nome Unificação sem occur-check Encadeamento de regras para trás Com backtracking sistemático e cronológico Criação da árvore de prova de cima para baixo em profundidade primeira

Hipóteses do mundo aberto x fechado
Dado uma base de conhecimento lógica B, existem sentenças lógicas S (consultas Ask) tal que nem S, nem S é conseqüência lógica de B Exemplo: B = {ônibusPara(garanhuns,10:00), ônibusPara(salgueiro,12:00)} S = ônibusPara(garanhuns,12:00) B | S e B | S Resposta a tal consulta depende da hipótese sobre a completude da informação na BC feita pela máquina de inferência Hipótese de mundo aberto (BC suposta incompleta ): se B | S e B | S, então Ask(S) = unknown utilizada pela lógica clássica (de qualquer ordem) e as lógicas descritivas Hipótese de mundo fechado (BC suposta completa ): se B | S e B | S, então Ask(S) = False utilizada pela programação em lógica, os sistemas de produção e os bancos de dados

Hipótese do mundo fechado
Concluir Ask(S) = False apenas a partir de B | S não é uma inferência dedutivamente correta Epistemologicamente: Ask(S) = False concluído a partir de B | S, é mais fraco do que Ask(S) = False derivado a partir de B | S É uma forma limitada de: Abdução Raciocínio por default Raciocínio não monótono Maioria da máquinas de inferência que utilizam a hipótese do mundo fechado: Não armazenam fatos negativos nas suas BC, i.e., não há ações Tell(S) Nem são capaz de deduções da forma B | S, apenas B | S

Hipótese da unicidade do nome
Tabela Curso Área Número cs 101 102 106 ee Consulta SQL count * from Curso no BD do lado retorna? 4 Tradução em lógica clássica do conhecimento contido na tabela: course(CS,101)  course(CS,102)  course(CS,106)  course(EE,101) ? Quantas respostas retornaria um provador de teorema a consulta Ask(area,number) ? Entre 1 e + ! Porque? Lógica clássica usa a hipótese do mundo aberto, mas não usa a hipótese da unicidade do nome Então como a tradução acima não contém:  (CS = EE)   (101 = 102)   (101 = 106)   (102 = 106) tradução acima não exclui que a conjunção se reduz a um único literal Tradução correta: c,n (c,n) course(c,n)  [d,n]  {[CS,101],[CS,102],[CS,106],[EE,101]}

Prolog: sintaxe Igual a lógica da 1a ordem exceto:
Constantes: começam com letras minúsculas, ou quota ´ Variáveis: começam com letras maiúsculas, _, ou números na BC, todas universalmente quantificadas e de escopo local a uma cláusula nas consultas, todas existencialmente quantificadas Fatos da Lógica de Horn T  C(...,xk,...) se escrevam c(...,Xk,...). em Prolog Regras definidas da Lógica de Horn: P1(...,x1i,...) ... Pn(...,xnj,...)  Cm(...,xml,...) se escrevam c(...,Xml,...) :- p1(...,X1i,...), ...,pn(...,Xnj,...).

West é criminoso? 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? 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? Encadeamento de regras para trás
criminal(west)? criminal(P) american(P) weapon(W) nation(N) hostile(N) sells(P,N,W) sells(west,nono,W) missile(W) enemy(N,america) owns(nono,W) american(west) missile(m1) nation(nono) enermy(nono,america) owns(nono,m1) nation(america)

criminal(west)? criminal(west) american(P) weapon(W) nation(N) hostile(N) sells(P,N,W) sells(west,nono,W) missile(W) enemy(N,america) owns(nono,W) american(west) missile(m1) nation(nono) enermy(nono,america) owns(nono,m1) nation(america)

criminal(west)? criminal(west) american(west) weapon(W) nation(N) hostile(N) sells(west,N,W) sells(west,nono,W) missile(W) enemy(N,america) owns(nono,W) american(west) missile(m1) nation(nono) enermy(nono,america) owns(nono,m1) nation(america)

criminal(west)? criminal(west) american(west) weapon(W) nation(N) hostile(N) sells(west,N,W) sells(west,nono,W) missile(m1) enemy(N,america) owns(nono,W) american(west) missile(m1) nation(nono) enermy(nono,america) owns(nono,m1) nation(america)

criminal(west)? criminal(west) american(west) weapon(m1) nation(N) hostile(N) sells(west,N,W) sells(west,nono,W) missile(m1) enemy(N,america) owns(nono,W) american(west) missile(m1) nation(nono) enermy(nono,america) owns(nono,m1) nation(america)

criminal(west)? criminal(west) american(west) weapon(m1) nation(N) hostile(N) sells(west,N,m1) sells(west,nono,W) missile(m1) enemy(N,america) owns(nono,W) american(west) missile(m1) nation(nono) enermy(nono,america) owns(nono,m1) nation(america)

criminal(west)? criminal(west) american(west) weapon(m1) nation(nono) hostile(N) sells(west,N,m1) sells(west,nono,W) missile(m1) enemy(N,america) owns(nono,W) american(west) missile(m1) nation(nono) enermy(nono,america) owns(nono,m1) nation(america)

criminal(west)? criminal(west) american(west) weapon(m1) nation(nono) hostile(nono) sells(west,nono,m1) sells(west,nono,W) missile(m1) enemy(N,america) owns(nono,W) american(west) missile(m1) nation(nono) enermy(nono,america) owns(nono,m1) nation(america)

criminal(west)? criminal(west) american(west) weapon(m1) nation(nono) hostile(nono) sells(west,nono,m1) sells(west,nono,W) missile(m1) enemy(nono,america) owns(nono,W) american(west) missile(m1) nation(nono) enermy(nono,america) owns(nono,m1) nation(america)

criminal(west)? criminal(west) american(west) weapon(m1) nation(nono) hostile(nono) sells(west,nono,m1) sells(west,nono,m1) missile(m1) enemy(nono,america) owns(nono,W) american(west) missile(m1) nation(nono) enermy(nono,america) owns(nono,m1) nation(america)

criminal(west)? criminal(west) american(west) weapon(m1) nation(nono) hostile(nono) sells(west,nono,m1) sells(west,nono,m1) missile(m1) enemy(nono,america) owns(nono,m1) american(west) missile(m1) nation(nono) enermy(nono,america) owns(nono,m1) nation(america)

criminal(west)? yes criminal(west) american(west) weapon(m1) nation(nono) hostile(nono) sells(west,nono,m1) sells(west,nono,m1) missile(m1) enemy(nono,america) owns(nono,m1) american(west) missile(m1) nation(nono) enermy(nono,america) owns(nono,m1) nation(america)

West é criminoso ? 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.

criminal(west)? criminal(west) american(west) weapon(m1) nation(N) hostile(N) sells(west,N,m1) sells(west,nono,W) missile(m1) enemy(N,america) owns(nono,W) american(west) missile(m1) nation(america) enermy(nono,america) owns(nono,m1) nation(nono)

criminal(west)? criminal(west) american(west) weapon(m1) nation(america) hostile(N) sells(west,N,m1) sells(west,nono,W) missile(m1) enemy(N,america) owns(nono,W) american(west) missile(m1) nation(america) enermy(nono,america) owns(nono,m1) nation(nono)

criminal(west)? criminal(west) american(west) weapon(m1) nation(america) hostile(america) sells(west,america,m1) sells(west,nono,W) missile(m1) enemy(N,america) owns(nono,W) american(west) missile(m1) nation(america) enermy(nono,america) owns(nono,m1) nation(nono)

criminal(west)? criminal(west) american(west) weapon(m1) nation(america) hostile(america) sells(west,america,m1) sells(west,nono,W) missile(m1) enemy(N,america) owns(nono,W) fail american(west) missile(m1) nation(america) enermy(nono,america) owns(nono,m1) nation(nono)

criminal(west)? criminal(west) american(west) weapon(m1) nation(america) hostile(america) sells(west,america,m1) sells(west,nono,W) backtrack missile(m1) enemy(N,america) owns(nono,W) fail american(west) missile(m1) nation(america) enermy(nono,america) owns(nono,m1) nation(nono)

criminal(west)? criminal(west) backtrack american(west) weapon(m1) nation(N) hostile(N) sells(west,N,m1) sells(west,nono,W) missile(m1) enemy(N,america) owns(nono,W) american(west) missile(m1) nation(america) enermy(nono,america) owns(nono,m1) nation(nono)

criminal(west)? criminal(west) american(west) weapon(m1) nation(N) hostile(N) sells(west,N,m1) sells(west,nono,W) missile(m1) enemy(N,america) owns(nono,W) american(west) missile(m1) nation(america) enermy(nono,america) owns(nono,m1) nation(nono)

criminal(west)? criminal(west) american(west) weapon(m1) nation(nono) hostile(N) sells(west,N,m1) sells(west,nono,W) missile(m1) enemy(N,america) owns(nono,W) american(west) missile(m1) nation(america) enermy(nono,america) owns(nono,m1) nation(nono)

criminal(west)? criminal(west) american(west) weapon(m1) nation(nono) hostile(nono) sells(west,nono,m1) sells(west,nono,W) missile(m1) enemy(N,america) owns(nono,W) american(west) missile(m1) nation(america) enermy(nono,america) owns(nono,m1) nation(nono)

Algoritmo da máquina de inferência Prolog
Tentar unificar termo do objetivo Oi corrente com as cabeças das claúsulas da BC, na ordem de escritura Seja C a 1a cabeça a se unificar com Oi via subsituição : se C for um fato, devolve: T e  como resultado se C for conclusão da regra C :- P1, ..., Pn, então: o novo objetivo corrente Oi+1 = P1 se P1 for verdade, então recursivamente tentar provar P2, ..., Pn Se nenhuma cabeça das claúsulas da BC se unifica com Oi: devolver F como resultado, e retroceder, buscando uma prova alternativa para Oi-1, o último objetivo provado antes de Oi

West é criminoso? Encadeamento de regras para frente
criminal(west)? criminal(P) american(P) weapon(W) nation(N) hostile(N) sells(P,N,W) sells(west,nono,W) missile(W) enemy(N,america) owns(nono,W) american(west) missile(m1) nation(nono) enermy(nono,america) owns(nono,m1) nation(america)

criminal(west)? criminal(P) american(P) weapon(W) nation(N) hostile(N) sells(P,N,W) sells(west,nono,W) missile(m1) enemy(nono,N) owns(nono,m1) american(west) missile(m1) nation(nono) enermy(nono,america) owns(nono,m1) nation(america)

criminal(west)? criminal(P) american(P) weapon(m1) nation(N) hostile(N) sells(P,N,W) sells(west,nono,W) missile(W) enemy(nono,N) owns(nono,W) american(west) missile(m1) nation(nono) enermy(nono,america) owns(nono,m1) nation(america)

criminal(west)? criminal(P) american(P) weapon(m1) nation(N) hostile(N) sells(P,N,W) sells(west,nono,W) missile(m1) enemy(nono,N) owns(nono,m1) american(west) missile(m1) nation(nono) enermy(nono,america) owns(nono,m1) nation(america)

criminal(west)? criminal(P) american(P) weapon(m1) nation(N) hostile(nono) sells(P,N,W) sells(west,nono,W) missile(W) owns(nono,W) american(west) missile(m1) nation(nono) enemy(nono,N) owns(nono,m1) nation(america)

criminal(west)? criminal(P) american(P) weapon(m1) nation(N) hostile(nono) sells(P,N,W) sells(west,nono,W) missile(m1) owns(nono,m1) american(west) missile(m1) nation(nono) enemy(nono,america) owns(nono,m1) nation(america)

criminal(west)? criminal(P) american(P) weapon(m1) nation(N) hostile(nono) sells(P,N,W) sells(west,nono,m1) american(west) missile(m1) nation(nono) enermy(nono,america) owns(nono,m1) nation(america)

criminal(west)? criminal(P) american(west) weapon(m1) nation(nono) hostile(nono) sells(west,nono,m1) sells(west,nono,m1) american(west) missile(m1) nation(nono) enermy(nono,america) owns(nono,m1) nation(america)

criminal(west)? criminal(west) weapon(m1) hostile(nono) sells(west,nono,m1) american(west) missile(m1) nation(nono) enermy(nono,america) owns(nono,m1) nation(america)

criminal(west)? yes criminal(west) weapon(m1) hostile(nono) sells(west,nono,m1) american(west) missile(m1) nation(nono) enermy(nono,america) owns(nono,m1) nation(america)

Encadeamento de regras para trás e resolução
Encadeamento para trás de Prolog é um caso particular de refutação por resolução para Lógica de Horn Com estratégia de resolução SLD: D: para cláusulas Definidas (fatos e regras definidas) L: Linear de entrada , i.e., a cada passo, resolve (1) uma das clausulas iniciais (base de conhecimento e negação da consulta) com (2) cláusula derivada no último passo S: com Função de seleção escolhendo: Escolhendo cláusulas iniciais na ordem de escritura de cima para baixo Escolhendo os literais de cada cláusula na ordem de escritura da esquerda para direta A resolução é correta e completa para refutação Prolog então é uma máquina de inferência correta e completa para a Lógica de Horn?

West é criminoso? Prova Prolog como refutação com resolução SLD
(american(P)  weapon(W)  nation(N)  hostile(N)  sells(P,N,W)  criminal(P)) //1  (T  owns(nono,m1)) //2a  (T  missile(m1)) //2b  (owns(nono,W)  missile(W)  sells(west,nono,W)) //3  (T  american(west)) //4  (T  nation(nono)) //5  (T  enemy(nono,america)) //6  (missile(W)  weapon(W)) //7  (enemy(N,america)  hostile(N)) //8  (T  nation(america)) //9  (criminal(west)  F) //0 1. Resolver 0 com 1 unificando P/west: american(west)  weapon(W)  nation(N)  hostile(N)  sells(west,N,W)  F //10 2. Resolver 10 com 4: weapon(W)  nation(N)  hostile(N)  sells(west,N,W)  F //11 3. Resolver 11 com 7: missile(W)  nation(N)  hostile(N)  sells(west,N,W)  F //12 4. Resolver 12 com 2b unificando W/m1: nation(N)  hostile(N)  sells(west,N,m1)  F //13 5. Resolver 13 com 5 unificando N/nono: hostile(nono)  sells(west,nono,m1)  F //14 6. Resolver 14 com 8 unificando N/nono: enemy(nono,america)  sells(west,nono,m1)  F //15 7. Resolver 15 com 6: sells(west,nono,m1)  F //16 8. Resolver 16 com 3 unificando W/m1: owns(nono,m1)  missile(m1)  F //17 9. Resolver 17 com 2a: missile(m1)  F //18 10. Resolver 18 com 2b: F

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). 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 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 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.

Prolog puro: sem atribuição explícita, nem predicado de igualdade
Em Prolog, = é o operador de unificação explícita: é uma consulta lógica que retorno verdadeiro ou falso e potencialmente instância variáveis não é um operador de atribuição como na programação imperativa não é um predicado de declaração de igualdade como na lógica dos predicados ?- geber = senior -> no. ?- prof(X,disc(Y,dept(di,ufpe))) = prof(geber,disc(ia,Z)). -> X = geber, Y = ia, Z = dept(di,ufpe). 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).

Prolog para engenharia de software
Linguagem de especificação formal com semântica declarativa lógica Linguagem de programação de propósito geral em duas camadas: Prolog puro: a semântica formal de cada linha do programa é dada pela formula correspondente em lógica da 1a ordem Predicados extra-lógicos: introduzidos por razões de conveniência Funcionam com efeitos colaterais como na programação imperativa Não são bem integrados com o paradigma lógico de Prolog puro Linguagem de scripting não tipado

Aspectos de Prolog fora da Lógica Clássica de Horn da 1a ordem
Acrescentados por necessidades práticas de programação Semântica imperativa, funcional, de lógicas não clássicas ou clássicas de ordem superior Negação por falha: not Controle e poda da busca: ! (cut), repeat, ... Entrada/saída: read, write, ... Aritmética: is, +, -, *, /, =>, <=, ... Modificação dinâmica da base de conhecimento: assert, retract Meta-programação: var, =.., name, list Maioria das extensões de Prolog, os substituem por predicados lógicos No entanto, não existe padrão para essas extensões

Permite integrar duas filosofias tradicionalmente opostas de engenharia de software: Métodos formais, SPIV (Specify Prove Implement Verify) Prototipagem rápido Code first, think after Extreme programming RUDE (Run Understand Debug Edit) Via especificação formal executável Em Prolog: Implement é feito via Prove

Metáfora da programação em lógica para engenharia de software: Programar = apenas declarar axiomas e regras Execução do programa = construção de prova de teorema Compilador/interpretador = provador de teorema Estrutura de controle (única) = mecanismo de dedução automática Disparar execução do programa = perguntar verdade de um teorema É um exemplo de paradigma de programação declarativa Outros paradigmas declarativos: Programação funcional, ex Haskell Programação por resolução de restrições, ex Eclipse Programação por re-escritura, ex XSLT Programador especifica apenas o que fazer Como fazê-lo é problema do interpretador ou compilador

Programação procedimental x programação em lógica
Modelagem estrutural Modelagem comportamental Codificar estruturas de dados Codificar passo a passo estruturas de controle Compilar/interpretar programa Executar programa Declarar o que é verdade (fatos e regras) Compilar/interpretar programa Fazer consulta sobre verdade de um fato A = 1+3 C = 6 Não há necessidade de 2 e 4 ! Estrutura de controle única (dedução automática) embutida no compilador/interpretador usada para todos os problemas !

Prolog: 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,[_|Z]) :- member(X,Z). ?- member(b,[a,b,c]) -> yes. ?- member(X,[a,b,c]) -> X = a ; X = b ; X = c ; no.

Programação relacional: vários usos do mesmo predicado
Definiçaõ única: append([],L,L). append([H|T1],L,[H|T2]) :- append(T1,L,T2). Uso como verificador: ?- append([a,b],[c],[a,b,c]). -> yes. ?- append([a,b],[c],[a]). -> no. Uso como instanciador: ?- append([a,b],[c],R). -> R = [a,b,c]. ?- append(H,[c],[a,b,c]). -> H = [a,b]. Uso como resolvedor de restrições: ?- append(X,Y,[a,b,c]). -> X = [], Y = [a,b,c] ; -> X = [a], Y = [b,c] ... Uso como enumerador: ?- append(X,Y,Z). -> X = [], Y =[], Z = [] ; -> X = [_], Y = [], Z = [_] ... Implementa sozinha funcionalidades de 8 métodos imperativos!

Prolog: 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 1
> ? < yes > ? =:= > ? = no > ?- 1 + A = B + 2. A = 2 B = 1 > ?- 1 + A =:= B + 2. Error > ?- A = 2, B = 1, 1 + A =:= B + 2. > ?- C = C = 1+2 > ?- C == no > ?- C is C = 3 > ?- C is D, D = Error. > ?- D = 1 + 2, C is D. D=1+2 C=3 > ? = +(-(1),2). > ? =:= +(-(1),2). yes

Prolog: 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

Evitar backtracking inútil: ! (o Cut)
Operador built-in de poda da árvore de prova Logicamente 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

Exemplo de Cut sign(X,-1) :- X<0, !. sign(X,0) :- X=0, !.
sign(-2,Y) Exemplo de Cut Y=-1 Y=0 Y=1 -2 < 0, ! -2=0, ! -2 > 0 sign(X,-1) :- X<0, !. sign(X,0) :- X=0, !. sign(X,1) :- X>0. ?- sign(-2,Y). Y=-1 yes ?- sign(0,Y). Y=0 ! fail fail yes Sub-árvore podada sign(0,Y) Y=-1 Y=0 Y=1 0 < 0, ! 0=0, ! 0 > 0 fail ! fail Sub-árvore podada yes

Prolog: entrada/saída 1
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: entrada/saída 2
Ler e escrever termos: read, write, display. Ler e escrever caracteres: get, get0, put. Formatar a saída legívelmente: nl, tab. Ligar um canal de E/S com a tela ou com arquivos: tell, telling, told, see, seeing, seen . Carregar arquivo fonte no ambiente do interpretador: consult, reconsult ex.: ?- read(X), Z is X + 1, write(Z). 2. 3 X = 2, Z = 3; no ?

Prolog para bancos de dados
Datalog: Sub-conjunto de Prolog excluindo símbolos de funções, e assim garante decidabilidade da inferência da 1a ordem Estende modelo de dados relacional com visões recursivas Fatos datalog de um determinado predicado: tabelas de um BD relacional parte extensionais de um BD dedutivo Regras definidas datalog: visões de um BD relacional parte intencional de um BD dedutivo Mais compacto (e lento) do que BD inteiramente extensionais: Armazena apenas fatos primitivos e freqüentemente requisitados vistos como axiomas lógicos Consulta a outros são teoremas a provar

Prolog para bancos de dados
Máquina de inferência datalog: Estende processador de consulta com poder da dedução da 1a ordem É um tamborete de dados dedutivo não persistente Consulta ao BD: perguntar verdade de um teorema BD dedutivo: Integra serviço de inferência da 1a ordem Com serviços tradicionais de BD: persistência, gerenciamento de memória secundária, concorrência e segurança Vários sistemas acadêmico Nenhum comercial depois de 25 anos de pesquisa

Vantagens de Prolog Como formalismo de representação do conhecimento
Intuitividade das regras com rigor formal da lógica Teoria muito completa sobre semântica, corretude e completude da inferência, limites de expressividade, complexidade etc. Compiladores muito eficientes Versátil, serve de base para grande maioria dos mecanismos de inferência da IA Como linguagem de programação Declarativo com semântica formal Conciso Eficiente De nível suficientemente alto para implementação rápida e concisa de máquinas de inferência Computacionalmente completo Versátil, serve como linguagem de programação, de script e de definição e consulta de dados

Prolog como máquina de inferência para IA
Limitações: Unificação sem occur-check: Torna a unificação linear no lugar de quadrática em tempo Faz com que Prolog pode entrar em loop com algumas regras recursivas pela direta com funções Busca em profundidade primeira Torna inferência econômica em memória Faz com que Prolog pode entrar em loop com regras recursivas pela esquerda Juntos: Inferência sem garantia de completude nem corretude no caso geral Balanço: Imperfeita mas muito eficiente em tempo e memória (competitivo com C sobre vários benchmark) Maiorias da imperfeições facilmente contornáveis com um pouco de experiencia em engenharia do conhecimento em Prolog

Limitações de Prolog Como formalismo de representação do conhecimento
Objetos compostos com restrições complexas Raciocínio com hipótese do mundo aberto Conhecimento procedimental e numérico Tratamento da incerteza Atualização da base de conhecimento (Tell e Retract) com semântica declarativa Especificação declarativa de estratégia de busca Como linguagem de programação Recursos muito limitados para: Estruturação de objetos complexos Programação de larga escala Sem recursos para interfaces gráfica, programação concorrente e distribuída Baixa integração com metodologias e ferramentas de desenvolvimento de larga divulgação UML, RUP, Java, XML, .net, web services, BD O-R, etc.

Extensões de Prolog PL tabelada, ex, XSB PL tipada, ex, Mercury
PL funcional, ex, -Prolog PL de ordem superior, ex, Hilog PL orientada a objetos, ex, F-Logic PL multi-paradigma, ex, LIFE PL com restrições, ex, Eclipse PL concorrente, ex, BinProlog PL distribuída, ex, Jinni BD dedutivos, ex, Transaction Logic Disciplinas: Paradigmas de linguagens computacionais Programação declarativa e banco de dados inteligentes PL com negação explícita PL com disjunções PL abdutiva PL indutiva PL probabilista Disciplinas: Agentes autônomos e sistemas multiagentes Engenharia do conhecimento e sistemas especialistas Aprendizagem de máquina

Introdução a Programação em Lógica e Prolog

Apresentações semelhantes

Apresentação em tema: "Introdução a Programação em Lógica e Prolog"— Transcrição da apresentação:

Apresentações semelhantes

Sobre projeto

Feedback

Login

Autorizar-se através da rede social:

Introdução a Programação em Lógica e Prolog

Apresentações semelhantes

Apresentação em tema: "Introdução a Programação em Lógica e Prolog"— Transcrição da apresentação:

Apresentações semelhantes

Sobre projeto

Feedback