enriquepablo 0.1.0b4

词汇

Terms构造的主要构建块是词汇。

首先，有一些预定义的词汇：word（词）、verb（动词）、noun（名词）、number（数）、thing（事物）和exist（存在）。

新词汇是通过与现有词汇相关联来定义的。

可以在词汇对之间建立两种关系。

如下所示，这些关系在形式上类似于集合论关系“是元素的”和“是子集的”。

在英语中，我们表达第一种关系为“是类型的”，在Terms中则表示为

word1 is a word2.

因此，我们会说word1是类型word2，用word2定义word1（因此word2必须之前已定义，或为预定义）。第二种关系用英语表示为“是子类型”，在Terms中表示为

a word1 is a word2.

因此，我们会说word1是word2的子类型，也是用word2定义word1。在预定义词汇中，这些关系如下

word is a word.
verb is a word.
a verb is a word.
noun is a word.
a noun is a word.
thing is a noun.
a thing is a word.
exist is a verb.
a exist is a word.
number is a word.
a number is a word.

要定义一个新词汇，您需要将其与一个现有词汇建立关系。例如

a person is a thing.
a man is a person.
a woman is a person.
john is a man.
sue is a woman.

这些关系由2个隐式规则决定结果

A is a B; a B is a C -> A is a C.
a A is a B; a B is a C -> a A is a C.

因此，从所有上述内容中，我们得到例如以下内容

thing is a word.
person is a word.
person is a noun.
john is a word.
a man is a thing.
john is a thing.
sue is a person.
...

使用词汇，我们可以构建事实。事实由一个动词和任意数量的（标记的）对象组成。

动词是特殊词汇，因为它们决定了与它们一起构建的事实的修饰符。这些修饰符是词汇，并且有标签。要定义一个新动词，您首先提供一个祖先动词（或由冒号分隔的一系列祖先动词），然后是动词在事实中可以接受的修饰符词汇的类型，并与其标签关联。例如

to love is to exist, subj a person, who a person.

这可以读作：love被定义为存在的一个子类型，当它用于事实时，它可以接受一个类型为person的主语和一个标记为who的对象，该对象也是类型为person。

基本动词是exist，它只定义一个类型为thing的subj对象。还有更多预定义的动词，我们将通过解释Terms中时间的处理来了解它们的使用。

事实

事实是通过动词和若干对象构建的。它们用括号给出。例如，我们可能有一个如下的事实

(love john, who sue).

subj对象是特殊的：所有动词都有它，在事实中它不标记为subj，它只是在动词后面直接替换主语的位置。

动词继承其祖先对象类型。基本动词exist只接受一个对象，subj，类型为word，所有其他动词都继承了这个类型。因此，如果我们定义一个动词

to adore is to love.

它将有一个类型为 person 的 who 对象。如果 adore 提供了新的对象，它将被添加到继承的对象中。一个新的动词可以覆盖继承的对象类型，以提供原始对象类型的子类型（就像我们上面用 subj 做的那样；subj 预定义为类型 word。）

事实是单词，“一等公民”，可以在任何可以使用单词的地方使用。事实是类型 exist 的单词，也是类型 <verb>，其中 <verb> 是构建事实所用的动词。因此，我们的事实实际上是 (love john, who sue) is a love 的句法糖。

事实中的对象可以是任何类型（一个 word，一个 verb，一个 noun，一个 thing，一个 number）。此外，它们也可以是事实（类型 exist）。因此，如果我们定义一个动词

to want is to exist, subj a person, what a exist.

然后我们可以构建以下事实

(want john, what (love sue, who john)).

确实如此

(want john, what (want sue, what (love sue, who john))).

规则

我们可以构建规则，这些规则产生新的事实。一个规则有两个事实集，条件（首先给出）和结果。每个事实集中的事实由分号（合取）分隔，符号 ->（蕴含）将条件与结果分开。一个简单的规则可能是

(love john, who sue)
->
(love sue, who john).

知识库中的事实与规则的条件相匹配，当一个规则的所有条件都通过一致的事实匹配时，结果将被添加到知识库中。匹配事实之间所需的一致性涉及条件中的变量。

