Datalog初步理解

去年看的关于datalog写的一篇读书笔记，图片可能无法显示，具体可以查看云笔记的链接分享：
http://note.youdao.com/share/?id=270970f9e5d6f35babba3d022b436fc8&type=note#/

1 介绍
关系代数实际对应于一阶逻辑的子集，其中的操作数限制为有限关系，没有递归和否定的Horn子句。
实现递归查询有多种方法，从逻辑编程的角度来看可以使用演绎数据库中的datalog语言。

语法指用字符组合成合法语句的规则集（字符先通过词法组词或字串，再由代表不同句子成分的词组合成语句），语法定义语言的各种要素间的形式关系，因此给出了语言中各种不同的合法的语句的结构描述。语法只关注句法结构，不管其含义，语义关注其含义。
语义指定一条合法语句的含义。对自然语言来说，短语和语句的含义指相关的对象、思想和经验感觉；而对编程语言来说，语义描述了计算机执行一个程序时所表现的行为。揭示语义的行为包括描述程序输入输出之间的关系，逐步解说程序如何在真实或抽象机器的执行过程等。

三种不同但是等价的方式定义datalog程序语义，以下非正式的简要提及一下
1.模型理论
对于每一个输入实例的datalog程序，均存在一个最小的模型，即能够使程序成立的最少事实集合
2.证明理论
通过规则和基本事实推导出新的事实
两种推导方法：自底向上利用已知事实推出全部可能的新事实和自顶向下从一个要证的事实出发证明其成立。
自顶向下的方式称作消解（Resolution），消解过程中可以有变量的参与。
一些定义：
原子命题中，所描述的对象称为个体，用以描述个体性质或个体间关系的部分称为谓词。
项由下列规则形成：
1.个体常元和个体变元是项
2.若f是n元函数，且t1，t2，……，tn是项，则f(t1，t2，……，tn)是项
3.所有项都有1和2生成
一个谓词公式若至少存在一个解释使其为真，称该公式为可满足式。
（对各种变元用指定的特殊常元去代替，就构成了一个公式的解释）
3.不动点方法
datalog程序的语义可以由不动点方程给出的唯一解定义，通过迭代计算得到不动点，与证明理论中的自底向上方法联系紧密。

2 Datalog语法

定义 2.1：一个datalog规则有如下形式
R1(u1) ← R2(u2), … , Rn(un)
其中n≥1，R1……Rn是关系（谓词），u1……un是符合条件的元祖，每一个出现在u1中的变量，必须至少出现在u2，……，un中一次；一个常量或变量称为项，一个原子公式表示一个关系。（原子公式类似r（a1，……，an），其中ai为项，r为关系名）
注：术语谓词当作等价于术语关系名称。
一个datalog程序是若干个datalog规则的有限集合，R1(u1)是规则头， R2(u2), … , Rn(un)是规则体

给定datalog程序，出现在P中常量的集合记为adom（P）
给出一个数据库实例I，adom(P, I)视作 adom(P) ∪ adom(I)的简写。

定义2.2 给定一个赋值v， R1(ν(u1)) ← R2(ν(u2)), … , Rn(ν(un))是规则R1(u1) ← R2(u2), … , Rn(un)的实例，其中ν(ui)是对元组ui的实例化（为方便起见不区分原规则和赋值后语句的区别）

外延关系：问题中直接给出的关系，只能位于datalog规则体中。所有的外延关系的集合称为外延模式edb（P），对应edb谓词。
内涵关系：由规则计算间接得出的关系，可以位于规则头或规则体中。所有的内涵关系的集合称为内涵模式idb（P），对应idb谓词。

一个datalog程序的语义即为一个从edb（P）中实例到idb（P）中实例的映射。在基于逻辑的语言中，术语谓词经常用来代替术语关系名称

datalog程序与逻辑程序比较：
1.逻辑程序中可以有函数符号，但是datalog规则中不允许函数作为参数，只允许变量和常量。
2.逻辑程序中规则头部出现的变量不一定出现在规则体中。
3.datalog程序假定数据库相对较大同时规则数目相对较小，datalog程序认为是edb中实例到idb中实例的映射，在逻辑程序中一般将基本数据直接并入程序中，逻辑程序本身随着基本数据的变化而改变。
4.逻辑程序可以构造和操作复杂的数据结构

3 模型理论语义

模型理论方法的核心在于将程序视作一组描述问题的一阶逻辑语句，一个能满足这组逻辑语句的数据库实例称作关于这组语句的一个模型，满足这组逻辑语句的数据库实例可能有多个，需要从中找出所需的预定模型。
一个datalog规则ρ : R1(u1) ← R2(u2), … , Rn(un)的关联逻辑语句为∀x1, … , xm(R1(u1) ← R2(u2) ∧ · · · ∧ Rn(un))。

给定实例I，对于每一个实例化后的规则R1(ν(u1)) ← R2(ν(u2)), … , Rn(ν(un))，若R2(ν(u2)), … , Rn(ν(un))在I中时，R1(ν(u1))也在I中，则认为I符合datalog规则ρ，记作 : I |= ρ
datalog程序P的规则对应的全部关联语句的与记作∑P。

datalog程序中规则的关联语句此外还有两种等价的表述形式：
(1).∀x1, … , xq(∃xq+1, … , xm(R2(u2) ∧ · · · ∧ Rn(un)) → R1(u1))
其中 x1, … , xq 是出现在规则头部的变量
(2).∀x1, … , xm(R1(u1) ∨ ¬R2(u2) ∨ · · · ∨ ¬Rn(un))；这一种表述形式是一组文字的析取形式，且此组文字中只有一个正文字，这类的一组文字被称为Horn子句，一个datalog规则可视作若干Horn子句的集合。

