where do i even start with this prolog program?

Question

I Took the time to translate it properly
Four people are in front of you: a male magician, a female magician, a wizard
and a witch. Each person has a bag of one or more coins.
The coins are made of bronze, copper, brass or tin.
Which bag contains the fewest coins? Given that:

1 - There are no two bags of identical content.
2 – In a bag, there cannot be two of the same coins.
3 - A bag can contain either one, two or four coins.
4 - The sorcerer and the male magician each have a coin that
none of the other three have.
5 - All bags without a brass coin contain a bronze coin.
6 - All bags without tin coins do not contain a bronze coin either.
Create a Prolog program using depth-first search to find a solution
to this problem
I don't know where to go from here

coin(bronze).
coin(copper).
coin(brass).
coin(tin).
% 5: All bags without a brass coin contain a bronze coin.
hint_1(B) :- \+ \+ ( memberchk(brass, B) ; memberchk(bronze, B) ).

% 6: All bags without tin coins do not contain a bronze coin either.
hint_2(B) :- \+ ( \+ memberchk(tin, B), memberchk(bronze, B) ).

unique_coin(Us, Bags) :-
        member(U, Us),
        \+ (member(Bag, Bags), memberchk(U, Bag)).
bag(Cs) :-
        % 3: A bag can contain either one, two or four coins
        member(L, [1,2,4]), length(Cs, L),
     % 2: In a bag, there cannot be two of the same coins.
        foldl(ascending_coin, Cs, _, _).

ascending_coin(C, Prev, C) :-
        coin(C),
        Prev @< C..

 %All bags are different
all_dif([]).
all_dif([L|Ls]) :-
        maplist(dif(L), Ls),
        all_dif(Ls).

bags(Bs) :-
        Bs = [MM,FM,Wizard,Witch],
        maplist(bag, Bs),
        % 1: There are no two bags of identical content
        all_dif(Bs),
        % 4: The Wizard and the male magician each have a unique coin.
             unique_coin(Wizard, [MM,FM,Witch]),
        unique_coin(MM, [FM,Wizard,Witch]),
        maplist(hint_1, Bs),
        maplist(hint_2, Bs).

Answer 1

Here is my attempt at a solution. It seems to work, but I'm not very well practiced with these kinds of puzzles. Comments with #n indicate that the code on that line is meant to address rule n from your puzzle.

Edit: I've updated my code to incorporate two better ideas form yours:

1. I defined not_member/2, so I can maplist the check for unique items over the other lists. This is a compromise between generality and your unique_coin/2. Although your unique_coin/2 might just be a better option.
2. Following you, I translated my conditionals (enforcing the "if a list doesn't have a brass coin..." rules) into disjunctions.

---

bag_with_fewest_coins(Answers) :-
    Bags = [A, B, C, D],                                 % there are four bags...
    maplist(coin_bag, Bags),                             % ... of coins
    is_set(Bags),                                        % #1
    member(MemA, A), maplist(not_member(MemA), [B,C,D]), % #4
    member(MemB, B), maplist(not_member(MemB), [A,C,D]), % #4
    predsort(compare_lengths, Bags, [Answer|_]). % Answer is shortest list.

not_member(X, Ys) :-
    \+ member(X, Ys).

%% To be used with predsort/3:
compare_lengths(Comp, A, B) :-
    length(A, LenA), length(B, LenB),
    compare(Comp, LenA, LenB).         % Per @mat's suggestion in comments.

coin_bag(Bag) :-
    Coins = [bronze, copper, brass, tin],          % types of coins
    member(Len, [1,2,4]), length(Bag, Len),        % #3
    set_subset(Coins, Bag),                        % #2
    (member(brass, Bag) ; member(bronze, Bag)),    % #5
    (member(tin, Bag)   ; \+ member(bronze, Bag)). % #6

% Taken form gusbro's SO answer: http://stackoverflow.com/a/4917016/1187277
% For the purposes of this predicate, each element of Set is thought of as
% distinct, qua differentiable entity, regardless of whether it would unify,
% equate with, or otherwise match another element in Set.
set_subset([], []).
set_subset([X|Set], [X|Subset]) :-
    set_subset(Set, Subset).
set_subset([_|Set], Subset) :-
    set_subset(Set, Subset).

Then, as per @mat's advice in the comments, we can use set_of/3 to be sure that we collect all distinct answers:

?- setof(B, bag_with_fewest_coins(B), Answers).
Answers = [[brass]].

Which shows that there is only one unique answer.

---

These tips pertained to a previous version of the question. I left them in case they are helpful to someone in the future:

It is helpful to use very descriptive names for rules and facts. rule is not helpful in that it tells us nothing about what kind of rule we're describing. In Prolog, anything of the form <head> :- <body>. is a rule, so we know something is a rule just based on its syntax. That frees us up to name our rules something descriptive, e.g., bag_contents.

Some of your rules don't make much sense to me, and I think this is because you're slightly misunderstanding what the expressions are in Prolog. So here are some pointers on your rules:

I expect you mean this rule to say "M2 is the first element of a list and it is a either a list with length 2, or a list with length 4":

rule(M2,[M2|_]):- length(M2,X), X=2; X = 4.

But it actually says "M2 has length X and X = 2, or X = 4", and this is because the precedence of th ;/2 operator is greater than that of the ,/2 operator. Thus, you need to use parenthesis to group the expressions in the right way—like so: length(M2,X), (X=2; X = 4).

The second disjunct of this rule will never succeed:

rule([A|B]):- length(A,Y), Y= 1; Y = 2, Y=4, rule(B).

Because the second part (after the ;) reads "Y = 2 and Y = 4 and rule(B)", but if Y = 2 then \+ Y = 4, so it will always fail.

So, my recommendation for further progress is to give your rules descriptive, distinct names, correct the flawed logic in some clauses, and try setting up cases where you can test rules in the top level as you go.

Answer 2

Try http://swish.swi-prolog.org/ this will work.. there maybe some problem SWI-Prolog desktop edition. The desktop veriosn can't check build in memberchek and foldl function.. hope this helps