Question

Two related questions in one:

Can Clojure’s core.logic module perform arithmetic, logical comparison, etc, like ordinary Prolog? I am envisioning something like the following:

(defrel points person n) 
(fact :bob 2)
(fact :charlie 3)
(run* [q] (fresh [x y] 
   (points :bob x) 
   (points :charlie y) 
   (< x y) 
   (== q (+ x y))))

=> (5)

In this example, neither the logical comparison (< x y) nor the attempted binding of q to (+ x y) works. I suppose that this is because I’m working with LVars, not integers at this point, and I can’t make these comparisons because the symbols aren’t yet bound. But it works in prolog:

points(bob, 2).
points(charlie, 3).
?- points(bob, X), points(charlie, Y), Result is X + Y.

=> Result = 5.

In a similar vein, can I somehow use Clojure functions (which return booleans or other “truthy” values) as logic predicates? In other words, to use functions to tell Minikanren which terms unify or not. Something along the lines of:

(defmagic startswithhi-o [v]
  (.startsWith v "hi"))
(defrel person n)
(fact person "bob")
(fact person "hillary")
(run* [q] 
   (fresh [n]
     (person n)
     (startswithhi-o n)
     (== q n)))

=> ("hillary")

If I try things like this I get errors also complaining that the LVars aren’t bound. Is there a way to do this?

Lastly if anyone has read this far, I might as well ask: are there plans to incorporate probabilistic logic into core.logic, along the lines of:

http://dtai.cs.kuleuven.be/problog/ ?

I’m not holding my breath but it would be awesome!

Answer 1

Non-relational arithmetic is possible via project.

(run 1 [q]
   (fresh [x y]
        (== x 1)
        (== y 2)
        (project [x y]
                 (== q (+ x y)))))
(3)

I believe the Prolog example given is also non-relational.

The second half of your question can also be solved via project, but you must be careful that you always input a ground value.

(defn startwith [x]
    (project [x]
         (== true (.startsWith x "hi"))))

PS: Hold your breath for Constraint Logic Programming to come to core.logic!