Prolog program returns false

Question

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 cod

Answer 1

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:

1. Original definition (from the question):

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

2. Accepted answer:

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

3. Other answer:

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

Obviously, the solution shown in the accepted answer yields a different result, and is worth considering further.

Here is the program again:

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

Let us ask something simple first: Which solutions are there at all? This is called the most general query, because its arguments are all fresh variables:

?- puissance(X, Y, Z).
Y = 0,
Z = 1.

The program answers: There is only a single solution: Y=0, Z=1.

That's incorrect (to see this, try the query ?- puissance(0, 1, _) which succeeds, contrary to the same program claiming that Y can only be 0), and a significant difference from the program shown in the question. For comparison, the original program yields:

?- puissance(X, Y, Z).
Y = 0,
Z = 1 ;
ERROR: puissance/3: Arguments are not sufficiently instantiated

That's OK: On backtracking, the program throws an instantiation error to indicate that no further reasoning is possible at this point. Critically though, it does not simply fail!

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.

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

Answer 3

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.