Re: RDF Extensibility

[Reto Bachmann-Gmuer]

On Thu, Jul 8, 2010 at 7:21 PM, Pat Hayes  wrote:

>
> On Jul 7, 2010, at 11:31 AM, Reto Bachmann-Gmuer wrote:
>
> On Wed, Jul 7, 2010 at 1:57 PM, Toby Inkster  wrote:
>
>> Without knowing the definition of foaf:Person, it's difficult to
>> conclude that foaf:Person is not a property. However, even without
>> knowing the definition of a literal, it is easy to conclude that it is
>> not a suitable node to be used as a property, so in my opinion, it is
>> sensible to state that triples containing a literal as the predicate
>> have no meaning (even though I think they should be syntactically
>> allowed).
>>
>
> I think it would be perfectly possible to have a datatype mapping to a
> value-space of properties. But I see no practical benefit with this so I'd
> prefer not to support literal predicates syntactically.
>
>
> I'd suggest, as a general principle, that one should ask: which is easier,
> to allow them or to prohibit them? There are costs both ways. Words like
> 'support' beg the question.
>

Evaluating the revision of a standard many questions are around the
trade-off between stability and design elegance. The allegedly neutral terms
"allow" and "prohibit" seem to beg this question.

Reto

Re: Subjects as Literals

[Reto Bachmann-Gmuer]

On Tue, Jul 6, 2010 at 10:23 AM, Danny Ayers  wrote:

> I've been studiously avoiding this rat king of a thread, but just on
> this suggestion:
>
> On 2 July 2010 11:16, Reto Bachmann-Gmuer 
> wrote:
> ...
> > Serialization formats could support
> >
> > "Jo" :nameOf :Jo
> >
> > as a shortcut for
> >
> > [ owl:sameAs "Jo"; :nameOf :Jo]
> >
> > and a store could (internally) store the latter as
> >
> > "Jo" :nameOf :Jo
> >
> > for compactness and efficiency.
>
> what about keeping the internal storage idea, but instead of owl:sameAs,
> using:
>
> :Jo rdfs:value "Jo"
>
> together with
>
> :Jo rdf:type rdfs:Literal
>
> rdf:value has no clear semantics and it might be used and interpreted
differently. owl:sameAs has a clear semantics and if the processor supports
owl the above is legal and an unambiguous expression of the intended
meaning.

While there might be arguments and advantages on a theoretical level for
empowering the rdf layer itself to allow expressing the synonymity of terms
and literal subjects I don't see any practical benefits. We're moving
towards higher levels of abstraction, to describe the world with triples in
the semantic web owl is an essential foundation. With this semantic web we
can have what we need and want (literal subjects). To me the discussion on
the ideal separation of the layers might be theoretically interesting, but
for practical purposes I don't care where IP ends and TCP begins, how my
files maps to sector and similarly if the semantic stack is designed as
elegant as it could if I have to use owl to have my literal subjects. What I
do care about is the stability of what I'm building upon.

Bring RDF and OWL (Full) closer by combined introductions and tutorial, I
can see lots of benefits in that, but mainly costs in changing RDF.


Cheers,
reto

Re: RDF Extensibility

[Reto Bachmann-Gmuer]

On Wed, Jul 7, 2010 at 1:57 PM, Toby Inkster  wrote:

> Without knowing the definition of foaf:Person, it's difficult to
> conclude that foaf:Person is not a property. However, even without
> knowing the definition of a literal, it is easy to conclude that it is
> not a suitable node to be used as a property, so in my opinion, it is
> sensible to state that triples containing a literal as the predicate
> have no meaning (even though I think they should be syntactically
> allowed).
>

I think it would be perfectly possible to have a datatype mapping to a
value-space of properties. But I see no practical benefit with this so I'd
prefer not to support literal predicates syntactically.

Reto

Re: Subjects as Literals

[Reto Bachmann-Gmuer]

On Thu, Jul 1, 2010 at 4:20 AM, Hugh Glaser  wrote:
> In fact, a question I would like to ask, but suspect that noone who can
> answer it is still reading this thread ( :-) ):
> For those who implement RDF stores, do you have to do something special to
> reject RDF that has literals as subject?

I think more important than storing RDF is storing the expressed
content. For the content expressed with RDF and OWL, resources can
have 0 to n names and 0 or 1 literal value. When the content has to be
represented as RDF triples owl:sameAs statements are created for the
multiple names as well as possibly a bnode to prevent the literal
being in subject position. As by using OWL this limitation of the RDF
Abstract Syntax does not limit the expressiveness I see no need to
change anything.

Serialization formats could support

"Jo" :nameOf :Jo

as a shortcut for

[ owl:sameAs "Jo"; :nameOf :Jo]

and a store could (internally) store the latter as

"Jo" :nameOf :Jo

for compactness and efficiency.

