DCG и инверсия списка в Prolog

Я пытаюсь сосчитать число завороты в список. Предикат inversion(+L,-N) унифицирует N к числу инверсий в этом списке. А инверсия определяется как X > Y и X появляется перед Y в списке (если X или Y is 0). Например:

?- inversions([1,2,3,4,0,5,6,7,8],N).
N = 0.

?- inversions([1,2,3,0,4,6,8,5,7],N).
N = 3.

для чего я использую это, список всегда будет иметь ровно 9 элементов и всегда содержать числа 0-8 однозначно.

я совершенно новичок в Prolog, и я пытаюсь сделать это как можно более лаконичным и элегантным; это похоже на DCG вероятно, очень поможет. Я прочитал официальное определение и некоторые учебные сайты, но до сих пор не понимаю, что это такое. Любая помощь будет очень признательна.

13
clpfd list prolog

6 ответов

такие ограничения для конкретных приложений часто могут быть построены с помощью овеществленные ограничений (ограничения, значение истинности которых отражается в переменной 0/1). Это приводит к относительно естественной формулировке, где B-1, если условие, которое вы хотите подсчитать, выполнено:

:- lib(ic).

inversions(Xs, N) :-
    ( fromto(Xs, [X|Ys], Ys, [_]), foreach(NX,NXs) do
        ( foreach(Y,Ys), param(X), foreach(B,Bs) do
            B #= (X#\=0 and Y#\=0 and X#>Y)
        ),
        NX #= sum(Bs)       % number of Ys that are smaller than X
    ),
    N #= sum(NXs).

этот код затмение.

3

вот еще одно решение, которое не оставляет точек выбора с помощью if_/3:

