Introduo a Programao em Lgica e Prolog Jacques

  • Slides: 59
Download presentation
Introdução a Programação em Lógica e Prolog Jacques Robin CIn-UFPE

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

O que é Prolog? Primeira e mais divulgada linguagem do paradigma da Programação em

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 * PL unifica: * • Engenharia de Software (especificação formal, linguagens de programação) • Inteligência Artificial (IA) (raciocínio com Formalismos de Representação do Conhecimento (FRCs)) • Banco de Dados -- Dedutivos (BDDs) • Teoria Lógica (TL) das provas

Metáfora da programação em lógica Teoria Lógica = Programa = BD dedutivo = Base

Metá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

Aplicações da programação em lógica * Inteligência Artificial • Representação do conhecimento • Sistemas

Aplicações da programação em lógica * Inteligência Artificial • Representação do conhecimento • Sistemas especialistas • Provadores de teoremas • Aprendizagem de máquina • Processamento de linguagem natural • Sistemas multi-agentes • Robótica * 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 DOO • Mineração de Dados e Descoberta de Conhecimento • Integração de Dados e Interoperabilidade

Programação procedimental x programação declarativa * * * * 1. Escolher linguagem de especificação

Programação procedimental x 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: t t : booleana (L 0, L 1) : instanciação de variáveis (L 1)

Revisão de L 1: sintaxe Fórmula ® | | Fórmula-Atômica (Fórmula) ù Fórmula Quantificador

Revisão de L 1: sintaxe Fórmula ® | | Fórmula-Atômica (Fórmula) ù Fórmula Quantificador Variável, . . . Fórmula, Fórmula Conectivo Fórmula-Atômica® Predicado(Termo, . . . ) | Termo = Termo ® | | Função(termo, . . . ) Constante Variável Conectivo Quantificador Constante Variável Predicado Função ® ® ® Ú| | |Û | | ! Wumpus | Agente | Flecha |. . . x | y | wumpus | agente |. . . Adjacente | Vivo |. . . Em | Brisa |. . .

Revisão de L 1: mecanismo de inferência completo (para verificação) Fórmula da lógica de

Revisão de L 1: mecanismo de inferência completo (para verificação) Fórmula da lógica de 1 a. ordem Fórmula na forma normal Conversão para forma normal Demodulação Fórmula instanciada ou False Prova por refutação Resolução Unificação Refutação: aplicação repetitiva da regra de resolução Problema: a cada passo, como escolher o par de fórmulas a resolver?

Revisão de L 1: forma normal e cláusulas de Horn * Def: Thm: *

Revisão de L 1: forma normal e cláusulas de Horn * Def: Thm: * Cláusula de Horn é uma formula de L 1: * • em forma normal implicativa, com uma conclusão única e positiva • ie, da forma: P 1 . . . Pn C * * Muitas mas nem todas as formulas de L 1 tem conjunto equivalente de cláusulas de Horn, cex: Lógica de Horn:

Revisão de L 1: refutação, unificação e substituição Motivação de provas por refutação: KB

Revisão de L 1: refutação, unificação e substituição Motivação de provas por refutação: KB P Û Û Û ØØ(KB P) ØØ(ØKB Ú P) Ø(KB Ø P) Ú False (KB Ø P) False Substituição de variáveis de uma formula f: conjunto de pares Var/const ou Var 1/Var 2 Unificação de 2 formulas f e g: • substituição S das variáveis de f e g tal que S(f)=S(g) • 2 resultados: t t S r=S(f)=s(g)

Revisão de L 1: unificação posicional * Exemplos: • unif(conhece(joao, X), conhece(Y, leandro)) =

Revisão de L 1: unificação posicional * Exemplos: • unif(conhece(joao, X), conhece(Y, leandro)) = {X/Leandro, Y/joao} • unif(conhece(joao, X), conhece(X, leandro) = fail • unif(conhece(joao, X), conhece(Y, mae(Y)) = {Y/joao, X/mae(joao)} • unif(conhece(joão, X), conhece(Y, Z)) = {Y/João, X/Z}, ou {Y/joão, X/Z, W/zelda} ou {Y/joão, X/joão, Z/joão}. . . * * Unificador mais geral: com menor número de variáveis instanciadas Substituição mínima: com menor número de pares Var/const

Revisão de L 1: regra de resolução * simples: * ex. : * geral:

Revisão de L 1: regra de resolução * simples: * ex. : * geral:

Cláusulas Prolog e Cláusulas de Horn * Fatos Prolog: • cláusulas de Horn com

Clá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 : - P 1, . . . , Pn. <=> P 1 &. . . & Pn => C * Premissas de cláusulas com a mesma conclusão implicitamente disjuntivas: • ex: {C : - P 1, . . . , Pn. , C : - Q 1, . . . , Qm} <=> (P 1&. . . & Pn) v (Q 1 &. . . & Qm) => C * Escopo das variáveis = uma cláusula

West é criminoso? : em L 1 * Requisitos em inglês 1. It is

West é criminoso? : em L 1 * Requisitos em inglês 1. It is crimimal for an American to sell weapons to an hostile country 2. Nono owns missiles 3. Nono acquires all its missiles from West 4. West is American 5. Nono is a nation 6. Nono is an enemy of the USA 0. Is West a crimimal? * Em lógica da 1 a ordem 1. 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? em formal normal * Em lógica da 1 a ordem 1.

West é criminoso? em formal normal * Em lógica da 1 a ordem 1. 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 normal american(P) weapon(W) nation(N) hostile(N) sells(P, N, W) criminal(P) owns(nono, m 1) missile(m 1) 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? em Prolog Em Lógica de Horn: american(P) weapon(W) nation(N) hostile(N) sells(P,

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, m 1) missile(m 1) 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, m 1). missile(m 1). 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).

West é criminoso? busca criminal(P) : - american(P), weapon(W), nation(N), hostile(N), sells(P, N, W). owns(nono, m 1). missile(m 1). 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 = m 1. tmissile(W)? -> W = m 1. • nation(N)? -> N = nono. • hostile(nono)? <- yes. tenemy(nono, america)? -> yes. • sells(west, nono, m 1)? <- yes. towns(nono, m 1)? -> yes. tmissile(m 1)? -> yes.

West é criminoso? backtracking criminal(P) : - american(P), weapon(W), nation(N), hostile(N), sells(P, N, W).

West é criminoso? backtracking criminal(P) : - american(P), weapon(W), nation(N), hostile(N), sells(P, N, W). owns(nono, m 1). missile(m 1). 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 = m 1. tmissile(W)? -> W = m 1. • nation(N)? -> N = america. • hostile(america)? <- no. tenemy(america, america)? -> no. • backtrack: nation(N), N {america}? -> N = nono. • hostile(nono)? <- yes. tenemy(nono, america)? -> yes. • sells(west, nono, m 1)? <- yes. towns(nono, m 1)? -> yes. tmissile(nono, m 1)? -> yes.

Interpretador Prolog: controle e busca * Aplica regra de resolução: • com estratégia linear

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

Prolog devolve a primeira resposta g 1(a). g 21(a). g 3(a). g 4(a). g

Prolog devolve a primeira resposta g 1(a). g 21(a). g 3(a). g 4(a). g 1(b). g 22(b). g 3(b). g(X) : - g 1(X), g 2(X). g(X) : - g 3(X), g 4(X). g 2(X) : - g 21(X), g 22(X). $ prolog ? - consult(“g. pl”). yes ? - g(U). U=b ? - ; U=a ? - ; no ? - halt. $

Forçar o backtracking para obter todas as respostas g 1(a). g 21(a). g 3(a).

