如何在GNU Prolog中实现忽略下划线变量的全异列表检查谓词

Let's fix this step by step. Your original code has a couple of issues that are causing it to fail:

• Syntax errors: Clauses like unique([_,[]]). and unique([T,Q]) don't use Prolog's correct list recursion structure. You need to use [Head|Tail] to split a list into its first element and the remaining elements, not [Head, Tail] (which represents a list with exactly two elements).
• Logical gaps: Your current logic only checks if the current element exists in the immediate tail, but doesn't account for non-variable elements later in the list that might duplicate earlier non-variable elements—even if anonymous variables are in between.

Solution 1: Filter First, Then Check Uniqueness #

A clean approach is to first filter out all anonymous/free variables from the list, then verify that the remaining non-variable elements are all distinct. This separates concerns and makes the logic easier to follow.

First, define a helper predicate to filter non-variable elements:

% Filter out free variables from a list, keeping only non-variable elements
filter_non_vars([], []).
filter_non_vars([Head|Tail], [Head|FilteredTail]) :-
    \+ var(Head),  % Keep the element if it's not a free variable
    !,             % Cut to avoid backtracking to the next clause
    filter_non_vars(Tail, FilteredTail).
filter_non_vars([_|Tail], FilteredTail) :-
    % Skip free variables entirely
    filter_non_vars(Tail, FilteredTail).

Next, define a predicate to check if all elements in a list are distinct:

% Check that all elements in a list are mutually unique
all_different([]).
all_different([Head|Tail]) :-
    \+ member(Head, Tail),  % Ensure the current element isn't in the rest of the list
    all_different(Tail).

Finally, implement the unique/1 predicate by combining these two:

unique(List) :-
    filter_non_vars(List, NonVarElements),
    all_different(NonVarElements).

Testing the Implementation #

This works perfectly with your test cases in GNU Prolog:

?- unique([3,1,2]).
true.

?- unique([3,1,2,_]).
true.

?- unique([3,1,2,_,_,_]).
true.

?- unique([3,1,2,1]).
false.

?- unique([3,1,2,1,_]).
false.

Solution 2: Combined Recursive Logic #

If you prefer to avoid helper predicates and handle everything in a single recursive predicate, you can do this instead:

unique([]).
unique([Head|Tail]) :-
    var(Head),  % Skip free variables immediately
    !,
    unique(Tail).
unique([Head|Tail]) :-
    % Ensure no non-variable element in the tail matches the current element
    \+ (member(Element, Tail), \+ var(Element), Element = Head),
    unique(Tail).

This version directly checks for duplicates among non-variable elements during recursion, skipping any anonymous variables it encounters. It will also pass all your test cases.

内容的提问来源于stack exchange，提问作者bastien-r