Below is an email I sent to the OWL Working Group mailing list (which is public) in response to an action to talk about how I thought we could address OWL Full. I share it here with those of you who are not following the group’s mail. I made a couple of minor edits because I referred in the email to some things in the charter, and was reminded our charter is member only by W3C rules (but I promise, nothing important is missing)….
Before I get to something resembling a proposal, I first want to outline my “ideal vision” (which I know is not the same as some other people’s but at least it makes it clear where I’m coming from), then “define” what I mean by a couple of the terms with respect to that vision, and then make the proposal and provide a justification– so if you don’t care about anything but the latter, drop to the bottom.
Ideal world: If I could start all over again, there would be one language called OWL. The language would be defined as a set of vocabulary terms “owl:xxx” and the definition of an OWL document would be any RDF document (by whatever definition of document one uses) that includes the use of those terms. The language would be aimed at being a good common denominator for the definition of ontologies, not aimed at being a good KR language for AI use (i.e. it’s main function would be interoperability, more precise and expressive KR languages would use it for exchanging at least some of their information where possible). The language would be primarily aimed at “modeling”, not reasoning, and thus the semantics could be less formal than it is now.
Attached to OWL would be a privileged fragment called OWL DL, which would have a very clean semantics. OWL DL would be intended for people whose use of OWL fits one of the important niches OWL can handle – which is classification reasoning (via consistency checking). Folks looking for an expressive common denominator with good reasoning tools would be drawn towards OWL DL, and they would find that most of the documents they created in OWL either already worked well with OWL DL tools, or needed a small amount of work to get there. There could also be a number of special extensions to the OWL vocabulary (lets call it owldl:xxx) that could be used where they were needed for making reasoners better. The semantics of this fragment, which need to be extremely clear and clean, would be very formal. Syntaxes for developing documents in this language would still need to talk to RDF, since they want to provide URIs that would be of use in the Semantic Web (so regular OWL users would have benefit of the clean ontologies built in OWL DL)
There could also be other communities that come to the W3C, or which work in other forums, and create other priviledged versions of OWL for other KR approaches or for other purposes. These fragments would be defined as vocabulary fragments (i.e. the document could contain only these terms) or they could have specific semantics — OWL DL would be an obvious candidate for the semantic base of these, since that would greatly enhance reuse.
Some (loose) definitions:
Operational semantics: I use Java and C all the time. I have never seen any semantics for them other than an “operational semantics” — that is one that says what the intended use of the language constructs is. I also have books on Prolog and Lisp and Scheme, which have something closer, but in fact when I implemented my own prolog once upon a time, the formalism wasn’t really what it is today – I used a document that said what the various features of the language were and how they interacted. These semantics, like the ones in Java and C were written in a language called English. In fact. most languages whether they be programming languages, markup languages, or modeling languages are defined against this kind of semantics. What is called a “reference” (for example, the “programming in C” book or the “Moonual” for Lisp) is generally the user guide to understanding these operational semantics.
A fallacy about operational semantics: Some on this group keep telling me that the difference is that OWL is not a programming language. I happen not to agree, but even if you take that view, I point out most other languages including HTML and XML (and, in fact SQL) have these semantics. (SQL also has a mathematical underpinning, but it includes a number of features that are not covered by that, and are only explaining operationally – what we would call non-semantic features). The fallacy has been that if one says “OWL” and means “OWL DL” then they are right that the language is not like a programming or markup langauge, it is a KR language and that does indeed need a formal semantics. So what I call OWL in the above is the main language, and if it has any semantics at all, it should be operational (and maybe we have to abide by the fact that RDF has a semantics – but that was a mistake in my opinion).
An axiomatic semantics – the term has been used in a number of different ways. I think Boris and I came close to agreeing that many things in OWL and OWL DL could be defined in a fairly straight forward way against traditional rules of logic. This is using logic as the “spec” for the operational semantics — that is, we could say (making up a simple example)
A owl:sameInstanceAs B <=> forall(x) P(A,x) -> P(B,x)
there was one of these done in KIF for DAML, so it is pretty clear that a great amount of what is in the current OWL Full could be defined this way. Note that this does not mean one necessarily should, or could, implement the language by simply inputting these to a logic engine (although that is probably possible for at least the great bulk of the language) but rather that the axioms are being used to provide a more precise description than NL does – but I would still claim this is primarily an operational semantic approach.
OK – my proposal.
I believe we can actually reach the ideal world above with one exception – the language called “OWL” is going to have to be called OWL Full for historical reasons.
We would need to update the OWL reference, which pretty much contains the operational semantics for OWL Full to include those new constructs we think are of use, and we can remove the part about the restrictions for OWL DL (because there is no longer the need for the 1-1 mapping) – so the OWL 1.0 reference would be extended into the OWL Full document.
We would define OWL DL precisely as we have already and, in my opinion, other than cleanup and resolving the OWL DL only issues, much of the complexity would disappear – because we could have features (and syntax) that are particular to the needs of reasoners that extend the above. The semantics would be aimed at reasoners so and would be based on the current model theory.
Taking this approach has some nice features:
1 – we are almost done (we would need to decide which OWL DL features need to be added to the OWL Full reference and write them up)- [sentence deleted]
2 – <a few words deleted> we would be defining both Full and DL, the feature mapping would be clear where needed. Features and syntax of DL that seem not to have Full realization would with (a) be added or (b) be declared as “extensions” that are not needed in Full.
3 – We could have fragments like OWL Prime that are defined for OWL Full easily. If we want corresponding fragments in OWL DL, we need to do the semantic work, but that is relatively straightforward. Fragments of DL, like those in the current fragments document, would also be easily derived as they wouldn’t necessarily impact the Full world. (Folks who want mappings from OWL to provably polynomial fragments would either use the OWL DL semantics, or could invent their own – we don’t have to do that work for them)
hmm, looks like my ideal world might be closer to realizable than I thought…
I look forward to being torn to shreds since I know this was written in a language very foreign from that of many in the WG. On the other hand, when we invented Web ontologies at Maryland (SHOE claims earliest use of the term), this is the vision I had in mind, so I guess I’m at least consistent….