定义 3.1
给定datalog程序P和从edb（P）中选取的实例I，从sch（P）中以I为基础扩充选取一个数据库实例,若其满足全部语句∑P，则此数据库实例称作P的一个模型。
最小语句模型不包含多余的符合∑P的事实，即不能删除其中的任何事实，其语义如下：
P为一个datalog程序，并且I为edb（P）中的一个实例。P的模型指的是在sch（P）中选取符合∑P的实例。如果存在P关于I的最小语句模型，则此最小模型记作P（I）。

接下来需要讨论两个问题：
(1).对于给定的datalog程序P和实例I，是否一定存在满足∑P且包含I的最小模型P（I）
(2).假设存在此P（I），如何求出P（I）

P（I）是sch（P）中的一个实例，sch（P）中的实例B（P，I）定义如下：
1.对于edb（P）中的每个关系R，一个事实R（u）在B（P，I）中当且仅当事实R（u）在I中；
2.对于idb（P）中的每个关系R，当任一事实R（u）的常量来自adom（P，I）时，事实R（u）在B（P，I）中。

引理 3.2：给定datalog程序P和从edb（P）中选取的数据库实例I，则B（P，I）是P中包含I的一个模型。
R1(u1) ← R2(u2), … , Rn(un)为P中的任一规则，将规则体中的变量赋值后使得R2(ν(u2)), … , Rn(ν(un))作为事实置于B（P，I）中，再考虑R1(ν(u1))，由于规则体中出现的变量值必须出现在规则头部，故R1(ν(u1))中的变量所赋值后的常量必属于adom（P，I），根据B（P，I）的定义2可知R1(ν(u1))也在B（P，I）中，所以B（P，I）满足∑P，故B（P，I）为P的一个模型；由B（P，I）的定义1知B（P，I）包含I，所以B（P，I）是P中包含I的一个模型。
P（I）是B（P，I）的一个子集。（朴素算法找P（I）：考虑B（P，I）中所有子集，在其中找出包含I关于P的模型，计算它们的交集，但效率较低）

定理 3.3：给定datalog程序P和从edb（P）中选取的数据库实例I，X是P中包含I的模型的集合，则有
1.∩X=P（I）（即∩X为P中包含I的最小模型，所以P（I）是唯一确定的）
2.adom(P(I)) ⊆ adom(P, I)
3.对每一个edb（P）中的关系R，有P(I)(R) = I(R)
证明：
1.B（P，I）∈X，B(P,I)中已经包含有I中关系，所以X非空，
对于P中任一规则r：A1 ← A2, … , An，将规则中变量赋值后实例化为：v（A1） ← v（A2）, … ,v（ An），
先作如下假设：若 v（A2）, … , v（An）均位于∩X中则v（A1）也在∩X中
由假设知 ∩X |= r成立，由规则r的任意性可知∩X满足∑P，因为X中的每个集合均包含I，故∩X也包含I，所以∩X是P中包含I的模型，所以∩X∈X，所以∩X是P关于I的最小模型。
证明假设：取X中任一模型K，则有∩X ⊆ K，由模型的定义知，若v（A2）, … ,v（ An）均位于∩X中时，v（A2）, … ,v（ An）也均位于K中，K | = ΣP，所以A1∈K，上述过程适用于X中的任一元素K，故v（A1）∈∩X，假设成立。
2.由B（P，I）的定义2知adom（B（P，I））=adom（P，I），由引理知B（P，I）为P中包含I的模型，故P（I）⊆ B（P，I），所以adom（P（I））⊆ adom(B(P,I))，故adom(P(I)) ⊆ adom(P, I)成立。
3.对于edb中的任一关系R，由P（I）包含I可得I（R）⊆P（I）（R），同时P（I）为B（P，I）的子集和B（P，I）的定义1可得P（I）（R）⊆B（P，I）（R）=I（R），所以P(I)(R) = I(R)。

可以得到如下结论：
（1）对于给定的datalog程序P和从edb(P)中选取的数据库实例I，P（I）都是存在的。
（2）若给定的程序P和实例I都是有限集，则P（I）也是有限集。
选择最小模型的原因：封闭世界假说（CWA）和需要契合逻辑编程的原因。

4 不动点语义

从不动点理论衍生出针对datalog程序的操作语义 ，模型理论中的P(I)也可由不动点方程的最小解定义。

使用直接后果算子（不动点算子），此算子从已知的事实产生新的事实。
主要求解过程：将所有idb关系赋初值为空，对每个方程式，将当前的idb关系和edb关系带入等式右端，计算出idb关系的新值，不断重复直到idb关系不再发生变化，就得到了最小不动点。（逻辑程序不带否定）
可以视为模型理论中定义的P（I）的一种求解实现。

Let P be a datalog program and K an instance over sch(P). A fact A is an immediate consequence for K and P if either A ∈ K(R) for some edb relation R, or A ← A1, … , An is an instantiation of a rule in P and each Ai is in K. The immediate consequence operator of P , denoted TP , is the mapping from inst(sch(P)) to inst(sch(P)) defined as follows. For each K, TP(K) consists of all facts A that are immediate consequences for K and P .
给定datalog程序P和sch（P）中选取的实例K， 一个事实R(v(u))对于K和P是一个直接后果的定义如下：
R∈edb(P)且R(v(u))∈K或 R(v(u))←A1….An是P中规则的实例且Ai∈ K， i∈ [1,n]。
注：R(v(u))是对R(u)的实例化，直接后果选取了实例K中edb关系事实，以及能由K中实例一次性能够得到的新的事实。

P中的直接后果算子记作Tp
Tp可看成映射: inst( sch(P)) → inst (sch(P))；
对每个K，Tp(K)是给定P和K的全部直接后果的集合，即Tp(K) = { A | A是给定程序P和实例K的直接后果}；

对于一个算子T，有如下定义：
对任意的I,J，若I⊆ J时有T(I)⊆ T(J)，则T被认为是单调的。
若Tp (K) = K则称K是Tp的一个不动点。

