Prolog：“findall”用于有限数量的解决方案

Question

假设我想找到一个谓词的所有解的总和，我就可以使用

findall(L, find(L), Sols),

并且只是对 Sols 的成员求和。

但是，如果 find(L) 有大量（可能是无限的）解决方案，而我只想获得其中的前 10 个呢？

我希望它可以在 B-Prolog 和 ECLiPSe CLP 中使用。

Answer 1

有很多类似的用途，所以也许可以考虑在两者之间定义一些抽象。 例如call_firstn(Goal_0,N)最多在Goal_0的前N答案中Goal_0 。 这反过来可以使用call_nth(Goal_0, Nth)来实现。

findfirstn(N, Template, Goal_0, Instances) :-
   findall(Template, call_firstn(Goal_0, N), Instances).

call_firstn(Goal_0, N) :-
   N + N mod 1 >= 0, % ensures that N >=0 and N is an integer
   call_nth(Goal_0, Nth),
   ( Nth == N -> ! ; true ).

不泄漏且仍可重入的call_nth/2完整实现不能直接在 ISO Prolog 中定义。 您需要诉诸各种低级操作，这些操作通常具有不完整的语义，而这些操作对普通程序员来说更好。

Answer 2

这就是你在 ECLiPSe 中的做法：

find_n(N, Term, Goal, Solutions) :-
    ( N < 1 ->
        Solutions = []
    ;
        record_create(Bag),
        shelf_create(count(N), Counter),
        ( 
            once((
                call(Goal),
                recordz(Bag, Term),
                \+shelf_dec(Counter, 1)   % succeed if enough
            )),
            fail
        ;
            recorded_list(Bag, Solutions)
        )
    ).

这是可重入的并且不会泄漏内存（两者都是基于全局变量或动态谓词的解决方案的问题）。 如果您希望它正确处理模块，则需要进行少量添加。

您当然可以对 Paulo 使用的 assert/retract 原语使用相同的代码结构。

Answer 3

ISO Prolog 中的便携式解决方案：

:- dynamic(find_n_solution/1).
:- dynamic(find_n_counter/1).

find_n(N, Term, Goal, Solutions) :-
    (   set_find_n_counter(N),
        retractall(find_n_solution(_)),
        once((
            call(Goal),
            assertz(find_n_solution(Term)),
            dec_find_n_counter(M),
            M =:= 0
        )),
        fail
    ;   findall(Solution, retract(find_n_solution(Solution)), Solutions)
    ).

set_find_n_counter(N) :-
    retractall(find_n_counter(_)),
    assertz(find_n_counter(N)).

dec_find_n_counter(M) :-
    retract(find_n_counter(N)),
    M is N - 1,
    assertz(find_n_counter(M)).

使用示例谓词find/1 @ChristianF 回答：

| ?- find_n(10, X, find(X), L).
L = [0,1,2,3,4,5,6,7,8,9]
yes

请注意，即使解决方案数量少于所需数量，此解决方案仍将返回解决方案列表。 一些 Prolog 编译器，包括 B-Prolog 和 ECLiPSe，提供了非逻辑全局变量，可用于实现计数器，但这会使解决方案不可移植。

Answer 4

SWI-Prolog 提供内置谓词findnsols/4和 findnsols/5

?- findnsols(5, I, between(1, 12, I), L).
L = [1, 2, 3, 4, 5] ;
L = [6, 7, 8, 9, 10] ;
L = [11, 12].

您可能希望将整个调用包装在一次/1 中，以防止对更多解决方案组进行回溯（例如，如果在上面的示例中您希望 1-5 列表成为您唯一的解决方案）。

?- once( findnsols(5, I, between(1, 12, I), L) ).
L = [1, 2, 3, 4, 5].

Answer 5

我刚刚意识到在 B-Prolog 中，通过制表来做很简单：

%% an example predicate with infinite solutions
%% from ChristianF answer.
find(0).
find(X) :- find(X1), X is X1+1.

