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

Re: Converting SHOE to RDF: about 2/3 done; some gotchas

From: Jeff Heflin <heflin@cs.umd.edu>
Date: Tue, 16 May 2000 14:23:14 -0400
Message-ID: <39219212.E69B1566@cs.umd.edu>
To: Dan Connolly <connolly@w3.org>
CC: Sean Luke <seanl@cs.umd.edu>, www-rdf-interest@w3.org
Dan Connolly wrote:
> Sean Luke wrote:
> >
> > [context everyone: Jeff does SHOE, Dan is working informally on a SHOE ->
> > RDF converter and had asked some SHOE questions]
> >
> > On Fri, 12 May 2000, Dan Connolly wrote:
> >
> > > Jeff Heflin wrote:
> > >
> > > > <rdfs:Class rdf:about="http://schema.org/web#Web_Developer">
> > > >   <rdfs:subclassOf rdf:resource="#Silly_Person">
> > > > </rdfs:Class>
> > > >
> > > > I do not see any restrictions in the RDFS spec to prevent such a
> > > > statement.
> > >
> > > Why should we prevent such a statement? Anyone can say anything
> > > about anything, no?
> >

I was not trying to say that such a statement should be prevented, just
that without something else built on top of RDF/RDFS it will cause
problems. Recall that the original purpose of my example was to show
that SHOE Use-Ontology elements serve as more than just namespace
identifiers. In SHOE, a Use-Ontology tag states that the referenced
ontology provides additional information for interpreting the page. This
information includes machine-readable definitions of the terms used. As
such, it is similar to the "include" or "assert" constructs proposed by
Tim Berners-Lee in

> > [snip]
> >
> > > > Also, as I understand it way namespaces are used in RDF is
> > > > only to uniquely identify what object you're talking about, not which
> > > > sets of definitions you subscribe to. Thus, if I state that I am
> > > > Web_Developer, then do I also imply that I am a Silly_Person?
> > >
> > > If you say P and P->Q, then you imply Q, yes. But
> > > if you say P and somebody else says P->Q, then a third
> > > party may or may not decide to trust you both enough
> > > to conclude Q.

If there was a model for specifying trust of RDF statements and such a
model allowed for efficient computation of trust over the Internet, then
I would agree that the problem would be avoided. However, there is no
spec for trust in RDF yet, and even if there was I have my doubts as to
whether a general trust mechanism could be efficiently computed. Trust
can get really complicated really quicky. Different users are willing to
believe different things, and the level of trust assigned to a
particular source might depend on the subject matter (I'd trust my
doctor on what to do if I have a severe case of the flu, but if he was
telling me how to optimize my computer I'd be more skeptical, unless of
course this doctor had demonstrated himself to be computer guru in the
past). When you start applying this level of trust to logical axioms,
you would have to go through a chain of inference just to determine
which axioms you believe, and then another chain of inference to
determine what you conclude from them.


> > I think that dealing with the
> > weirdness caused by a lack of control inherent in a distributed system is
> > one of the features that RDF needs to work more on.
> Well... sure... RDF 1.0 is just a syntax for ground assertions
> using 2-place predicates. There's lots more work on all
> sorts of issues, combining issues from untrusted sources
> being a noteable one.
> cf
>  http://www.w3.org/DesignIssues/Semantic.html

I agree that anything can be built on top RDF, after all I can translate
anything into a set of 3-tuples. The problem is these tuples don't mean
anything without applying a semantics to them. RDF had virtually no
semantics, RDFS added a little, other future specs will add more. I
understand the argument for proceeding incrementally, but fear that if
we aren't careful we'll end up with a Semantic Web standard that
consists of 10 different specs and different systems will implement
different combinations of the specs so that nothing will be

> >  Because RDF lets
> > "anyone say anything about anything", with no notion of authority at all,
> > then people are free to redefine the semantics of a language in a very
> > fine-grained, highly distributed fashion.
> The RDF Schema specification prohibits changing schemas at all.
> (mechanisms of enforcement aren't discussed, but I think
> it's clear how to implement them.)

As my example from above illustrated, you don't have to change an RDF
schema to change its definitions. You need very "fine-grained" trust
mechanisms to be able to control which definitions you will believe.


> I just read the SHOE versioning paper in the last few days...
> SHOE just follows the simple
> "if you want to publish a new schema, you use a new URI" rule that
> RDF Schema (and COM and lots of other sensible systems) use:
>         SHOE maintains each version of the ontology as a separate
>         web page and an instance must state which version it
>         commits to. As a result, data sources can upgrade to the
>         new ontology at their own pace and some may never upgrade.
>         -- section 3.2 Versioning
>         http://www.cs.umd.edu/projects/plus/SHOE/pubs/#aaai2000
> I don't see how the version numbers in a SHOE ontology have
> any actual effect on anything... nor the schema IDs,
> for that matter. But maybe I missed it... could you give
> an example of how the version numbers actually matter?

Essentially SHOE ontology ids and version numbers indicate when
ontologies are alternatives of each other and which alternative is the
most recent one. Version numbers are important for
backwards-compatability in SHOE. If an intelligent agent understands
"foo-ont, v.2" and comes across a web pages that use "foo-ont, v.1" to
make a set of assertions, as long as "foo-ont, v.2" is
backwards-compatible with v.1 the agent can feel confident about how it
interprets this new knowledge. However, although version numbers are
useful for backward-compatability, I think that it is more important
that they are a common way for people to distinguish between changing
documents. Now of course you could express the necessary information in
RDF as well, but you would need to define a "Schema" schema. Such a
schema might have a "Schema" class, a "revises" property, and a
"backwards-compatible-with" property.

Regardless, the key point of the paper was not that "Thou must use
version numbers." If you look at the formal model, version numbers are
no where to be found. The key point is that "perspectives" as I define
them provide a simple mechanism for reasoning with knowledge that is
distributed and dynamic (like that on the Web). That is, we can get a
lot of bang for a buck without having complicated trust mechanisms.


> The RDF 1.0 specification doesn't address issues of semantics in a
> distributed system... heck, it doesn't even address the traditional
> inference mechanism done in sandboxed KR systems: no variables,
> no if-then nor not, etc.
> But RDF 1.0 is intended to be the bottom layer of systems that
> do address these uncomfortable facts... even model them
> explicitly.
> We only standardize stuff after we're pretty certain about it.
> And at this point, the only thing we're pretty certain about
> is that everybody needs to be able to make assertions
> using 2-place predicates. The rest, we're all just experimenting
> with.

I think that is one of the differences in the approaches to SHOE and
RDF. In SHOE, we consider the semantics of a distributed system to be a
fundamental component. As such, SHOE is out there in front of RDF trying
out new ideas that are not yet ready for standardization (one of the
luxuries of being a research project). I hope that the RDF working group
will find that the SHOE work provides some insights into the design of a
semantic web, and look forward to seeing how the RDF working group
eventually handles logic, trust, and distributed systems,

Received on Tuesday, 16 May 2000 14:23:17 UTC

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