引理 4.1：给定datalog程序P
1.算子Tp是单调的，即当K1⊆K2时，Tp（K1) ⊆ Tp（K2）；
2.从sch（P）中选取的实例K是满足∑p的一个模型当且仅当Tp（K ）⊆K ；
解释：即进行了Tp运算后没有得到新的事实，而原先的K中可能包含idb关系事实，所以是⊆关系而不一定是=关系。
3.Tp的每个不动点（符合Tp (K) = K的不动点K）都是一个满足∑p的模型，反之不一定成立。

定理 4.2：给定datalog程序P和从edb(P)中选取的实例I，存在一个包含I的最小不动点且其值与P（I）相等。
证明：先证P（I）是Tp的一个不动点，此即等同于证明Tp (P(I)) = P(I)；
因为P（I）是满足∑p的模型故由引理2知Tp (P(I)) ⊆ P(I)；
下证P(I) ⊆ Tp(P(I))，
已知Tp (P(I)) ⊆ P(I)且Tp单调，故Tp(Tp(P(I))) ⊆ Tp(P(I))，再由引理2可知Tp(P(I))是满足∑p的一个模型，
由直接后果算子的定义和Tp（K）的定义知Tp(P(I))包含了P（I）中的edb关系，又因为P（I）是由I扩充得到且I是从edb（P）中选取的实例，所以I⊆ Tp(P(I))，故Tp(P(I))是包含I且符合∑p的模型。因为P（I）是包含I且符合∑p的最小模型，故P(I) ⊆Tp(P(I))。
每个Tp的不动点均为P的一个模型，同时P（I）也是Tp的不动点，由P（I）的定义知P（I）是P中包含I的最小不动点。

不动点的迭代
给定从edb(P)中选取的实例I，定义序列：
I0=I，Ii=Tp（Ii-1） i≥0
由Tp的单调性知I0 ⊆ I1 ⊆ I2 ⊆ · · · ⊆ Ii ⊆ Ii+1⊆ · · ·B（P，I）
注：迭代最终会得到P(I)，而P(I)是B（P，I）的一个子集。
上式的出发点是I0 ⊆ I1 和算子Tp的单调性
N为B（P，I）中的事实数量（N的值取决于I），则最多经过N次迭代可以得到不动点，即∀i≥N，Ii=IN，此时Tp(IN)=IN,即IN为Tp的一个不动点，将此不动点IN记作
定理 4.4：给定datalog程序P和从edb（P）中选取的实例I，有=P（I）。
证明：根据先前的定义有
Tp（）=Tp（）==，其中N= |B(P, I)|（B（P，I）中事实的数量），由引理知是包含I的一个不动点。
接下来证明其为最小不动点，考虑Tp中任一包含I的不动点J，对于每个i有J⊇ ，i≥0，故J⊇ ，因此是包含I的最小不动点，=P（I）

满足=的最小整数 i 记作stage（P，I），stage（P，I）≤N= |B(P, I)|。

5 证明理论方法

这种方法定义datalog程序语义的方式基于证明，给定datalog程序P和数据库实例I，其问题答案是由能够使用P和I证明的事实组成的集合，其最终与P（I）一致，

首先定义什么是证明，给出datalog程序P和实例I，事实A的证明树是有限标签树T需满足：
T的每个顶点都以事实作为标签
T的根以A作为标签
T的每个叶节点以I中的事实作为标签
T的一个非叶节点用A1作为标签并且它的儿子节点分别用A2，……An作为标签，则存在程序P中的一个基础实例r满足H(r) = A1和 B(r) = {A2, … , An}

证明树提供了对事实的证明，直接表明若事实A在P（I）中当且仅当存在一个A从I和P中得出的证明树，现证明一个事实A有自底向上和自顶向下两种方法。
自底向上利用来自I的事实和规则，以各种可能的方式使用规则推出新的事实，类似于直接后果算子，这种方法不断重复直至无法生成新的事实。规则不断从已经证明的事实生成新的事实，所有的事实都能得到证明。就是以EDB谓词为底，从规则体出发，在规则体谓词都计算出以后，应用规则来计算头的IDB谓词，有限的EDB必能根据datalog规则导出有限的IDB，本质上等同于不动点方法。
与之相对的是自顶向下，自顶向下的方法指从目标出发，利用规则来得到成功证明或求解该目标的方法，具体步骤为：将目标与各规则的规则头进行进行匹配，一旦成功，再进一步证明或求解相应规则的规则体所包含的谓词。不断重复这些步骤，直到EDB谓词为止，将结果返回到最初的目标，就可以判断其真假，或者求出其中的变量值。
自顶向下利用了目标中的限定条件，效率较高，但可能需要多次回溯，容易形成无限循环，自底向上结构更为简单，且总能得到最终答案。

To bar an easy access to newcomers every scientific domain has introduced its own terminology and notation
符号表示
一个正文字是一个原子（即具有特定元组u值的P(u)）
如果一文字包 含一否定符号，将其称为负文字，否则为正文字，一个子句是若干文字的任意析取。
正文字和负文字组成的的公式如下：
∀x1,…,xm(A1 ∨ · · · ∨ An ∨ ¬B1 ∨ · · · ∨ ¬Bp)
Ai,Bj为正文字
上述公式等价于语句：A1,…,An ← B1,…,Bp
单个正文字将其视为事实，一个正文字和若干个负文字的析取视为规则。
确定子句：头部只有单个文字的子句
单元子句：文体部分为空的确定子句。
目标子句：子句头部为空。（目标子句作为一个问题输入，一般表示为 ← A1,…,An（或?- A1,…,An））
空子句：一个子句头部和文体部分均为空，记作口，空子句即为出现反驳。
基本子句：不含变量的子句。

自顶向下证明方法在这里被称作SLD分解，以目标子句作为开始，不断由先前的目标子句生成之后的目标子句，直到最后无法生成新的目标则证明完成。
datalog规则与确定子句之间的不同点：datalog规则中每个出现在规则头部的变量必须要出现在规则体中（且datalog单元子句必须为基本子句），而确定子句则不需要。
我们用PI表示基于实例I的datalog程序P（I中的关系为已知事实R(u)，将其表示成单元基本子句R(u) ←），此时不再区分IDB和EDB

