Uso de metas redundantes em consultas

(Por sugestão de @repeat ) Considere uma consulta de um programa puro ¹ ?- G_0. Que utilidade teria a consulta ?- G_0, G_0.?

^{Notas

de rodapé 1 Sem tabelas (por segurança), as restrições são aceitáveis.

Post anterior sobre o assunto.}

prolog logical-purity falso
fonte

Quadrando o número de resultados?

Willem Van Onsem

Suponho que nenhuma informação do estado seja preservada da execução consecutiva da meta. Em outras palavras, uma variação da pergunta não é permitida, por exemplo, ?- G_0(State), G_0(State).também nenhum estado está sendo passado na pilha do resultado do primeiro objetivo para o segundo objetivo?

Guy Coder

G_0pode ser qualquer objetivo (puro), incluindo, digamosG_0 = append(Xs,Ys,Zs)

false

@ BuyCoder: é necessária uma conjunção. ( G_0;G_0Pode-se testar efeitos colaterais ou problemas de desempenho / armazenamento em cache / marcação)

false

BTW, em vez de G_0(State),G_0(State)um pouco escrevecall(G_1,State), call(G_1,State)

false

Respostas:

A consulta ?- G_0, G_0.ajuda a identificar respostas redundantes de?- G_0.

Para fazer isso, basta comparar o número de respostas de ?- G_0.com o número de respostas de ?- G_0, G_0.. Não há necessidade de armazenar essas respostas (que é uma fonte frequente de erros). Apenas dois inteiros são suficientes! Se forem iguais, não haverá redundância. Mas se ?- G_0, G_0.tiver mais respostas, haverá alguma redundância. Aqui está um exemplo:

p(f(_,a)).
p(f(b,_)).

?- p(X).
   X = f(_A, a)
;  X = f(b, _A).  % two answers

?- p(X), p(X).
   X = f(_A, a) 
;  X = f(b, a)
;  X = f(b, a)
;  X = f(b, _A).   % four answers
                   % thus p(X) contains redundancies

... e agora vamos corrigir isso:

p(f(B,a)) :-
   dif(B, b).
p(f(b,_)).

?- p(X).
   X = f(_A, a), dif(_A, b)
;  X = f(b, _A).

?- p(X), p(X).
   X = f(_A, a), dif(_A, b), dif(_A, b).
;  X = f(b, _A).    % again two answers, thus no redundancy

Não há necessidade de inspecionar manualmente as restrições envolvidas.

Isso pode ser estendido ainda mais quando estamos procurando explicitamente apenas por respostas redundantes call_nth/2.

?- G_0, call_nth(G_0, 2).

falso
fonte

Considere a consulta de um programa puro1? - G_0. De que usaria a consulta? - G_0, G_0. ter?

Não vejo utilidade para o segundo objetivo, especialmente quando a otimização da recursão da cauda ( otimização da última chamada ) está ativada .

Eu pude perceber um problema de GC (estouro de pilha / pilha) quando a consulta é gananciosa por recursos e as opções acima estão DESLIGADAS (por exemplo, durante a depuração).

Eu acho que a segunda chamada é redundante (para programa puro) e deve ser eliminada pelo compilador.

Anton Danilov
fonte