Forçar o backtracking para obter todas as respostas g 1(a). g 21(a). g 3(a). g 4(a). g 1(b). g 22(b). g 3(b). g(X) : - g 1(X), g 2(X). g(X) : - g 3(X), g 4(X). g 2(X) : - g 21(X), g 22(X). g(U)? <- U = b. * g 1(U)? -> U = a. * g 2(a)? <- no. • g 21(a)? -> yes. • g 22(a)? -> no. * * g 1(U), U {a}? -> U = b. g 2(b)? <- yes. • g 21(b)? -> yes. • g 22(b)? -> yes. ; * g 1(U), U {a, b} ? -> no.

Backtracking em cascatas g 1(a). g 21(a). g 3(a). g 4(a). g 1(b). g

Backtracking em cascatas g 1(a). g 21(a). g 3(a). g 4(a). g 1(b). g 22(b). g 3(b). g(X) : - g 1(X), g 2(X). g(X) : - g 3(X), g 4(X). g 2(X) : - g 21(X), g 22(X). g(U), g {g 1, g 2}? <- U = a. * g 3(U)? -> U = a. * g 4(a)? -> yes. ; * g 3(U), U {a}? -> U = b. * g 4(b)? -> no. * g 3(U), U {a, b}? -> no. g(U), g {g 1, g 2 ; g 3, g 4}? -> no.

Prolog: sintaxe 1 * * * * fato -> fa. (abrev. para Formula Atômica)

