Clojure JIRA

[LOGIC-90] These three FD constraints seem to diverge with certain domains

Tue, 1 Jan 2013 13:45:35 -0600

This code:

(run 1 [a b c d]
     (infd a b c d (interval 0 3))
     (<fd a b)
     (<fd c d)
     (<fd d a))

returns

([2 3 0 1])

as expected. However, if we change the interval to (interval 0 4) it seems to diverge. The behavior is the same between (domain 0 1 2 3) and (domain 0 1 2 3 4).

[LOGIC-91] nom/tie and spurious reification of predc constraint

Wed, 2 Jan 2013 08:46:44 -0600

(is (= (run* [q]
           (nom/fresh [a]
             (fresh [x]
               (predc x number? `number?)
               (== x 1)
               (== (nom/tie a [a x]) q))))
        [(nom/tie 'a_0 '(a_0 1))]))
  (is (= (run* [q]
           (nom/fresh [a]
             (fresh [x]
               (== x 1)
               (predc x number? `number?)
               (== (nom/tie a [a x]) q))))
        [(nom/tie 'a_0 '(a_0 1))])) ;; false b/c of extra :- number? constraint

[LOGIC-88] disequality reification is broken

Wed, 2 Jan 2013 18:43:40 -0600

(run* [q]
  (fresh [x y]
    (!= [1 x] [y 2])
    (== q [x y])))

Does not return the following expected reified value:

(([_0 _1] :- (!= [_0 2] [_1 1])))

Even more bizarre things happen with the following:

(run* [q]
  (fresh [x y z]
    (!= [1 x z] [y 2 3])
    (== q [x y])))

z leaks out in the reified value.

(run* [q]
  (fresh [x y z]
    (!= [1 x z] [y 2 3])
    (== q [x y z])))

We only see one var constraint in the reified value.

[LOGIC-53] core.logic converts defrecords to maps in it's query results

Wed, 2 Jan 2013 19:18:19 -0600

(defrecord Test [a b])

(run* [q]
  (== q (->Test 1 2 )))

;; ({:a 1, :b 2})
;; Where's my record?

[LOGIC-95] disequality

Fri, 4 Jan 2013 11:23:47 -0600

This snippet wrongly succeeds with the result:

(([foo _0] :- (!= (foo _0))))