:- table find(-).

?- table_cardinality_limit(find/1, 10), findall(X, find(X), L).
L = [0,1,2,3,4,5,6,7,8,9]
yes

Answer 6

需要在 SWI Prolog 中创建一个线程安全的解决方案，我带来了这个：

find_n( N, Solution, Goal, Solutions ) :-
    thread_self( Thread_id ),
    atomic_list_concat( [counter, Thread_id], Counter_flag_key ),
    flag( Counter_flag_key, _, 0 ),

    findall( Solution, (

        call( Goal ),

        flag( Counter_flag_key, X, X ),
        X1 is X + 1,
        flag( Counter_flag_key, _, X1 ),

        ( X1 >= N -> !; true )

    ), Solutions ).

Answer 7

最近添加的 Logtalk 线程引擎 API 或 SWI-Prolog 协程引擎 API 提供了替代解决方案。 例如，使用 Logtalk 线程引擎：

find_at_most(N, Template, Goal, List) :-
    threaded_engine_create(Template, Goal, Engine),
    collect_at_most(N, Engine, List0),
    threaded_engine_destroy(Engine),
    List = List0.

collect_at_most(N, Engine, [X| Xs]) :-
    N > 0,
    threaded_engine_next(Engine, X),
    !,
    M is N - 1,
    collect_at_most(M, Engine, Xs).
collect_at_most(_, _, []).

threaded_engine_create/3谓词计算第一个解，然后挂起等待threaded_engine_next/2谓词检索它。 当检索到一个解时，引擎开始计算下一个解，再次挂起直到它被消耗（当对threaded_engine_next/2谓词的调用发生在一个解准备好之前，这个谓词只是阻塞等待它）。 因此，最多计算N解。

使用 SWI-Prolog 协程引擎的解决方案几乎相同，但没有阻塞语义（在线程引擎版本中），并且预计会更有效，除非通过在应用程序中利用并发性（其他地方）来抵消线程的隐式开销：

find_at_most(N, Template, Goal, List) :-
    engine_create(Template, Goal, Engine),
    collect_at_most(N, Engine, List0),
    engine_destroy(Engine),
    List = List0.

collect_at_most(N, Engine, [X| Xs]) :-
    N > 0,
    engine_next(Engine, X),
    !,
    M is N - 1,
    collect_at_most(M, Engine, Xs).
collect_at_most(_, _, []).

如果您想摆脱辅助谓词中的剪切，这两个 API 还支持_next/2谓词的具体化版本，以及find_at_most/4谓词的替代实现。

最后但并非最不重要的一点是，这里提出的解决方案源自 Paul Tarau 的工作和关于发动机的论文。

Answer 8

我认为您将需要手动实现 findall 中隐含的唯一性条件，即，您需要聚合解决方案，并为每个新的解决方案检查之前尚未选择的解决方案。

这是一个如何工作的示例：

%% an example predicate with infinite solutions
find(0).
find(X) :- find(X1), X is X1+1.

%% myfindall(+Num) holds when there are at least Num different solutions for find
myfindall(Num) :-
    length(L, Num),
    mfa_aux(L, [], All),
    %% now do something with All, e.g., sum it.
    writeln(All).

mfa_aux([], All, All).
mfa_aux([H|T], All, Rtv) :-
    find(H),
    not(member(H, All)), !,
    mfa_aux(T, [H|All], Rtv).


%% Test
%% ?- myfindall(10).

Answer 9

您可以将findall/3与来自库解决方案序列的limit/2结合起来，灵感来自 SQL：

限制（+计数，：目标）
限制解决方案的数量
https://www.swi-prolog.org/pldoc/man?predicate=limit/2

这是一个示例运行：

?- findall(X, limit(3, (repeat, X = 1)), L).
L = [1, 1, 1].

一些 Prolog 系统在他们的曲目中有像limit/2这样的谓词。