inversions([],0).
inversions([H|T], N):-
   if_( H = 0, 
        inversions(T,N),
        ( find_inv(T,H,N1),inversions(T, N2), N #= N1+N2 )
      ).

find_inv([],_,0).
find_inv([H1|T],H,N1):-
   if_( H1=0,
        find_inv(T,H,N1),
        if_( H#>H1, 
             (find_inv(T,H,N2),N1 #= N2+1),
             find_inv(T,H,N1) 
           )
       ).

#>(X, Y, T) :-
   (  integer(X),
      integer(Y)
   -> ( X > Y
      -> T = true
      ;  T = false
      )
   ;  X #> Y,
      T = true
   ;  X #=< Y,
      T = false
   ).
5

Я не уверен, что DCG будет полезен здесь. Хотя мы обрабатываем последовательность, есть много изучения всего списка в каждой точке при просмотре каждого элемента.

вот подход CLPFD, который реализует "наивный" алгоритм инверсий, поэтому он прозрачен и прост, но не так эффективен, как мог бы быть (это O(n^2)). Существует более эффективный алгоритм (O(N записей n)) с участием разделяй и властвуй подход, который я покажу ниже.

:- use_module(library(clpfd)).

inversions(L, C) :-
    L ins 0..9,
    all_distinct(L),
    count_inv(L, C).

% Count inversions    
count_inv([], 0).
count_inv([X|T], C) :-
    count_inv(X, T, C1),     % Count inversions for current element
    C #= C1 + C2,            % Add inversion count for the rest of the list
    count_inv(T, C2).        % Count inversions for the rest of the list

count_inv(_, [], 0).
count_inv(X, [Y|T], C) :-
    (   X #> Y, X #> 0, Y #> 0
    ->  C #= C1 + 1,         % Valid inversion, count it
        count_inv(X, T, C1)
    ;   count_inv(X, T, C)
    ).

?- inversions([1,2,3,4,0,5,6,7,8],N).
N = 0 ;
false.

?- inversions([1,2,3,0,4,6,8,5,7],N).
N = 3 ;
false.

?-  inversions([0,2,X],1).
X = 1 ;
false.

Он оставляет точку выбора, как вы можете видеть, которую я еще не разобрал.

Вот O(N log n) решение, которое использует алгоритм сортировки/слияния. 
inversion([], [], 0).
inversion([X], [X], 0).
inversion([HU1, HU2|U], [HS1, HS2|S], C) :- % Ensure list args have at least 2 elements
    split([HU1, HU2|U], L, R),
    inversion(L, SL, C1),
    inversion(R, SR, C2),
    merge(SL, SR, [HS1, HS2|S], C3),
    C #= C1 + C2 + C3.

% Split list into left and right halves
split(List, Left, Right) :-
    split(List, List, Left, Right).
split(Es, [], [], Es).
split(Es, [_], [], Es).
split([E|Es], [_,_|T], [E|Ls], Right) :-
    split(Es, T, Ls, Right).

% merge( LS, RS, M )
merge([], RS, RS, 0).
merge(LS, [], LS, 0).
merge([L|LS], [R|RS], [L|T], C) :-
    L #=< R,
    merge(LS, [R|RS], T, C).
merge([L|LS], [R|RS], [R|T], C) :-
    L #> R, R #> 0 #<==> D, C #= C1+D,
    merge([L|LS], RS, T, C1).

вы можете игнорировать второй аргумент, который является отсортированным списком (просто побочный эффект, если все, что вы хотите, это количество инверсий).

4

вот еще одна возможность определить отношение. Во-первых, #</3 и #\=/3 можно определить следующим образом:

:- use_module(library(clpfd)).

bool_t(1,true).
bool_t(0,false).

#<(X,Y,Truth)  :- X #< Y #<==> B, bool_t(B,Truth).
#\=(X,Y,Truth)  :- X #\= Y #<==> B, bool_t(B,Truth).

исходя из этого, if_/3 и (',')/3 предикат inv_t/3 можно определить, что дает true в случае инверсии и false в противном случае, в соответствии с определением, данным OP:

inv_t(X,Y,T) :-
   if_(((Y#<X,Y#\=0),X#\=0),T=true,T=false).

и впоследствии фактическое отношение можно описать так:

list_inversions(L,I) :-
   list_inversions_(L,I,0).

list_inversions_([],I,I).
list_inversions_([X|Xs],I,Acc0) :-
   list_x_invs_(Xs,X,I0,0),
   Acc1 #= Acc0+I0,
   list_inversions_(Xs,I,Acc1).

list_x_invs_([],_X,I,I).
list_x_invs_([Y|Ys],X,I,Acc0) :-
   if_(inv_t(X,Y),Acc1#=Acc0+1,Acc1#=Acc0),
   list_x_invs_(Ys,X,I,Acc1).

таким образом пример запросы, заданные ОП, преуспевают детерминированно:

?- list_inversions([1,2,3,4,0,5,6,7,8],N).
N = 0.

?- list_inversions([1,2,3,0,4,6,8,5,7],N).
N = 3.
4

используя clpfd et automaton / 8 мы можем написать

:- use_module(library(clpfd)).

inversions(Vs, N) :-
             Vs ins 0..sup,
             variables_signature(Vs, Sigs),
             automaton(Sigs, _, Sigs,
                       [source(s),sink(i),sink(s)],
                       [arc(s,0,s), arc(s,1,s,[C+1]), arc(s,1,i,[C+1]),
                        arc(i,0,i)],
                       [C], [0], [N]),
            labeling([ff],Vs).

variables_signature([], []).

variables_signature([V|Vs], Sigs) :-
            variables_signature_(Vs, V, Sigs1),
            variables_signature(Vs, Sigs2),
            append(Sigs1, Sigs2, Sigs).

variables_signature_([], _, []).

variables_signature_([0|Vs], Prev, Sigs) :-
      variables_signature_(Vs,Prev,Sigs).

variables_signature_([V|Vs], Prev, [S|Sigs]) :-
      V #\= 0,
      % Prev #=< V #<==> S #= 0,
      % modified after **false** remark 
      Prev #> V #<==> S,
      variables_signature_(Vs,Prev,Sigs).

примеры :

?- inversions([1,2,3,0,4,6,8,5,7],N).
N = 3 ;
false.

?- inversions([1,2,3,0,4,5,6,7,8],N).
N = 0 ;
false.

?- inversions([0,2,X],1).
X = 1.
3

в SWI-Prolog, с библиотеками совокупность и списки:

inversions(L,N) :-
    aggregate_all(count, (nth1(P,L,X),nth1(Q,L,Y),X\=0,Y\=0,X>Y,P<Q), N).

обе библиотеки загружены автоматически, нет необходимости явно включать их.

если вы хотите что-то более общее, вы можете увидеть пример в библиотеке (clpfd), в разделе автомата, для некоторых полезных идей. Но я бы попытался переписать вашу спецификацию в более простых терминах, используя элемент / 3 вместо nth1 / 3.

редактировать

после @ false comment я попробовал некоторые варианты операторов неравномерности, но ни один из них не смог решить проблемный запрос. Затем я попробовал еще раз с оригинальной идеей, чтобы хорошо использовать элемент / 3. Вот результат:

:- use_module(library(clpfd)).

inversions(L) :-
    L ins 0..8,
    element(P,L,X),
    element(Q,L,Y),
    X #\= 0, Y #\= 0, X #> Y, P #< Q,
    label([P,Q]).

inversions(L,N) :-
    aggregate(count, inversions(L), N) ; N = 0.

последняя строка label([P,Q]) - это ключ к правильному овеществления: теперь мы можем определить значение x.

?- inversions([0,2,X],1).
X = 1.
2