In place of not(X = Y) you need to write \+ X = Y or X \= Y. But consider to use dif(X,Y) instead. dif/2 is present in B, SWI, YAP, SICStus. To see the difference: ?- X = b, dif(a, X). X = b. ?- X = b, \+ a = X. X = … Read more
The actual reason for your problem is (\==)/2 within different/2. It succeeds simply too often. Replace it with dif/2 and you will get the expected behavior. dif/2 is available in many Prolog systems like SICStus, YAP, B, SWI. You can also define a safe approximation in ISO-Prolog like so: iso_dif(X, Y) :- X \== Y, … Read more
@gusbro’s answer (s(X)) shows you how you somewhat solve this with GNU’s debugger. However, if you cannot afford to see all the printing going on, or it is much too slow, you might consider the following “debugger” available as library(debug) in Scryer. I personally do not use debuggers offered by Prolog systems for the simple … Read more
This answer shows a logically pure way to do it. The following is based on clpfd. :- use_module(library(clpfd)). We define meta-predicate tcount/3 similarly to tfilter/3! :- meta_predicate tcount(2,?,?). tcount(P_2,Xs,N) :- N #>= 0, list_pred_tcount_(Xs,P_2,0,N). :- meta_predicate list_pred_tcount_(?,2,?,?). list_pred_tcount_([] , _ ,N ,N). list_pred_tcount_([X|Xs],P_2,N0,N) :- if_(call(P_2,X), (N1 is N0+1, N1 #=< N), N1 = N0), list_pred_tcount_(Xs,P_2,N1,N). … Read more
You have been using cut and an unsafe form of negation. Both have to be used with extreme care. An immediate fix would be to guard your program against uses it is not designed for: unique(X, Xs) :- iwhen(ground(X+Xs), your_unique(X, Xs)). This uses iwhen/2 which is similar to when/2 except that it does not delay: … Read more
If you want to study termination properties in depth, programs using successor-arithmetics are an ideal study object: You know a priori what they should describe, so you can concentrate on the more technical details. You will need to understand several notions. Universal termination The easiest way to explain it, is to consider Goal, false. This … Read more
Well for one thing, the name should be more declarative, like equality_truth/2.
The following is based on the reification of term equality/inequality. First, we first define list_memberd_t/3, which behaves just like the memberd_truth/3 but has a different argument order: list_memberd_t([] ,_,false). list_memberd_t([Y|Ys],X,Truth) :- if_(X=Y, Truth=true, list_memberd_t(Ys,X,Truth)). list_memberd_truth(Xs,X,Truth) :- list_memberd_t(Xs,X,Truth). For the sake of brevity, let’s define memberd_t/3 based on list_memberd_t/3: memberd_t(X,Xs,Truth) :- list_memberd_t(Xs,X,Truth). As a parallel to … Read more
When you give something a name, it suddenly becomes more real than it used to be. Discussing something can now be done by simply using the name of the concept. Without getting any more philosophical, no, there is nothing special about accumulators, but they are useful. In practice, going through a list without an accumulator: … Read more
Hoogle was not very useful, but Hayoo is! foldcmpl so this is a special form of fold for a list, but it does not apply length list times but one time less. isSortedBy is not entirely general in its name, but in its signature. Maybe insisting on the most general name is not that helpful. … Read more