Fork me on GitHub

@quoll: So I’m toying with reasoning about RDF triples with naga, starting with rdfs ranges. I have the following pabu rule: rdf:type(Z,X) :- rdfs:range(A, X), A(Y, Z). However to make that inference work, I also need the axiomatic triples loaded into naga. Obviously the easiest thing to do is to just load all my data as axioms into naga, which works, however most (if not all) of my axioms will be defined in user supplied data. e.g. for the above range rule to be inferred I also need at least two more axiomatics triple e.g. [:skos/inScheme :rdfs/range :skos/ConceptScheme] (which is trivially provided by loading vocabularies as axioms), however another triple is also required as an axiom e.g. something like [:ref/female :skos/inScheme :scheme/genders]. This final class of axiomatic triples will more commonly be found in my user supplied data, so I need to have a way for any given graph of user data to find and load them into naga. I can see I have all the information to do this. Presumably I just need to look at the graph of user data, and filter it to the set of predicates that are grounded in the antecedents of my rules?


One other thing… I can see when building the naga program that the axioms are defined defined as a lazy sequence, that then appears to get indexed by the storage layer. This makes sense as even though it’s forward chaining you presumably don’t want to do a linear search across axioms in rules that reference multiple axioms. My question is presumably in code like this:

(def program (rules/create-program (:rules rdfs-rules)
                                   (concat user-data
                                           (:axioms rdfs-rules))))

(defn apply-rules [db]
  (engine/run db program))

(-> index/empty-graph
    (graph/graph-transact 0 [user-data] nil)
    (graph-q '[:find ?a ?v :where [:scheme/genders ?a ?v]])
If I use engine/run I’ll presumably index those axioms twice. I’m guessing to avoid this I’ll want to reimplement engine/run to take the axioms from my graph of user-data?


(the above is obviously scratch code btw)


The idea of having “axioms” in a program is for statements that are necessary and the rest of the program won’t run without them, hence you want to ensure that they are present every time. But there is nothing particularly special about them, and they can be inserted whenever and wherever you like… so long as it’s before the program runs. Assuming that a used may want to insert data once was why I took the approach of loading the data separately in the CLI program: I apologize that this code uses the Naga APIs for storage and not the transact function. That’s historical.


You could try something like this instead:

(def program (rules/create-program (:rules rdfs-rules) []))

(-> index/empty-graph
    (graph/graph-transact 0 user-data nil)             ;; load user data
    (graph/graph-transact 0 (:axioms rdfs-rules) nil)  ;; load axioms explicitly
    (engine/run program)                               ;; program does not contain axioms
    (graph-q '[:find ?a ?v :where [:scheme/genders ?a ?v]])


@quoll: Thanks that’s essentially what I wrote first of all, but it doesn’t seem to work, it returns an empty seq:


OK, so this is a bug. Either the connection is not returning the modified graph, or the as-connection is not properly wrapping the graph.


Pretty sure the error is happening between lines 34 and 32. As inspecting the data returned by line 34 you can see the connection contains only the explicit triples and none of the inferred ones:


Inspecting the data at line 32 looks like this:


which yeah you’re right — I think it looks a bit garbled.


ok looks like the issue might be with asami’s graph-transact?! Inspecting this :

(-> index/empty-graph
    (graph/graph-transact 0 [user-data] nil)


 {[:ref/female :skos/inScheme :scheme/genders]
  {[:skos/inScheme :rdfs/range :skos/ConceptScheme] #{nil}}},
 {[:skos/inScheme :rdfs/range :skos/ConceptScheme]
  {nil #{[:ref/female :skos/inScheme :scheme/genders]}}},
  {[:ref/female :skos/inScheme :scheme/genders]
   #{[:skos/inScheme :rdfs/range :skos/ConceptScheme]}}}}


ok I think I just spotted the issue…


Ok @quoll you’ll be relieved that this is a bug in my code, not in asami/naga 🙂

(def user-data [[:ref/female :skos/inScheme :scheme/genders]
                [:skos/inScheme :rdfs/range :skos/ConceptScheme]

    (graph/graph-transact 0 [user-data] nil)
that graph-transact line should be: (graph/graph-transact 0 user-data nil)


With that correction, asami does indeed return the correct / expected results!! partywombat


OK… but I should probably have some better data checking in there. Silently failing while building invalid data structures isn’t particularly user friendly!


Perhaps… I did wonder if your plumatic schema stuff might have caught it, if I’d turned it on in dev with s/set-fn-validation! but I’ve just tried and it seems it still gets through


There are diminishing returns with checking for everything, and the cost can be high


My main reason for using plumatic schema has been documenting APIs. It really helps a lot! It’s also nice when it catches a bug 🙂


agreed — but it can work well to do it in development/repl contexts


For example I’ve just added

  (require '[schema.core :as s])
  (s/set-fn-validation! true))
At the end of my file, so when I hack on this next I can evaluate that and hopefully reduce any other mistakes like this.


I was making shortcuts last night by NOT using schema in my code. You’re going to guilt me into putting it back in 🙂


Well problems like this come with the territory of using a dynamic language. If I thought type systems were more important than everything else I’d be using Haskell or Idris day to day. You’ve clearly pulled in plumatic schema because you feel it benefits cases like this though, so it probably makes sense to keep leveraging it; but please don’t let me guilt you into anything. What you have already is great! 🙇


99% of why I use Schema is to document what a function does. This helps me write and debug code, since I know what is supposed to go in and out. It also documents it for someone else who wants to look at it, but really, I do it for me 🙂

👍 3

catching bugs is just a side effect


Anyway now I’m over this hurdle I shall look forward to playing with naga in my vanishingly little spare time


I have 3 children, so I can relate to this 🙂


I have 2 under 2 😂

❤️ 3

However moving the axioms from the user-data into the naga program does: