On 04/12/2014 05:20 PM, Ruben Verborgh wrote:
Hi Peter,
Ok, I describe ex:BaseballPlayer as
ex:BaseballPlayer owl:equivalentClass _:x .
_:x owl:intersectionOf ( ex:Person [ owl:onProperty ex:plays; owl:hasValue
ex:Baseball ] )
Is this RDF?
Yes.
I would say that this is OWL in RDF clothing.
Should all consumers of RDF understand all of this?
Yes, depending on your interpretation of "understand".
All of them should parse the triples. This is where RDF ends.
This I totally disagree with. RDF is much more than just triples. RDF
includes a meaning for triples.
Those that can interpret OWL will be able to infer additional things.
This is OWL and not part of the RDF model
(and thus also not extending the RDF model).
<h1>Baseball player</h1>
doesn't extend HTML.
It just applies HTML to describe a baseball player.
As using ex:BaseballPlayer doesn't extend RDF.
However, using owl:disjointWith as a predicate in triples, and expecting it to
have some relationship to disjointness of RDF class extensions, is an
extension of RDF.
No, quantification is not part of RDF.
Why not?
It is not in the spec.
But you appear to be using only part of the RDF spec. Why just that part and
not the whole RDF spec? If *you* leave parts out, surely it is just as
legitimate for *'me* to add parts.
I could certainly define an encoding of quanfification in RDF and use it to
define predicates.
You indeed can.
Predicates may not influence non-related triples,
however, other triples might be influenced through a cascade of relations.
Why not? I can define predicates however I want, after all?
Because, by definition of "related",
if your predicate is defined to influence a certain (kind of) triple,
that triple is related to the usage of the predicate.
Sure, but if I can add things to the RDF spec, then I could add something like:
The triple <a> <b> <c> means that all subclassOf relationships are strict.
What does using owl:differentFrom in RDF commit you to?
It says that two things are different.
Clients that can interpret this predicate can apply its meaning.
This application does not change the model.
What model?
The RDF model.
Do you mean that all you care about is the abstract syntax?
No.
But, but, but, isn't that what you said above? All that counts is triples,
i.e., the abstract syntax.
What about rdf:type? What about rdfs:domain? Do all consumers of RDF need to
commit to the standard meaning of these predicates?
Yes.
But this goes beyond triples.
RDF is just the model. Giving a predicate meaning is not extending the model.
How so? What else is giving a predicate meaning besides extending the model?
It defines something on top of the model.
Building a home with bricks does not extend the bricks; it uses them.
Yes, sure, which is why using rdfs:domain to infer rdf:type triples is not
going beyond RDF(S). However, using owl:sameAs as equality and inferring
other triples from this is going beyond RDF(S). It's just like turning a
little brick into a long I-beam - you are no longer working with a little brick.
I am really struggling to understand your view of RDF.
Likewise. But maybe further discussing this doesn't really help the community.
My view on RDF works for what I want to do and in my opinion, it's by no means
an unreasonable view.
But there might be other views… and that might just be fine.
Well that's a bit debatable. Standards, even W3C standards, are there so that
there is commonality of understanding. If different people take different
views of RDF, then its utility is weakened, particularly if everyone still
thinks that they are all using the same thing.
My view is that getting these differences of opinion out in the open is very
helpful.
My view is that RDF is defined by the W3C RDF recommendation and that going
beyond the inferences sanctioned here is no longer RDF.
Best,
Ruben
Petter