Prolog: sintaxe 1 * * * * fato -> fa. (abrev. 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 | numeros pred -> átomo Ao invés de L 1: • nenhuma distinção entre predicados e funções • ausência da igualdade semântica

Prolog: sintaxe 2 * * variável ex: G, Glr, geber-ramalho, 1 geber, _glr, _

Prolog: sintaxe 2 * * variável ex: G, Glr, geber-ramalho, 1 geber, _glr, _ átomo ex: g, glr, =>, geber_ramalho, geber 1, ‘geber ramalho’ número ex: 23 termos, fatos, regras e consultas sem variáveis: • instanciados (ground) • ex. : person(bob, 40, cs). * termos, fatos e regras com variáveis: • universais • ex. : pai(X, adao). ancestral(X, A) : - pai(X, P), ancestral(P, A). * consultas com variáveis: • existenciais • ex. : ? pai(F, P).

Igualdade x unificação: exemplos * * * ? - geber = senior -> no.

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

Prolog: listas * * * [ e ]: início e fim de lista ,

Prolog: listas * * * [ e ]: início e fim de lista , separação entre eltos |: separação entre 1 o 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|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.

Evitar backtracking inútil: ! (o cut) op built-in de pruning, logicalmente sempre verificado *

Evitar backtracking inútil: ! (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: t unicamente se M ou N falha t nunca se P ou Q falha

Cut: exemplo (cont. ) f 3(X, 0) : - X < 3, !. f

Cut: exemplo (cont. ) f 3(X, 0) : - X < 3, !. f 3(X, 2) : - X < 6, !. f 3(X, 4). ? - f 3(1, Y). Y=0 ? - ; no. ? * Esses cuts modificam até a semântica declarativa do programa f 4(X, 0) : - X < 3. f 4(X, 2) : - X < 6. f 4(X, 4). ? - f 4(1, Y). Y=0 ? - ; Y = 2. ? -

Hipótese do mundo fechado * Ao invés de L 1, Prolog não permite nem

Hipótese do mundo fechado * Ao invés de L 1, 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) 1 * Permite raciocínio não monótono, ex: ave(piupiu). papa_leguas(bipbip). ave(X)

Negação por Falha (NF) 1 * Permite raciocínio não monótono, ex: ave(piupiu). papa_leguas(bipbip). ave(X) : - papa_leguas(X). voa 1(X) : - ave(X), not papa_leguas(X). voa 1(X)? -> X = piupiu ; no. Sem semântica declarativa em L 1 * Depende da ordem, ex: * voa 2(X) : - not papa_leguas(X), ave(X). voa 2(X)? -> no.

Negação por Falha 2 * NF pode ser implementado apenas com !, fail (nunca

Negação por Falha 2 * NF pode ser implementado apenas com !, fail (nunca verificado) e true (sempre verificado), ex: • voa 3(X) : - papa_leguas(X), !, fail. voa 3(X) : - ave(X). • não(X) : - X, !, fail ; true. * NF torna resolução de Prolog (Select Depth-1 st 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.

Prolog: aritmética * 3 tipos de operadores built-in aritméticos: • calculadores (n-ários infixos): +,

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ão. Aritmé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 > ? - 1 + 1 < 1 +

Prolog: exemplos de aritmética 1 > ? - 1 + 1 < 1 + 2. yes > ? - 1 + 3 =: = 2 + 2. yes > ? - 1 + 3 = 2 + 2. no > ? - 1 + A = B + 2. A=2 B=1 > ? - 1 + A =: = B + 2. Error > ? - A = 2, B = 1, 1 + A =: = B + 2. A=2 B=1 > ? - C = 1 + 2. C = 1+2 > ? - C == 1 + 2. no > ? - C is 1 + 2. C=3 > ? - C is D, D = 1 + 2. Error. > ? - D = 1 + 2, C is D. D=1+2 C=3 > ? - -1+2 = +(-(1), 2). no > ? - -1+2 =: = +(-(1), 2). yes

Prolog: exemplos de aritmética 2 fac(0, 1) : - !. fac(I, O) : -

Prolog: exemplos de aritmética 2 fac(0, 1) : - !. fac(I, O) : - I 1 is I - 1, fac(I 1, O 1), O is I * O 1. ? - 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: exemplos de teste de tipos ? - var(X). X = _3 ? -

Prolog: exemplos de teste de tipos ? - var(X). X = _3 ? - var(2). no ? - var(a). no ? - var(p(a, X)). no ? - nonvar(2), nonvar(p(2, X, a)). X = _11 ? - X is 2 + 3, var(X). no ? - var(X), X is 2 + 3. X=5 ? - numberp(Term) : - integer(Term). numberp(Term) : - real(Term). structp(Term) : - nonvar(Term), not atomic(Term). listp(Term) : - nonvar(Term), listp 1(term). listp 1([]). listp 1([H|T]) : - listp 1(T). factp(Term) : - strucp(Term), not listp(Term).

Prolog: conversão de tipos name(Átomo, Caracteres): * conversão bi-direcional entre átomo e cadeia de

Prolog: conversão de tipos name(Átomo, Caracteres): * conversão bi-direcional entre átomo e cadeia de caracteres que constitui o seu nome list(Códigos. Ascii, Caracteres): * conversão bi-direcional entre um lista de inteiros vistos como códigos ascii e cadeia de caracteres correspondente Fato =. . Lista: * conversão bi-direcional entre fato e lista, funtor sendo cabeça e argumentos sendo resto ? - name(A, "blabla"). A = blabla ? - name(blabla, S). S = "blabla" ? - list(X, "bla"). X = [98, 108, 97] ? - list([98, 108, 97], Y). Y = "bla” ? - p(a, X, c) =. . Y. X = _5, Y = [p, a, _5, c] ? - Y =. . [p, a, X, c]. Y = p(a, _20, c), X = _20

Prolog: entrada/saída 1 * Ler/escrever estrutura de dados dificilmente pode ser visto como resultando

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ântica declarativa em L 1 * 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

Prolog: entrada/saída 2 Ler e escrever termos: read, write, display. * Ler e escrever caracteres: get, get 0, put. * Formatar a saída legívelmente: nl, tab. * Ligar um canal de E/S com a tela ou com arquivos: tell, telling, told, 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: failure-driven loop Loop gerada por backtracking forçado com fail e repeat. * repeat

Prolog: 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 sistemas de produção: controle Raciocino dirigido pelo objetivo (e não pelos dados)

Prolog 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 1 a regra aplicável encontrada (ie, sem resolução de conflitos) * Backtracking quando 1 a regra leva a uma falha *

Prolog x sistemas de produção: poder expressivo * Fatos universais (e não apenas instanciados):

Prolog x sistemas de produção: poder 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 programação imperativa 1 * Interativo: • compilação transparente integrada na interpretação •

Prolog 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 2 * Estrutura de dados única: termo Prolog þ variáveis

Prolog 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 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 programação funcional 1 Matematicamente, predicado = relação: * não-determinismo: • respostas múltiplas

Prolog 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 2 * Append em Haskell: append [] L = L

Prolog x programação funcional 2 * Append em Haskell: append [] L = L append H: T L = H : append T L ? - append([a, b], [c, d]) [a, b, c, d] * 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]. * Append relacional codifica 8 funções

Vários usos do mesmo predicado * verificador: ? - append([a, b], [c], [a, b,

Vá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 OO * Funcionalidades built-in: • + unificação e busca • -

Prolog 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: exemplo * Em OO: pt[subclass_of planobj; attrs[X inst_of int, Y

Prolog 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}]] 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. * 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-Graduação Prolog aprofundado * Programação por

Programação em Lógica: Disciplina Eletiva de Graduação e Pós-Graduação Prolog aprofundado * Programação por resolução de restrições a base lógica (Constraint Logic Programming) * • 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ógica + restrições + funcional + OO • todo a IA e mais !

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

Programação em Lógica: Disciplina Eletiva de Graduação e Pós-Graduação * Programação em lógica para engenharia de software • especificação formal prototipágem rápido • aceleração do modelo de desenvolvimento em espiral * Programação em lógica probabilista e bayesiana • raciocínio com incerteza * Programação em lógica indutiva • 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 • 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-Graduação * Bancos de dados dedutivos:

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

Programação em Lógica: Disciplina Eletiva de Graduação e Pós-Graduação * Gramáticas lógicas: • •

Programação em Lógica: Disciplina Eletiva de Graduação e Pós-Graduação * Gramáticas lógicas: • • * 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 • sistemas de informação inteligentes distribuídos e heterogêneos a infra -estrutura web t 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 * Aplicação fio condutor para

Programação em Lógica: Disciplina Eletiva de Graduação e Pós-Graduação * Aplicação fio condutor para ilustração dos conceitos

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

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

Exercícios * A terrível novela • em lógica da 1 a ordem • em

Exercícios * A terrível novela • em lógica da 1 a ordem • em Prolog * O banco de dados acadêmico • em Prolog • em lógica da 1 a ordem A curiosidade matou o gato? em Prolog * Coloração de mapa em Prolog *

A terrível novela: requisitos em inglês * * * 1. A soap opera is

A terrível novela: requisitos 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?

O BD acadêmico: requisitos em inglês 1. Bob is 40 and the manager of

O BD acadêmico: requisitos em inglês 1. 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 Ph. D. 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 0 a: Who are the midaged employees of the CS department and who are their boss? 0 b: Who published jointly with Mary in the Journal of the ACM? 0 c: Where did Mary published joint work with Phil?

A curiosidade matou o gato? * Requisitos em inglês 1. Jack owns a dog.

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 Tuna 5. Tuna is a cat 0. Did curiosity kill the cat? * Em L 1 1. x Dog(x) Owns(Jack, x) 2. x ( y Dog(y) Owns(x, y)) Animal. Lover(x) 3. x Animal. Lover(x) y Animal(y) ØKills(x, y) 4. Kills(Jack, Tuna) Ú Kills(Curiosity, Tuna) 5. Cat(Tuna) 6. x Cat(x) Animal(x) 0. Kills(Curiosity, Tuna)

Coloração de mapa * Colorir mapa tal que: * • países adjacentes • de

Coloração de mapa * Colorir mapa tal que: * • países adjacentes • de cores diferentes A Instância de problema de resolução de restrições A B B C C D D E F