Clojurians Log v2

@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)
    asami/as-connection
    apply-rules
    first
    :connection
    asami/db
    asami/graph
    (graph-q '[:find ?a ?v :where [:scheme/genders ?a ?v]])
    )

(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: https://github.com/threatgrid/naga/blob/main/cli/src/naga/cli.clj#L76 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
    asami/as-connection
    (engine/run program)                               ;; program does not contain axioms
    first
    :connection
    asami/db
    asami/graph
    (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:

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