SLX: Procedimentos para WFSX SLX (SL with eXplicit negation) é um procedimento top- down para a WFSXp –Aqui apresenta-se apenas a caracterização de AND-trees –Os detalhes do procedimento estão em [AP96] É semelhante ao SLDNF –Os nós são sucedidos ou falhados –Resolução com regras do programa é como em SLDNF Em SLX, falha não significa falsidade. Quer antes dizer não-veracidade (i.e. falso or indefinido)

Sucesso e falha Uma árvore finita é sucedida se a sua raiz é sucedida, e falhada se a sua raiz é falhada O estado dum nó da árvore é determinado por: –Uma folha com um literal objectivo é falhada –Uma folha com true é sucedida –Um nó intermédio é sucedido se todos os seus filhos são sucedidos, e falhado caso contrário

Negação por falha? Como em SLS, para reslver recursões positivas infinitas, árvores infinitas são (por definição) falhadas Pode-se usar NAF? Sim True de not A sucede se true-or-undefined de A falha True-or-undefined de not A sucede se true de A falha É esta a base do SLX. Define: T-Trees para provar verdade TU-Trees para provar verdade ou indefinição

T e TU-trees Diferem no facto de literais envolvidos em recursão sobre negação, e portanto indefinidos em WFSXp, falham em T-Trees mas sucedem em TU-Trees a not b b not a … b not a TU b not a TU a not b T a T x x x x

Negação explícita em SLX ¬-literais são tratados como átomos Para impôr coerência, usa-se versão semi-normal nas TU-trees a not b b not a ¬a b not a x a not b not ¬a ¬a¬a true x b not a ¬a¬a true … x x a not b not ¬a x

Negação explícita em SLX (2) Em TU-trees: L também falha se ¬L sucede em T I.e. se not ¬L falha em TU c not c b not c ¬b a b not a x ¬b¬b true c not c ¬a¬a b not ¬b a not ¬a x x x c not c c c c … x x x x x x

Definição de T e TU-trees T-Trees (resp TU-trees) são AND-trees etiquetadas por literais, construidas de forma top-down a partir da raiz, expandido nós da seguinte forma Nós com literal objectivo A Se não há regras com cabeça A, o nó é uma folha leaf Caso contrário, seleccione-se não-deterministicamente uma regra para A A L 1,…,L m, not L m+1,…, not L n Numa T-tree os filhos de A são L 1,…,L m, not L m+1,…, not L n Numa TU-tree A tem, para além daqueles, o filho not ¬A Nós com default literals são folhas

Sucesso e falha Todas as árvores infinitas são falhadas. Uma árvore finita é sucedida se a sua raiz é sucedida e falhada caso contrário. O estado dos nós é determinado por: Uma folha com etiqueta true é sucedida Uma folha com um literal objectivo é falhada Uma folha numa T-tree (resp. TU) com etiqueta not A é sucedida se todas as TU-trees (resp. T) com raiz A (árvores subsidiárias) são falhada; é falhada caso contrário Um nó intermédio é sucedido se todos os seus filhos são sucedidos; caso contrário é falhado Depois de aplicar todas estas regas, alguns literais podem com estado indeterminado (recursão sobre) Nós indeterminados em T-trees (resp.TU) são por definição falhados (resp. sucedidos)

Exemplo de árvores infinitas s not p, not q, not r p not s, q, not r q r, not p r p, not q WFM is {s, not p, not q, not r} not pnot qnot r s x p q not s r not q not r r not p p q not snot r r not p p not q x x q r not p p not q q not snot r

Exemplo com recursão sobre negação q not p(0), not s p(N) not p(s(N)) s true WFM = {s, not q} … not q p(0) not p(1) not p(0) q not s x 6 p(1) not p(2) p(2) not p(3) x x x x s true not p(0) … p(1) not p(2) p(0) not p(1) x x x p(2) not p(3)

Garantindo terminação Por causa de loops, este método não é eficaz Para garantir terminação em programas ground: Ancestors locais dum nó n são literais no caminho entre n e a raiz, excluindo o próprio n Ancestors globais são atribuidos a árvores: A árvore raiz não tem ancestors globais Os ancestors globais de T, uma árvore subsidiária do nó n em T, são os ancestors globais de T mais os ancestors locais de n Os ancestors globais dividem-se entre aqueles que provêm de T- trees e os que provêm de TU-trees

Regras de Pruning Para recursão sobre positivos: Regra 1 Se a etiqueta dum nó pertence aos seus ancestors locais, então o nó é falhado e os seus filhos ignorados Para recursão sobre negação: Regra 2 Se um literal L numa T-tree ocorre nos seus ancestors globais-T, então o nó é falhado e os seus filhos ignorados

Regra 2Regra 1 Regras de prunning (2) L L L L …

Outras regras correctas Regra 3 Se um literal L numa T-tree ocorre nos seus ancestors globais-TU, então o nó é falhado e os seus filhos ignorados Regra 4 Se um literal L numa TU-tree ocorre nos seus ancestors globais-T, então o nó é sucedido e os seus filhos ignorados Regra 5 Se um literal L numa TU-tree ocorre nos seus ancestors globais- TU, então o nó é sucedido e os seus filhos ignorados

Exemplos de Prunning a not b b not a ¬a b not a 6 a not b not ¬a ¬a¬a true 6 c not c b not c ¬b a b not a 6 ¬b¬b true c not c ¬a¬a b not ¬b a not ¬a Regra 3 b Regra 2 6

Caso não-ground A caracterização e regra de prunning só se aplica a programas allowed com perguntas ground Como é há muito reconhecido, não é possível aplicar regras de prunning no caso geral: p(X) p(Y) p(a) p(X) p(Y) Que fazer? p(Z) Se falha, então respostas incompletas Se continua então loop

Tabling Para garantir terminação em programas não-ground, em vez de ancestors e prunning, são necessários mecanismos de tabulação (tabling) –Se há um possível loop, suspender a literal e tentar soluções alternativas –Quando se encontra uma solução, guarda-se numa tabela –Acordar nós suspensos com novas soluções da tabela –Aplicar um algoritmo para determinar a completação do processo, i.e. deerminar quando já não há mais soluções, e falhar restantes nós suspensos

Exemplo de Tabling O XSB-Prolog usa tabling e implementa a WFS Experimentem em: p(X) p(Y) p(a) p(X) p(Y) 1) suspender X = a 2) acordar Y = a X = _ Tabela para p(X)

Tabling (cont.) Se a solução já está na tabela, e o predicado é chamado novamente, então: –Não é necessário calcular a solução novamente –Vai-se simplesmente buscar à tabela! Isto aumenta a eficiência. Algumas vezes em ordens de magnitude.

Exemplo de Fibonacci fib(1,1). fib(2,1). fib(X,F) :- fib(X-1,F1), fib(X-2,F2), F is F1 + F2. fib(4,A)fib(3,B)fib(2,C) C=1D=1 fib(1,D) B=3 fib(2,E) E=1 A=4 fib(3,F) F=3 Y=7 Tabela de fib Q F fib(6,X) fib(5,Y) fib(4,H) H=4 X= Linear em vez de exponencial

XSB-Prolog Usado para perguntas na WFS Prolog + tabling –Para usar tabling, eg, no predicado p com 3 argumentos: :- table p/3. –Para usar tabling em todos os predicados necessários: :- auto_table.

XSB Prolog (cont.) As tabelas são usadas de chamada para chamada até que: abolish_all_table,abolish_table_pred(P/A) Negação WF negation é usada via tnot(Pred) (Negação explícita via –Pred ) A resposta a Q é yes se Q é true ou undefined no WFM É no se Q é false no WFM do programa

Distinguir T de U Depois de todas as respostas, as tabelas guardam literais suspensos por recursão via negação Residual Program Se o residual é vazio, então True Se não é vazio, então Undefined O residual pode ser examinado através de: get_residual(Pred,Residual)

Exemplo de Residual program :- table a/0. :- table b/0. :- table c/0. :- table d/0. a :- b, tnot(c). c :- tnot(a). b :- tnot(d). d :- d. | ?- a,b,c,d,fail. no | ?- get_residual(a,RA). RA = [tnot(c)] ; no | ?- get_residual(b,RB). RB = [] ; no | ?- get_residual(c,RC). RC = [tnot(a)] ; no | ?- get_residual(d,RD). no | ?-

Fecho transitivo Devido à circularidade a completação não concluí not reach(c) SLDNF (e Prolog) entram em loop XSB-Prolog trabalha bem :- auto_table. edge(a,b). edge(c,d). edge(d,c). reach(a). reach(A) :- edge(A,B),reach(B). |?- reach(X). X = a; no. |?- reach(c). no. |?-tnot(reach(c)). yes.

Fecho transitivo (cont) :- auto_table. edge(a,b). edge(c,d). edge(d,c). reach(a). reach(A) :- edge(A,B),reach(B). Semântica declarativa mais próximo da operacional Recursão à esquerda tratada correctamente A versão da direita até é mais eficiênte :- auto_table. edge(a,b). edge(c,d). edge(d,c). reach(a). reach(A) :- reach(B), edge(A,B). Em vez disto, poderiamos ter escrito

SLX e XSB Existe uma implementação do SLX usando tabulação Essa implementação está baseada no XSB- Prolog Vem de base com o XSB-Prolog desde a versão 2.0, cf: