Clojurians Log v2

https://gist.github.com/aamedina/69e3cf586bfe8eec2449dee3fe9825f5

The essential elements of Datalog are: • a body, which matches patterns against data • a head, which uses bound values from the body to express new data

Traditionally, that’s done using predicate syntax, using comma separators in the body clause to separate multiple conjunctive terms, and :- to separate the head and body clauses: headTerm(arg,arg) :- pattern1(arg,arg), pattern2(arg,arg) . arguments can be ground terms or variables.

However, this is awkward with RDF, since it reorders the triple into: predicate(subject,object) Also, because any of these terms can be IRIs or QNames, then it doesn’t look a lot like standard predicate syntax.

[?d, :deptAvgSalary, ?z] :-
    [?d, rdf:type, :Department],
    AGGREGATE(
        [?x, :worksFor, ?d],
        [?x, :salary, ?s]
        ON ?d
        BIND AVG(?s) AS ?z) .

But most importantly, predicate logic like this doesn’t expect variable predicates, which are just fine in RDF. So using a triple-based syntax seems much more appropriate. RDFox made that switch (triple patterns, rather than predicate statements), but left everything else as-is. Datomic also uses triple-patterns, but then went with its usual data structures for the body, wrapped them in a function-looking syntax, and uses it in a query like a function, rather than the head creating new statements. There’s enough familiarity that it works

yeah if the head were a pattern too then you could have a head like [?x :owl/sameAs ?y]

Well, that would result in a new transaction, which isn’t what Datomic queries are for. But the result of a query can easily be passed in as the data for a transaction that follows it 🙂

Well, I definitely would like to be able to infer triples inside a query, can't speak for most others though

But now yeah I have to do inference and then chain logic

But it's still pretty nice!

That can be done where you say something like (rule-name ?entity ?attr ?value) instead of a standard [?entity ?attr ?value] pattern

Furthermore there is definitely alot of room to compile datalog rules that are more formally specified in a syntax like you shared into Clojure/datomic forms

But you can need a big ruleset to make it work

OWL RL isn't too big

I guess depending on big

Some of those rules aren’t easy to encode though

The only one I am having trouble with is property chain axiom

That one is a mind bender

The rest of pretty straightforward

Yes, I’ve been thinking that int1 would be easier in Clojure (SPARQL is awful for it)

I'm trying to understand the semantics of that vs int2

https://www.w3.org/TR/rif-owl-rl/ this has been the most useful reference ive found because it provides RIF equivalents for the rules and deals with the lists

(* <#cls-int1> *)
  Forall ?y ?c ?l (
    ?y[rdf:type->?c] :- And (
      ?c[owl:intersectionOf->?l]
      _allTypes(?l ?y) ))

  Forall ?l ?y ?ty ?tl (
    _allTypes(?l ?y) :- And (
      ?l[rdf:first->?ty rdf:rest->?tl]
      ?y[rdf:type->?ty]
      _allTypes(?tl ?y) ))

  Forall ?l ?y ?ty (
    _allTypes(?l ?y) :- And (
      ?l[rdf:first->?ty rdf:rest->rdf:nil]
      ?y[rdf:type->?ty] ))

OK, that’d work. It’s very recursive, but I guess that’s ideal for Clojure 🙂

SPIN was a pseudo Datalog, where they decided that mapping standard Datalog constraints to SPARQL was too hard, and they just encoded the SPARQL directly. This made it unstructured, and consequently, there was ability to automate dependencies between productions and rule scheduling. This made it inefficient. But… it worked. There were issues with trying to use it at scale though.

SHACL is basically a concession to software engineers who can’t get their head around the open world assumption, and how to construct constraints in OWL

It’s easy to build, since it can be built out of SPARQL

I do like that it’s declarative, but it is designed for a CWA system. That’s fine if you’re trying to use your RDF graph as a CWA representation of data, but it’s not “Semantic Web”, and breaks a number of assumptions for both RDF and OWL

SPDX adopted SHACL so I need to learn it anyway for software bill of materials

Oh, it’s popular. You need to know it. I just disagree with it 🙂

https://github.com/spdx/spdx-3-model/issues/464 specifications are not easy to collaborate on if you have any insight feel free to add comments I’m trying to understand a bunch of different aspects of the new model and had to reimplement it myself

I’m at work, so I don’t have time to read this, but I’m instantly on my guard reading > “Blank Nodes” - generally said to be harmful in the literature

As step 1, I’d like to know which literature

There are occasions where blank nodes are painful to deal with. In those cases, I advocate for the minting of IRIs. But I can’t fathom what’s considered wrong about them

Ha, yeah. But this kind of thing is common in my experience specifically in this domain

I just have to figure out how to contribute the right ideas :) maybe you can help, but not now

I mean… I’ve heard complaints. I’ve complained about them myself. But the complaints usually miss some elements of modeling. I know that I didn’t get it, because I was looking at it from a storage/querying point of view

I know that there have been some databases which allocated IDs that were externally addressable (e.g. Talis)

A bigger problem (which I’m not sure how to broach effectively) is that they are defining an RDF model with markdown using a WIP format that doesn’t really compile into turtle currently

Instead of collaborating with turtle directly

It doesn’t make contribution easier because the contributors need to learn the markdown format which isn’t specified well

And needs to be extended as they learn about RDF