我们可以在规则中使用变量。它们是逻辑变量，仅用于匹配单词，其作用域仅限于使用的规则。我们通过将单词的类型名称大写并附加任意数量的数字来构建变量。例如，一个变量 Person1 将匹配任何人，例如 sue 或 john。有了变量，我们可以构建一个规则

(love Person1, who Person2)
->
(love Person2, who Person1).

如果我们有这个规则，并且还有 (love john, who sue)，系统将得出结论 (love sue, who john)。

变量可以匹配整个事实。例如，使用我们定义的动词，我们可以构建一个规则

(want john, what Exists1)
->
(Exists1).

有了这个，以及 (want john, what (love sue, who john)).，系统会得出结论 (love sue, who john)。

匹配动词（或名词）的变量具有特殊形式，即在动词（或名词）名称之前加前缀，以便匹配前缀动词（或名词）的子类型。例如，使用我们上面的单词，我们可能制定一个规则

(LoveVerb1 john, who Person1)
->
(LoveVerb1 Person1, who john).

在这种情况下，LoveVerb1 将匹配 love 和 adore，因此 (love john, who sue) 和 (adore john, who sue) 都会产生结论 (love sue, who john) 或 (adore sue, who john)。

为了更详细地说明，我们可以定义一个新的动词

to be-allowed is to exist, subj a person, to a verb.

和一个规则

(want Person1, what (LoveVerb1 Person1, who Person2));
(be-allowed Person1, to LoveVerb1)
->
(LoveVerb1 Person1, who Person2).

然后，(be-allowed john, to adore) 将允许他爱慕但不得爱。

我们可以使用单词变量，例如 Word1，它将匹配任何单词或事实。

在条件中，我们可能想匹配整个事实，同时匹配其某些组成部分单词。为此，我们将事实名称与事实变量名称一起前置，并用冒号分隔。这样，上面的规则将变为

(want Person1, what Love1:(LoveVerb1 Person1, who Person2));
(be-allowed Person1, to LoveVerb1)
->
(Love1).

整数

整数是数字类型。我们并不定义数字，只是使用它们。在Python中，任何可以被转换为整数类型的字符序列在Terms中都是数字，例如：1。

数字变量仅由一个大写字母和一个整数组成，如N1、P3或F122。

Python式条件

在规则中，我们可以添加一个部分来测试条件或从现有变量中生成新变量。这主要是为了测试算术条件和执行算术运算。这部分位于条件之后，在符号<-和->之间。测试结果被放置在一个名为condition的Python变量中，如果评估结果为False，则规则不会被触发。

为了举例说明，让我们假设一些新术语

to aged is to exist, age a number.
a bar is a thing.
club-momentos is a bar.
to enters is to exist, where a bar.

现在，我们可以构建一个如下规则

(aged Person1, age N1);
(want Person1, what (enters Person1, where Bar1))
<-
condition = N1 >= 18
->
(enters Person1, where Bar1).

如果我们有

(aged sue, age 17).
(aged john, age 19).
(want sue, what (enters sue, where club-momentos)).
(want john, what (enters john, where club-momentos)).

系统将（仅）得出结论：(enters john, where club-momentos)。

否定

在Terms中，我们可以使用两种否定：经典否定和失败否定。

经典否定

任何事实都可以通过在其动词前添加!来进行否定。

(!aged sue, age 17).

一个否定的事实与非否定的一个是相同的。只有否定的才能与否定的匹配，并且它们可以在规则中被断言或使用。否定的唯一特殊之处在于，系统不会允许同一知识库中的事实及其否定同时存在：它将警告矛盾，并拒绝有问题的事实。

失败否定

在Python式条件下，我们可以使用一个函数runtime.count，它接受一个字符串参数，一个Terms事实（可能包含变量），该函数将返回数据库中与给定事实匹配的事实数量。我们可以使用它来测试知识库中是否存在任何给定事实，从而实现失败否定。

在count函数上需要注意一些事项。如果一个事实被输入，可能会匹配一个Python式count条件，它本身永远不会触发任何规则。规则是通过匹配正常条件的事实来激活的；而Python式条件只能允许或中止这些激活。换句话说，当事实被添加时，它会与所有规则中的所有正常条件进行比较，如果它激活了任何规则，则会测试Python式条件。这个行为的一个例子可以在这里看到。如果你检查前面的链接中的本体，你会看到它显然是错误的；这就是我为什么说需要小心。计数发生在时间上，不建议在不激活时间的情况下使用它。

