在Prolog中重构复杂的循环规则

首先：这不是一个家庭作业练习。我正在努力学习Prolog，这只是一个碰巧需要解决的问题，Prolog非常适合这个问题

我有一大堆家庭关系，包括我的事实：

male/1
female/1
husband/2
wife/2
father/2
mother/2
grandfather/2
grandmother/2
son/2
daughter/2
brother/2
sister/2
uncle/2
aunt/2
nephew/2
niece/2
cousin/2

我拥有的数据不完整，缺少家庭网格的许多链接。我的事实来自外部，我只能提供规则。对于一个特定的人，我可能有

男性

，

兄弟

和堂兄弟，对于另一个

母亲

和

妻子

。在最坏的情况下，我几乎不知道表亲，但有足够的其他事实可以推断谁是，比如说，叔叔，因此这个人可能是其他地方提到的兄弟，因此是男性。等等

我无法影响将要发生的事实。这就是问题的关键所在：如果事实是完整的，我就不需要这样做了。我可以用手猜，但如果我能找到一种表达方式的话，电脑就是用来猜的。因此，我们的目标是尽可能地填补缺失的环节，特别是关于叔叔、婶婶、侄子、侄女，尤其是表妹之间的“间接”关系，这些关系众所周知是不完整的

我可以这样天真地写我的规则：

male(Who) :-
   brother(Who, _); father(Who, _); uncle(Who, _); …
brother(Who, Whose) :-
   sibling(Who, Ofwhom), male(Who).
sibling(Who, Whose) :-
   brother(Who, Whose) ; brother(Whose, Who).
motherly_cousin(Cousin, Whose) :-
   cousin(Cousin, Whose),
   sibling(Mother, Uncle_or_Aunt),
   parent(Uncle_or_Aunt, Cousin).

我相当肯定，我试图以一种根本错误的方式解决这个问题，因为我认为没有办法打破循环推理。在不打破循环的情况下，我将为此设计的任何Prolog程序都将退化为无休止的递归

---

那么，我该怎么做才能把这个纠结分解成可以解决的问题呢？

一般来说，这是一个棘手的问题。这种递归的检查是可能的（类似于occurs检入统一），但是大多数实现都忽略了它们，因为（a）通常不清楚要排除哪些递归路径；（b） 它在计算上过于昂贵；或者（c）程序员通常有一种方法来规避代码中的问题

有很多方法可以解决这个问题，有些方法比其他方法更糟糕。我将提出一种方法，以：

• 允许您天真地合理定义谓词
• 处理一组不完整的事实
• 效率极低
• 不会无限递归

我将描述的方式使用了元解释器。Prolog中的标准解释器不会检查代码是否反复执行同一子句。例如，在

brother/2

和

sibling/2

的定义之间存在一个令人讨厌的相互递归的情况。虽然您为它们提供的定义似乎很好，但是考虑它们在所有参数未绑定的情况下会发生什么情况：

brother（X，Y）

↝ <代码>兄弟（X，Y）↝ <代码>兄弟（X，Y）↝ ... （无限远/瑙瑟姆）

相反，我们所能做的是定义这些谓词应该如何执行，并通过一个单独的谓词（我称之为

meta/1

）来指导它们的执行，从而充分了解它们可能是无限递归的。这个谓词是元解释器，它将指导Prolog如何以防止无限递归的方式执行您提供的规则和事实。以下是一个可能的定义（内嵌注释）：

meta/1

和

meta/2

的设计使它们能够执行提供给它们的目标，确保目标执行分支中使用的每个子句都不会明确重复。为了在你的案例中使用它，请考虑以下内容：

brother_of(a, b).
brother_of(b, c).
brother_of(d, e).
brother_of(X, Y) :- meta((sibling_of(X, Y), male(X))).

male(a).
male(d).
male(b).
male(X) :- meta(brother_of(X, _)).

female(c).
female(e).
female(X) :- meta(sister_of(X, _)).

sister_of(X, Y) :- meta((sibling_of(X, Y), female(X))).

sibling_of(X, Y) :- meta(brother_of(X, Y)).
sibling_of(X, Y) :- meta(brother_of(Y, X)).
sibling_of(X, Y) :- meta(sister_of(X, Y)).
sibling_of(X, Y) :- meta(sister_of(Y, X)).

请注意，任何递归子句的主体是如何包装在对

meta/1

的调用中的，它引导Prolog使用元解释器执行它们的定义，元解释器将确保它们的执行（通过解释）不会是递归的。例如，目标：

?- sister_of(X,Y).
X = c,
Y = b ;
X = c,
Y = b ;
X = c,
Y = b ;
... 
X = e,
Y = d ;
false.

请注意，它在通过所有可能的非递归执行路径找到所有绑定后终止，这意味着可能存在大量重复（因此，是效率低下的根源）。要查找唯一的绑定，可以使用

setof/3

，如下所示：

?- setof(sister_of(X,Y), sister_of(X,Y), Set).
Set = [sister_of(c, b), sister_of(e, d)].

这只是您可能会发现有用的一种方法，并且对于Prolog程序员来说，它通常是一个很好的（尽管很高级）工具。您不需要坚持固有的执行策略

对于任何想在实践中简单使用

meta/1

和

meta/2

的人，您还应该考虑以下几点：

• 在执行（子）目标时，您可能希望或需要允许同一子句执行多次（例如，如果您需要使用不同的头绑定执行同一子句）。例如，考虑如何使用元解释器递归地实现

  祖先/2

  ，元解释器可能需要使用不同的头绑定（即路径扩展）多次执行同一子句（自身）。在这种情况下，您可以将子句引用及其特定的头绑定作为

  Ref-head

  项进行跟踪，而不是简单地跟踪子句引用，并检查它们之前是否执行过。这可能需要大量的额外信息，而且可能会很昂贵
• 上面的

  meta/1

  和

  meta/2

  的定义只处理诸如事实之类的谓词（隐式

  true

  作为它们的主体）；或使用连接（

  ，/2

  ）和析取（

  ；/2

  ）的任意组合定义体的谓词。如果需要，您可以简单地在

  meta/2

  中添加更多子句来处理其他语言构造，如蕴涵（

  ->/2

  ）、否定（

  \+/1

  ）、剪切（

  ！/0

  ）等
• 并非所有这样的问题都需要一个元解释器。例如，您可能可以通过简单的structur逃脱

  ?- setof(sister_of(X,Y), sister_of(X,Y), Set).
  Set = [sister_of(c, b), sister_of(e, d)].
  

  :- use_module(library(chr)).
  
  :- chr_constraint male/1, brother_of/2, child_parent/2.
  
  brother_of(X, Y) \ male(X) <=> brother_of(X, Y).
  
  male(X), child_parent(X, P), child_parent(Y, P) ==> X \== Y | brother_of(X, Y).
  
  brother_of(X, Y) \ brother_of(X, Y) <=> true.
  

  ?- male(john), child_parent(john, mary), child_parent(susan, mary).
  brother_of(john,susan)
  child_parent(susan,mary)
  child_parent(john,mary)
  true ;
  false.