Re: Formalizing PROV-Constraints in OWL?

Hey Stian,

On Aug 7, 2012, at 15:21 , Stian Soiland-Reyes wrote:

> On Tue, Aug 7, 2012 at 11:36 AM, Ivan Herman <ivan@w3.org> wrote:
> 
>> The reason I am asking myself is because (again, I may be proven wrong) I have the impression that the translation of the Prov-Constraints into rules is way more natural (and it seems that a bunch of you guys have already made work on this). Whether we use RIF Core for this (essentially Datalog, if my understanding is correct), SPIN, or simply a set of SPARQL CONSTRUCT/ASK statements (much like Daniel & co. did for the Dublin core document) is a matter of choice, but all these are rule statements. If we have such a set of rules, those would be really useful; I am not sure what we would gain in practice by using OWL here.
>> 
>> (My personal preference would be to take the last alternative, ie, a set of SPARQL statements; the advantage is that it can be executed using any SPARQL processor whereas SPIN needs a particular, company specific implementation. But that is only me.)
> 
> 
> I agree that many of the constraints would fit much better in a rule
> system, in particular the inferences. It depends on what is the
> purpose of the whole thing. The rules would help find all inferences
> and violations of constraints, and would in particular be valuable for
> a validator.
> 
> This 'constraints OWL' should not do that, but would be more of a
> "fill in the blanks" ontology that can express those bits of PROV
> Constraints that can easily be formulated as OWL, but which we did not
> include in PROV-O as it would prevent "sloppy provenance".
> 
> If I am coming from the OWL community, and I pick up PROV-O, read the
> PROV Constraints document, and I see that prov:wasGeneratedBy is
> functional and prov:Usage and prov:Invalidation are disjoint, then I
> would find it a bit odd that this is not expressed anywhere in OWL.
> 
> 
> For instance, I used Elmo (Sesame's Java binding for OWL/RDFS) with
> PROV-O's OWL, and the generated API would seem to encourage me to add
> multiple generations. What would be the outcome of this effort would
> be a kind of 'restricted' or 'strict' OWL that you can choose to use
> if you know you are generating . It won't guarantee that you are not
> making invalid PROV statements, and the OWL reasoner might not give
> you all the inferences that PROV Constraints defines, but it would
> give you as a user of the ontology better guidance. In particular for
> anyone specializing the ontology (such as myself), I think this could
> be worthwhile.
> 
> Before we try, we don't know how good job it can do. If it turns out
> it can barely do 10% of the rules, then it might not be worth it. I
> would not suggest putting loads of effort into this - doing a
> validator would be something that should get more attention in the
> long run.
> 

Ok. I misunderstood the original mail which I read by setting out to describe the _full_ PROV-Constraints in OWL. If the idea is to add those statements that are easy or relatively easy, then I am fine with that (the usage of property chains is another example that is already used...).

But I would actually add then one more constraint: we should not lead the ontology further away from OWL-RL. It is unfortunate that we are already out of it a bit, but if we make the situation worse, we would loose a major constituency... And I do not think it is worth it.

> 
> As for the making rules, I would go for the pure SPARQL approach for
> inferences, and something like SPIN for constraints; like Paul has
> started in his Github project.
> 

Isn't it possible to express the constraints with SPARQL ASK (using filters inside)? Those would return TRUE or FALSE at the query, that may do the trick...

> Although I am not native with SPIN, I don't think SPIN rules [1] are
> necessarily restricted to a particular product, it is based on SPARQL,
> just generating new 'Invalid' statements when something is wrong.
> Could you not just run a SPARQL query to find validations afterwards?
> Paul?

Well, as far as I know

- In SPIN one has to convert SPARQL statements into RDF, which makes it fairly unreadable in my view (and I do not think that would be helpful for us)
- SPIN has additional object-oriented-like features (?this, constructors, etc) which sound very useful indeed but (a) require a specific processor to run them and (b) I am not sure they are needed for us.

That is why I am, at this moment, more in favour of keeping to pure SPARQL.

Ivan

P.S. Sigh. The ideal would be to use RIF if there was a proper, readable, and primarily implemented syntax. Oh well, we failed on that one up until now...


> 
> [1] http://www.w3.org/Submission/spin-modeling/
> 
> -- 
> Stian Soiland-Reyes, myGrid team
> School of Computer Science
> The University of Manchester


----
Ivan Herman, W3C Semantic Web Activity Lead
Home: http://www.w3.org/People/Ivan/
mobile: +31-641044153
FOAF: http://www.ivan-herman.net/foaf.rdf

Received on Tuesday, 7 August 2012 13:39:20 UTC