为什么在具体化中将 clpfd 变量分配给实际值？

我正在开发一个 (SWI-)Prolog 程序，该程序使用 CLP(FD) 约束来找到特定问题的解决方案。为此，我碰巧需要两个列表的“未定位”重叠。那是：

• List La长度为A
• List Lb长度为 B
• A > B
• 未定位的重叠列表是La+Lb，其中元素以一对一的方式添加。

但是，我需要Lb有一个可变偏移量（即每个列表的第一个元素不在相同位置La+Lb添加。然而，列出Lb始终在宽度内La。例如：

Be La = [0,1,1,1,1,0,1,1,1] and Lb = [1,2,2].

可能的情况1

(Lb) 1 2 2 . . . . . . ---> offset = 0
(La) 0 1 1 1 1 0 1 1 1
( +) 1 3 3 1 1 0 1 1 1   

可能的情况2

(Lb) . . . 1 2 2 . . . ---> offset = 3
(La) 0 1 1 1 1 0 1 1 1
( +) 0 1 1 2 3 2 1 1 1   

可能的情况3

(Lb) . . . . . 1 2 2 . ---> offset = 5
(La) 0 1 1 1 1 0 1 1 1
( +) 0 1 1 1 1 1 3 3 1   

我想要的是定义offset as a clpfd具有与其关联的特定域的变量。为了计算La+Lb我已经写了谓词overlap/6，如下所示：

overlap([],[],_,_,_,[]) :- !.
overlap([],_, _,_,_,[]) :- !.
overlap(A, [],_,_,_, A) :- !.
overlap(A, _,Os,_,_, A) :- length(A,L), L =< Os, !.
overlap([A|As],[B|Bs],0,Os,S,[A|Ls]) :-  % Os is the actual Offset 
    A #= B #<== S #= Os,                 % S is a clpfd variable
    overlap(As,Bs,0,Os,S,Ls),!.
overlap([A|As],Bs,Acc,Os,S,[A|Ls]) :-
    Acc > 0,
    Acc0 is Acc-1,
    overlap(As,Bs,Acc0,Os,S,Ls),!.

想法是找到La+Lb通过致电overlap/6然后，与indomain(S)，使数字收敛到加法的特定解。我的问题是当 Prolog 到达该行时A #= B #<==> S #= Os, S被分配给Os（案例偏移值），而不是约束A具有具体化的条件。

我是不是疯了，这毫无意义？有没有正确的方法来做我正在尝试的事情？提前致谢！

Edit:这个想法是打电话overlap/6对于其中的每个点S的域，并使用此约束列表来标记适当的S然后。

统一示例：

?- S in 0..2,
   L0 = [0,0,0,0],
   overlap(L0, [1,2], 0, S, L1),
   overlap(L1, [1,2], 1, S, L2),
   overlap(L2, [1,2], 2, S, L).
L = [_G1, _G2, _G3, _G4]

_G1 in 0\/1
_G2 in 0\/1\/2
_G3 in 0\/1\/2
_G4 in 0\/2

_G1 #= 1 #<== S #= 0
_G1 #= 0 #<== S #> 0

_G2 #= 2 #<== S #= 0
_G2 #= 1 #<== S #= 1
_G2 #= 0 #<== S #> 2

_G3 #= 0 #<== S #= 0
_G3 #= 2 #<== S #= 1
_G3 #= 1 #<== S #< 2

_G1 #= 0 #<== S #= 0
_G4 #= 0 #<== S #= 1
_G4 #= 2 #<== S #= 2

Or:

?- S in 0..2,
   L0 = [0,0,0,0],
   overlap(L0, [1,2], 0, S, L1),
   overlap(L1, [1,2], 1, S, L2),
   overlap(L2, [1,2], 2, S, L),
   indomain(S).
S = 0
L = [1, 2, 0, 0]

如果与起始位置重叠S，我们期望连词的约束，以便覆盖所有重叠的位置。例如：

:- use_module(library(clpfd)).

overlap_at(As, Bs, S, ABs) :-
        length(As, L),
        L1 #= L - 1,
        S in 0..L1,
        overlap_at_(As, Bs, S, 0, ABs).

overlap_at_([], _, _, _, []).
overlap_at_([A|As], Bs, S, N0, [AB|ABs]) :-
        overlap_here(Bs, [A|As], [AB|ABs], Conj),
        S #= N0 #==> Conj,
        S #> N0 #==> AB #= A,
        N1 #= N0 + 1,
        overlap_at_(As, Bs, S, N1, ABs).

overlap_here(_, [], _, 1) :- !.
overlap_here([], _, _, 1).
overlap_here([B|Bs], [A|As], [AB|ABs], (AB #= A + B #/\ Rest)) :-
        overlap_here(Bs, As, ABs, Rest).

请注意我如何描述连词overlap_here/4.

示例查询：

?- overlap_at([0,1,1,1,1,0,1,1,1], [1,2,2], 3, ABs).
ABs = [0, 1, 1, 2, 3, 2, _G909, _G912, _G915],
_G909 in inf..sup,
_G912 in inf..sup,
_G915 in inf..sup.

这为您提供了解决方案的很大一部分：所有元素直到并包括重叠根据需要实例化。第三个参数当然也可以是一个变量：尝试例如

?- overlap_at([0,1,1,1,1,0,1,1,1], [1,2,2], S, ABs), 
   indomain(S), writeln(ABs), false.

其结果如下：

[1,3,3,_,_,_,_,_,_]
[0,2,3,3,_,_,_,_,_]
[0,1,2,3,3,_,_,_,_]
[0,1,1,2,3,2,_,_,_]
[0,1,1,1,2,2,3,_,_]
[0,1,1,1,1,1,3,3,_]
[0,1,1,1,1,0,2,3,3]
[0,1,1,1,1,0,1,2,3]
[0,1,1,1,1,0,1,1,2]

我将其余部分作为练习：不受重叠影响的尾随位置需要等于A。另外，您可能想进一步限制重叠的可能位置，我对此保持了相当笼统的态度。