Predicate to match list (all possibilities) with no duplicate integers, have length N, and be within a domain of 1 to N

This is for GNU-Prolog

I'm having trouble getting a certain predicate to work. Its functionality is that it matches a list of integers that have a domain of 1 to N with no duplicates and length N. Basically what I want to do is have this as inputs and outputs:

| ?- row_valid(X, 3).

X = [1, 2, 3] ? ;
X = [1, 3, 2] ? ;
X = [2, 1, 3] ? ;
X = [2, 3, 1] ? ;
X = [3, 1, 2] ? ;
X = [3, 2, 1] ? ;

no

| ?- row_valid(X, 2).

X = [1, 2] ? ;
X = [2, 1] ? ;

no

| ?- row_valid(X, 1).

X = [1] ? ;

no

But right now, this is what is happening:

| ?- row_valid(X, 3).

X = [] ? ;

no

This is probably happening because of the row_valid([], _). predicate I have in the code. However, I can verify that the predicate matches correctly since:

| ?- row_valid([1,2,3], 3).

true ?

yes

Here are the predicates defined. Do you have any suggestions on how I could get this to work the way I want? Thanks for your time.

% row_valid/2: matches if list of integers has domain of 1 to N and is not duplicated
% 1 - list of integers
% 2 - N
row_valid([], _).
row_valid(Row, N) :-
    length(Row, N),                % length
    no_duplicates_within_domain(Row, 1, N),
    row_valid(RestRow, N).

% no_duplicates/1: matches if list doesn't have repeat elements
% 1 - list
no_duplicates([]).        % for empty list always true
no_duplicates([Element | RestElements]) :-
    \+ member(Element, RestElements),        % this element cannot be repeated in the list
    no_duplicates(RestElements).

% within_domain/3 : matches if list integers are within a domain
% 1 - list
% 2 - m开发者_开发知识库in
% 3 - max
within_domain(Integers, Min, Max) :-
    max_list(Integers, Max),
    min_list(Integers, Min).

% no_duplicates_within_domain/3: matches if list integers are within a domain and isn't repeated
% 1 - list
% 2 - min
% 3 - max
no_duplicates_within_domain(Integers, Min, Max) :-
    no_duplicates(Integers),
    within_domain(Integers, Min, Max). 

How about the following?

row_valid(Xs,N) :-
   length(Xs,N),
   fd_domain(Xs,1,N),
   fd_all_different(Xs),
   fd_labeling(Xs).

Running it with GNU Prolog 1.4.4:

?- row_valid(Xs,N).          

N = 0
Xs = [] ? ;

N = 1
Xs = [1] ? ;

N = 2
Xs = [1,2] ? ;

N = 2
Xs = [2,1] ? ;

N = 3
Xs = [1,2,3] ? ;

N = 3
Xs = [1,3,2] ? ;

N = 3
Xs = [2,1,3] ? ;

N = 3
Xs = [2,3,1] ? ;

N = 3
Xs = [3,1,2] ? ;

N = 3
Xs = [3,2,1] ? ;

N = 4
Xs = [1,2,3,4] ?        % ...and so on...

Here is a simple piece of code that does this in SWI-Prolog. I don't know if GNU-Prolog provides between/3 and permutation/2, so maybe it doesn't directly answer your question, but maybe it can still help you further.

row_valid(List, N) :-
    findall(X, between(1, N, X), Xs),
    permutation(Xs, List).

Usage examples:

?- row_valid(List, 0).
List = [].

?- row_valid(List, 1).
List = [1] ;
false.

?- row_valid(List, 2).
List = [1, 2] ;
List = [2, 1] ;
false.

?- row_valid(List, 3).
List = [1, 2, 3] ;
List = [2, 1, 3] ;
List = [2, 3, 1] ;
List = [1, 3, 2] ;
List = [3, 1, 2] ;
List = [3, 2, 1] ;
false.