时间

在我们迄今为止描述的单调经典逻辑中，表示物理时间非常简单：你只需要将一个time类型的number对象添加到任何时间动词中即可。然而，为了表示现在时间，即一个变化的、被区分的时间点，这种逻辑就不够了。我们需要使用一些非单调技巧来实现这一点，这些技巧在Terms中作为某种时态逻辑实现。这种时态逻辑可以在设置文件中激活

[mykb]
dbms = postgresql://terms:terms@localhost
dbname = mykb
time = normal
instant_duration = 60

如果它被激活，会发生几件事情。

首先，系统开始跟踪当前时间：它有一个整数寄存器，其值表示当前时间。该寄存器每 config['instant_duration'] 秒更新一次。对于时间设置中的 mode，有3个可能的值：如果设置为 none，则不对时间进行任何操作。如果设置为 normal，则在更新时将系统当前时间加1。如果设置为 real，则使用 Python 的 import time; int(time.time()) 更新系统当前时间。

其次，我们不是定义扩展 exist 的动词，而是使用两个新的动词 occur 和 endure，这两个动词都是 exist 的子类型。这些新动词有特殊的 number 对象：occur 有一个 at_ 对象，而 endure 有一个 since_ 和一个 till_ 对象。

第三，系统开始维护两个不同的事实集，一个用于现在，一个用于过去。所有推理都在现在事实集中进行。当我们用这些动词添加事实时，系统会自动将 at_ 对象添加到 occur 中，将 since_ 对象添加到 endure 中，这两个对象的值都是其“现在”寄存器的值。 endure 事实的 till_ 对象被保留为未定义。我们从不明确设置这些对象。每次更新时间时，所有 occur 事实都会从现在事实集中移除并添加到过去事实集中，从而停止产生后果。如果我们在查询中指定了 at_ 对象，则查询 occur 事实将转到过去事实集，如果没有提供 at_ 对象，则转到现在。对于 endure 事实也是如此，将 at_ 替换为 since_。我们可以这样说，现在事实集中的 endure 事实是现在进行时态。

当我们激活时态逻辑时，第四件事发生的是，我们可以在规则的后果中使用一个新的谓词 finish。这个动词的定义如下

to finish is to exist, subj a thing, what a exist.

当具有这种后果的规则被激活时，它会从现在事实集中获取提供的 what 事实，将其添加一个 till_ 对象，其值为当前时间，并将其从现在事实集中移除，并添加到过去事实集中。

还有一个时态动词 exclusive-endure，它是 endure 的子动词。 exclusive-endure 的特殊性在于，每当带有此类动词的事实被添加到知识库中时，任何具有相同主语和动词的先前现在事实都会被 finish。

还有一个由 occur 派生出来的动词 happen，它的特殊性在于，当一个事实作为其他事实的后果被添加时，并且是用从 happen 派生的动词构建的，它将通过管道反馈给添加事实的用户，以便添加产生后果的事实。

查询

查询是由分号分隔的事实集合，可以包含或不含变量。如果查询不包含变量，则答案将为存在的事实为true，不存在的事实为false。要确定一个事实是否被否定，我们必须查询其否定形式。

如果我们把变量包含在查询中，我们将获得所有产生true查询的变量替换，以字符串映射的json列表的形式。

然而，我们不能添加特殊的约束，就像我们可以在具有Python条件规则的约束中做的那样。

一些技术备注。

• 我展示了多种不同类型的变量，用于事物、动词、数字和事实。但术语背后的逻辑是一阶的，只有一种个体，变量类型的激增只是语法糖。例如Person1相当于“对于所有x，x是一个人且x...”。LoveVerb1相当于“对于所有x，一个x是一个爱且x...”。

• 系统的设计使得添加新事实（及其后果）和查询事实都应独立于知识库的大小。唯一依赖数据大小的地方是在算术条件下，因为目前数字对象没有被作为索引。

• 规则的Python部分在具有 locals 中的 condition 变量和空字典的全局中的字典上执行。我们可以添加我们喜欢的任何内容作为全局变量；例如，numpy。