Model-Theoretic Semantics for OWL

Authors:: Peter F. Patel-Schneider

Abstract

The OWL Web Ontology Language is being designed by the W3C Web Ontology Working Group as a revision of the DAML+OIL web ontology language. This model-theoretic semantics for OWL serves to provide a formal meaning for OWL. This semantics uses the abstract syntax for OWL, as it is the easiest to work with, and thus the semantics here is easier to work with than semantics provided for other ways of looking at OWL. Semantics for the exchange syntax for OWL are provided by mapping back to the abstract syntax.

Introduction
Model-Theoretic Semantics
Semantics for the Exchange Syntax

1. Introduction

This semantics for OWL knowledge bases uses the abstract syntax used in the abstract syntax document. Semantics are given for the XML presentation syntax and to the RDF exchange syntax in the exchange syntax section.

2. Model-Theoretic Semantics

2.1. Vocabularies and Interpretations

The semantics here starts with the notion of a vocabulary, which can be thought of as the names that are of interest in a knowledge base. It is, however, not necessary that a vocabulary consist only of the names in a knowledge base.

An OWL vocabulary V is a set of expanded qualified names (which are meant to be equivalent to URI references). Each OWL vocabulary includes QNames for each of the XML Schema non-list built-in simple datatypes.

An OWL interpretation with vocabulary V is an extension of an RDFS interpretation of vocabulary V, a five-tuple of the form

I = <R, EXT, S, EC, ER> where 
	R is a non-empty set of resources
	EXT : R -> 2  ^  (R x (R u D))
	S   : V -> R
	EC  : V -> 2^R  u  2^V
	ER  : V -> 2^(RxR) u  2^(RxD)

EC and ER provide meaning for OWL class names and property names.

OWL interpretations have the following extra conditions:

D is the (disjoint) union of the value spaces of the built-in primitive XML Schema datatypes.
R and D are disjoint.
If d is the name of an XML Schema non-list built-in simple datatype then EC(d) is the value space of this datatype.
If c is not the name of any XML Schema non-list built-in simple datatype then EC(c) is a subset of R.
If d,l is a datatype,literal pair then XMLS(d)(l) is the data value for l in XML Schema datatype d.

2.2. Interpreting Embedded Constructs

EC is extended to various syntactic constructs that are parts of axioms and facts as follows:

EC(restriction(p range=r))	{x in V \| <x,y> in ER(p) -> y in EC(r)}
EC(restriction(p required=e))	{x in V \| exists <x,y> in ER(p) with y in EC(e)}
EC(restriction(p value=i))	{x in V \| <x,S(i)> in ER(p)}
EC(restriction(p value=d,l))	{x in V \| <x,XMLS(d)(l)> in ER(p)}
EC(restriction(p atleast(n)))	{x in V \| exists atleast n <x,y> in ER(p)}
EC(restriction(p atmost(n)))	{x in V \| exists atmost n <x,y> in ER(p)}
EC(restriction(p exactly(n)))	{x in V \| exists exactly n <x,y> in ER(p)}
EC(pv(p f))	{x in V \| exists y in EC(f) with <x,y> in ER(p)}
EC(pv(p i))	{x in V \| <x,S(i)> in ER(p) }
EC(pv(p d,l))	{x in V \| <x,XMLS(d)(l)> in ER(p) }
EC(restriction(p x1 ... xn))	EC(restriction(p x1))^...^EC(restriction(p xn))
EC(oneOf(i1 ... in))	{S(i1), ..., S(in)}
EC(unionOf(c1 ... cn))	EC(c1) u ... u EC(cn))
EC(intersectionOf(c1 ... cn))	EC(c1) ^...^ EC(cn))
EC(complementOf(c))	R - EC(c)
EC(Individual(c pv1 ... pvn))	EC(p) ^ EC(pv(pv1)) ^...^ EC(pv(pvn))
EC(Individual(i c pv1 ... pvn))	{S(i)} ^ EC(p) ^ EC(pv(pv1)) ^...^ EC(pv(pvn))
EC(oneOf(d1,l1 ... dn,ln))	{ XMLS(d1)(l1), ..., XMLS(dn)(ln) }

2.3. Interpreting Directives

An OWL interpretation, I, is an interpretation of OWL directives as follows:

EquivalentClass(c descr1 ... descrn): if EC(c) = EC(descr1) ^...^ EC(descrn)
SubClass(c decr1 ... descrn): if EC(c) ≤ EC(descr1) ^...^ EC(descrn)
EnumeratedClass(c i1 ... in): if EC(c) = { S(i1), ..., S(in) }
DisjointClasses(d1 ... dn): if EC(di) ^ EC(dj) = { } for 1 ≤ i < j ≤ n
EquivalentClasses(d1 ... dn): if EC(di) = EC(dj) for 1 ≤ i < j ≤ n
SubClassOf(d1 d2): if EC(d1) ≤ EC(d2)
DataProperty(p super=s1 ... super=sn domain=d1 ... domain=dn range=r1 ... range=rn [Functional]): if ER(p) ≤ ER(s1) ^...^ ER(sn) ^ EC(d1)xV ^...^ EC(dn)xV ^ RxEC(d1) ^...^ RxEC(dn) [and ER(p) is functional]
IndividualProperty(p super=s1 ... super=sn domain=d1 ... domain=dn range=r1 ... range=rn [inverse=i] [Symmetric] [Functional] [InverseFunctional] [OneToOne] [Transitive]): if ER(p) ≤ ER(s1) ^...^ ER(sn) ^ EC(d1)xR ^...^ EC(dn)xR ^ RxEC(d1) ^...^ RxEC(dn) [and ER(p) is the inverse of ER(i)] [and ER(p) is symmetric] [and ER(p) is functional] [and ER(p) is inverse functional] [and ER(p) is one to one] [and ER(p) is transitive]
EquivalentProperties(p1 ... pn): if ER(pi) = ER(pj) for 1 ≤ i < j ≤ n
SubPropertyOf(p1 p1): if ER(p1) ≤ ER(p2)
SameIndividual(i1 ... in): if S(ii) = S(ij) for 1 ≤ i < j ≤ n
DifferentIndividuals(i1 ... in): if S(ii) /= S(ij) for 1 ≤ i < j ≤ n
Individual([i] c pv1 ... pvn): if EC(Individual([i] c pv1 ... pvn)) is nonempty

2.4. Interpreting Ontologies

An OWL interpretation, I, is an interpretation of an OWL ontology, O, iff I is an interpretation of each axiom and fact in the closure of O. An OWL ontology entails an OWL axiom or fact if each interpretation of the ontology is also an interpretation of the axiom or fact.

3. Semantics for the Exchange Syntax

The basic idea for providing semantics for OWL documents written in the exchange syntax is to map the triples in the document back to the abstract syntax, if possible. If there is no mapping back to the abstract syntax, then the document does not have an OWL meaning.

The details of this mapping have yet to be worked out, and may involve an intermediate step of mapping into an XML presentation syntax for OWL.