Raw

John Sowa just posted some criticism of OWL as a KR language to the Conceptual Graphs list. I responded but the list's playing up, I ended up with an over quota message. So I'll post the text here and send John the link...

On 14 February 2011 22:59, John F. Sowa <sowa@bestweb.net> wrote:
> I have often commented on the limitations of OWL as a knowledge
> representation language.

...and I believe I have leapt to its defence more than once :)

I don't believe I've done so since OWL 2 [1] came out, so it behoves
me to add my few cents once again.

OWL is limited as a knowledge representation language, by design. As
with most other modelling languages it's a trade off between
expressivity and computational demands. But it has certain features
that sets it apart from most other such languages, the key ones being
related to the fact that it's a Web language. Three such features
spring to mind:

* Most of the language's constructs (individuals, classes, relations
etc) are identified using URIs, so there's Web-compatibility built in
at a low level
* While the binary relation that's at the heart of OWL can seem like a
handicap (especially coming from a DB perspective), when the
information is seen as a graph structure, echoing the Web, its utility
is hard to dismiss
* By making the open world assumption (statements are either true or
unknown) the language reflects the real world as expressed on the Web
- in a global environment, we can't know everything

Given these features as a starting point, OWL does a good job of
providing an ontology language that ticks many of the logician's
boxes.

As it happens, as development of OWL 2 was being proposed, I'd argued
with some of its advocates that there were more useful things the time
could be spent on than the logic side of the language. Turns out it
didn't matter anyway - the enthusiasts there produced what they wanted
(and what apparently their customers were demanding) and there's been
no discernible impact on other development tracks.

The thing is RDF (plus RDFS, perhaps with a tiny bit of OWL) is enough
to cover the vast majority of descriptions (the statements of
interest) to a useful degree. Most of the time you don't actually need
expressive constructs to get useful data on the Web, a very simple
statement of relationship between resources is enough. Logic-wise, the
SPARQL query language (syntactically like SQL, but operating over
graphs) covers the requirements of the vast majority of applications
(IMHO), its simple pattern-matching being substantially more useful
than most other inferences.

The aspect of RDF/RDFS/OWL that really seems to work well is what's
been called the 'follow your nose' protocol. As when browsing the Web,
if you want to find out more about something (and it has a link), you
click the link to get more information. With RDF & OWL entities and
relations being identified by URIs, typically HTTP URIs, your machine
can do the same.

If it encounters a statement, say something like:

Fornitura(John Sowa, Something)

- it (and you) may have now idea of what's being stated. However all
three parts of the statement are Web resources, the statement could be
written longhand as (e.g.) :

<http://www.jfsowa.com/people#me> <http://some-vocab.org/fornitura>
<http://example.org/something> .

To find out more information, you can do a HTTP GET on the unknowns.
Because of it's position in the statement you know :fornitura is a
predicate (a rdf:Property) and by following the link you can get more
information in a machine readable form. In this case, by asking for an
RDF mime type, you will typically get back the ontology defining the
predicate.

Where 'better' knowledge representation (and reasoning) is required, a
lot of the time that can be carried out locally. For example, you may
have a traditional SQL database covering your specific domain.
Internally there will a closed-world assumption, native n-ary
relations and so on. On your own data you can use whatever languages
you like. But that data may be exposed to the Web through RDF (etc),
making it reusable elsewhere.

Ok, there's the argument that to be really useful, you need powerful
knowledge representation globally. But there is a major hurdle - to be
really useful you need a lot of people using *and publishing*
information in that form. Unfortunately along with the
representational power comes complexity, and the extra work required
has to be justifiable - in economic terms at least.

I forget the source, but there's a nice line: "what's new about the
Semantic Web isn't the semantics, it's the Web". When it comes to
global information sharing, the Web part is really where the
difficulties lie. Any logic/data has to actually be widely adopted.

Though the development of the Semantic Web is happening slower than
most folks hoped, it is happening. Take the recent statistics from
Yahoo! :
[[
The data shows that the usage of RDFa has increased 510% between
March, 2009 and October, 2010, from 0.6% of webpages to 3.6% of
webpages (or 430 million webpages in our sample of 12 billion).
]]
https://tripletalk.wordpress.com/2011/01/25/rdfa-deployment-across-the-web/

(RDFa is an RDF format allowing it to be embedded in HTML)

Also the Linked Data Cloud is a nice visualisation of some of the big
datasets out on the Web:
http://linkeddata.org/

So while RDF (alone) is a much more limited knowledge representation
language than OWL (essentially simple binary relations), at least the
data's getting out.

[snip]
> the OMG group is proposing as a way of representing type hierarchies
> in a simpler and more readable form than OWL.

I can't personally see how it could be much simpler than in OWL:

SubClassOf( :Woman :Person )

(in functional syntax)

Note also that structures other than tree can easily be represented,
an artificial example:

#node1 :connectsTo #node2 .
#node2 :connectsTo #node3 .
#node3 :connectsT0 #node1 .

(Turtle syntax)