热身
讨论SLD分解前，考虑一类只含有基本规则的方法，为此，考虑全部规则实例化（没有出现变量）的datalog程序PI（集成了事实）
考虑PI中一个基本目标g ≡ ← A1, … , Ai, … , An以及一些基本规则r ≡ Ai ← B1, … , Bm
g关于r的消解式为：← A1, … , Ai−1, B1, … , Bm, Ai+1, … , An
最好的理解是将其写成子句形式：
(¬A1 ∨ · · · ∨ ¬Ai ∨ · · · ∨ ¬An) ∧ (Ai ∨ ¬B1 ∨ · · · ∨ ¬Bm) ⇒ (¬A1 ∨ · · · ∨ ¬Ai−1 ∨ ¬B1 ∨ · · · ∨ ¬Bm ∨ ¬Ai+1 ∨ · · · ∨ ¬An).（反之不一定成立）
一个目标子句可以被视作是一个查询，箭头有时候可以代表问号，如?- S(1, 6) 等同于 ← S(1, 6)
PI中的g可以递归生出很多gi，gi是关于g（i-1）的消解式，随着i不断增加，若存在gi为空子句（false）则证伪。（g0 ≡← A, g1,…,gi,…, gq ≡ 口）
来说明一下为什么证伪能够证明事实
我们希望证明事实A1 ∧ · · · ∧ An成立，可以通过证明¬A1 ∨ · · · ∨ ¬A n是错误的，换句话说即证明← A1,…,An是错误的。
eg：为了证明S（1，6），可以通过证伪¬S(1, 6)（即←S（1，6）），PI或证明过程如下：
1. S(x1, x3) ← T (x1, x2), R(x2, a, x3)
2. T (x1, x4) ← R(x1, a, x2), R(x2, b, x3), T (x3, x4)
3. T (x1, x3) ← R(x1, a, x2), R(x2, a, x3)
4. R(1, a, 2) ←
5. R(2, b, 3) ←
6. R(3, a, 4) ←
7. R(4, a, 5) ←
8. R(5, a, 6) ←

¬S(1, 6) ………………………………………………………………………………. (1)
⇒ ¬T (1, 5) ∨ ¬R(5, a, 6)………………………………………………… (2)
⇒ ¬R(1, a, 2) ∨ ¬R(2, b, 3) ∨ ¬T (3, 5) ∨ ¬R(5, a, 6) (4)
⇒ ¬R(2, b, 3) ∨ ¬T (3, 5) ∨ ¬R(5, a, 6)……………………….. (5)
⇒ ¬T (3, 5) ∨ ¬R(5, a, 6)…………………………………………………. (3)
⇒ ¬R(3, a, 4) ∨ ¬R(4, a, 5) ∨ ¬R(5, a, 6)…………………….. (6)
⇒ ¬R(4, a, 5) ∨ ¬R(5, a, 6) ……………………………………………….(7)
⇒ ¬R(5, a, 6)………………………………………………………………………… (8)
⇒ false
（不断消除最开始处出现已知的事实（即原程序中出现的基本单元子句），直至false得到矛盾则证伪）

定理 5.5
给出datalog程序PI以及规则实例化后的PI，ground(PI) 是PI中规则实例的集合（实例化的常量值来自adom（P，I）），则对于每个基本目标子句g，PI(∅) |= ¬g当且仅当存在g的一个证伪。

SLD分解:
接下来要考虑目标子句元祖中为变量的情况，而非先前的常量。
目标子句（不需要一定为基本子句）：← A1, … , Ai, … , An. 选择文字Ai = Q(1, x2, x5)进行替换，任何一条规则替换文字Ai其规则头都必须有谓词Q，例如可能用到规则Q(x1, x4, x3) ← P (x1, x2), P (x2, x3), Q(x3, x4, x5)来替换Ai。
替换过程可能遇到两个问题，(i)在被替换的文字和使用的规则里面出现了相同的变量但是其各自含义不同；(ii)选中的文字中的变量或是常量可能对应所用到规则中名称不一样的变量。
可以通过对变量的重命名解决第一个问题，使用下面的重命名规则：每次规则的使用，都会伴随一个不同的变量集合来替换整个规则中的变量（如使用规则Q(x11, x14, x13) ← P (x11, x12), P (x12, x13), Q(x13, x14, x15)替代），第二种情况可以用合一方式解决，将选中的文字和所使用的规则头部进行匹配（如果可行的话）：寻找一个置换θ使得θ(Q(1, x2, x5)) = θ(Q(x11, x14, x13))，这些θ称作Q(1, x2, x5)和Q(x11, x14, x13)的一致置换符
For example, the substitution θ(x11) = 1, θ(x2) = θ(x14) = θ(x5) = θ(x13) = y is a unifier for Q(1, x2, x5) and
Q(x11, x14, x13), because θ(Q(1, x2, x5)) = θ(Q(x11, x14, x13)) = Q(1, y, y).

定义 5.6：A，B为两个原子（即两个关系），若一个置换θ满足θA = θB称其称作A和B的一致置换符；如果对于A和B的每个一致置换符v，都存在一个置换v‘，使得v=θv’（即先用θ置换再用v’置换）；则θ为A和B的mgu（最通用一致置换符）

计算mgu：
关系R(x1, … , xp), R(y1, … , yp)中的变量均不相交，若某个xi和其对应的yi其值分别为两个不相等的常量，则不存在mgu，否则按如下方式计算mgu（置换 θ表示）
1. If z ≡ a for some constant a, θ(z) = a;
2. Otherwise θ(z) =z’, where z’ is the smallest (under a fixed ordering on var) such that z ≡ z’.

A和B如果存在一致置换符，则A和B的mgu存在且唯一确定

