RE: value and Dumb-down.

Hi,

I've struggled some with the dumb-down process (with Dublin core data.)
The fact that the dc properties are untyped (to allow either a qualified
or an unqualified property value) is nice from an authoring-flexibility
perspective but makes things a bit difficult in practice. For example,
in your example you end up with two values of <b> for <A> (<C> and "x").
You're often force to filter one of them out when querying the data
based upon some extra-rdf knowledge (e.g. pull out the one that is a
literal). I imagine that's why you're suggesting reification - so you
can distinguish easily between the two forms?

Another solution I've found that works well within the scope of an
application is to map (via rules) the untyped properties into a new
typed property. For example, I might map the untyped dc:date property
into a typed ex:mydate property and then perform my query against the
ex:mydate property. For example in rdfql I might do something like:

Infer {[ex:mydate] ?s ?dt} from {[dc:date] ?s ?d} and ?dt=date(?d)
Infer {[ex:mydate] ?s ?dt} from {[dc:date] ?s ?o} 
	and {[rdf:value] ?o ?v} and ?dt=date(?v)

//then perform my query against the mydate property knowing that it will
be of type date

select ?item using mydata where {[ex:mydate] ?item ?myd} and ...


So it's similar to your solution in that you can distinguish the
inferred property value from the original but doesn't need to use the
mess of reification.

-Geoff		

> -----Original Message-----
> From: www-rdf-interest-request@w3.org [mailto:www-rdf-interest-
> request@w3.org] On Behalf Of Jon Hanna
> Sent: Friday, November 22, 2002 8:40 AM
> To: www-rdf-interest@w3.org
> Subject: rdf:value and Dumb-down.
> 
> 
> Hi.
> 
> I was thinking about the use of rdf:value for "dumb-down".
> 
> Dumb down takes statements:
> <A> <b> <C> .
> <C> <rdf:value> "x" .
> 
> and infers (in the loosest sense of the word):
> 
> <A> <b> "x" .
> 
> The idea being that the application that makes use of this either
can't
> handle <C> or that <C> exists only to allow one to encode the RDF/XML
in
> such a way that if embedded into HTML a non-RDF/XML aware browser
won't
> mistakenly render it.
> 
> As such it is honest about being imperfect. But the ill-defined nature
of
> the relationship between the first two statements, and the statement
> inferred is irritating, and could lead to problems down the line. It
can't
> be fitted into the MT, or similar.
> 
> One idea that occurred to me is that there might be some value in
> generating
> the third "dumbed-down" triple, and then use reification to indicate
how
> we
> arrive at it, hence resulting in the following triples
> 
> _:v1 <rdf:type> <rdf:Statement> .
> _:v1 <rdf:subject> <A> .
> _:v1 <rdf:predicate> <b> .
> _:v1 <rdf:object> <C> .
> _:v2 <rdf:type> <rdf:Statement> .
> _:v2 <rdf:subject> <C> .
> _:v2 <rdf:predicate> <rdf:value> .
> _:v2 <rdf:object> "x" .
> _:s1 <rdf:type> <rdf:Statement> .
> _:s1 <rdf:subject> <A> .
> _:s1 <rdf:predicate> <b> .
> _:s1 <rdf:object> "x" .
> _:r1 <rdf:type> <rdf:Bag> .
> _:r1 <rdf:_1> _:v1 .
> _:r1 <rdf:_2> _:v2 .
> _:r1 <xx:suggests> _:s1 .
> 
> Does anyone else see any value to this?
> 
> 
> Jon Hanna
> 
> PGP http://www.spin.ie/jon.asc
> PGP Fingerprint 707E 5E39 3BF5 533A D1DD  2083 8169 BFD7 F532 BD18
> "...it has been truly said that hackers have even more words for
equipment
> failures than Yiddish has for obnoxious people." - jargon.txt

Received on Friday, 22 November 2002 09:28:20 UTC