GNU Prolog - 递归问题（简单？）
好的，所以我有这个
edu_less(hs,college).
edu_less(college,masters).
edu_less(masters,phd).
，我需要编写一个函数来判断某些东西是否小于另一个。谓词是
edu_le.
So if i put edu_le(hs,phd). 它应该返回 yes。 我想出了这个。
edu_le(A,B) :- A = B.
edu_le(A,B) :- edu_less(A,B).
edu_le(A,B) :- edu_less(A,C), edu_le(C,B).
我真的不希望它遍历所有内容并返回多个答案。
如果发现它实际上小于或等于第二个参数，是否可以只返回 yes 或 no？
所以基本上，如果我再次使用示例 edu_le(hs,phd)，那么因为 hs 小于 College，而 College 小于 Master，而 Master 小于 phd，那么 hs 必定小于 phd它会说是的。
抱歉，序言真的很新，仍在尝试掌握这一点。
Ok, so i have this
edu_less(hs,college).
edu_less(college,masters).
edu_less(masters,phd).
I need to write a function to tell if something is less than the other. The predicate is
edu_le.
So if i put edu_le(hs,phd). it should return yes.
I came up with this.
edu_le(A,B) :- A = B.
edu_le(A,B) :- edu_less(A,B).
edu_le(A,B) :- edu_less(A,C), edu_le(C,B).
I really don't want it to go through everything and return multiple answers.
Is it possible to only return yes or no if it finds that it is in fact less than or equal to the 2nd argument?
So basically if i use the example edu_le(hs,phd) again, then because hs is less than college, and college is than masters, and masters is less than phd, then hs must be less than phd and it would say yes.
Sorry, really new to prolog, still trying to get the hang of this.
如果你对这篇内容有疑问，欢迎到本站社区发帖提问 参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。
绑定邮箱获取回复消息
由于您还没有绑定你的真实邮箱，如果其他用户或者作者回复了您的评论，将不能在第一时间通知您！
发布评论
评论（4）
在谓词定义中，
第二个子句是多余的，会导致重复生成答案。使用
这会给您一个
true答案，然后在回溯时不再有答案(false)。您可以在第一个子句中使用剪切，但随后生成将不再起作用。变得不完整：
正如 mat 所建议的，使用
once/1代替。在良好的 Prolog 实现中，该谓词的工作方式就好像您的程序在战略位置进行了削减，从而在不干扰其逻辑语义的情况下加速您的程序。In the predicate definition
the second clause is superfluous and causes repeated generation of answers. Use
This gives you one
trueanswer, then no more answers (false) on backtracking. You can use a cut in the first clause, but then generating won't work anymore.becomes incomplete:
As mat suggested, use
once/1instead. In a good Prolog implementation, this predicate works as if your program had cuts in strategic places, speeding up your program without disturbing its logical semantics.编写此类谓词的最实用方法是使用剪切 (!)。削减导致回溯时不考虑进一步的条款。您可以将谓词编写如下：
最后一个子句不需要剪切，因为无论如何都没有其他子句需要考虑。剪切是在任何测试之后进行的，以确定该子句是否应该成功。
逻辑编程纯粹主义者不赞成剪切，因为它使谓词的含义取决于子句的顺序，这与数学中的逻辑不同。
The most practical way to write predicates like that is to use the cut (!). The cut causes further clauses not to be considered when backtracking. You would write your predicate as following:
The last clause does not need a cut because there are no further clauses to consider anyway. The cut is placed after any tests to determine whether the clause should succeed.
Logic programming purists disapprove of the cut, because it makes the meaning of a predicate depend on the ordering of the clauses, which is unlike logic in mathematics.
!/0 也会使这个程序不完整，例如考虑两个版本的最通用查询：
如果您只想要特定目标的单个证明，通常最好使用一次/1：
!/0 also makes this program incomplete, consider for example the most general query with both versions:
It is often better to use once/1 if you only want a single proof of a particular goal:
我建议你不要遵循 Juho Östman 提出的路径并保持纯洁性 - 否则，为什么你应该首先使用 Prolog？如果你过于宽容地坚持逻辑范式，你会得到一些令人不快的结果。在这种情况下，Juho 的谓词肯定与您的不同，我将向您展示原因。
首先，按照 larsmans 的建议，删除无用的
edu_le(A,B) :- edu_less(A,B).规则。您将获得原始谓词的冗余度较低的版本：它的行为与
edu_le相同，意思是：给定任意查询，它会生成完全相同的答案，除了重复项 (edu_le1 较少）。你可能只是对它感到满意，但它仍然有一些你可能不喜欢的冗余答案；例如，在SWI下：现在你可能会说你不喜欢它，因为它仍然有多余的
false，但是如果你使用Juho的谓词来代替（没有无用的规则）：你确实消除了无用的Final
false：但你失去的不止于此：正如 mat 所说，当一个变量未实例化时，你失去了生成所有解决方案的可能性：
换句话说，后一个谓词不等于前者：
edu_le和edu_le1的类型为edu_le(?A, ?B)，而edu_le2的类型为 < code>edu_le2(+A, +B) （含义参见[1]）。请确保：edu_le2的用处较小，因为它执行的操作较少，因此可以在较少的上下文中重用。这是因为edu_le2中的剪切是红色剪切，即改变了引入它的谓词的含义的剪切。不过，鉴于您了解两者之间的区别，您可能会对此感到满意。这完全取决于您想用它做什么。如果您想充分利用这两个世界，则需要在 edu_le1 中引入适当的绿色剪切，以在 A 和 B 完全实例化为项时降低冗余。为此，您必须在切割之前检查 A 和 B 是否已实例化为相同的项。您不能使用
=来执行此操作，因为=不会检查，而是统一。正确的运算符是==：请注意，仅当
A和B恰好是同一个术语时，第一条规则中的附加剪切才有效。既然切割是正确的绿色切割，那么在最常见的情况下，谓词也可以像原始情况一样工作：通过 Prolog 回溯所有解决方案。
我认为没有某种方法可以消除最后一个
false而不引入对edu_lt的过强依赖。这是因为我们必须保持开放的可能性，即有另一个edu_lt可供探索，以防您稍后决定用更多基础事实来丰富它。所以，在我看来，这是你能拥有的最好的。[1] SWI Prolog 参考手册，第 4.1 节。
I would suggest you NOT to follow the path proposed by Juho Östman and keep purity - otherwise, why should you use Prolog in first instance? If you are too lenient with sticking to the logical paradigm you obtain some unpleasing results. In this case, Juho's predicate is definitely different from yours, and I'll show you why.
First, just drop the useless
edu_le(A,B) :- edu_less(A,B).rule, as larsmans suggests. You will obtain a less redundant version of your original predicate:It just behaves as
edu_le, meaning: given an arbitrary query, it produces exactly the same answer, except for duplicates (edu_le1has less). You may just be happy with it, but it still has some redundant answers that you may not like; e.g, under SWI:Now you may say you do not like it because it still has the redundant
false, but if you use Juho's predicate instead (without the useless rule):it's true that you eliminate the useless final
false:but you lose more than that: You lose, as mat remarks, the possibility of generating all the solutions when one variable is not instantiated:
In other words, the latter predicate is NOT equivalent to the former:
edu_leandedu_le1have typeedu_le(?A, ?B), while insteadedu_le2has typeedu_le2(+A, +B)(see [1] for the meaning). Be sure:edu_le2is less useful because it does less things, and thus can be reused in less contexts. This because the cut inedu_le2is a red cut, i.e., a cut that changes the meaning of the predicate where it is introduced. You may nevertheless be content with it, given that you understand the difference between the two. It all depends on what you want to do with it.If you want to get the best of the two worlds, you need to introduce in
edu_le1a proper green cut that lowers the redundancy when A and B are completely instantiated to terms. At the purpose, you must check that A and B are instantiated to the same term before cutting. You cannot do it with=, because=does not check, but unifies. The right operator is==:Note that the additional cut in the first rule is active only when
AandBhappen to be the same term. Now that the cut is a proper green cut, the predicate works also in the most general cases as your original one:with Prolog backtracking through all the solutions.
I don't think there is some way to eliminate the last
falsewithout introducing too strong dependency onedu_lt. This because we must keep open the possibility that there is anotheredu_ltto explore, in the case you decide later to enrich it with more ground facts. So, in my opinion, this is the best you can have.[1] SWI Prolog reference manual, section 4.1.