Reto

Re: An idea I need help with, or told to stop wasting time on!

[Reto Bachmann-Gmuer]

On Sun, Jun 6, 2010 at 10:08 PM, Story Henry wrote:

>
> But also see the follow up
>
>   http://lists.w3.org/Archives/Public/semantic-web/2010Mar/0038.html
>
> And as we don't control the xsd: namespace, we can't tell if they will use
> this
> interpretation or the inverse.
>
>  In the case of the cert ontology we can define a datatype to also be such
> a
> relation. See:
>
>   http://www.w3.org/ns/auth/cert.n3
>
>
I think think a mapping from datatypes to property could be defined in
rdf-semantic instead of requiring the uri to explicitely be a Property and
not just a Datatype.

:r :p "..."^^ex:dt <=> :r :p [ex:dt "..."]

reto

Re: An idea I need help with, or told to stop wasting time on!

[Reto Bachmann-Gmuer]

On Sun, Jun 6, 2010 at 9:44 PM, Nathan  wrote:

>
> so are we saying that all of these express the same:
>
> :me foaf:name 'nathan'^^xsd:string .
>
:me foaf:name [
  owl:sameAs 'nathan'^^xsd:string .
] .

this two mean the same

:me foaf:name [
>   xsd:string 'nathan' .
> ] .

this should mean the same, but while not illegal the specs do not define the
meaning clearly


