标签: logic-programming

当我想阅读逻辑编程时,我总是偶然发现两种"主要"方式来做到这一点:

• miniKanren,一种在The Reasoned Schemer中引入的小语言,由于core.logic而在当下流行.
• Prolog,第一个"大"逻辑编程语言.

我现在感兴趣的是:两者之间的主要技术差异是什么？它们在方法和实现方面是非常相似的,还是采用完全不同的逻辑编程方法？他们来自哪些数学分支,理论基础是什么？

我正在开发一个Java应用程序,它需要做一些复杂的逻辑规则推导作为其功能的一部分.我想在Prolog或其他逻辑/约束编程语言而不是Java中编写我的逻辑演绎编码,因为我相信生成的代码将更加简单和易于维护.

我在Prolog上搜索了嵌入式Java实现,并发现了它们的数量,每个都只有很少的文档.我的(适度)选择标准是:

• 应该可以嵌入Java(例如,可以与我的java包捆绑在一起,而不需要在外部程序上进行任何本机安装)
• 从Java使用的简单接口(用于启动扣减,检查结果和添加规则)
• 至少有一些关于如何使用它的例子
• 不一定必须是Prolog,但具有上述标准的其他逻辑/约束编程语言也适合我的需要.

我有什么选择,它们的优点和缺点是什么？

考虑到https://speakerdeck.com/folone/theres-a-prolog-in-your-scala,我想"滥用"Scala类型系统来查找CanBuildFrom符合给定条件的所有实例.Prolog风格,我会评估以下伪代码的行:

can_build_from(Src, int, list[int])
Src = somecollectiontype1[int]
Src = somecollectiontype2[int]
... etc

即运行时将查找Src满足该语句的所有值can_build_from(Src, int, list[int]).

现在,我知道,原始的约束/逻辑编程环境,斯卡拉隐含查询系统,并不意味着使用这种技巧,并且不能用于"重返"不止一个发现价值Src出来的箱,所以我的问题是:是否有一个"魔术",使其工作,所以无论如何我会得到所有可能的值X的CanBuildFrom[X, Int, List[Int]]？

附加示例:

trait CanFoo[T, U]

implicit val canFooIntString  = new CanFoo[Int,     String] {}
implicit val canFooDblString  = new CanFoo[Double,  String] {}
implicit val canFooBoolString = new CanFoo[Boolean, String] {}
implicit val canFooIntSym     = new CanFoo[Int,     Symbol] {}
implicit val canFooDblSym     = new CanFoo[Double,  Symbol] {}
implicit val canFooBoolSym    = …

我是一名长期的python开发人员,最近已被介绍给Prolog.我喜欢为某些类型的任务使用关系规则的概念,并希望将其添加到我的保留曲目中.

在Python中有没有适合逻辑编程的好库？我在谷歌上做了一些搜索,但只发现了以下内容:

关于relational_python的jtauber博客系列

很想和其他人比较......谢谢!

-AJ

逻辑编程我指的是声明性编程语言的子范例.不要混淆这个问题和"如果 - 那么其他什么问题可以解决？"

像Prolog这样的语言非常吸引人,为了学习而值得学习,但我不得不想知道哪种类型的现实问题最能用这种语言表达和解决.还有更好的语言吗？在更流行的编程语言中,逻辑编程是否存在另一个名称？这个答案的愤世嫉俗版本是Python Paradox的一个变种吗？

和许多程序员一样,我在大学里学过Prolog,但只是很少.我知道Prolog和Datalog密切相关,但Datalog更简单吗？另外,我相信我读到Datalog不依赖于逻辑子句的排序,但我不确定为什么这是优点.据说CLIPS完全不同,但对我来说理解太微妙了.有人可以提供其他语言的一般语言亮点吗？

我试图理解逻辑编程语言(在我的例子中是Prolog)和Haskell的类型系统之间的关系.

我知道两者都使用统一和变量来根据关系查找值(或类型,在Haskell的类型系统中).作为练习更好地理解它们之间的相似点和不同点的练习,我尝试在Haskell的类型级别中重写一些简单的prolog程序,但是我遇到了一些问题.

首先,我重写了这个简单的prolog程序:

numeral(0).
numeral(succ(X)) :- numeral(X).

add(0,Y,Y).
add(succ(X),Y,succ(Z)) :- add(X,Y,Z).

如:

class Numeral a where
    numeral :: a
    numeral = u

data Zero
data Succ a

instance Numeral Zero
instance (Numeral a) => Numeral (Succ a)

class (Numeral a, Numeral b, Numeral c) => Add a b c | b c -> a where
    add :: b -> c -> a
    add = u

instance (Numeral a) => Add a Zero a
instance (Add x y z) => Add …

随着时间的推移,似乎越来越像函数式编程对其他编程语言产生更多影响.我们在我的AI课程中开始使用Prolog,似乎有一些东西可以使非AI领域的编程变得更容易.我的问题是:为什么逻辑编程没有以同样的方式被捕获？

在本主题中,似乎达成了一个普遍的共识,即逻辑编程很有用,但必须这样证明.它有没有被认为有用的原因？

更新:也许我应该更清楚一点.我不是在问Prolog.我可以理解为什么在大多数真实世界的应用程序中选择Prolog不是一个好主意.

为了举一个我正在讨论的内容的例子,请考虑Python中的列表推导/ map/filter.这些明显受功能语言的影响.为什么像Python这样的语言还没有从逻辑编程语言中学到这些东西,比如它们有函数式语言？

从咖喱教程的 3.13.3节:

剩余的操作称为刚性操作,而缩小的操作称为灵活操作.所有已定义的操作都是灵活的,而大多数基本操作(如算术运算)都是严格的,因为猜测对它们来说不是一个合理的选择.例如,prelude定义了一个列表连接操作,如下所示:

infixr 5 ++
...
(++)             :: [a] -> [a] -> [a]
[]       ++ ys   = ys
(x:xs) ++ ys     = x : xs ++ ys

由于操作"++"是灵活的,我们可以使用它来搜索满足特定属性的列表:

Prelude> x ++ [3,4] =:= [1,2,3,4]       where x free
Free variables in goal: x
Result: success
Bindings:
x=[1,2] ?

另一方面,诸如加"+"之类的预定义算术运算是刚性的.因此,使用逻辑变量作为参数的"+"调用flounders:

Prelude> x + 2 =:= 4 where x free
Free variables in goal: x
*** Goal suspended!

库里似乎没有防止写入将被暂停的目标.什么类型的系统可以提前检测到目标是否会被暂停？

我想使用Clojure的Core.logic.但是,我想了解它是如何工作的.在某处有简明的解释吗？(就像实施一个元外评估者？)

谢谢!