recursively define object positions like 'above' Prolog - recursion

Question

I need to write a rule that recursively defines when an object is above another object, based on the objects in this picture
For example ?- above(scissors, clock). should return true
this is what I have so far
adjacent_left(clock, rocket).
adjacent_left(rocket, guitar).
adjacent_left(guitar, telephone).
on_top_of(paperclip, clock).
on_top_of(scissors, guitar).
adjacent_right(rocket, clock).
adjacent_right(guitar, rocket).
adjacent_right(telephone, guitar).
underneath(clock, paperclip).
underneath(guitar, scissors).
right_of(Obj1, Obj2):-
adjacent_right(Obj1, Obj2).
right_of(Obj1, Obj3):-
adjacent_right(Obj1, Obj2),
right_of(Obj2, Obj3).
above(Obj1, Obj2):-
on_top_of(Obj1, Obj2).
above(Obj1, Obj3):-
on_top_of(Obj1, Obj2),
above(Obj2, Obj3).

Answer 1

First I would define left_of/2 the same way you have defined right_of/2.
Then there are two cases in the image. The first you have: An object is above another object if it is on top of it.
The second case is object1 is above another object2 if object2 is on the same level as an object that object1 is above.
If you have more than two levels, then you need the third case which you already have: an object1 is above another object3 if object 1 is on top of an object2 that is above object3 .
There are two cases for an object to be on the same level. Either its left_of or right_of.
So:
adjacent_left(clock, rocket).
adjacent_left(rocket, guitar).
adjacent_left(guitar, telephone).
on_top_of(paperclip, clock).
on_top_of(scissors, guitar).
adjacent_right(rocket, clock).
adjacent_right(guitar, rocket).
adjacent_right(telephone, guitar).
underneath(clock, paperclip).
underneath(guitar, scissors).
right_of(Obj1, Obj2):-
adjacent_right(Obj1, Obj2).
right_of(Obj1, Obj3):-
adjacent_right(Obj1, Obj2),
right_of(Obj2, Obj3).
left_of(Obj1,Obj2):-
adjacent_left(Obj1,Obj2).
left_of(Obj1,Obj3):-
adjacent_left(Obj1,Obj2),
left_of(Obj2,Obj3).
same_level(Obj1,Obj2):-
left_of(Obj1,Obj2).
same_level(Obj1,Obj2):-
right_of(Obj1,Obj2).
above(Obj1, Obj2):-
on_top_of(Obj1, Obj2).
above(Obj1, Obj3):-
on_top_of(Obj1, Obj2),
above(Obj2, Obj3).
above(Obj1,Obj3):-
on_top_of(Obj1,Obj2),
same_level(Obj2,Obj3).
I would also recommend renaming predicates to go with the arguments. So above_below/2 instead of above/2 for example.

Answer 2

Firstly, it is useful to have your individual items listed in your fact database, as this allows for more straightforward construction of clauses (but this is just personal preference).
item(clock).
item(rocket).
item(guitar).
item(telephone).
item(scissors).
item(paperclip).
Then, I'd remove redundancy from some of your clauses
adjacent_left(clock, rocket).
adjacent_left(rocket, guitar).
adjacent_left(guitar, telephone).
on_top_of(paperclip, clock).
on_top_of(scissors, guitar).
adjacent_right(X, Y) :- adjacent_left(Y, X).
underneath(X, Y) :- on_top_of(Y, X).
left_of(X, Y) :- adjacent_left(X, Y), !.
left_of(X, Z) :- adjacent_left(X, Y), left_of(Y, Z).
right_of(X, Y) :- left_of(Y, X).
and define a helper predicate
siblings(X, Y) :- left_of(X, Y), !.
siblings(X, Y) :- left_of(Y, X).
Then the above relation is
above(X, Y) :- above(X, Y, []).
above(X, Y, Acc) :- on_top_of(X, Y), !.
above(X, Z, Acc) :- on_top_of(X, Y), above(Y, Z, Acc), !.
above(X, Z, Acc) :- item(Y), siblings(Y, Z), not(member(Y,Acc)), above(X, Y, [Z|Acc]), !.
The accumulator pattern is necessary to avoid a circular logic of "check if a is the sibling of b, then check if b is the sibling of a, etc etc ad infinitum).