现在改述之前的术语
g ≡← A1, … , Ai, … , An, r ≡ B1 ← B2, … , Bm分别为一个目标子句和一条规则，有：
1.g和r没有相交的变量（保证了规则中变量的重命名）
2.Ai和B1有一个mgu
则g关于r分解后的目标子句为：← θ(A1), … , θ(Ai−1), θ(B2), … , θ(Bm), θ(Ai+1), … , θ(An)（使用mgu—θ进行相关变量的置换）
一个关于程序PI的目标子句g的SLD推导可以看作是一个目标序列g0 = g, g1, … 和一个置换序列 θ0, … ，对于每一个j，g（j-1）的消解式为gj（使用PI中的相关规则以及某个mgu置换θj1），程序PI中目标g的一个SLD refutation即为PI中一个SLD推导：g0 = g, … , gq =口
the existence of a refutation of a goal ← A1, … , An with PI can be viewed as a proof of the
negation of the goal：∀x1, … , xm(¬A1 ∨ · · · ∨ ¬An)，where x1, … , xm are the variables in the goal

｛
置换是从变量到项映射，它是恒等映射，对于两个项t1和t2存在置换δ，使得δ（t1）=δ（t2），则称t1和t2是可合一的，这时δ称为这两个项的合一置换，则他们必定具有最一般的合一置换mgu（t1，t2），而且它是唯一的。
g ≡← A1, … , Ai, … , An, r ≡ B1 ← B2, … , Bm分别作为一个目标和规则
1.g和r中没有变量相同
2.Ai和B1有一个mguθ
g关于r的消解式（使用了θ后）为目标：← θ(A1), … , θ(Ai−1), θ(B2), … , θ(Bm), θ(Ai+1), … , θ(An)
一个SLD推导从目标g开始可以表示成一个目标序列g0 = g, g1, … 和一个置换序列θ0, … ，对于任意j，gj是关于g（j-1）的消解式（使用到了PI中的规则和θj1）。
证明目标← A1, … , An等价于证明目标∀x1, … , xm(¬A1 ∨ · · · ∨ ¬An)，x1, … , xm为目标中的变量。上述目标取反后为∃x1, … , xm(A1 ∧ · · · ∧ An)。
｝

SLD归结是一种证明事实的方法，具有正确性(产生事实唯一正确的证明)和完备性（能够证明所有的事实）
正确性：给定程序PI和目标子句g ≡← A1, … , An，如果存在一个关于g的SLD-refutation ，且mgu依次为 θ1, … , θq, 则PI中蕴含θ1 ◦ · · · ◦ θq(A1 ∧ · · · ∧ An)成立。（即如果某事实存在一个SLD归结过程，则此事实一定为真）
完备性：给出程序PI和目标子句g ≡← A1, … , An， 如果PI 蕴含¬g, 则存在g的一个SLD-refutation。（所有正确的事实都可以通过SLD归结过程证明出来）

SLD-树
一棵SLD树代表一组从问题出发的SLD推导过程，程序的执行可以认为是在相应的SLD树上搜索反驳的遍历过程，反驳即为终止于空子句的路径，可以证明，如果一个程序的某个SLD树中存在以空子句标识的节点，则该程序的任何SLD树中都将存在以空子句标识的节点。因此，搜索任何一棵SLD树就足以解决是否存在反驳的问题。执行策略对应于SLD树的深度优先搜索，并且总是在目标中选取最左边的原子，而且树中节点的子节点是按照相应子句在程序中的正文次序加以排列的，。这一模式下，对原子目标的调用通过依次选择适当的子句并与其合一来完成。
（ 简而言之为自上而下匹配子句( 即合一); 从左向右选择子目标; 归结后产生的 新子目标总是插入被消去的目标处( 即目标序列的左 边) )
SLD-树中的每一条路径均表示一个可能的SLD-推导，而以空子句结束的路径表示SLD-refutation

eg： 如下datalog程序PI的SLD-树，目标为←S（1，x）
1. S(x1, x3) ← T (x1, x2), R(x2, a, x3)
2. T (x1, x4) ← R(x1, a, x2), R(x2, b, x3), T (x3, x4)
3. T (x1, x3) ← R(x1, a, x2), R(x2, a, x3)
4. R(1, a, 2) ←
5. R(2, b, 3) ←
6. R(3, a, 4) ←
7. R(4, a, 5) ←
8. R(5, a, 6) ←

几点解释：选中的原子项用方框代表，边上标签的第一个数字表示使用的规则，剩余部分表示使用的置换。
An SLD tree is a representation of all the derivations obtained with a fixed selection rule for atoms.
infinite subtree的出现是由于可以无限的选择第二条语句进行T（x3，x2）的不断迭代。
no possible derivation是由于最后在程序中找不到对应的事实，分解的出口在于消解为空子句口（即false）
以空子句结束的路径表示SLD-refutation，即对应原问题可证实的路径。
可能存在无法继续下去的推导分支。

6 程序静态属性分析
主要考虑datalog程序的三种静态属性
satisfiability：给定datalog程序P，一个内涵关系T对于P可满足指的是存在一个edb（P）中的实例I使得P（I）（T）非空，对于一个idb中的关系T的可满足性是可判定的。
containment：对于给定的datalog程序P，P1 (edb(P ) = edb(P1))和目标关系T（在P和P1中均出现）， P ⊆T P 1不可判定。
boundedness：一个datalog程序P是有界的指的是存在一个常数d使得对于edb（P）中选取的实例I，有stage（P，I）≤d。datalog程序的有界性不可判定

7 Evaluation of Datalog
7.1 Seminaive 算法
Query-Subquery是自顶向下方法，magic set rewriting是先预处理程序再使用自底向上方法。
研究的第一步是如何提高12章中的自底向上方法的效率，为此用到了一个例子程序：
RSG（Reverse-Same-Generation）：
rsg(x,y) ← flat(x,y)
rsg(x,y) ← up(x,x1), rsg(y1,x1), down(y1,y)

