带约束的 Prolog 查询返回 false，但有答案

Question

我正在尝试编写一个 prolog 程序来确定我可以在大学课程目录中选择哪门课程。 每门课程都有一个唯一的代码，如cs180，每门课程可能有一些必修课，这意味着必修课必须在注册本课程之前完成。

假设课程不存在循环依赖，大学所有课程形成一个没有循环的有向图。

req(ma262, [ma261,ma182,ma174,ma271,ma27101,ma172,ma263]).
req(ma351, [ma174,ma172,ma182,ma261,ma271,ma27101,ma263]).
req(ma366, [ma351,ma265]).
req(ma341, [ma174,ma172,ma182,ma261]).
req(ma440, [ma35301]).
req(ma35301, [ma265,ma351]).
req(cs314, [ma262,ma265,ma350,ma351]).
req(cs314, [cs180,cs158,cs177,cs159]).
ok(ma172).
ok(cs180).

在这个程序中， req(A,B)表示：要注册 class A，我必须至少完成 B 类列表中的一门课程。如果有多个要求陈述，则必须满足所有要求。 例如，要注册cs314 ，我需要从两个列表中完成一门课程。 ok/1表示我已经完成了课程。

然后我将一个valid scheme定义为一个课程列表，这样列表中的每个 class 要么

1. 完成，或
2. 列表中的其他一些类满足其要求。

例如， [ma172]是一个有效的方案，因为它已完成。 [ma172,ma262]是一个有效的方案，因为ma262可以满足ma172的要求。

这是我的代码。

valid(Cs):-
    is_set(Cs), /*Cs is distinct*/
    maplist({Cs}/[C]>>( /*for each class in Cs*/
                      ok(C); /*either completed, or meets requirements*/
                      (setof(P,req(C,P),Ps), /*get all requirements*/
                       maplist({Cs}/[L]>>( /*check all requirements*/
                                         member(X,L),
                                         (member(X,Cs);ok(X))
                                         
                                         ),Ps)
                      )),Cs).

当我查询?- valid(N)时， prolog 只返回[]然后返回false 。 然而，这些例子是正确的：

?- valid([ma366,ma351])
   true
?- valid([ma366,ma351,ma172])
   true

我不知道为什么求解器不能正常工作。 如果我的代码打破了单调性，你想指出在哪里？ 我应该如何更改我的代码以使其正常工作？

Answer 1

根据上下文，我假设您使用的是 SWI-Prolog。 SWI 的is_set/1谓词不是很合乎逻辑：

?- Set = [a, b, c], is_set(Set).
Set = [a, b, c].

?- is_set(Set), Set = [a, b, c].
false.

这是您的代码的主要问题，因为调用valid(Cs)将使用自由变量Cs调用is_set(Cs) ，这将失败：

?- is_set(Cs).
false.

解决此问题的一种简单方法是接受is_set/1不合逻辑并将调用移至定义的末尾。 从操作上讲，这意味着您的大maplist目标将生成大量非集合，然后您对其进行测试并丢弃。

更好的方法是利用dif/2约束的逻辑行为。

我们可以定义：

nonmember_of(_X, []).
nonmember_of(X, [Y | Ys]) :-
    dif(X, Y),
    nonmember_of(X, Ys).

其行为类似于：

?- nonmember_of(X, [A, B, C]).
dif(X, C),
dif(X, B),
dif(X, A).

并基于此：

alldif([]).
alldif([X | Ys]) :-
    nonmember_of(X, Ys),
    alldif(Ys).

它可以更好地替代is_set/1 ：

?- alldif([A, B, C]).
dif(A, C),
dif(A, B),
dif(B, C).

?- Set = [a, b, c], alldif(Set).
Set = [a, b, c] ;
false.

?- alldif(Set), Set = [a, b, c].
Set = [a, b, c] ;
% nontermination, but it's better than nothing

也可以与完全自由的参数一起使用：

?- alldif(Xs).
Xs = [] ;
Xs = [_2154] ;
Xs = [_2604, _2610],
dif(_2604, _2610) ;
Xs = [_2902, _2908, _2914],
dif(_2902, _2914),
dif(_2902, _2908),
dif(_2908, _2914) ;
Xs = [_3320, _3326, _3332, _3338],
dif(_3320, _3338),
dif(_3320, _3332),
dif(_3320, _3326),
dif(_3332, _3338),
dif(_3326, _3332),
dif(_3326, _3338) ;

鉴于此，您可以使用alldif作为原始定义中is_set的替代品，并且您将能够生成答案：

?- valid(Courses).
Courses = [] ;
Courses = [ma172] ;
Courses = [cs180] ;
Courses = [ma262] ;
Courses = [ma341] ;
Courses = [ma351] ;
Courses = [ma172, cs180] ;
Courses = [ma172, ma262] ;
Courses = [ma172, ma262] ;
Courses = [ma172, ma341] .

?- length(Courses, 5), valid(Courses).
Courses = [ma172, cs180, cs314, ma262, ma341] ;
Courses = [ma172, cs180, cs314, ma262, ma341] ;
Courses = [ma172, cs180, cs314, ma262, ma351] ;
Courses = [ma172, cs180, cs314, ma262, ma351] .

请注意，这里有一些重复。 另请注意，如果您要枚举所有有限多个解决方案，则谓词不会终止，因为alldif会尝试枚举越来越长的列表。 您可以通过将列表的长度限制为课程总数来避免这种情况。

编辑：为了证明使用dif实现这一点不仅仅是“让事情纯粹出于学术兴趣”的练习，而且实际上是一个非常实际的问题，请考虑使用dif的变体的性能：

?- length(Cs, 7), time(valid(Cs)).
% 96,569 inferences, 0.012 CPU in 0.012 seconds (100% CPU, 7886094 Lips)
Cs = [ma172, cs180, cs314, ma262, ma341, ma351, ma35301] .

?- length(Cs, 8), time(valid(Cs)).
% 804,129 inferences, 0.053 CPU in 0.053 seconds (100% CPU, 15080361 Lips)
Cs = [ma172, cs180, cs314, ma262, ma341, ma351, ma35301, ma366] .

?- length(Cs, 9), time(valid(Cs)).
% 6,204,344 inferences, 0.394 CPU in 0.394 seconds (100% CPU, 15766728 Lips)
Cs = [ma172, cs180, cs314, ma262, ma341, ma351, ma35301, ma366, ma440] .

相反，在谓词定义末尾带有is_set的 generate-and-test 根本不能很好地扩展：

?- length(Cs, 7), time(valid(Cs)).
% 84,099,589 inferences, 11.362 CPU in 11.362 seconds (100% CPU, 7402118 Lips)
Cs = [ma172, cs180, cs314, ma262, ma341, ma351, ma35301] .

?- length(Cs, 8), time(valid(Cs)).
% more than 3 minutes, didn't want to wait longer

这是因为 generate-and-test 会生成指数数量的非集合，之后必须拒绝这些集合。 使用dif相应的约束会更早地拒绝非集，只要搜索过程尝试构建甚至是部分非集。