W3C home > Mailing lists > Public > www-rdf-interest@w3.org > January 2005

Re: a simpler form of rdf xml

From: Henry Story <henry.story@bblfish.net>
Date: Sat, 15 Jan 2005 17:52:03 +0100
Message-Id: <C7F10086-6715-11D9-9C7C-000A95D9FA7A@bblfish.net>
Cc: www-rdf-interest@w3.org, bloged <users@bloged.dev.java.net>
To: atom-owl@googlegroups.com

Yes, that was a very helpful discussion on irc.

The main point was that xml-rdf allows for xml such as the following

<Feed>
    <entry>
        <Entry>
           <title>my first entry</entry>
        </Entry>
    </entry>
</Feed>

which in xml-rdf has the following model

_f --is-a--> <Feed>
|---entry--> _e
              |--title-->"my first entry"

my mapping of xml onto graphs required that all elements and
attributes be relationships. Rdf-xml syntax makes a strong distinction 
between resources that point to nodes and resources that point to
relationships.

So the above is a bit problematic for me. Because Feed is not
a relationship: it is an entity. IE. in the graph I represent
it like this <Feed> and not like this ---Feed-->

Of course both are resources (URL, URIs, IRIs). So this distinction
suddenly seems a little contrived to me. What if all we had were
relationships? What if a resource just is a special type of
relationship, a relationship an object has with itself?

_f --is-a--> <Feed>

is just equivalent to

_f ---+------is-a--+
^     |            |
|    <Feed> <------+
------+


hehe :-)

So let me try again.

<Feed>
    <entry>
        <Entry>
           <title>my first entry</entry>
        </Entry>
    </entry>
</Feed>


_F --Feed--> _f
             |--entry-->_E
                       |--Entry-->_e
                                  |--title-->_t
                                             |--xxx:string--+
                                                            |
                                   "My first entry" <-------+

Ok. So now we look the above up in an ontology.

we find that

--------------------8<------------------------------------
default:Entry
       a       owl:Class ;
       rdfs:comment "see section 5 of the Atom 
spec"^^<http://www.w3.org/2001/XMLSchema#string> ;
       rdfs:subClassOf owl:Thing ;
--------------------8<------------------------------------

from this we can perhaps deduce that Entry is relationship of things
of type Entry on themselves, so that _E == _e and also of course that 
both _E and _e are of type <Entry>

The same reasoning can be applied to <Feed> and so the graph above
is equivalent to

  _f --is-a--> <Feed>
   |--entry-->_e --is-a--> <Entry>
               |--title-->_t
                          |--xxx:string-->"My first entry"

because we also know that

if Subj ---xxx:string--> Obj then Obj == Subj

We end up with the following graph:

  _f --is-a--> <Feed>
   |--entry-->_e --is-a--> <Entry>
               |--title-->"My first entry"

which is exactly the same as what RDF/XML gives us. :-)

Wow!


On 15 Jan 2005, at 11:48, Sean B. Palmer wrote:
> Henry Story wrote:
>
> > If we only map xml very minimally to our graph then I think
>> we get very close to a default mapping of xml into a graph.
>
> Here's a quick summary of the points that we discussed [1] on IRC, for 
> the benefit of mailist-list only folk who'd otherwise miss it:
>
> * There is no default mapping of XML document instances to RDF 
> triples, other than the representation of the infoset in RDF, since 
> XML is a generic framework that allows people to create an unbounded 
> amount of applications on top of it.

Yes, but graphs are also incredibly powerful structures. I think as 
strong as set theory at least. And people have tried to base all of
logic and mathematics on set theory... So if xml came with a default
mapping I was thinking this would hardly prove to be a limitation on
xml.

> * As proof: your particular mapping is based on skipping typed nodes, 
> and as such will fail on all RDF/XML documents that use typed nodes in 
> them. In other words, if you interpret every XML element as an RDF 
> property, you'll fail on any document containing elements that are 
> actually intended to represent classes or other non-properties. And 
> that's for RDF/XML, which really *does* have a mapping to triples!

Yes. That is a very good point.

> * RDF is highly inefficient for transferring certain types of data, 
> e.g. for those where the natural representation is to use >3 tuples. 
> XML is also rather inefficient for many applications, including RDF.

If xml had a default mapping then encoding rdf would be just as
efficient as encoding any xml. :-)

> And as I said on IRC: "you're trying to find a mapping for all XML 
> documents, but that won't work, so instead why not try to come up with 
> a series of mappings that people can then choose between and overtly 
> *say* work for their particular documents/languages?"

yes. In which case what I have done is perhaps found an encoding of
rdf in xml that is much closer to the intuitions of key people in the
xml world: Tim Bray and Fielding for example. If this could be
formalized as one of your encodings, then perhaps it might turn out to
be the most widely used encoding in the xml world. Also if it chimed
nicely with people's intuitions then it would provide for a smooth
transition from learning the xml syntax to learning how to model
this.

I am happy that what I have described, even if it does not provide a
model for all xml, does at least enable one to encode all rdf graphs
that xml/rdf does.

For the Atom working group this could be very nice as it could allow
us to describe a framework for Atom extensibility, that is well
structured and well founded.

> Cheers,
>
> [1] http://ilrt.org/discovery/chatlogs/swig/2005-01-15.html#T10-19-31
>
> -- 
> Sean B. Palmer, http://inamidst.com/sbp/
>
Received on Saturday, 15 January 2005 16:52:24 GMT

This archive was generated by hypermail 2.2.0+W3C-0.50 : Monday, 7 December 2009 10:52:12 GMT