`prime/1`

Question

我甚至不确定这是否可行，但我正在尝试编写一个谓词prime/1，它将其参数限制为素数。

我遇到的问题是我没有找到任何表达方式“将约束应用于小于变量整数的所有整数”。

这是一种不起作用的尝试：

prime(N) :-
    N #> 1 #/\                       % Has to be strictly greater than 1
    (
        N #= 2                       % Can be 2
        #\/                          % Or
        (
            N #> 2 #/\               % A number strictly greater than 2
            N mod 2 #= 1 #/\         % which is odd
            K #< N #/\
            K #> 1 #/\
            (#\ (
                N mod K #= 0         % A non working attempt at expressing:
                                         “there is no 1 < K < N such that K divides N”
            ))
        )
    ).

我希望#\的行为与\+相同，并检查所有可能情况都是错误的，但似乎并非如此，因为此实现会这样做：

?- X #< 100, prime(X), indomain(X).
X = 2 ;    % Correct
X = 3 ;    % Correct
X = 5 ;    % Correct
X = 7 ;    % Correct
X = 9 ;    % Incorrect ; multiple of 3
X = 11 ;   % Correct
X = 13 ;   % Correct
X = 15     % Incorrect ; multiple of 5
…

基本上这与2\/{Odd integers greater than 2}结合。

修改

表示数字 not prime 非常简单：

composite(N) :-
    I #>= J,
    J #> 1,
    N #= I*J.

基本上：“N是复合的，如果它可以用I*J”写成I >= J > 1。

我仍然无法“否定”这些限制。我已经尝试过使用像#==>这样的东西（暗示），但这似乎根本不是一种诡计！ N #= I*J #==> J #= 1适用于复合数字，即使12 = I*J并不意味着必须J = 1！

Answer 1

`prime/1`

这花了我很长一段时间，我确信它远没有效率，但这似乎有用，所以这里什么都没有：

我们为约束prime/1创建了一个自定义约束传播器（this example之后），因此：

:- use_module(library(clpfd)).
:- multifile clpfd:run_propagator/2.

prime(N) :-
    clpfd:make_propagator(prime(N), Prop),
    clpfd:init_propagator(N, Prop),
    clpfd:trigger_once(Prop).

clpfd:run_propagator(prime(N), MState) :-
    (
        nonvar(N) -> clpfd:kill(MState), prime_decomposition(N, [_])
        ;
        clpfd:fd_get(N, ND, NL, NU, NPs),
        clpfd:cis_max(NL, n(2), NNL),
        clpfd:update_bounds(N, ND, NPs, NL, NU, NNL, NU)
    ).

如果N是变量，我们将其下限约束为2，或者如果它大于2则保持其原始下限。

如果基于<{1}} ，那么我们使用此N谓词检查N是否为素数：

prime_decomposition/2

显然，你可以用任何确定性的素数检查算法替换这个谓词。这是一个素数因子分解算法的修改，一旦找到一个因子，它就被修改为失败。

一些查询

prime_decomposition(2, [2]).
prime_decomposition(N, Z) :-
    N #> 0,
    indomain(N),
    SN is ceiling(sqrt(N)),
    prime_decomposition_1(N, SN, 2, [], Z).

prime_decomposition_1(1, _, _, L, L) :- !.
prime_decomposition_1(N, SN, D, L, LF) :-
    (   
        0 #= N mod D -> !, false
        ;
        D1 #= D+1,
        (    
            D1 #> SN ->
            LF = [N |L]
            ;
            prime_decomposition_2(N, SN, D1, L, LF)
        )
    ).

prime_decomposition_2(1, _, _, L, L) :- !.
prime_decomposition_2(N, SN, D, L, LF) :-
    (   
        0 #= N mod D -> !, false
        ;
        D1 #= D+2,
        (    
            D1 #> SN ->
            LF = [N |L]
            ;
            prime_decomposition_2(N, SN, D1, L, LF)
        )
    ).

一些问题

此约束不会像应该的那样强烈传播。例如：

?- prime(X).
X in 2..sup,
prime(X).


?- X in -100..100, prime(X).
X in 2..100,
prime(X).


?- X in -100..0, prime(X). 
false.


?- X in 100..200, prime(X).
X in 100..200,
prime(X).


?- X #< 20, prime(X), indomain(X).
X = 2 ;
X = 3 ;
X = 5 ;
X = 7 ;
X = 11 ;
X = 13 ;
X = 17 ;
X = 19.

?- prime(X), prime(Y), [X, Y] ins 123456789..1234567890, Y-X #= 2, indomain(Y).
X = 123457127,
Y = 123457129 ;
X = 123457289,
Y = 123457291 ;
X = 123457967,
Y = 123457969
…


?- time((X in 123456787654321..1234567876543210, prime(X), indomain(X))).
% 113,041,584 inferences, 5.070 CPU in 5.063 seconds (100% CPU, 22296027 Lips)
X = 123456787654391 .

我们应该知道?- prime(X), X in {2,3,8,16}. X in 2..3\/8\/16, prime(X).和8是不可能的，因为它们是偶数。

我试图在传播器中添加其他约束但是它们似乎比其他任何东西都慢，所以我不确定我是做错了什么，或者更新constaints比检查更慢标签时的优点。

CLPFD约束：是素数

修改

1 个答案:

`prime/1`

一些查询

一些问题