(run* [q]
      (nom/fresh [a b]
        (fresh [x y]
          (!= x y)
          (== (nom/tie a (nom/tie b [b y])) (nom/tie b (nom/tie a [a x])))
          (== x 'foo)
          (== [x y] q))))

Moving the disequality anywhere further down makes the snippet rightly fail.

[LOGIC-18] clojure.core.logic namespace instead of clojure.core.logic.minikanren + prelude

Sun, 20 Nov 2011 15:14:56 -0600

clojure.core.logic namespace instead of clojure.core.logic.minikanren + prelude

[LOGIC-3] nonrel/lvar -> nonrel/lvaro, nonrel/nonlvar -> nonrel/nonlvaro

Sat, 21 May 2011 13:02:27 -0500

They are relations and should probably follow the naming convention for goals. This also avoids confusing newcomers when trying to to use the nonrel namespace.

[LOGIC-1] Tabling bug

Sat, 21 May 2011 13:00:21 -0500

Pepjin pointed out that trying to determine the path on this graph, http://paste.pocoo.org/show/391274/, does not terminate even with tabling.

[LOGIC-6] no way to unify the first of a seq to one lvar and the rest to another

Thu, 2 Jun 2011 16:52:55 -0500

would be nice to be able to do stuff like

(cond-m foo
(cons ?a nil) (println a))

where foo is some value, and (cons ?a nil) is pattern to match and (println a) is code to execute if it matches. (cons ?a nil) would match a sequence with one element, with ?a matching that one element.

you can sort of do this by modifying replace-lvar to turn (cons a b) into (lcons a b) this works for some cases but fails for the one given above, not sure why

[LOGIC-5] cannot unify an lcons currently

Thu, 2 Jun 2011 16:50:53 -0500

if you have an lcons in your pattern somehow (modify replace-lvar to emit lcons for unifying lvars to the head and tail of a seq) currently you will get an exception because unify.clj uses metadata to pass the list of lvars around and lcons don't support metadata, so lcons at the toplevel get an exception when trying to attach metadata.

either lcons needs to support metadata or the list of lvars should be passed around some other way.

[LOGIC-7] cannot emit lvars from macros

Sun, 24 Jul 2011 13:20:30 -0500

if we have a pattern matching macro like, for example, a cond-m that does something like
(cond-m some-value
some-pattern some-code-to-execute-on-match
some-other-pattern ...
another-pattern ...)
it would be nice if the work of preping the patterns could be done at compile time and just emit clojure literals representing the prepared patterns, lvars are currently not emittable in code, so the cost of prepping patterns would be incurred at runtime.

[LOGIC-8] tabled goals perisist across runs

Wed, 8 Jun 2011 22:41:57 -0500

Tabled goals store state in the same way memoize does.

(run 5 [q] (tabled-goal)) and then (run 10 [q] (tabled-goal)) will both return 5 results.
multiple runs wil accumulate memory.

[LOGIC-9] make run non-lazy, add lazy-run variant

Wed, 8 Jun 2011 22:42:55 -0500

The laziness of the run interface is not essential to core.logic's operation. lazy-sequences are used in core.logic simply as a way to get TCO like behavior / prevent stack overflow. run being non-lazy makes tabling goals only for the duration of a run much simpler to implement.

[LOGIC-11] Disequality Constraints - lvar remains fresh if we have disequality constraint that involves lcons

Sun, 24 Jul 2011 13:09:49 -0500

(run* [q]
(exist [x a b]
(!= x (lcons a b))
(== x 1)))

;; (_.0)

[LOGIC-29] Indexed relations return incorrect results for partially ground values

Sun, 4 Mar 2012 15:46:33 -0600

Consider the following code:
(defrel rel1 ^:index a)
(fact rel1 [1 2])
(run* [q] (fresh [a] (rel1 [q a]) (== a 2)))

The result of the above query is () although it should be (1). If the index is dropped, the correct result is returned.

[LOGIC-41] Unexpected behavior when using functions

Thu, 31 May 2012 14:50:48 -0500

Not sure if this is a bug, but it seems a bit strange

=>(defn cp [a b c d] (== a b) (== c d))
=>(run* [q] (fresh [x y] (cp 1 x 2 y) (== q [x y])))
([_.0 2])

My expectation was that I get ([1 2)]

[LOGIC-22] Unqualified Symbols at Macroexpansion via defrel

Fri, 25 Nov 2011 15:35:17 -0600

https://gist.github.com/1392568

The particular problem here is because the call to "to-stream" in "clojure.core.logic/extend-rel" isn't namespace qualified.

Looking through the implementation of the facts, there are some strange things going on with the macros.

Seems to be some more unqualified symbols representing vars in "extend-rel".

Also, why is clojure.core.logic/f-sym and clojure.core.logic/a-sym being used instead of gensym?

[LOGIC-21] Remove ?x variable pattern

Sun, 27 Nov 2011 22:55:26 -0600

?x is a bit noisy. We should just allow defining logic vars via match with any symbol. We can use &env to figure out if the user is referring to existing locals or not.

[LOGIC-20] Switch conde style to use vectors instead of list

Sun, 27 Nov 2011 20:18:16 -0600

Suggested by Christophe Grand.

(defn foo [...]
  (conde
    [(g0 ...) ...]
    [(g1 ...) ...]))

We should update all the source to use this default style.

[LOGIC-32] Unification bug

Thu, 15 Mar 2012 18:17:56 -0500

(run* [q] (== q #{1}))

Results in the following exception:

IllegalArgumentException 
Don't know how to create ISeq from: 
java.lang.Long  clojure.lang.RT.seqFrom (RT.java:487)

[LOGIC-31] unifier is not commutative

Sat, 17 Mar 2012 14:15:11 -0500

I am not sure if this is actually a bug

user=> (require '[clojure.core.logic :as logic])
nil
user=> (logic/unifier (logic/unifier '{:a ?x} '{:a ?y}) '{:a 5})
nil
user=> (logic/unifier (logic/unifier '{:a ?x} '{:a 5}) '{:a ?y})
{:a 5}

For comparison: here is the result of core.unify (and what I expected)

user=> (require '[clojure.core.unify :as unify])
nil
user=> (unify/unifier (unify/unifier '{:a ?x} '{:a ?y}) '{:a 5})
{:a 5}
user=> (unify/unifier (unify/unifier '{:a ?x} '{:a 5}) '{:a ?y})
{:a 5}

[LOGIC-17] ClojureScript compatibility

Sat, 24 Mar 2012 21:11:15 -0500

ClojureScript compatibility

[LOGIC-23] Locals not available in matche

Fri, 9 Dec 2011 12:23:49 -0600

Ran into an issue with the fix for ~~LOGIC-21~~. Locals used inside of a matche clause were not recognized as existing and new fresh values were assigned instead.

(defn locals-membero [x l]
  (matche [l]
          ([[x . tail]])
          ([[head . tail]]
             (membero x tail))))

In the above example, x was not found in locals and a new fresh value was assigned, giving incorrect results. A fix for the issue is attached.

[LOGIC-24] Suspected Regression from 0.6.5-0.6.6

Tue, 10 Jan 2012 21:35:55 -0600

Outlined here: http://stackoverflow.com/questions/8568894/why-run-does-not-work-with-natural-number-in-core-logic

[LOGIC-27] runtime error when using ^:index

Sun, 13 May 2012 11:36:54 -0500

runtime error when using ^:index

[LOGIC-54] Set unification does not operate symmetrically

Thu, 27 Sep 2012 21:38:33 -0500

A check is absent in unify-with-set that would check for missing values in addition to missing lvars. The incorrect behavior is shown below:

user> (run* [out] (== #{out} #{1}))
(1)
user> (run* [out] (== #{1} #{out}))
()

The attached patch includes a similar test to the above and was run against the HEAD as of this posting.

[LOGIC-55] Unification of sets allows for duplicate values leading to non-set-like behavior

Thu, 27 Sep 2012 21:38:47 -0500

Considering this behavior:

user> (run* [out] (== 3 out) (== #{3 out} #{3 out}))
(3)

There are other more convoluted cases involving multiple lvars but I think the above is enough for discussion. I think the above behavior is at least unexpected (desiring documentation) if not actually incorrect behavior.

A possible solution would be to apply distincto (or some equivalent) to the members of each incoming set before the body of unify-with-set (extending IUnifyWithSet to clojure.lang.IPersistentSet). Naturally this makes set unification even more expensive than it currently is but I'm currently inclined to think that this additional cost is unavoidable, at least with the current approach.

[LOGIC-56] Unification of sets does not consider all possibilities

Thu, 27 Sep 2012 21:39:00 -0500

The current unify-with-set logic will unify the first lvars it comes across, preventing backtrack unification with other lvars in the sets. See examples:

user> (run* [out]
        (fresh [a b c d]
          (== out [a b c d])
          (== #{a b} #{c d})))
([_.0 _.1 _.0 _.1])

user> (run* [out]
        (fresh [a b c d]
          (== out [a b c d])
          (== [a c] [7 9])
          (== #{a b} #{c d})))
()

I'm still thinking of a way to efficiently handle this but wanted to post it when I came across it.

[LOGIC-37] The facts and retractions functions do not take the relation's namespace into account when resolving the index.

Thu, 27 Sep 2012 21:52:52 -0500

Inserting facts into a relation that is defined in another namespace, specifically a namespace that has been required but not referred (I don't see the bug if I :use the other namespace).

I've tracked the problem down to this line:

https://github.com/clojure/core.logic/blob/master/src/main/clojure/clojure/core/logic.clj#L1621

In the facts function, when the relation index gets resolved, the namespace is not taken into account,

index (var-get (resolve (index-sym (.name rel) arity o)))

as it is when resolving the relation set.

rel-set (var-get (ns-resolve rel-ns (set-sym (.name rel) arity)))

Using ns-resolve, with rel-ns, seems to fix the issue for me.

index (var-get (ns-resolve rel-ns (index-sym (.name rel) arity o)))

[LOGIC-46] Unification on Struct Maps Causes Error

Thu, 4 Oct 2012 19:30:41 -0500

Unless two struct maps satisfy identical?, attempting to unify on them results in an error. Consider the following:

(defstruct element :tag :attrs :content)
(def an-element (struct element :div [] "bar"))

(run* [q]
  (membero an-element (all-elements))

Results in:

java.lang.RuntimeException: Can't remove struct key
 at clojure.lang.Util.runtimeException (Util.java:156)
    clojure.lang.PersistentStructMap.without (PersistentStructMap.java:178)
    clojure.lang.RT.dissoc (RT.java:736)
    clojure.core$dissoc.invoke (core.clj:1404)
    clojure.core.logic$eval4245$fn__4246.invoke (logic.clj:1430)
    clojure.core.logic$eval2230$fn__2231$G__2221__2240.invoke (logic.clj:36)
    clojure.core.logic$eval4139$fn__4140.invoke (logic.clj:1280)
    clojure.core.logic$eval2050$fn__2051$G__2041__2060.invoke (logic.clj:18)

During unification for IPersistentMap, the two map-like arguments have the just-compared entry removed with dissoc on recursion. For struct maps, this obviously throws the above error, whereas for Clojure records it "downgrades" them to regular maps (also sub-optimal).

(Aside: I've encountered the above using Christophe Grand's Enlive library, which still uses struct maps for modeling parsed HTML/XML documents.)

[LOGIC-49] minimal map type for unifying only part of a map

Fri, 12 Oct 2012 13:52:05 -0500

currently it's a bit obnoxious that map unification must be over the entire map. It would be useful to have a new datatype - partial-map this would allow us to only match part of a map instead of the whole thing. Is this unsound?

[LOGIC-62] distincto bug

Fri, 26 Oct 2012 00:39:44 -0500

(run 16 [q] (distincto q) (everyo #(membero % (range 3)) q))
;; returns (() [0] [1] [2] (0 0) (0 1) (1 0) (0 2) (1 1) (2 0) (1 2) (2 1) (2 2) (0 0 0) (0 0 1) (0 1 0)), incorrect

[LOGIC-60] Simple unification and partial-map support for ClojureScript

Fri, 26 Oct 2012 00:40:52 -0500

This ports over the simple unifier (and prep and binding-map) as well as the partial-map support into ClojureScript. Additionally some deprecated protocol use was patched up.

[LOGIC-57] poor performance when using tabling

Fri, 26 Oct 2012 01:01:00 -0500

poor performance when using tabling

[LOGIC-52] Bug in finite domains (+fd, infd)

Fri, 26 Oct 2012 01:03:46 -0500

When running the code:

(run* [q]
(fresh [a b c d]
(infd a b c d (domain 1 3 4 5))
(+fd b 1 a)
(+fd c 1 b)
(+fd d 1 c)
(== q [a b c d])))

I get the ouput:

([5 4 3 1])

But I would expect:

()

Because [5 4 3 1] is no sequence where the next element is always one number higher than the one before.

It seems to me like +fd behaves as it would take the next element in the domain, instead of taking the next higher number (I hope I didn't misunderstand +fd or infd).

[LOGIC-39] core.logic is inconsistent in how it handles nil and false

Fri, 26 Oct 2012 01:07:50 -0500

Unification failure should always return nil. The fact that we sometimes return false and sometimes return nil creates problems when providing lower level data sources.

[LOGIC-63] Prep's use of metadata needs to be extended to other objects in ClojureScript

Fri, 26 Oct 2012 17:53:04 -0500

The simple unifier and binding-map work great in the simple cases, but fail with more complicated unification.
The root cause is prep's use of metadata banging up against JS Objects.

For the cases that fail, see the current failing tests:
https://github.com/clojure/core.logic/blob/master/src/test/cljs/cljs/core/logic/tests.cljs#L871

[LOGIC-61] partial-map in ClojureScript does not correctly unify map members

Fri, 26 Oct 2012 18:04:59 -0500

In the most recent changes to the core.logic's CLJS support (~~LOGIC-60~~), partial-map does not correctly unify the members within the map:

(m/run* [q]
  (m/fresh [pm x]
    (m/== pm (partial-map {:a x}))
    (m/== pm {:a 1 :b 2})
    (m/== x q))))
=> (1)

but,

(m/run* [q]
  (m/fresh [pm x]
    (m/== pm (partial-map {:a x}))
    (m/== pm {:a 1 :b 2})
    (m/== pm q))))
=> (#PMap{:a <lvar:x_3>})

The latter should unify to {:a 1}

[LOGIC-67] match(e/a) in ClojureScript always creates free var

Wed, 14 Nov 2012 17:52:35 -0600

The following code:

(defn map-geto* [m k v]
  (matche [m]
    ([[[k v] . _]])
    ([[_ . tail]] (map-geto* tail k v))))

(run* [q] (map-geto* (seq {:title "Blub" }) :title q))

works in Clojure as expected, returning ("Blub"). However in ClojureScript I get (_.0) instead. From what I can tell, this is because within the matche clause that matches [k v], both k and v are not being matched against the upper k and v, but rather create fresh variables instead.
I can work around the issue by writing the following:

(defn map-geto* [m k v]
  (matche [m]
    ([[[k' v'] . _]] (== k k') (== v v'))
    ([[_ . tail]] (map-geto* tail k v))))

(run* [q] (map-geto* (seq {:title "Blub" }) :title q))

Is this intended behavior?

[LOGIC-69] prep does not properly recurse terms

Wed, 21 Nov 2012 08:57:52 -0600

(prep {:a {:b ?c} :d ?d})

?c is not walked according to Kevin Lynagh. This should also handle complex map keys.

[LOGIC-72] Unification with partial-map fails when a map contains a map value with extra keys

Fri, 23 Nov 2012 15:58:44 -0600

Unification fails for partial-map when there is a partial match on a sub-map.

A failing test case:

(is (= '[#clojure.core.logic.PMap{:a {:b 2}}]
         (run* [q]
           (fresh [pm x]
             (== (partial-map {:a {:b x}}) pm)
             (== {:a {:b 2 :c 3}} pm)
             (== q pm)))))

[LOGIC-73] Usage of c.c.l/prep can lead to a different result (compared to not using it)

Fri, 23 Nov 2012 22:03:36 -0600

Below are two expressions that differ only in the use of c.c.l/prep. When using prep there is an extra term returned, that includes a free ?a, which seems wrong, considering the second pattern should unify on the :a key.

(let [rules
      [{:pattern (partial-map (prep {:a :clojure.core.logic/not-found :x 1}))
        :production (prep {:a 1})}
       {:pattern (partial-map (prep {:a '?a :c :clojure.core.logic/not-found}))
        :production (prep {:c '(* ?a 2)})}]]
  (run* [q]
    (fresh [pattern production guards rule rule-name]
      (membero {:pattern pattern :production production} rules)
      (== {:x 1}  pattern)
      (== q production))))
  => ({:a 1} {:c (* _.0 2)})

(let [rules
      [{:pattern (partial-map {:a :clojure.core.logic/not-found :x 1})
        :production {:a 1}}
       {:pattern (partial-map {:a '?a :c :clojure.core.logic/not-found})
        :production {:c '(* ?a 2)}}]]
  (run* [q]
    (fresh [pattern production guards rule rule-name]
      (membero {:pattern pattern :production production} rules)
      (== {:x 1}  pattern)
      (== q production))))
  => ({:a 1})

[LOGIC-75] Combining maps and finite domains in core.logic returns only one result

Wed, 12 Dec 2012 11:53:35 -0600

I'm trying to combine maps with finite domains with some odd results.

A simple query using finite domains correctly returns all values:

(run* [q]
	  (fresh [x]
	    (infd x (interval 1 3))
	    (== q x)))
	
	;=> (1 2 3)

But putting this result in a map returns only the first value:

(run* [q]
	  (fresh [x]
	    (infd x (interval 1 3))
	    (== q {:foo x})))
	
	;=> ({:foo 1})

FYI this works with vectors:

(run* [q]
	  (fresh [x]
	    (infd x (interval 1 3))
	    (== q [x])))
	
	;=> ([1] [2] [3])

But lcons seems to fail as well:

(run* [q]
	  (fresh [x]
	    (infd x (interval 1 3))
	    (== q (lcons x 'foo))))
	
	;=> ((1 . foo))

[LOGIC-58] make defrecord unification easier to adopt

Sat, 15 Dec 2012 19:19:25 -0600

make defrecord unification easier to adopt

[LOGIC-45] add everyo (?) when we want to apply a goal to every element of a sequence.

Sat, 15 Dec 2012 19:21:32 -0600

It's a common pattern to do the following

(defn everyo [g xs]
  (if (seq xs)
    (all
      (g (first xs))
      (everyo g (next xs)))
    succeed))

We should add this to the standard library.

[LOGIC-81] predc constraint is not enforced when it could be

Thu, 20 Dec 2012 09:43:08 -0600

The predc number constraint fails to be enforced here.

(is (= (run* [q]
           (fresh [x]
             (== q x)
             (predc q number? `number?)
             (== x "foo")))
        ())) ;; false -- actual is ((_0 :- number?))

Inverting the first two goals gives the expected result.

(is (= (run* [q]
           (fresh [x]
             (predc q number? `number?)
             (== q x)
             (== x "foo")))
        ())) ;; OK

[LOGIC-82] conso and seq, when unifying tail later

Thu, 20 Dec 2012 23:50:14 -0600

These two snippets should both succeed, but the second one fails.

(run 1 [q]
  (fresh [a c]
    (conso a nil c)
    (== `(~a) c))) ;; '(_0)

(run 1 [q]
  (fresh [a b c]
    (conso a b c)
    (== b nil)
    (== `(~a) c))) ;; expected: '(_0), actual: '()

[LOGIC-79] Setting finite domain on more than two lvars using domain fn throws UnsupportedOperationException

Thu, 20 Dec 2012 23:51:55 -0600

When specifying domains on more than two lvars core.logic 0.8.0-beta3 throws an UnsupportedOperationException. Here's an example:

(run* [q]
    (fresh [x y z]
        (infd x y z (domain 1 2 3))
  	    (<fd x y)
  	    (<fd y z)
        (== q [x y z])))

0.8.0-beta2: nil.
0.8.0-beta3: UnsupportedOperationException count not supported on this type: FiniteDomain clojure.lang.RT.countFrom (RT.java:545)
0.8.0-beta4-SNAPSHOT (739ec7e): ([1 2 3]) (correct result)

I've checked and commit 07f2f6a introduced the fix, so this is possibly related to ~~LOGIC-77~~.

When trying to isolate the bug I found that:

Using `(interval 1 3)` instead of `(domain 1 2 3)` works.
Using two fresh variables instead of three works:

(run* [q]
      (fresh [x y]
	      (infd x y (domain 1 2))
  	    (<fd x y)
        (== q [x y])))
;=> ([1 2])

Here's a test that checks the behavior. The test works in the latest version but fails in all commits before 07f2f6a.

(deftest test-domfd-three-lvars []
  (is (= (run* [q]
           (fresh [x y z]
           (infd x y z (domain 1 2 3))
           (<fd x y)
           (<fd y z)
           (== q [x y z])))
         '([1 2 3]))))

[LOGIC-85] another issue with predc constraint is not enforced when it could be

Mon, 24 Dec 2012 18:14:21 -0600

This returns ([1 1]) instead of ().

(run* [q]
  (fresh [x y]
    (predc y even? `even?)
    (predc x odd? `odd)
    (== x y)
    (== x 1)
    (== q [x y]))))

[LOGIC-77] Finite-domain vars inside a vector crash when constrained.

Mon, 24 Dec 2012 18:14:34 -0600

I don't know a lot about the finite domain code, but it surprised me that this crashes:

(run 1 [r a b x]
  (== r [a b])
  (infd a b x (domain 1 2))
  (<fd a b)
  (firsto r x))

This was the most minimal example I could come up with.

[LOGIC-76] partial-maps break the transitivity of unification

Fri, 28 Dec 2012 00:42:54 -0600

partial-map should never unify with fresh vars - this should be a hard error. This means partial-map functionality needs to be accessible by some other means - probably a constraint - `featurec` might be a good name for it. This way partial-maps never leak into an actual program, and users don't try to make the concrete data structure participate in unification. At the same time this does allow extracting features of interest via unification once the term (map) being checked actually becomes ground.

[LOGIC-59] tabled goals should have tables local to a particular run

Fri, 28 Dec 2012 20:35:26 -0600

Currently tabled goals cannot be used across multiple runs which is simply awful.

[LOGIC-78] nominal unification inspired by alphaKanren

Mon, 31 Dec 2012 10:14:50 -0600

The new core.logic.nominal namespace implements the alphaKanren primitive fresh, tie and hash.
The tests also run the examples from the alphaKaren paper.

See https://github.com/clojure/core.logic/pull/12 for the patch in progress.

(Meta: Should I add the patch-in-progress now or wait until we finalize the review on GitHub?)

[LOGIC-84] make occurs-check a field

Tue, 1 Jan 2013 12:38:35 -0600

This way we can control occurs-check without worrying about laziness.

[LOGIC-92] nominal is missing a few constraints-related tweaks

Wed, 2 Jan 2013 09:17:25 -0600

These tests fail. We get only the first result.

(is (= (run* [q]
           (fresh [x]
             (nom/fresh [a]
               (infd x (interval 1 3))
               (== q (nom/tie a x)))))
        [(nom/tie 'a_0 1) (nom/tie 'a_0 2) (nom/tie 'a_0 3)]))
  (is (= (run* [q]
           (nom/fresh [a b c]
             (fresh [x]
               (infd x (interval 1 3))
               (== (nom/tie b (nom/tie a x)) (nom/tie c q)))))
        [(nom/tie 'a_0 1) (nom/tie 'a_0 2) (nom/tie 'a_0 3)]))

[LOGIC-94] nominal, spurious nil

Thu, 3 Jan 2013 18:51:49 -0600

(nth
    (run 2 [q]
      (nom/fresh [a0 a1]
        (redo* q `((~'fn ~(nom/tie a0 a0)) (~'fn ~(nom/tie a1 a1))))))
    1) ; => ((fn  [a_0] (quote ((fn  [a_1] a_1) (fn  [a_2] a_2)))) nil)

[LOGIC-97] disequality pruning

Fri, 4 Jan 2013 13:13:54 -0600

Why we need disequality pruning in updatec:

(run* [q]
           (fresh [x y z]
             (!= x [y])
             (== x [z])
             (== y 'foo)
             (== z 'bar)))

Instead of returning just '(_0), this snippet returns '((_0 :- (!= ([bar] [foo])))).

[LOGIC-101] nom/hash and variable noms

Mon, 7 Jan 2013 08:34:21 -0600

It would be nice if nom/hash handled variable noms:

(run* [q]
  (nom/fresh [x]
    (fresh [y]
      (nomo y)
      (nom/hash y x)
      (== x y)))

This returns '(_0) instead of (). Fortunately, a work-around is to use != instead of nom/hash when comparing two noms. However, it's bad that this silently does something unexpected.

[LOGIC-103] another non-termination case with CLP(FD)

Thu, 10 Jan 2013 17:37:50 -0600

(run 2 [q]
  (fresh [a b s p]
    (infd a b (interval 2 99))
    (<=fd b a)
    (+fd a b s)
    (*fd a b p)
    (== q [a b s p])))

It's strange that we don't get the next possibility.

[LOGIC-104] -merge-doms for ::nom is not closed under composition

Fri, 11 Jan 2013 08:35:03 -0600

(run* [q]
  (nom/fresh [a b c d]
    (fresh [x y z]
      (== (nom/tie a (nom/tie b y)) (nom/tie b (nom/tie a x)))
      (== (nom/tie c (nom/tie d x)) (nom/tie d (nom/tie c z)))
      (== x y)
      (== z x))))

The snippet above fails with a no implementation of method -merge-doms for LazySeq, because -merge-doms for ::nom is implemented for vectors but returns a lazy seq, not a vector.

The simplest fix is to change `concat` to `into` in the -merge-doms implementation of nominal.clj. However, while I am at it, I will replace the vector with a set, which makes more sense given how it's used anyways.

Patch will be attached shortly.

[LOGIC-98] nominal unification misses after-the-fact fd constraints

Fri, 11 Jan 2013 10:49:38 -0600

Related to http://dev.clojure.org/jira/browse/LOGIC-92, these two snippets both return (nom/tie 'a_0 1) instead of three results for 1, 2, 3.

(run* [q]
  (nom/fresh [a b c]
    (fresh [x y]
      (== (nom/tie b (nom/tie a x)) (nom/tie c q))
      (infd x (interval 1 3)))))

(run* [q]
  (nom/fresh [a b c]
    (fresh [x y]
      (infd y (interval 1 3))
      (== (nom/tie b (nom/tie a x)) (nom/tie c q))
      (== x y))))

[LOGIC-105] java.lang.IllegalArgumentException: No single method: _id of interface: clojure.core.logic.IConstraintId found for function: -id of protocol: IConstraintId

Fri, 18 Jan 2013 09:53:51 -0600

When compiling this project https://github.com/timowest/symbol with the master version of core.logic I run into the following stacktrace

Exception in thread "main" java.lang.IllegalArgumentException: No single method: _id of interface: clojure.core.logic.IConstraintId found for function: -id of protocol: IConstraintId, compiling:(clojure/core/logic.clj:177:5)
at clojure.lang.Compiler.analyzeSeq(Compiler.java:6566)
at clojure.lang.Compiler.analyze(Compiler.java:6360)
at clojure.lang.Compiler.analyze(Compiler.java:6321)
at clojure.lang.Compiler$IfExpr$Parser.parse(Compiler.java:2668)
at clojure.lang.Compiler.analyzeSeq(Compiler.java:6559)
at clojure.lang.Compiler.analyze(Compiler.java:6360)
at clojure.lang.Compiler.analyze(Compiler.java:6321)
at clojure.lang.Compiler$BodyExpr$Parser.parse(Compiler.java:5707)
at clojure.lang.Compiler$FnMethod.parse(Compiler.java:5138)
at clojure.lang.Compiler$FnExpr.parse(Compiler.java:3750)
at clojure.lang.Compiler.analyzeSeq(Compiler.java:6557)
at clojure.lang.Compiler.analyze(Compiler.java:6360)
at clojure.lang.Compiler.analyzeSeq(Compiler.java:6547)
at clojure.lang.Compiler.analyze(Compiler.java:6360)
at clojure.lang.Compiler.access$100(Compiler.java:37)
at clojure.lang.Compiler$DefExpr$Parser.parse(Compiler.java:528)
at clojure.lang.Compiler.analyzeSeq(Compiler.java:6559)
at clojure.lang.Compiler.analyze(Compiler.java:6360)
at clojure.lang.Compiler.analyze(Compiler.java:6321)
at clojure.lang.Compiler.eval(Compiler.java:6622)
at clojure.lang.Compiler.load(Compiler.java:7062)
at clojure.lang.RT.loadResourceScript(RT.java:361)
at clojure.lang.RT.loadResourceScript(RT.java:352)
at clojure.lang.RT.load(RT.java:431)
at clojure.lang.RT.load(RT.java:402)
at clojure.core$load$fn__5039.invoke(core.clj:5520)
at clojure.core$load.doInvoke(core.clj:5519)
at clojure.lang.RestFn.invoke(RestFn.java:408)
at clojure.core$load_one.invoke(core.clj:5326)
at clojure.core$load_lib$fn__4988.invoke(core.clj:5365)
at clojure.core$load_lib.doInvoke(core.clj:5364)
at clojure.lang.RestFn.applyTo(RestFn.java:142)
at clojure.core$apply.invoke(core.clj:619)
at clojure.core$load_libs.doInvoke(core.clj:5403)
at clojure.lang.RestFn.applyTo(RestFn.java:137)
at clojure.core$apply.invoke(core.clj:621)
at clojure.core$use.doInvoke(core.clj:5497)
at clojure.lang.RestFn.invoke(RestFn.java:421)
at symbol.types$eval75$loading_4931auto___76.invoke(types.clj:9)
at symbol.types$eval75.invoke(types.clj:9)
at clojure.lang.Compiler.eval(Compiler.java:6618)
at clojure.lang.Compiler.eval(Compiler.java:6607)
at clojure.lang.Compiler.load(Compiler.java:7062)
at clojure.lang.RT.loadResourceScript(RT.java:361)
at clojure.lang.RT.loadResourceScript(RT.java:352)
at clojure.lang.RT.load(RT.java:431)
at clojure.lang.RT.load(RT.java:402)
at clojure.core$load$fn__5039.invoke(core.clj:5520)
at clojure.core$load.doInvoke(core.clj:5519)
at clojure.lang.RestFn.invoke(RestFn.java:408)
at clojure.core$load_one.invoke(core.clj:5326)
at clojure.core$load_lib$fn__4988.invoke(core.clj:5365)
at clojure.core$load_lib.doInvoke(core.clj:5364)
at clojure.lang.RestFn.applyTo(RestFn.java:142)
at clojure.core$apply.invoke(core.clj:619)
at clojure.core$load_libs.doInvoke(core.clj:5403)
at clojure.lang.RestFn.applyTo(RestFn.java:137)
at clojure.core$apply.invoke(core.clj:619)
at clojure.core$require.doInvoke(core.clj:5486)
at clojure.lang.RestFn.invoke(RestFn.java:408)
at symbol.includes_test$eval69$loading_4931auto___70.invoke(includes_test.clj:9)
at symbol.includes_test$eval69.invoke(includes_test.clj:9)
at clojure.lang.Compiler.eval(Compiler.java:6618)
at clojure.lang.Compiler.eval(Compiler.java:6607)
at clojure.lang.Compiler.load(Compiler.java:7062)
at clojure.lang.RT.loadResourceScript(RT.java:361)
at clojure.lang.RT.loadResourceScript(RT.java:352)
at clojure.lang.RT.load(RT.java:431)
at clojure.lang.RT.load(RT.java:402)
at clojure.core$load$fn__5039.invoke(core.clj:5520)
at clojure.core$load.doInvoke(core.clj:5519)
at clojure.lang.RestFn.invoke(RestFn.java:408)
at clojure.core$load_one.invoke(core.clj:5326)
at clojure.core$load_lib$fn__4988.invoke(core.clj:5365)
at clojure.core$load_lib.doInvoke(core.clj:5364)
at clojure.lang.RestFn.applyTo(RestFn.java:142)
at clojure.core$apply.invoke(core.clj:619)
at clojure.core$load_libs.doInvoke(core.clj:5403)
at clojure.lang.RestFn.applyTo(RestFn.java:137)
at clojure.core$apply.invoke(core.clj:619)
at clojure.core$require.doInvoke(core.clj:5486)
at clojure.lang.RestFn.invoke(RestFn.java:408)
at user$eval29$fn__50.doInvoke(NO_SOURCE_FILE:1)
at clojure.lang.RestFn.applyTo(RestFn.java:137)
at clojure.core$apply.invoke(core.clj:617)
at user$eval29.invoke(NO_SOURCE_FILE:1)
at clojure.lang.Compiler.eval(Compiler.java:6618)
at clojure.lang.Compiler.eval(Compiler.java:6608)
at clojure.lang.Compiler.eval(Compiler.java:6581)
at clojure.core$eval.invoke(core.clj:2852)
at clojure.main$eval_opt.invoke(main.clj:300)
at clojure.main$initialize.invoke(main.clj:319)
at clojure.main$null_opt.invoke(main.clj:354)
at clojure.main$main$fn__6676.invoke(main.clj:432)
at clojure.main$main.doInvoke(main.clj:429)
at clojure.lang.RestFn.invoke(RestFn.java:421)
at clojure.lang.Var.invoke(Var.java:419)
at clojure.lang.AFn.applyToHelper(AFn.java:163)
at clojure.lang.Var.applyTo(Var.java:532)
at clojure.main.main(main.java:37)
Caused by: java.lang.IllegalArgumentException: No single method: _id of interface: clojure.core.logic.IConstraintId found for function: -id of protocol: IConstraintId
at clojure.lang.Compiler$InvokeExpr.<init>(Compiler.java:3422)
at clojure.lang.Compiler$InvokeExpr.parse(Compiler.java:3629)
at clojure.lang.Compiler.analyzeSeq(Compiler.java:6561)
... 99 more
Subprocess failed

[LOGIC-106] cannot use fresh/conde in the invoke of a constraint

Mon, 21 Jan 2013 11:56:41 -0600

This means that we cannot really emulate modes with constraints. The problem is related to -inc.

An easy way to try it out is to have a dummy fresh goal in predc and see the failing tests.

@@ -2932,7 +2932,7 @@
        (invoke [this a]
          (let [x (walk a x)]
            (when (p x)
-             ((remcg this) a))))
+             (bind* a (fresh [y] (== x x)) (remcg this)))))
        IConstraintOp
        (rator [_] (if (seq? pform)
                     `(predc ~pform)

[LOGIC-109] custom defc constraint does not run

Tue, 29 Jan 2013 11:26:59 -0600

I have a custom constrain defined using defc, it looks like

(defc string-containsc [x y]
  (and (string? x)
       (.contains x y)))

I have a little core.logic program

(defn t []
  (logic/run* [q]
    (c/string-containsc q "foo")
    (logic/== q 1)))

the result of calling t is (1)

if I change the order of the goals:

(defn t []
  (logic/run* [q]
    (logic/== q 1)
    (c/string-containsc q "foo")))

the result of (t) is ()

[LOGIC-111] conda expression that no longer works in rc2

Wed, 13 Feb 2013 14:56:48 -0600

(run* [x]
  (conda 
    [succeed
      (project [x] succeed)
      (project [x] succeed)]))

This is issue was reported by the damp.ekeko developers.

[LOGIC-113] A conde clause that beings with a fresh expression will initially fail

Fri, 15 Feb 2013 12:49:03 -0600

(ns test                                                                                                                                                                          
  (:refer-clojure :exclude [==])                                                                                                                                                  
  (:require                                                                                                                                                                       
   [clojure.core.logic :refer :all]))                                                                                                                                             

;; This expression should evaluate to true, but it does not, 
;; because the second run* returns (2 1) instead of (1 2).
                                                                                                                                                                                  
(= (run* [q]                                                                                                                                                                      
     (conde                                                                                                                                                                       
       [(== q 1)]                                                                                                                                                                 
       [(== q 2)]))                                                                                                                                                               
   (run* [q]                                                                                                                                                                      
     (conde                                                                                                                                                                       
       [(fresh [a] (== q 1))]                                                                                                                                                     
       [(== q 2)])))

[LOGIC-115] fd/interval with (== lb ub) fails

Tue, 19 Feb 2013 19:38:54 -0600

Test case:

(run* [q] (fd/in q (fd/interval 3 3)))

[LOGIC-102] generalize the notion of hash for robustness

Mon, 11 Mar 2013 12:30:03 -0500

The second nom/hash throws an exception, because the nom/hash constraint is ran before the predc one.

(is (= (run* [q]
         (nom/fresh [x]
           (fresh [y]
             (predc y nom? `nom?)
             (nom/hash y x)
             (== y 'foo))))
      ()))

(is (= (run* [q]
         (nom/fresh [x]
           (fresh [y]
             (nom/hash y x)
             (predc y nom? `nom?)
             (== y 'foo))))
      ()))

Perhaps, we can generalize the notion of hash.

[LOGIC-112] Incorrect results with tabled resolution

Wed, 13 Mar 2013 08:51:19 -0500

We (authors of damp.qwal and damp.ekeko) are trying to track the cause of some indeterminism with respect to the solutions to a path query over a control flow graph. To this end, we wrote a small test case that mimics the qwal part of the query. This test case works under core.logic 0.7.5, but exhibits incorrect behavior in the latest release.

The test case illustrates two problems:
First, the solutions to two logically equivalent path queries return differ. The query that uses predicate test-2 returns the correct amount of solutions (4 nodes encountered on the single path through a graph).
The query that uses predicate test-1 returns just 2 nodes.

damp.tabling-test> (test-1)
(:baz :quux)
damp.tabling-test> (test-2)
(:foo :bar :baz :quux)

Both queries skip an arbitrary number of nodes (using patho), capture a node to obtain a solution (through unification), and skip an arbitrary number of nodes.
The predicates only differ in the last step: either this is achieved by including 'patho' as the last element in the last that is passed to solve-goals, or by calling 'patho' separately after the call to solve-goals. Logic-wise, both queries should be equivalent. Note that omitting 'tabled' from the definition of 'patho' causes the tests to behave as expected.

Second, we encountered a minor issue concerning the number of results returned by the faulty query. This sometimes changes when the file is recompiled.

damp.tabling-test> (test-1)
(:quux)
;;recompile
damp.tabling-test> (test-1)
(:baz :quux)

More comments can be found in the code for the test case that is attached.

[LOGIC-122] Subpattern {?x (?y ?y)} fails to unify

Sun, 17 Mar 2013 11:39:25 -0500

This expression should unify but doesn't:

(unify {:as '{?x (?y ?y)}} '[[?y ?x] [1 (1 1)]])

[LOGIC-121] Unifier fails on some nested forms

Sun, 17 Mar 2013 11:39:47 -0500

The expression

(unifier '[((?x ?y)) ((1 2))])

returns the (invalid) result {?x 1}. Note that unify works as expected:

(unify '[((?x ?y)) ((1 2))])
=> ((1 2))

[LOGIC-120] (unify '[?x 1]) throws IllegalArgumentException

Sun, 17 Mar 2013 11:40:06 -0500

The following two expressions throws IllegalArgumentException Don't know how to create ISeq from: java.lang.Long:

(unify '[?x 1])

(unifier '[?x 1])

The same thing happens for any non-sequential form.

[LOGIC-116] ClassCastException in core.logic depending on ordering

Sun, 17 Mar 2013 18:29:49 -0500

I have two files:
1 -https://github.com/m0smith/LogicPuzzles/blob/master/src/logicpuzzles/coresucceed.clj
2 -https://github.com/m0smith/LogicPuzzles/blob/master/src/logicpuzzles/corefail.clj

The first one compiles and runs fine. The second throws a ClassCastException. The only difference is that rule-0 is moved in the second file.

[LOGIC-71] set reify-vars to false for the user if the unifier is given more than 2 arguments

Sun, 17 Mar 2013 18:47:52 -0500

(unifier '(?x) '(?x) '(1))

This will fail which is surprising.

[LOGIC-36] Unification bug in binding-map

Sun, 17 Mar 2013 18:52:10 -0500

I tried some tests of core.unify against core.logics binding-map function and found some inconsistencies:
(binding-map '(?x ?y) '(?y ?x)) ==> {?y _.0, ?x _.0}
while core.unify returns ==> {?x ?y}

[LOGIC-108] featurec or something similar to provide recursive partial partial map constraints

Sun, 17 Mar 2013 19:50:16 -0500

featurec or something similar to provide recursive partial partial map constraints

[LOGIC-124] Order of args to fd/!= changes results (gives incorrect answer)

Sun, 24 Mar 2013 14:47:55 -0500

I have attached a failing test for the Arch Friends logic puzzle. Swapping the args to fd's != fixes the problem. So does moving the call to fd's != to after the fd's == or fd's + below it.

Tried this on 0.8.0-rc2, 0.8.0 and 0.8.1.

[LOGIC-125] Using membero with a vector as an element

Mon, 25 Mar 2013 11:31:39 -0500

Running this code gives an unexpected result of only one of the 2 members being present:

(defn solve1 [q]
  (symbol-macrolet   [_ (lvar)]
          (membero [_ _ 'blue-cheese 'Fortune] q) ;; 2
          (membero [:5:00 _ 'mozzarella _] q) ;; 11
          ))

(run 1 [q] (solve1 q))
=> (([:5:00 _0 mozzarella _1] . _2))

While adding an empty fresh seems to resolve the problem:

(defn solve2 [q]
  (symbol-macrolet   [_ (lvar)]
   (fresh []
          (membero [_ _ 'blue-cheese 'Fortune] q) ;; 2
          (membero [:5:00 _ 'mozzarella _] q) ;; 11
        )))

(run 1 [q] (solve2 q))
=> (([_0 _1 blue-cheese Fortune] [:5:00 _2 mozzarella _3] . _4))

[LOGIC-126] fd/* and fd/+ interaction bug

Thu, 28 Mar 2013 22:40:58 -0500

Via this StackOverflow question http://stackoverflow.com/questions/15671823/unexpected-results-with-clojure-core-logic-using-clp-fd

(defn product-pluso [factor1 factor2 number sum]
  (fd/eq (= sum (+ number (* factor1 factor2)))))

(run* [x y]
  (fd/in x y (fd/interval 1 38))
  (product-pluso x y 2 40))

Returns too many answers. Even if we desugar into:

(run* [q]
  (fresh [x y p]
    (fd/in x y (fd/interval 1 38))
    (fd/* x y p)
    (fd/+ p 2 40)
    (== q [x y p])))

We see results which clearly violate the fd/+ constraint.

[LOGIC-127] Swapping noms turns maps (and other collections) into seqs

Wed, 10 Apr 2013 03:33:00 -0500

When I unify two binders, the swapping procedure turns all the maps inside the body into seqs of key/value pairs, which do not unify with maps, leading to the following trickiness:

(require '[clojure.core.logic :as l])
(require '[clojure.core.logic.nominal :as n])
(l/run* [q]
  (l/fresh [body]
    (n/fresh [a b]
      (l/== (n/tie a {:k a}) (n/tie b body))
      (l/== {:k q} body))))
;=> ()
; Expected (a_0)

For my purposes, fixing this by adding two new implementations of INomSwap for vectors and maps works well.

[LOGIC-132] "PMap is non-storable" exception when using featurec with nested feature map.

Sun, 5 May 2013 19:34:42 -0500

This works as expected:

(run* [x y]
  (featurec x {:a {:b 1}})
  (== y {:b 1})
  (== x {:a y}))

;; => ([{:a {:b 1}} {:b 1}])

But with the last two goals swapped an exception is thrown:

(run* [x y]
  (featurec x {:a {:b 1}})
  (== x {:a y})
  (== y {:b 1}))

;; =>
Exception clojure.core.logic.PMap@3c6f0bed is non-storable
    clojure.core.logic.LVar (logic.clj:647)
    clojure.core.logic/unify (logic.clj:231)
    clojure.core.logic/unify-with-pmap* (logic.clj:2601)
    clojure.core.logic.PMap (logic.clj:2614)
    clojure.core.logic/unify (logic.clj:232)
    clojure.core.logic/==/fn--2819 (logic.clj:1135)
    clojure.core.logic/composeg/fn--2745 (logic.clj:1029)
    clojure.core.logic/-featurec/reify--3655 (logic.clj:2646)
    clojure.core.logic/composeg/fn--2745 (logic.clj:1029)
    clojure.core.logic/composeg/fn--2745 (logic.clj:1030)
    clojure.core.logic/run-constraint/fn--3431 (logic.clj:2184)
    clojure.core.logic/fix-constraints (logic.clj:2211)

The same exception is thrown when (== y {:b 1}) is left out:

(run* [x y]
  (featurec x {:a {:b 1}})
  (== x {:a y}))

[LOGIC-135] membero should be updated to use disequality constraints

Tue, 7 May 2013 22:24:25 -0500

William Byrd considers the version of membero that appears in core.logic to be outdated and inferior to a version that uses disequality constraints. Full discussion here: http://youtu.be/MTAhbsWUUxM?t=1h20m00s

NEW version:

(defne membero
  "A relation where l is a collection, such that l contains x"
  [x l]
  ([_ [x . tail]])
  ([_ [head . tail]]
     (!= x head)       ;; The addition of this line is the only change.
     (membero x tail)))

(run* [q] (membero q [1 1 1])) 
;; => (1)
;; The current version returns (1 1 1).

Patch to follow.

[LOGIC-134] Historic artifacts in the implementation of Choice prevent take* from being generally usable.

Tue, 7 May 2013 23:37:31 -0500

The implementation of Choice is slightly broken, because in certain contexts it is assumed that the first value in the Choice stream will be wrapped in a list. I believe this is a historical artifact; maybe the list wrapper was used to differentiate two types of values, as in the case of distinguishing not-found from nil.

This defect prevents take* from being used generally, since the current implementation of take* for Choice assumes the first value is wrapped in a list, which is not the case for Choice streams during the search.

Patch to follow.

[LOGIC-13] defne and variants should support docstring

Sun, 20 Nov 2011 15:17:51 -0600

defne and variants should support docstring

[LOGIC-4] Don't use extend-type on Substitutions LVar or LCons

Sat, 21 May 2011 13:30:12 -0500

We shouldn't use extend-type to add methods to types we control, unnecessary perf hit.

[LOGIC-2] Provide more convenient syntax for defining a series of facts

Sun, 24 Jul 2011 13:18:42 -0500

Provide more convenient syntax for defining a series of facts

[LOGIC-16] Add print goal

Mon, 14 Nov 2011 07:17:06 -0600

Wrap print and println in a goal.

[LOGIC-19] Make it possible to define facts on a relation defined in a different namespace.

Sun, 13 Nov 2011 22:21:44 -0600

Currently there's no way of defining facts on a relation defined in a different namespace. It would be better to make this possible.

[LOGIC-15] Improved docstrings for relations

Thu, 24 Nov 2011 09:58:09 -0600

I have improved the docstrings of some relations in the prelude, inspired by The Art of Prolog.

[LOGIC-42] Generalize run to accept multiple logic vars

Thu, 14 Jun 2012 09:19:32 -0500

(run 1 [x y z]
  ...goals...)

;; equivalent to

(run 1 [q]
  (fresh [x y z]
    (== q [x y z])
    ...goals...))

[LOGIC-25] Allow retraction of previously stated facts in a relation

Wed, 18 Jan 2012 17:45:07 -0600

For long-running or interactive programs, it is useful to allow facts to become "no longer" true at a point in time.

[LOGIC-40] Retractions with an empty collection produces a NullPointerException

Fri, 18 May 2012 19:24:28 -0500

Example:

(defrel load-factor src snk lf)
(retractions load-factor [])

Results in NPE. Should do nothing without complaining.

[LOGIC-50] Rel relation PersistentHashSet becomes LazySeq after issuing a retraction

Wed, 5 Sep 2012 11:32:52 -0500

The first retraction of facts from a relation transforms the internal PersistentHashSet -set var+atom, which guarantees uniqueness, into a LazySeq which allows duplicate facts to be added. Once the first retraction occurs, a LazySeq persists for the rest of the life of the relation. Only the value of the primary -set var+atom is affected, not the -index var+atom values.

This issue is not an external correctness issue but does affect performance of subsequent duplicate fact additions which grow the size relation.

Preparation:

user=> (defrel foo x y)
#<user$eval4287$fn__4288 user$eval4287$fn__4288@1a9d489b>
user=> (facts foo [[:joe :man][:jane :woman][:sue :boy]])
nil
user=> foo_2-set
#<Atom@52aaf223: #{[:joe :man] [:jane :woman] [:sue :boy]}>
user=> (class @foo_2-set)
clojure.lang.PersistentHashSet
user=> (retraction foo :jane :woman)
nil

Without patch applied:

user=> foo_2-set
#<Atom@52aaf223: ([:joe :man] [:sue :boy])>
user=> (class @foo_2-set)
clojure.lang.LazySeq
user=> (facts foo [[:joe :man][:jane :woman][:sue :boy]])
nil
user=> foo_2-set
#<Atom@52aaf223: ([:sue :boy] [:jane :woman] [:joe :man] [:joe :man] [:sue :boy])>
user=> (class @foo_2-set)
clojure.lang.LazySeq

With patch applied:

user=> foo_2-set
#<Atom@31eb9b15: #{[:joe :man] [:sue :boy]}>
user=> (class @foo_2-set)
clojure.lang.PersistentHashSet
user=> (facts foo [[:joe :man][:jane :woman][:sue :boy]])
nil
user=> foo_2-set
#<Atom@31eb9b15: #{[:joe :man] [:jane :woman] [:sue :boy]}>
user=> (class @foo_2-set)
clojure.lang.PersistentHashSet

I've filed this as a Minor issue as it does not affect core.logic correctness and degraded performance can be avoided by not re-asserting duplicate facts.

I will also issue a GitHub pull request which can be used or ignored at your convenience.

[LOGIC-51] fd comparison relations behave strange when used with literals

Fri, 26 Oct 2012 07:04:24 -0500

The fd comparison relations always succeed when used with strings or a string and an integer:

user> (run* [q]
 (<=fd "foo" "bar"))
(_.0)
user> (run* [q]
 (<=fd "foo" 1))
(_.0)
user> (run* [q]
 (<=fd 1 "bar"))
(_.0)

IMHO, they should always fail if one argument is not a integer.

Furthermore, you get an exception when comparing integers and the larger integer is given first.

user> (run* [q]
 (<=fd 1 2))
(_.0)  ;; That's correct, but...
user> (run* [q]
 (<=fd 2 1))
IllegalArgumentException No implementation of method: :member? of protocol: #'clojure.core.logic/ISet found for class: nil  clojure.core/-cache-protocol-fn (core_deftype.clj:533)

I'd expect that comparisons of two integers should always work. You can circumvent this issue by unifying the numbers with some logic variables first, but is that really needed?

user> (run* [q]
 (fresh [a b]
  (== a 1)
  (== b 2)
  (<=fd a b)))
(_.0)
user> (run* [q]
 (fresh [a b]
  (== a 1)
  (== b 2)
  (<=fd b a)))
()

The first issue cannot be circumvented using this approach, though.

user> (run* [q]
 (fresh [a b]
  (== a "foo")
  (== b 2)
  (<=fd b a)))
(_.0)
user> (run* [q]
 (fresh [a b]
  (== a "foo")
  (== b 2)
  (<=fd a b)))
(_.0)
user> (run* [q]
 (fresh [a b]
  (== a "foo")
  (== b "bar")
  (<=fd a b)))
(_.0)
user> (run* [q]
 (fresh [a b]
  (== a "foo")
  (== b "bar")
  (<=fd b a)))
(_.0)

[LOGIC-64] Support inequalities in finite domain sugar

Sat, 27 Oct 2012 11:33:23 -0500

The attached patch enables the follow code:

(run* [x]
  (infd x (interval 0 9))
  (eqfd (!= 6 (* 2 x))))

You can also substitute != with <, >, >=, or <=

[LOGIC-65] fix for corrupted rel indexes if retracting duplicate tuples

Tue, 30 Oct 2012 18:37:49 -0500

If a duplicate tuple is retracted from a rel, the rel indexes get corrupted, resulting in a NullPointerException when the following query is run:

(defrel rel2 ^:index e ^:index a ^:index v)
(facts rel2 [[:e1 :a1 :v1]
             [:e1 :a2 :v2]])
(retractions rel2 [[:e1 :a1 :v1]
                   [:e1 :a1 :v1]
                   [:e1 :a2 :v2]])

(deftest rel2-dup-retractions
  (is (= (run* [out]
               (fresh [e a v]
                      (rel2 e :a1 :v1)
                      (rel2 e a v)
                      (== [e a v] out))))
      '()))

[LOGIC-100] pruning of unsatisfiable non-ground disequalities

Mon, 7 Jan 2013 11:00:06 -0600

Not sure whether we actually want to do anything about this.

When running this snippet,

(run* [q]
  (fresh [a b]
    (== q [a b])
    (!= a q)))

we get the result:

(([_0 _1] :- (!= (_0 [_0 _1]))))

The reified != constraint is arguably spurious, because of the occurs-check.

Even if we instantiate the a:

(run* [q]
  (fresh [a b]
    (== q [a b])
    (!= a q)
    (== a 1)))

we get the result:

(([1 _0] :- (!= (1 [1 _0]))))

while there is no way the != constraint can be satisfied.

Thoughts?

[LOGIC-107] Less dependencies for non-dev environments?

Tue, 22 Jan 2013 10:37:58 -0600

I am considering using core.logic, but after looking into its dependencies I am hesitating. Should I really pull in datomic and google closure if I just want to use core.logic in a normal Clojure project?

[LOGIC-110] Allow anonymous constraints

Mon, 4 Feb 2013 16:03:59 -0600

Add `fnc` macro that defines anonymous constraints.
Rename `defc` to `defnc` for consistency.

[LOGIC-34] Unification should carry along metadata

Wed, 28 Mar 2012 11:11:30 -0500

Unification should not swallow metadata:

(run* [q]
(== q (quote ^:haz-meta-daytuhs (form form form))))

should yield

(^:haz-meta-daytuhs (form form form))

[LOGIC-74] Bug in conde (ClojureScript)

Sun, 17 Mar 2013 19:00:30 -0500

While working on a project I found a somewhat strange behaviour. I reworked the problem in some simple predicate. Let's take this predicate foobad.

(defn foobad 
  [?bar]
  (l/project [?bar]
    (l/fresh [?var]
      (l/conde 
        [(l/== true (instance? js/Array ?bar))
          (membero ?var (seq ?bar))]))))

When running (l/run* [?f] (foobad 0)) it produces this error:

#<Error: No protocol method ISeqable.-seq defined for type number: 0>

Because 0 is not an instance of Array it should not be entering that conde clause where it tries (seq 0).

With this workaround we get a normal behaviour:

(defn foo 
  [?bar]
  (l/project [?bar]
    (l/fresh [?var]
      (l/conde 
        [(l/== true (instance? js/Array ?bar)) 
         (fresh [?s]
          (l/== ?s (seq ?bar))
          (membero ?var ?s))]))))

Running (l/run* [?f] (foo 0)) gives us (), which is what we expect.
While 0 is clearly not an instance of Array that conde clause is still executed resulting in previous error.

[LOGIC-83] test rel2-dup-retractions may need a fix

Sun, 17 Mar 2013 19:08:31 -0500

src/test/clojure/clojure/core/logic/tests.clj

function rel2-dup-retractions

parentheses may need a fix -> (== ...)

changing the expected expr from '() to '(:x) does
not make this test fail for me.

i like core.logic ... thanks for making it happen

[LOGIC-131] Docstrings for lvaro and nonlvaro need improvement.

Tue, 7 May 2013 22:29:08 -0500

Assuming the following definitions:

1. A term is ground if it does not contain unassociated logic variables.
2. Otherwise, it is non-ground.

My suggestions:

lvaro: A non-relational goal that succeeds if the supplied logic variable is fresh.

nonlvaro: A non-relational goal that succeeds if the supplied logic variable is not fresh.

In the case nonlvaro, it's important to recognize that the implementation only tests whether the supplied lvar is not fresh, and "not fresh" != grounded; the result could be partially instantiated. For example, nonlvaro succeeds here when its argument is neither fresh nor grounded:

(run* [q]
  (fresh [x]
    (== q [x])
    (nonlvaro q)))
;; => ([_0])

[LOGIC-93] eliminate FDConstraint, use a template instead of delegation

Fri, 17 May 2013 00:57:05 -0500

Currently the all different goals will exhibit entailment issues since they have implementations of `IRelevant` that just return `true`.

[LOGIC-12] Improved warnings/errors for pattern matching

Thu, 1 Sep 2011 19:32:20 -0500

I've added some simple syntax checks for the pattern matching macros like matche.

clojure.core.logic.prelude=> (let [x 1]
(matche [x]
(1 [1 1] 1)))
#<CompilerException java.lang.RuntimeException: java.lang.Exception: Expecting vector of matches, instead 1, compiling:(REPL:53)>

clojure.core.logic.prelude=> (let [x 1]
(matche [x]
([1 1] 1)))
#<prelude$eval4469$fn_4471 clojure.core.logic.prelude$eval4469$fn_4471@e9ebe1>
WARNING: Differing number of matches. Matching [1 1] against [x]

clojure.core.logic.prelude=> (let [x 1]
(matche
([1 1] 1)))
#<CompilerException java.lang.Exception: Expecting vector of arguments, instead , compiling:(REPL:58)>

Attached patch.

[LOGIC-14] Typo in docstring

Thu, 1 Sep 2011 19:33:31 -0500

The docstring in clojure.core.logic.arithmatic/<= has a typo in "whether".

[LOGIC-10] Add documentation strings to stable functions

Sun, 20 Nov 2011 15:38:28 -0600

Candidates:

clojure.core.logic.minikanren

==
conde
exist
run
run*
lvar, lvar?
lcons, lcons?
llist

clojure.core.logic.prelude:

nilo, emptyo, conso, firsto, resto, membero

clojure.core.logic.nonrel:

project
lvaro, nonlvaro

[LOGIC-66] Add test-paths to project.clj to be able to run tests with lein2

Tue, 30 Oct 2012 18:39:58 -0500

Add test-paths to project.clj to be able to run tests with lein2. Also remove "src/test/clojure" from :source-paths.

[LOGIC-33] Added usage section to readme.md

Sun, 17 Mar 2013 19:11:55 -0500

added a short usage section in readme.md

the latest working repo was 0.6.7 for me, so that's what in the patch. (i have signed CA)