> :me foaf:name [
>   rdf:value 'nathan'^^xsd:string .
> ] .
>
I find it hard to communicate using a term that "has no meaning on its own"
(accoring to: http://www.w3.org/TR/rdf-schema/#ch_value)

>
> :me foaf:name :myname .
> :myname xsd:string 'nathan' .
>

> :me foaf:name :myname .
> :myname owl:sameAs 'nathan'^^xsd:string .
>
these two graphs are equivalent and entail the original graph, additional
they assign the uri :myname to the name

>
> :me foaf:name :myname .
> :myname rdf:value 'nathan'^^xsd:string .
>
meaningless rdf:value again

>
> ?
>
> I can see the rdf:value and owl:sameAs versions expressing the same, unsure
> about the xsd:string version..
>
> what about..
>
> :London rdfs:label [ rdf:value "London"@en, "Londres"@fr, "Лондон"@ru ].
>
clearly owl:samesAs couldn't be used here, and a label is usually a literal
and not a multivalued object

>
> or..
>
> :London rdfs:label
>[ rdf:value "London"@en ] ,
>[ rdf:value "Londres"@fr ] ,
>[ rdf:value "Лондон"@ru ] .


 :London rdfs:label "London"@en, "Londres"@fr, "Лондон"@ru.

cheers,
reto

Re: An idea I need help with, or told to stop wasting time on!

[Reto Bachmann-Gmuer]

ops, accidentally sent too eraly

On Sun, Jun 6, 2010 at 6:17 PM, Nathan  wrote:

> ...
>
>
>  :me foaf:name [
> ex:value 'nathan' ;
> ex:type xsd:string ;
> ex:language 'en-gb' .
>  ] .
>
> foaf:name has range rdfs:Literal, this still allows us to say:

:me foaf:name [
ex:sha_1 'KLSJFS9F7S9D8F7SLADFSLKDJF98SD7' .
]

in this case we know about the bnode that it stands for a literal value and
the ex:sha_1 value of that literal.

your way of specifying the type of the literal reminds me the recent
discussion started by Henry Story:
http://lists.w3.org/Archives/Public/semantic-web/2010Feb/0174.html

following this we could also say:

:me foaf:name [
xsd:string 'nathan' ;
ex:sha_1 'KLSJFS9F7S9D8F7SLADFSLKDJF98SD7' .
 ] .

which expresses the same as:

:me foaf:name [
owl:sameAs 'nathan'^^xsd:string;
ex:sha_1 'KLSJFS9F7S9D8F7SLADFSLKDJF98SD7' .
 ] .



> And do some funkier stuff:
>
>  :me foaf:mbox :myemail ;
>  :myemail ex:value  ;
> ex:sha_1 'KLSJFS9F7S9D8F7SLADFSLKDJF98SD7' ;
> dcterms:created '2010-06-03T15:19:35-05:00' ;
> dcterms:replaces :oldmail .
>  :oldmail ex:value  .
>
> so because of the way ex:value works, in there we have the triple:
>
>  dcterms:replaces  .
>
ex:way seems to work the same way as owl:sameAs

ex:sha_1 to me seems to make sense with literals but not with a mailbox,
there the foaf-approach of having a distinct property convinces me more:
mbox point to the mailbox which is a resource typically identified by its
mailto-uri, mbox_sha1sum by contrast point to a literal with an
sha1-encoding of the mailto-uri of an email address of the subject. Your
second usage of ex:sha1 ties a resource to its name which seems very
limiting.

the statement " dcterms:replaces  ." seems however perfectly sound I don't see why this
should need the construct with ex:value an the additional node.

reto

Re: An idea I need help with, or told to stop wasting time on!

[Reto Bachmann-Gmuer]

On Sun, Jun 6, 2010 at 6:17 PM, Nathan  wrote:

> ...
>
>  :me foaf:name [
> ex:value 'nathan' ;
> ex:type xsd:string ;
> ex:language 'en-gb' .
>  ] .
>
> foaf:name has range rdfs:Literal, this still allows us to say:

:me foaf:name [



> And do some funkier stuff:
>
>  :me foaf:mbox :myemail ;
>  :myemail ex:value  ;
> ex:sha_1 'KLSJFS9F7S9D8F7SLADFSLKDJF98SD7' ;
> dcterms:created '2010-06-03T15:19:35-05:00' ;
> dcterms:replaces :oldmail .
>  :oldmail ex:value  .
>
> so because of the way ex:value works, in there we have the triple:
>
>  dcterms:replaces  .
>
> but we've also introduced a way to make non http URIs dereferencable..
>
>  ex:value  .
>
> see why my head is hurting with this?
>
>
> 2: Double Serialization
>
> In a way we can already do this with rdf:XMLLiteral
>
> :x content:encoded 'http://www.w3.org/1999/02/22-rdf-syntax-ns#";>http://ex.org/egg#i";> xml:lang="en">egg'^^<
> http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral> .
>
> so we could say:
>
> :x a ex:NamedGraph ;
>  ex:graph '
> or including ex:value as outlined in 1 earlier:
>
> :graph1 a ex:NamedGraph ;
>  ex:graph [
> ex:value '''some serialized rdf in here''' ;
> ex:type 'text/rdf+n3' . ] .
>
> Would allow you to strap provenance / meta to a value and/or the named
> graph.. and here's where it's either so simple, or so complex that my brain
> simply pickles:
>
> example onto:
>
> ex:graph rdfs:domain ex:NamedGraph;
>   rdfs:range ex:Graph .
>
> example graph:
>
> :graph1 ex:graph :v3 .
>
> :v3 ex:value '''some serialized rdf in here''' ;
>  ex:type 'text/rdf+n3' ;
>  dcterms:replace :v2 .
>
> v2 ex:value '''old serialized rdf here''' ;
>  ex:type 'text/rdf+n3' ;
>  dcterms:replace :v1 .
>
> .. I'm sure there's something in using [ log:content, log:n3String,
> log:uri ] here instead, and quite sure that by stating that graph contents
> where either a Truth or a Falsehood you could use for rdf updates..
>
> So, is there something in this, am I going down a wrong path, thoughts,
> feedback, anything?
>
> Best,
>
> Nathan
>
>

Re: RDF, XML, XSLT: Grit

[Reto Bachmann-Gmuer]

I'm wondering what the advantages of grit are when compared with
simple subsets of RDF/XML than can be used for XSLT transformation,
e.g. Morten's R3X [1].

Cheers,
reto

1. 
http://www.wasab.dk/morten/blog/archives/2004/05/30/transforming-rdfxml-with-xslt
(just to allow XSLT the special RSS 1.0 handling can be ignored)

2010/1/17 Niklas Lindström :
> Hi all!
>
> In light of the recent discussions about both using RDF in contexts
> where RDF awareness and availability of RDF tools are more limited,
> and in relation to the thoughts on RDF/XML (re-)emerging in the "RDF
> 2.0" discussion thread [1], I find it timely to document and announce
> an instrumental format I recently made, called Grit ("Grokkable RDF Is
> Transformable"), at [2].
>
> I made this primarily for using XSLT to produce (xhtml) documents from
> controlled sets of RDF, e.g. vocabularies and such. I've found it
> conventient enough to think that there may be general interest.
>
> As described at [2], Grit deviates from RDF/XML to form a syntax with
> as little variation as possible (partially comparable to normalized,
> "pretty" RDF/XML). I would love feedback if you find this to be
> interesting, either for just XSLT/XQuery etc., or even as ("yet
> another"..) RDF format usable in its own right (for instance, I do
> suspect that something like it would be easier to sell in Linked Data
> contexts than either RDF/XML or e.g. TriX).
>
> (In the works I also have an XSLT-based chain for producing XHTML
> documentation from RDFS/OWL vocabularies transformed to Grit
> (basically a pedagogical cleanup of existing code I use in my work),
> and a GRDDL XSLT to take Grit back to RDF/XML, for good measure.)
>
> Best regards,
> Niklas Lindström
>
> [1]: http://lists.w3.org/Archives/Public/semantic-web/2010Jan/0068.html
> [2]: http://code.google.com/p/oort/wiki/Grit
>
>