前面的自底向上方法在输入实例为I0时求rsg值最终得到不动点步骤如下：
level 0: ∅
level 1: {(g,f) ,( m,n),( m,o),( p,m)}
level 2: {level 1} ∪ {(a,b), (h,f) , (i,f) ,( j,f) , (f,k)}
level 3: {level 2} ∪ {(a,c), (a,d)}
level 4: {level 3}
很明显其中含有很多冗余计算步骤，每一个level都重复计算了前一层的level元素，比如计算level3时，用到了level2中的全部元素{(g,f) ,( m,n),( m,o),( p,m),(a,b), (h,f) , (i,f) ,( j,f) , (f,k)}；而其中的元素(g,f) ,( m,n),( m,o),( p,m)早已经在level2步骤中生成了元素(a,b), (h,f) , (i,f) ,( j,f) , (f,k)，这一次又重新生成一次level2中的元素(a,b), (h,f) , (i,f) ,( j,f) , (f,k)，当然这些元素(a,b), (h,f) , (i,f) ,( j,f) , (f,k)也利用规则2生成了新的元素(a,c), (a,d)。
注：其实如果只利用每一层新的元素生成下一层新的元素也会出现冗余计算，比如第1层计算第2层新元素，level2中的新元素(a,b), (h,f) , (i,f) ,( j,f) , (f,k)，然而level1中新元素由规则2生成的元素为(a,b),(g,f), (h,f) , (i,f) ,( j,f) , (f,k)，其中(g,f)存在于第1层的元素中，此计算也为冗余计算。
这个是由datalog程序P中Tp算子的单调性所导致的。

上述算法被称作datalog求值的naive算法（朴素算法）
而seminaive算法（半朴素算法）主要关注每一层产生的新的事实从而尽量避免对之前出现过的事实重新计算。
考虑使用RSG中规则2在naive方法中的每一步推导，都会产生相应的新的事实（直到到达不动点），为了在第i+1步推出新的事实，至少需要使用一个第i步中生成的新的事实，这是seminaive方法的主要依据，可以通过如下的RSG2（即RSG’）程序体现：
上述程序的第二条规则包含了i≥1的情况。严格意义上RSG2不是一个datalog程序，因为程序中的规则是无限多的，同时它也不具有递归特性。
直观可以看出包含了RSG程序中第i步通过naive算法计算得到的全部新生成的事实（但两者不一定相等）；
要弄清楚这个，我们注意到的重复应用和其值之间的密切联系。令I为固定的输入实例，则：
表示RSG程序中使用naive算法得到的第i步的全部事实
利用RSG2程序第i步得到的新的事实（即naive算法中利用第i-1步生成的所有新的事实生成的事实）
因此有等式成立；更进一步，如果j满足，则RSG(I)(rsg)=，也就是说只要计算RSG2程序j个level，就可以找出RSG(I)(rsg)（即对于RSG程序和输入实例I的不动点），同时RSG2程序的自底向上计算方法比RSG程序的直接自底向上计算方法减少了很多冗余运算。

继续进一步的非正式讨论，可以提出两项改进措施进一步减少冗余计算。
第一项改进措施基于对执行RSG2程序的观察，并不是总能有等式成立，比如在开始时提到的例子有（例子下方的注中有详细解释）；从这可以得出新的方法：用代替RSG2程序规则2中的
如下为使用混杂了datalog和一些命令的语言的程序，改进后的RSG3（RSG“）程序：

（第二个大括号中的规则包含了i≥1的情况）
上述程序避免了开始提到的冗余情况的发生

第二项改进当给定的idb谓词在同一条规则中出现两次时很有用，考虑一个非线性程序：
anc(x,y) ← par(x,y)
anc(x,y) ← anc(x,z), anc(z,y)
类似第一项改进得到的seminaive版本程序：
利用和保证得到下一level的全部新的事实
temp中存的是利用前一level中新的事实生成的下一level中的全部事实（其中可能有重复计算的事实，即中的事实），所以下一步除去原本上一level已经有的事实，得到即为下一level相对上一level生成的全部新事实.
输入实例I=｛par（1，2），par（2，3）｝，有
上述例子中对于的计算会出现重复，第二个大括号中的规则1和规则2都会计算，而且这在任意一个level的计算中都可能出现这种情况。
一种避免这种情况发生的方法是用如下的两条规则替换上述计算的两条规则：

这种方式同样适用于下面所述的情况。

现在讨论一般情况下的seminaive算法，给定datalog程序P（P中的edb R和idb T），考虑程序P中的如下规则：
其中Rk是edb谓词，Tj是idb谓词

对每个j∈[1,m]和i≥1的情况构造规则：
由于j从1到m有m种情况，所以上述规则在i为某一值时有m个规则，分别对应j在idb谓词T中的不同位置。（这个形式类似于上面提到的简单形式的扩充）
现在假设T1, … , Tl是P中规则S规则体中的idb谓词列表，将

表示已给出值的实例I和已求出值应用了中规则计算得到的元组（每个元组对应一个事实）的集合（即中存储的由上一level中全部新的事实所计算得到的下一level的事实，本身计算也要用到l条规则）
解释：
1.P‘表示程序P中规则的规则体只有edb事实构成的子句
2.初始已有事实设为空集（第0level）
3.单独考虑初始情况，将P’中这些事实作为第一个level生成的全部新的事实用符号记录，为下面做准备
4.下面情况包含i≥1所有情况
5.执行下述步骤：对于P的某一规则中出现的每个idb谓词S（规则体中有idb谓词T1……Tl定义规则头idb谓词S）作如下运算
先将第i-1level已有的事实和第i步生成的全部新的事实合并得到第ilevel的全部事实，而后再计算第ilevel相对于第i-1level生成的全部新的事实（即需除去Si中的已有事实），i自增重复上述步骤直到对于每个idb谓词S有=Ø，即相对上一level不再有新的事实产生停止
6：得到最终结果不动点P(I).

