小编cod*_*der的帖子

我已经阅读了很多关于Prolog的失败否定的内容,其中Prolog是为了证明\+Goal持有试图证明Goal失败.

这与CWA(近距离世界假设)高度相关,例如,如果我们查询\+P(a)(在哪里P是arity 1的谓词),并且我们没有线索导致证明P(a)Prolog假定(由于CWA)not P(a)如此\+P(a)成功.

从我所搜索的内容来看,这是一种解决经典逻辑弱点的方法,如果我们对此毫无头绪,P(a)那么我们无法回答是否\+P(a)持有.

上面描述的是在Prolog中引入非单调推理的方法.此外,有趣的部分是Clark证明Negation by Failure与经典否定相容/类似仅适用于地面条款.我明白这个例子:

X=1, \+X==1.:应该在Prolog中返回false(在经典逻辑中).

\+X==1, X=1.:应该在经典逻辑中返回false,但是在检查NF的时候它在Prolog中成功,X不受约束,这与classic-Pure Logic不同.

\+X==1.:在X绑定之前,不应该给经典逻辑中的任何答案,但在Prolog中它返回false(可能打破经典逻辑的弱点),这与纯逻辑不相同/兼容.

我的尝试是模拟经典否定,感谢评论中的@false的建议,目前的实施是:

\\+(Goal) :- when(ground(Goal), \+Goal). 

一些测试:

?- \\+(X==1).
when(ground(X), \+X==1).

?- X=1, \\+(X==1).
false.

?- \\+(X==1), X=1.
false. 

我的问题:

以上是对经典否定的正确解释吗？(是否有任何明显的极端情况,它错过了？当使用/ 2时我也关注逻辑纯度,可以安全地假设上面是纯粹的吗??).

嘿伙计,所以我试图创造一些像这样的工作:

?- unpacking([[1], [1,2], [3]], Lst1, NewLst).
NewLst=[1,3]

我这样写的:

unpacking([], Lst1, Lst1).
unpacking([[H]|T], Lst1, NewLst):-
    append([H], Lst2),
    unpacking(T, Lst2, NewLst).
unpacking([_|T], Lst1, NewLst):-
    unpacking(T, Lst1, NewLst).

我知道我做错了什么,但是,我是在Prolog开始所以,需要从我的错误中吸取教训:)

我有一个带有整数和匿名变量的List,我试图找到一个特殊值的索引.问题是我用它nth1/3来找到索引Prolog为匿名变量分配值,因此我也找到了索引.

例如: List = [1,\_,1],我想要的结果是X = 1, X = 3从nth1(X,List,1),而是说之前,我X = 1, X = 2, X = 3.

我正在编写一个Prolog程序clp(fd),并且很难实现我想要的约束之一.

输出是整数列表(长度取决于程序另一部分的输入),其中存在某些互斥的预定义数字对,并且每对中的一个数字必须在输出中.

一个例子:

输出是一个整数列表,每个整数在1到10之间.输出必须包含3或4,但不能同时包含两者.

到目前为止,我有以下,从而限制了它,这样3和4不能同时输出,但它不保证其中之一是在输出中.

