Uso di obiettivi ridondanti nelle query

(Su suggerimento di @repeat ) Si consideri una query di un programma puro ¹ ?- G_0. Che utilità avrebbe avere la query ?- G_0, G_0.?

^{Note a piè di pagina

1 Nessuna presentazione (per sicurezza), i vincoli sono OK.

Post precedente sull'argomento.}

prolog logical-purity

— falso
fonte

Quadrare il numero di risultati?

— Willem Van Onsem,

Presumo che nessuna informazione sullo stato venga preservata dalla corsa consecutiva dell'obiettivo. In altre parole, non è consentita una variazione della domanda, ad es. ?- G_0(State), G_0(State).Inoltre, nessuno stato viene passato in pila dal risultato del primo goal al secondo goal?

— Guy Coder,

G_0può essere qualsiasi obiettivo (puro), incluso, diciamoG_0 = append(Xs,Ys,Zs)

— falso

@GuyCoder: è richiesta la congiunzione. (Con G_0;G_0uno si potrebbero verificare effetti collaterali o problemi di prestazioni / cache / tabulazione)

— falso

A proposito, invece di G_0(State),G_0(State)scrivere piuttostocall(G_1,State), call(G_1,State)

— falso

Risposte:

La query ?- G_0, G_0.consente di identificare le risposte ridondanti di?- G_0.

Per fare ciò è sufficiente confrontare il numero di risposte di ?- G_0.con il numero di risposte di ?- G_0, G_0.. Non è necessario memorizzare tali risposte (che è comunque una frequente fonte di errori). Bastano solo due numeri interi! Se sono uguali, allora non c'è ridondanza. Ma se ?- G_0, G_0.ha più risposte, allora c'è un po 'di ridondanza. Ecco un esempio:

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 ora sistemiamo questo:

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

Non è necessario ispezionare manualmente i vincoli coinvolti.

Questo può essere ulteriormente esteso quando stiamo cercando esplicitamente risposte ridondanti solo usando call_nth/2.

?- G_0, call_nth(G_0, 2).

— falso
fonte

Considerare una query di un puro programma1? - G_0. A che cosa servirebbe la query? - G_0, G_0. avere?

Non vedo alcuna utilità del secondo obiettivo, soprattutto quando l' ottimizzazione della ricorsione della coda ( ottimizzazione dell'ultima chiamata ) è attivata .

Potrei realizzare un problema GC (overflow stack / heap) quando la query è avida di risorse e le opzioni sopra sono disattivate (ad es. Durante il debug).

Penso che la seconda chiamata sia ridondante (per il programma puro) e dovrebbe essere eliminata dal compilatore.

— Anton Danilov
fonte