7.2 Top-Down算法
考虑上一节中的RSG程序，增加一个查询：
rsg(x,y) ← flat(x,y)
rsg(x,y) ← up(x,x1), rsg(y1,x1), down(y1,y)
query(y) ← rsg(a,y)
其中a为常量，这个程序被称为RSG查询，假定使用seminaive求值方法，可以求出每一对rsg，有些求出的rsg不会产生对于query(y)的解答。比如采用例子13.1中实例I0
产生了关系rsg（f，k），但查询query(y) ← rsg(a,y)没有用到这个关系,top-down方法注重尽量避免产生这些不能用于生成查询所需元组的关系（即元组）
定义一个datalog查询为（P，q），P为datalog程序，q是一个datalog规则（规则头部为新的关系query，规则体中为P中的关系），一般假定只有一条规则定义谓词query，形如：query(u) ← R(v) R为idb谓词
给定实例I，如果一个事实与一个查询（P，q）相关定义为存在一个关于这个事实的证明树（该事实产生查询结果），只推导与查询（P，q）相关的事实是一种直接提高datalog求值效率的方式。
接下来讨论具体的实现步骤，但是这种方式也并非完美。
top-down方法关注相关事实，特别的，它使用SLD-归结的框架。
这些算法的出发点（即需要回答的查询）经常包含常量，这对推导树的搜索产生了限制且因此产生了相关的事实集合。
在不带函数的数据库上下文中，top-dow方法对datalog程序求值通常可以终止在全部输入上。（全部输入指的是输入的实例I）即便当对应的SLD-归结算法也没有，接下来的着重点放在QSQ框架（query-subquery）上。
这个框架有四个基本组成部分：
1.使用SLD归结的总体框架，但是采用一次一集合（set-at-a-time）方式，即操作的对象和结果都是集合。故允许使用关系代数操作的优化策略。
2.将常量不断从最初查询的目标传递到下一个子目标。
3.使用sideways information passing方式来在子目标的原子项之间传递约束作用的常量。
4.使用有效的全局控制流策略。

修饰符与子查询
考虑先前的RSG查询程序
rsg(x,y) ← flat(x,y)
rsg(x,y) ← up(x,x1), rsg(y1,x1), down(y1,y)
query(y) ← rsg(a,y)
观察其SLD树，树根的子节点为rsg（a，y），直观来说，不是所有的rsg关系都是必需的，只需要第一个坐标的值为a的rsg关系。更一般来说，我们对第一个坐标是bound和第二个坐标是free的rsg关系感兴趣。这个关系可以表示成，右上方的’bf’标注称作修饰符。
SLD树的下一层会有保存flat(a，y)的一个节点和保存up(a, x1), rsg(y1, x1), down(y1, y)的一个节点，这些节点中的第一个节点的答案生成由（利用选择和投影求出flat第二个属性列，即flat中第二个坐标值）给出；其余节点的答案可以通过从左到右求值生成，x1的可能值集合由给出，接下来y1的可能值集合由{y1 | （y1, x1） ∈ rsg and x1 ∈ J} 给出（即此rsg关系中的第一个坐标值取决于其在J中的第二个坐标值），需要对求值（子目标），关系的第二个坐标被集合J约束，给定y1的值，可以通过down关系得到y的值（即得到了查询的答案）。
由上述过程可知top-down方法对一个出现了常量的查询求值可以分解成一系列形如的子查询，其中γ是是idb谓词R的修饰符，J是γ给定约束条件列中可以取值的元组集合，形如的表达式称为子查询，
如果RSG查询（即出发点为rsg（a，y））应用到Fig.13.1中，则第一个子查询为
注：此表示式即表明利用规则2查询rsg(a,y)，会产生up（a，e）和up（a，f）关系符合条件，因此规则体中的rsg关系的第二个坐标被集合｛,｝约束，对此rsg关系的查询记作），rsg的右上方修饰符表示第一个坐标free而第二个坐标bound。
所以QSQ框架基于一个子查询求值体系。

给定datalog程序P和输入实例I，R是idb谓词，γ为R的修饰符（即b和f组成的字符串序列，长度等于R的属性数量），bound（R，γ）表示在γ中被约束的R的坐标项。设t为bound（R，γ）中的一个元组（即取出一个含有各约束列值的元组，因为每一约束列有值约束必能取到此元组），对于中元组t的一个完整约束是一个元组s使得s[bound（R，γ）]=t，同时s∈ P(I)(R)，对于输入实例I的子查询的答案是全部的完整约束的完整形式的集合（即每个答案元组受到限制的项所组成的元组对应J中的约束条件列中所能选取的全部元组）
注：此处如果子查询是仍为关系rsg，则s为在P(I)中，即位于不动点之中，此时s即为查询的答案之一。

The use of adornments within a rule body is a generalization of the technique of
sideways information passing discussed in Chapter 6. Consider the rule
规则体内修饰符的使用是侧向信息传递技术，考虑如下规则：
R(x, y, z) ← R1(x, u, v), R2(u, w, w, z), R3(v, w, y, a).
假设一个子查询涉及查询，假设从左至右求值，将会有下述子查询，为了强调修饰符一般将规则改写为如下形式：
这个是一个有饰规则（adorned rule）例子，可以看到，规则体中的idb谓词修饰符能够用来指导查询和子查询的求值，规则经常省略edb谓词修饰符。

给定规则头一个确定的修饰符，同时使规则体文字（关系）有序排列，则给一个规则加上修饰符的通用算法为：
(1).所有出现在规则头的bound变量在规则体中都用bound修饰
(2).所有出现的常量都为bound
(3).如果一个变量x出现在规则体中，则在此之后的文字（关系）中出现的x都为bound
规则体中文字（关系）的排序不同可能会有不同的修饰符表示，一般对于给定的规则头允许规则体文字由不同的排序得到不同的修饰符表示。

有饰规则（adorned rule）的定义同样适用于出现变量和常量重复的情况，然而，adornments do not capture all of the relevant information that can arise as the result of repeated variables or constants that occur in idb predicates in rule bodies. Mechanisms for doing this are discussed in Section 13.4.

互补关系和QSQ模板

QSQ模板的用途是QSQ模板的一个关键部分（在一个求值过程的中间步骤存储合适的信息），考虑之前的规则：
R(x, y, z) ← R1(x, u, v), R2(u, w, w, z), R3(v, w, y, a)
尝试进行子查询求值：，这会产生如下查询：
，关系K和关系L取决于先前的查询求值，可以看到K依赖于J和R1，L依赖于R1和R2，一个QSQ模板提供了在从左至右子查询求值时记住全部所需值的基本数据结构。
注：第一个中π1(J)是bff约束条件列中可以取值的元组集合，即在约束条件下的R1第一个属性取值集合。

要做到这一点，QSQ模板依赖于互补关系，一个含有n个原子规则体关联到总数为n+1个互补关系，例如，规则头的修饰符表示为的规则：
R(x, y, z) ← R1(x, u, v), R2(u, w, w, z), R3(v, w, y, a)
的互补关系sup0,…, sup3
注意到变量作为互补关系的属性名 ，正式来说，规则体中原子为A1,…,An时，第i个互补关系中属性所使用的变量值集合定义如下：
(1).第0个互补关系，属性集合是规则头中bound变量的集合X0，最后一个互补关系的属性集合为规则头的变量集合Xn
(2).当 i ∈ [1,n − 1]，第i个互补关系的属性集合 is the set Xi of variables that occur both “before” Xi (i.e., occur in X0,A1,…,Ai) and “after” Xi
(i.e., occur in Ai+1,…,An,Xn).

一个有饰规则的QSQ模板是此规则互补关系的一个关系模式序列 (sup0,…, supn) ，在QSQ查询求值的过程中，关系实例被分配到这些模式中；通常在算法求解时这些实例不断更新元组。下图展示了关于RSG查询的QSQ模板使用

QSQ求值要点
QSQ求值的关键如下所述：给定一个datalog查询（P，q）和edb实例I，概念来看，最开始需要对P中的每个idb谓词和查询q添加修饰符以创建有饰规则，只需在算法执行过程需要时创建。 让表示变换后的有饰规则查询。
RSG查询的关联有饰规则如下：
注意到规则4，规则体中文字是有序的，所以down关系中变量y的约束可以产生对rsg中y1的约束和up关系中x1的约束。

一个QSQ模板对应每一个关联有饰规则，将 （从0开始计数）应用了的有饰规则的互补关系记作

此外，下述关系是必需的同时将会作为QSQ求值算法中的变量
(a)对每个idb谓词R和相关修饰符γ，变量的属性与R相同。
(b)对每个idb谓词R和相关修饰γ，变量和属性相同
(c)对每个互补关系，变量
将用于子查询，中元组的完整形式为，中元组属于P(I)(R)且产生于基于的子查询。
一个QSQ算法对上述每个关系开始于一个空集，然后查询用于初始化过程，例如规则：query(y) ← rsg(a,y) 给出了的初始值 {}。
一般来说，这类查询规则给出了子查询，t是使用了初始查询中的常量集合来构造的。
注：在上述查询规则中t即查询语句的规则体中出现的a，这类查询中的常量集合组成t。

执行本质上有四种方法，这些方法会考虑不同的排序方式，第一个是用来初始化规则
(A) Begin evaluation of a rule: This step can be taken whenever there is a rule with
head predicate Rγ and there are “new” tuples in a variable input_Rγ that have not yet
been processed for this rule. The step is to add the “new” tuples to the 0th supplementary
relation for this rule. However, only “new” tuples that unify with the head of the rule are
added to the supplementary relation. A “new” tuple in input_Rγ might fail to unify with
the head of a rule defining R if there are repeated variables or constants in the rule head
(see Exercise 13.9).
New tuples are generated in supplementary relations supji in two ways: Either some
new tuples have been obtained for supi
j−1 (case B); or some new tuples have been obtained
for the idb predicate occurring between supi
j−1 and supji (case C).
(B) Pass new tuples from one supplementary relation to the next: This step can be taken
whenever there is a set T of “new” tuples in a supplementary variable supi
j−1 that have not
yet been processed, and supi
j−1 is not the last supplementary relation of the corresponding
rule. Suppose that Aj is the atom in the rule immediately following supji−1.
Two cases arise:
(i) Aj is Rγ(u) for some edb predicate R. Then a combination of joins and projections on R and T is used to determine the appropriate tuples to be added to
sup i
j .
(ii) Aj is Rγ(u) for some idb predicate R. Note that each of the bound variables in
γ occurs in sup i
j−1. Two actions are now taken.
(a) A combination of joins and projections on ans_Rγ (the current value
for R) and T is used to determine the set T  of tuples to be added to
sup i
j .
(b) The tuples in T [bound(R, γ )] − input_Rγ are added to input_Rγ .
(C) Use new idb tuples to generate new supplementary relation tuples: This step is
similar to the previous one but is applied when “new” tuples are added to one of the idb
relation variables ans_Rγ . In particular, suppose that some atom Aj with predicate Rγ
occurs in some rule, with surrounding supplementary variables sup i
j−1 and supji. In this
case, use join and projection on all tuples in sup i
j−1 and the “new” tuples of ans_Rγ to
create new tuples to be added to supji.
(D) Process tuples in the final supplementary relation of a rule: This step is used to
generate tuples corresponding to the output of rules. It can be applied when there are “new”
tuples in the final supplementary variable supi n of a rule. Suppose that the rule predicate isRγ . Add the new tuples in supi n to ans_Rγ .

全局控制策略

Theorem 13.2.2 Let (P,q) be a datalog query. For each input I, any evaluation of QSQ on (P ad,qad) yields the answer of (P,q) on I.

a more specific algorithm based on the QSQ framework. This algorithm, called QSQ Recursive (QSQR) is based on a recursive strategy.