W3C home > Mailing lists > Public > www-rdf-interest@w3.org > November 2000

Orthogonal triples

From: Alberto Reggiori <alberto.reggiori@jrc.it>
Date: Thu, 23 Nov 2000 17:02:19 +0100
Message-ID: <3A1D3F8B.86F10C7C@jrc.it>
To: RDF Interest Group <www-rdf-interest@w3.org>


I have been following silently the interesting threads about
reification, and as an implementor
I started thinking about useful and practical implications, especially
related to searching a RDF storage.

Either by reading your interesting emails about reification and by
talking with a colleague early this week, I realised that the RDF model
is so nicely designed to allow to either model resources (BLOBs) and
entities (facts about resources) using the same concept/model; in this
way one could represent different views of the same thing. A view in
this sense would correspond
to the concept of "context" or "space" given previously [1].

Is this idea I got stupid?
Isn't reification useful to attach properties to statements as RDF self
is useful to attach arbitrary properties to resources?

I.e.  Are the "abstract statements" space and the "concrete
statements/entities" space orthogonal in some sense? :-)

I am probably not up to tell whether the RDF model is correct or not
here, but as more I use it as more I like it.
E.g. using the strawman syntax at [2] one could easily add a Language
"context" attribute to a statement

      <rdf:subject rdf:resource="http://xml.jrc.it/RDFStore" />
rdf:resource="http://dublincore.org/2000/03/13-dces#creator" />
      <rdf:object>A really stupid italian guy</rdf:object>

to say the ["http://xml.jrc.it/RDFStore"
"http://dublincore.org/2000/03/13-dces#creator"  "A really stupid
italian guy"] statement has been stated in an English "context". This
technique could be also used to attach more interesting properties (e.g.
Natural Language Understanding (NLU) patterns) to query and match
triples in a database in a more sensible way.

When we search a RDF storage or database normally we assume some
"context" and consequently
select and join result sets. But I think in more complex cases (such as
a semantic Web applications) one application
can not assume (hardcode) such things; you need some way to carry out
user inputs as a set of atomic queries by
unifying query results from different "contexts".

Am I wrong, partially, completely, crazy or stupid?

Is RDF logic/inference work in the domain of the abstract or concrete
space, or both?
Can one write an "intelligent" program using simple RDF queries over
triple stores, where resources
are either BLOBs or statements (like SiRPAC [3] and RDFStore [4])? I.e.
can I hardcode some "semantic rules"
to actually use user input to query facts in a database?

Wasn't this one of the motivations why reification was originally
inserted into the RDF spec?



[1] http://public.research.mimesweeper.com/RDF/RDFContexts.html
[2] http://www.openhealth.org/RDF/rdf_Syntax_and_Names.htm
[3] http://www-db.stanford.edu/~melnik/rdf/api.html
[4] http://xml.jrc.it/RDFStore/
Received on Thursday, 23 November 2000 11:04:07 UTC

This archive was generated by hypermail 2.3.1 : Wednesday, 7 January 2015 15:07:33 UTC