问题

I implemented the following power program in Prolog:

puissance(_,0,1).
puissance(X,N,P) :- N>0,A is N-1, puissance(X,A,Z), P is Z*X.

The code does what is supposed to do, but after the right answer it prints "false.". I don't understand why. I am using swi-prolog.

回答1:

You can add a cut operator (i.e. !) to your solution, meaning prolog should not attempt to backtrack and find any more solutions after the first successful unification that has reached that point. (i.e. you're pruning the solution tree).

puissance(_,0,1) :- !.
puissance(X,N,P) :- N>0,A is N-1, puissance(X,A,Z), P is Z*X.

Layman's Explanation:

The reason prolog attempts to see if there are any more solutions, is this:

At the last call to puissance in your recursion, the first puissance clause succeeds since P=1, and you travel all the way back to the top call to perform unification with P with the eventual value that results from that choice.

However, for that last call to puissance, Prolog didn't have a chance to check whether the second puissance clause would also be satisfiable and potentially lead to a different solution, therefore unless you tell it not to check for further solutions (by using a cut on the first clause after it has been successful), it is obligated to go back to that point, and check the second clause too.

Once it does, it sees that the second clause cannot be satisfied because N = 0, and therefore that particular attempt fails.

So the "false" effectively means that prolog checked for other choice points too and couldn't unify P in any other way that would satisfy them, i.e. there are no more valid unifications for P.

And the fact that you're given the choice to look for other solutions in the first place, exactly means that there are still other routes with potentially satisfiable clauses remaining that have not been explored yet.

回答2:

Can do like this instead:

puissance(X,N,P) :-
  ( N > 0 ->
    A is N-1,
    puissance(X,A,Z),
    P is Z*X
  ; P = 1 ).

Then it will just print one answer.

(Your code leaves a `choice point' at every recursive call, because you have two disjuncts and no cut. Using if-then-else or a cut somewhere removes those. Then it depends on the interpreter what happens. Sicstus still asks if you want ((to try to find)) more answers.)

回答3:

Semantic differences

Currently, there are 3 different versions of puissance/3, and I would like to show a significant semantic difference between some of them.

As a test case, I consider the query:

?- puissance(X, Y, Z), false.

What does this query mean? Declaratively, it is clearly equivalent to false. This query is very interesting nevertheless, because it terminates iff puissance/3 terminates universally.

Now, let us try the query on the different variants of the program:

Original definition (from the question):

?- puissance(X, Y, Z), false.
ERROR: puissance/3: Arguments are not sufficiently instantiated

Accepted answer:
```
?- puissance(X, Y, Z), false.
false.
```

Improving determinism

So, let us stick to the original program, and consider the query:

?- puissance(1, 1, Z).
Z = 1 ;
false.

We would like to get rid of false, which occurs because the program is not deterministic.

One way to solve this is to use zcompare/3 from library(clpfd). This lets you reify the comparison, and makes the result available for indexing while retaining the predicate's generality.

Here is one possible solution:

puissance(X, N, P) :-
        zcompare(C, 0, N),
        puissance_(C, X, N, P).

puissance_(=, _, 0, 1).
puissance_(<, X, N, P) :-
        A #= N-1,
        puissance(X, A, Z),
        P #= Z*X.

With this version, we get:

?- puissance(1, 1, Z).
Z = 1.

This is now deterministic, as intended.

Now, let us consider the test case from above with this version:

?- puissance(X, Y, Z), false.
nontermination

Aha! So this query neither throws an instantiation error nor terminates, and is therefore different from all the versions that have hitherto been posted.

Let us consider the most general query with this program:

?- puissance(X, Y, Z).
Y = 0,
Z = 1 ;
X = Z,
Y = 1,
Z in inf..sup ;
Y = 2,
X^2#=Z,
Z in 0..sup ;
Y = 3,
_G3136*X#=Z,
X^2#=_G3136,
_G3136 in 0..sup ;
etc.

Aha! So we get a symbolic representation of all integers that satisfy this relation.

That's pretty cool, and I therefore recommend you use CLP(FD) constraints when reasoning over integers in Prolog. This will make your programs more general and also lets you improve their efficiency more easily.

来源：https://stackoverflow.com/questions/42078614/prolog-program-returns-false

标签

prolog

prolog-toplevel

Prolog program returns false

问题

回答1:

回答2:

回答3:

Semantic differences

Improving determinism