Re: updated updated bams model

I have some comments on:
http://esw.w3.org/topic/HCLS/ 
HCLSIG_DemoHomePage_HCLSIG_Demo#head-50710462ea5aac416fd063dce8621ce0354 
d2d5a

> Formal Definition of Semantics
>
> OWL and RDF have a formal definition for the semantics of an OWL/ 
> RDF knowledge base, i.e., given a knowledge base, associated  
> semantics are primarily provided explicitly within the knowledge  
> base itself. Commonly used database languages, e.g., XML and  
> relational database (RDB), have at most a semi-formal definition.

XML is a way of standardising syntax, not semantics. XML isn't a  
database language, I'm not sure why it's classified as such here.

It's not quite correct to state that an RDB (which is not a database  
language either) has only a semi-formal definition. The strength of  
the relational model is precisely the formal definition - either as  
relational algebra or relational calculus. How much more formal do  
you want?

Of course, existing databases use various extensions to the  
relational model, and, regrettably, departures from it. But this may  
well be the case for practical OWL/RDF implementations. I think it's  
a fairly minor point, and not something you want to base your  
argument on.

> XML is a grammar writing system with no defined relationship  
> between a given schema and its semantic meaning. An XML schema is  
> simply a grammar. Any semantics represented by that schema and its  
> associated documents are specified external to those  
> representations, e.g., in documentation.
>
> RDB has more than one semi-formal definition, e.g., the ISO  
> Standard SQL [sql].

You state there is >1 formal definition, give the SQL standard as an  
example of one - can you give an example of another? Perhaps you mean  
successive iterations of the SQL standard? Again, variations from  
this are relatively minor. Relational algebra precedes the ISO SQL  
standard and forms the basis for all relational databases.

> Thus, given an RDB schema and repository, it is not possible to  
> know from those which definition of semantics, if any, was used. In  
> common use, a given RDB database and repository may make use of no  
> semi-formal definition of semantics or borrow from several  
> different ones.

What is a repository in this context?

> Like XML, other means, such as, documentation, external to the  
> schema and repository describes the semantics.

So OWL/RDF dispenses with documentation?

> For example, consider how a relation between two sets would be  
> represented in OWL/RDF, XML, and RDB. In OWL/RDF, the semantics of  
> a relation is formally defined similar to the mathematical  
> definition, i.e., as a subset of the cross product of the domain  
> and range. Because the relation is a cross product, it has a  
> direction. An element of the domain is related to an element of the  
> range, but not necessarily the other way around. In an XML schema,  
> there are many different ways of representing a relation using  
> elements, subelements, and attributes. Similarly, in an RDB schema,  
> depending on which semi-formal definition of RDB semantics is used,  
> there are multiple ways to represent a relation. How a relation is  
> represented in an XML or RDB schema/repository can only be known  
> external to the schema/repository itself.

I'm afraid I can't make head nor tail of this.

   "In OWL/RDF, the semantics of a relation is formally defined  
similar to the mathematical definition, i.e., as a subset of the  
cross product of the domain and range."

Actually, I think you are talking about mathematical functions, not  
relations. As OWL/RDF is restricted to binary relations the  
terminology of functions makes sense (ie we can call the first  
argument domain the domain, and the second the range)

So you seem to be stating a strength of OWL/RDF is that you can state  
the domain and range of a relation? Note that in the relational model  
you can of course state the domain of every argument of the relation.

   "Because the relation is a cross product, it has a direction. An  
element of the domain is related to an element of the range, but not  
necessarily the other way around"

Can you elaborate on this? I don't understand this at all.

   "in an RDB schema, depending on which semi-formal definition of  
RDB semantics is used, there are   multiple ways to represent a  
relation"

??

Are we talking about mathematical relations? As far as I understand  
this, this is simply false. Using the relational model you would  
represent a relation using, ummm, a relation. A relation is the cross- 
product of the domains of each argument. It would seem that an RDB  
relation is much closer to a mathematical relation than the OWL/RDF  
equivalent. (For one thing, there is no restriction to binary  
relations forcing use of n-ary patterns). This is true for all RDBs,  
even ones that fall short of the ideal relational model. Can you give  
an example of two different definitions of RDB semantics that would  
give different answers here?


If this demo is to convince people of the strength of the OWL/RDF  
approach as opposed to a traditional XML or SQL approach, then this  
section needs some work.

I would not lump XML in with the relational model - the relational  
model has more in common with logic-based approaches than with XML  
(it's unfortunate for both camps they do not yet have more in common)

I think it would be more appropriate to compare and contrast the  
expressivity of, say, XML Schema with OWL than, say, XML with OWL/ 
RDF. Make sure you are comparing like with like. Similarly, I would  
compare the expressivity of standard SQL DDL with OWL, perhaps using  
an example - e.g. a simple one with class subsumption. If you're  
going to use the term semantics, give a definition. Note that both  
relational algebra and OWL's model theoretic semantics are rock-solid  
and formal (I'll leave others to comment on the semantics of OWL  
layered on RDF/RDFS).

I think the point you want to make is that OWL (arguably) provides a  
more expressive (and perhaps agile?) framework for representations of  
real-world entities. Although you simultaneously seem to be making  
the case for RDF too, which makes your task harder.

Cheers
Chris

Received on Monday, 26 March 2007 15:07:13 UTC