mutual2([A], ME1):-
    (A in 3 #==> ME1) #/\ (#\ A in 4 #<== ME1).
mutual2([A, B| Tail], ME1):-
    (A in 3 #==> ME1) #/\ (#\ A in 4 #<== ME1),
    (B in 3 #==> ME1) #/\ (#\ B in 4 #<== ME1),
    mutual2([B|Tail], ME1).

编辑:
运行:

[A,B] ins 2..6, A #< B, mutual2([1,2,B,A,5],M), label([A,B]).

得到:

A = 2,
B = 3,
M = 1 ;
A = 2,
B …

假设我们有以下程序:

human(socrates).
day(tomorrow).
die(X) :- human(X).
may_go_to_school(Y) :- day(Y), 
                       not holiday(Y).

如果我们运行clingo来获取程序的答案集,我们就会得到

Answer: 1
human(socrates) day(tomorrow) die(socrates) may_go_to_school(tomorrow)

我们知道地滚球将首先将所有变量实例化为常数,因此接地后的程序将是:

human(socrates).
day(tomorrow).
die(socrates) :- human(socrates).
may_go_to_school(tomorrow) :- day(tomorrow), 
                              not holiday(tomorrow).

我在Gelfond的书中读到它给出了3个获得答案集的规则:

1. 满足Π的规则.换句话说,如果你相信它的身体,相信一个规则的头.

2. 不要相信矛盾.

3. 坚持"理性原则",其中说:"相信没有你不会被迫相信."

在规则中:

may_go_to_school(tomorrow) :- day(tomorrow), 
                              not holiday(tomorrow).

我们因为失败而得到了否定 not holiday(tomorrow)

如本书所示:

符号not是一种新的逻辑连接,称为默认否定,(或否定为失败); 不是l经常被解读为"不相信我是真的."请注意,这并不意味着l被认为是假的.理所当然,理性推理者既不相信也不相信p否定,这是可以想象的¬p.

然后根据规则1,我应该相信believe in the head of a rule if you believe in its body身体,not holiday(tomorrow).因为我既不相信holiday(tomorrow).也不相信¬holiday(tomorrow).？

根据答案,我应该相信 ¬holiday(tomorrow).

• 那么为什么我们需要这种否定作为失败呢？
• 我们可以只使用经典否定吗？

我知道fork() sys_call从线程调用是一个坏主意.但是,如果线程使用fork()？创建新进程会发生什么？

新进程将是创建线程的主线程的子进程.我认为.

如果其父级首先完成,则新进程将附加到init进程.它的父级是主线程,而不是创建它的线程.

如果我错了,请纠正我.

#include <stdio.h>
#include <pthread.h>

int main () 
{
     thread_t pid;
     pthread_create(&(pid), NULL, &(f),NULL);
     pthread_join(tid, NULL);
     return 0;
}

void* f()
{
     int i;
     i = fork();

     if (i < 0) {
         // handle error
     } else if (i == 0) // son process
     {
          // Do something;
     } else {
          // Do something;
     }
 }

我有一长串数字，如下所示。我想找到每个数字的频率分布，但我无法使用 Counter 函数来获取每个项目的频率，因为它们是整数，并且我收到错误，它是不可迭代的，因此我无法将列表转换为字符串。我检查了类似的问题，但它们对我不起作用。

data=[1.0, 2.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 15.0, 0.0, 0.0, 0.0, 0.0, 3.0, 1.0, 1.0, 1.0, 0.0, 0.0, 1.0, 7.0, 1.0, 0.0, 0.0, 4.0, 3.0, 3.0, 1.0, 1.0, 2.0, 4.0, 0.0, 1.0, 7.0, 2.0, 1.0, 1.0, 4.0, 1.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 2.0, 3.0, 2.0, 1.0, 1.0, 0.0, 1.0, 1.0, 1.0, 0.0, 10.0, 0.0, 1.0, 1.0, 0.0, 0.0, 1.0, 2.0, 3.0, 0.0, 3.0, 2.0, 11.0, 0.0, 5.0, 2.0, 0.0, 1.0, 2.0, 1.0, 8.0, …

我是 Prolog 的新手，但我掌握了基础知识。我在读取文件时遇到问题。这是我的文件：

16
78 45 12 32 457 97 12 5 731 2 4 55 44 11 999 7 

我想阅读它，以便将字符作为数字取回。第一行是第2行的数字数量，问题是：

1) 如何在空格或新行字符上拆分它们

2）它们必须是数字：32，而不是字符串：“32”

我正在使用 SWI-Prolog。

我试图解决这个问题:"在给定的链接列表中排列元素,使得所有偶数都放在奇数之后.各元素的顺序应保持相同."

这是我正在使用的代码:

class Node<T> {
    T data;
    Node<T> next;
    Node(T data) {
        this.data = data;
    }
}

这是主要逻辑:

static Node<Integer> sortOddEven(Node<Integer> head) {
    if(head == null || head.next == null) {
        return head;
    }

    Node<Integer> middle = getMiddle(head);
    Node<Integer> nextOfMiddle = middle.next;

    middle.next = null;

    Node<Integer> temp1 = sortOddEven(head);
    Node<Integer> temp2 = sortOddEven(nextOfMiddle);

    Node<Integer> sortedList = sortOddEvenMerger(temp1, temp2);
    return sortedList;
}

static Node<Integer> sortOddEvenMerger(Node<Integer> head1, Node<Integer> head2) {
    Node<Integer> head3 = null, tail3 = null;

    if(head1.data.intValue()%2 != 0) {
        head3 …

我正在尝试编写一个谓词,如果变量X和谓词f(X)都是输入列表的元素,则返回1,如果L缺少其中一个,则返回0.

这就是谓词应该做的事情:

?- f_in_list([X, f(X)], Val).
  should return Val = 1

?- f_in_list([X, f(Y), Z], Val).
  should return Val = 0, as X and Y are different variables.

我写了这个简单的代码:

f_in_list(L, 1) :-
    member(X, L),
    member(f(X), L),
    !.
f_in_list(_, 0).

我的问题是Prolog总是试图统一输入变量,所以它分别返回X = f(X)和X = f(Y).
我试图用来dif(X, f(X))绕过这个问题,但即使这样也行不通.Val如果列表包含至少两个元素,则始终为1.

有没有办法将变量转换为原子或字符串,所以Prolog无法统一变量？或者更好的是,有没有办法阻止同名变量的统一？