Question

我在教程中遇到了逻辑数字的这种自然数字评估，这让我头疼不已：

natural_number(0).
natural_number(s(N)) :- natural_number(N).

规则粗略地说明：如果N是0，那么它很自然，如果不是，我们会尝试将s/1的内容递归返回到规则，直到内容为{{1那么它是一个自然数，如果不是那么它不是。

所以我测试了上面的逻辑实现，我想，如果我想将0表示为s(0)而将1表示为s(s(0))，那么这是有效的，但是我我希望能够将2转换为s(0)。

我已经想到了基本规则：

所以这是我的问题：如何将s（0）转换为1，将s（s（0））转换为2？

已被回答

编辑：我在实施中修改了基本规则，我接受的答案指向了我：

sToInt(0,0). %sToInt(X,Y) Where X=s(N) and Y=integer of X

所以我现在可以像我想的那样使用它，谢谢大家！

Answer 1

这是另一个使用SWI，YAP或SICStus library(clpfd)“双向”工作的解决方案

:- use_module(library(clpfd)).

natsx_int(0, 0).
natsx_int(s(N), I1) :-
   I1 #> 0,
   I2 #= I1 - 1,
   natsx_int(N, I2).

Answer 2

没问题与meta-predicate nest_right/4同时进行 Prolog lambdas！

:- use_module(library(lambda)).
:- use_module(library(clpfd)).

:- meta_predicate nest_right(2,?,?,?).
nest_right(P_2,N,X0,X) :-
   zcompare(Op,N,0),
   ord_nest_right_(Op,P_2,N,X0,X).

:- meta_predicate ord_nest_right_(?,2,?,?,?).
ord_nest_right_(=,_,_,X,X).
ord_nest_right_(>,P_2,N,X0,X2) :-
   N0 #= N-1,
   call(P_2,X1,X2),
   nest_right(P_2,N0,X0,X1).

示例查询：

?- nest_right(\X^s(X)^true,3,0,N).
N = s(s(s(0))).                 % succeeds deterministically

?- nest_right(\X^s(X)^true,N,0,s(s(0))).
N = 2 ;                         % succeeds, but leaves behind choicepoint
false.                          % terminates universally

Answer 3

这是一项标准任务 - 解决方案在此处：http://www.docstoc.com/docs/82593705/Prolog-%E2%80%93-Family-Tree（第109页）。

关键的见解是s(N)的值是N的值的1+，如果N是0，则值为0。

Answer 4

这是我的：

实际上以列表形式更适合Prolog的峰号。

为什么列出？

之间存在同构
- 长度为N的列表，仅包含s，并终止于空列表
- 具有功能符号s的深度N的递归线性结构以符号zero
- ...所以这些都是相同的东西（至少在此情况下如此）。
没有特别的理由可以依赖19世纪的数学家（即Giuseppe Peano）被认为是“要推理的良好结构”（源于功能）我想象中的应用程序。）
之前已经完成：有人真的使用Gödelization进行编码吗？琴弦？没有！人们使用字符数组。看中了。

我们走吧，中间有个小谜语，我不知道该怎么做。解决（也许使用带注释的变量？）

% ===
% Something to replace (frankly badly named and ugly) "var(X)" and "nonvar(X)"
% ===

ff(X) :- var(X).     % is X a variable referencing a fresh/unbound/uninstantiated term? (is X a "freshvar"?)
bb(X) :- nonvar(X).  % is X a variable referencing an nonfresh/bound/instantiated term? (is X a "boundvar"?)

% ===
% This works if:
% Xn is boundvar and Xp is freshvar: 
%    Map Xn from the domain of integers >=0 to Xp from the domain of lists-of-only-s.
% Xp is boundvar and Xn is freshvar: 
%    Map from the domain of lists-of-only-s to the domain of integers >=0
% Xp is boundvar and Xp is boundvar: 
%    Make sure the two representations are isomorphic to each other (map either
%    way and fail if the mapping gives something else than passed)
% Xp is freshvar and Xp is freshvar: 
%    WE DON'T HANDLE THAT!
%    If you have a freshvar in one domain and the other (these cannot be the same!)
%    you need to set up a constraint between the freshvars (via coroutining?) so that
%    if any of the variables is bound with a value from its respective domain, the
%    other is bound auotmatically with the corresponding value from ITS domain. How to
%    do that? I did it awkwardly using a lookup structure that is passed as 3rd/4th
%    argument, but that's not a solution I would like to see.
% ===

peanoify(Xn,Xp) :-
   (bb(Xn) -> integer(Xn),Xn>=0 ; true),                  % make sure Xn is a good value if bound
   (bb(Xp) -> is_list(Xp),maplist(==(s),Xp) ; true),      % make sure Xp is a good value if bound 
   ((ff(Xn),ff(Xp)) -> throw("Not implemented!") ; true), % TODO
   length(Xp,Xn),maplist(=(s),Xp).

% ===
% Testing is rewarding! 
% Run with: ?- rt(_).
% ===

:- begin_tests(peano).

test(left0,true(Xp=[]))          :- peanoify(0,Xp).
test(right0,true(Xn=0))          :- peanoify(Xn,[]).
test(left1,true(Xp=[s]))         :- peanoify(1,Xp).
test(right1,true(Xn=1))          :- peanoify(Xn,[s]).
test(left2,true(Xp=[s,s]))       :- peanoify(2,Xp).
test(right2,true(Xn=2))          :- peanoify(Xn,[s,s]).
test(left3,true(Xp=[s,s,s]))     :- peanoify(3,Xp).
test(right3,true(Xn=3))          :- peanoify(Xn,[s,s,s]).
test(f1,fail)                    :- peanoify(-1,_).
test(f2,fail)                    :- peanoify(_,[k]).
test(f3,fail)                    :- peanoify(a,_).
test(f4,fail)                    :- peanoify(_,a).
test(f5,fail)                    :- peanoify([s],_).
test(f6,fail)                    :- peanoify(_,1).
test(bi0)                        :- peanoify(0,[]).
test(bi1)                        :- peanoify(1,[s]).
test(bi2)                        :- peanoify(2,[s,s]).

:- end_tests(peano).

rt(peano) :- run_tests(peano).

在Prolog中将peano数字s（N）转换为整数

4 个答案: