CODEWITHSUNDEEP
prolog
krs
krs

Reputation: 25

Prolog: Chaining multiple rules

So I am an absolute beginner in Prolog. I am learning recursion at the moment and this is what I got until now on my task.

dance(start). 
dance(forward(T)) :- dance(T). 
dance(backward(T)) :- dance(T). 

count(start,0,0).                   
count(forward(X),succ(Y),Z) :- count(X,Y,Z).  
count(backward(X),Y,succ(Z)) :- count(X,Y,Z).   

greater(succ(0),0).   
greater(succ(Y),succ(Z)):-greater(Y,Z).`

Summary of what this is supposed to do: There can be dances starting with the "start" and then either forward or backward addition per recursion. In count, I managed to be able to count the amount of forward and backward in a given sequence and save them in the "succ" notation and in greater I want to compare two of such "succ" numbers. And greater shall be true if the first argument is larger (consists of more "succs" than the second argument.

Now my task is to write a new rule "more(X)" which is true if the sequence X (build from dance) has more forward than backward in it. I think I have all the subtasks I need for it but now I am helpless with chaining them together because until now I only had 2 rules with the same amount of parameters but in this case, I got one with one, two, and three parameters. The solution should be something like this

more(X):-greater(Y,Z)

but how do I get my "succ" umbers from "count" to "greater" and the given sequence X to "count"? I do have to change some of the rules otherwise count is never called, right?

So it should be more like more(X):-greater(count(X,Y,Z)) ?

But like this, I would have to change the greater rules to be able to "get" this type of parameter.

Example query ?- more(backward(forward(start))).

false.

?- more(forward(start)).

true.

Upvotes: 1

Views: 444

Answers (2)

TA_intern
TA_intern

Reputation: 2436

Your dance/1 and count/3 predicates seems correct.

If you want "greater" where greater(X, Y) means that X is greater than Y, you'd write:

greater(succ(_), 0).
greater(succ(X), succ(Y)) :- greater(X, Y).

Your solution checks if X is exactly one greater than Y.

Note that nothing is greater than 0.

If you implement more/1 in terms of count/3 and greater/2, you'd write:

more(X) :-
    count(X, Forward, Backward),
    greater(Forward, Backward).

Upvotes: 2

TessellatingHeckler
TessellatingHeckler

Reputation: 29048

So it should be more like more(X):-greater(count(X,Y,Z)) ?

No, you are writing that as if it is Python and greater(count(X,Y,Z)) will call greater(...) on the return from count. Prolog predicates are not function calls, and count(...) does not return anything in that way.

The result of the count is Y and Z. (These names you are using could be clearer). Do the count, and then after, use the Y and Z for something else.

count(X,Y,Z),
greater(Y,Z)

The comma being AND; "this code works if count of X is Y and Z AND Y is greater than Z".

Upvotes: 0

Related Questions