The Web Ontology Language (OWL')

	XML compatible
	RDF compatible for base facts

		Peter F. Patel-Schneider
		Bell Labs Research

		(3 January 2002)


[Common portions elided.]

4. Interpretations

An OWL' interpretation, I, over a datatyping scheme DT consists of 
	R, nonempty, disjoint from V	the domain of resources 
	EXT : N -> 2^(Rx(RuV))		property extensions
	CEXT : N -> 2^(RuV)		class extensions
	S : N -> R			mapping from names to denotation

The URIs for datatypes must be disjoint from the URIs used below.


The following conditions must be satisfied by an interpretation.

4.1 Conditions from RDF

R1  [not meaningful]
R2  [not meaningful]
R3  [not meaningful]

4.2 Conditions from RDFS  


S1  CEXT(rdfs:Resource)  =  R
S2  [not meaningful]
S3  CEXT(rdfs:Literal)   =  V

S4  [not meaningful]
S5  [not meaningful]
S6  [not meaningful]
S7  [not meaningful or in definition above]
S8  [not meaningful or in definition above]

S9  [not meaningful]
S10 [not meaningful]

S11 [not meaningful]
S12 [not meaningful]

4.3 Conditions for datatypes

D1  [not meaningful]
D2  [not meaningful]
D3  [not meaningful]
D4  [not meaningful]
D5  for d in DT    CEXT(U(d)) = Vd

4.4 Conditions for OWL'

W1  [not meaningful]
W2  [not meaningful]
W3  [not meaningful]
W4  [not meaningful]
W5  [not meaningful]
W6  [not meaningful]

W7  [not meaningful]
W8  [in satisfaction conditions]
W9  [in satisfaction conditions]
W10 [in satisfaction conditions]
W11 [in satisfaction conditions]
W12 [in satisfaction conditions]

W13 [in satisfaction conditions]
W14 [in satisfaction conditions]
W15 [in satisfaction conditions]
W16 [in satisfaction conditions]
W17 [in satisfaction conditions]
W18 [in satisfaction conditions]
W19 [in satisfaction conditions]

W20 CEXT(swol:Thing) = R
W21 CEXT(swol:Nothing) = {}

4.5 Discussion

Note that interpretations here are much less complex than interpretations
in the initial definition.  This has two important consequences:
1/ The chances that this definition is incoherent are very small.  Further,
   extensions to this definition are much easier than for the other
   definition. 
2/ Reasoning in this definition is much easier to characterise, and may
   even be computationally less difficult.


5. Satisfaction

Given an OWL' KB an extended interpretation, I', for KB is an OWL'
interpretation, I,  with the following extra component
	A : K -> R u V		mapping from nodes to denotation
with the condition that non-text nodes map into R and text nodes map into V.
I' is said to be an extension of the interpretation I.

An extended interpretation OWL'-satisfies a KB as follows:

Note:  The construction rdf:name refers to the QName with local part name
       and URI http://www.w3.org/1999/02/22-rdf-syntax-ns
       The construction rdfs:name refers to the QName with local part name
       and URI http://www.w3.org/[rdfs URI]
       The construction swol:name refers to the QName with local part name
       and URI http://www.w3.org/[swol URI]


5.1 Satisfaction for non-descriptions

Syntax		Semantic Conditions

kb ::= ( definition | resourceElement ) *

definition ::= 
     ELEMENT(swol:defineClass,{},<id,desc>)
		CEXT(Q(id)) = ID(desc)
   | ELEMENT(swol:definePrimitiveClass,{},<id,desc>)
		CEXT(Q(id)) <= ID(desc)
   | ELEMENT(swol:disjointWith,{},<id1,id2>)
		CEXT(Q(id1)) ^ CEXT(Q(id2)) = {}

   | ELEMENT(swol:samePropertyAs,{},<id1,id2>)
		EXT(Q(id1)) = EXT(Q(id2))
   | ELEMENT(swol:subPropertyOf,{},<id1,id2>)
		EXT(Q(id1)) <= EXT(Q(id2))

   | ELEMENT(swol:domain,{},<id,desc>)
		EXT(Q(id)) <= ID(desc) x (RuV)
   | ELEMENT(swol:range,{},<id,desc>)
		EXT(Q(id)) <= R x IC(desc)

   | ELEMENT(swol:ObjectProperty,{},<id>)
		EXT(Q(id)) <= R x R
   | ELEMENT(swol:DatatypeProperty,{},<id>)
		EXT(Q(id)) <= R x V
   | ELEMENT(swol:UniqueProperty,{},<id>)
		EXT(Q(id)) is functional
   | ELEMENT(swol:UnambiguousProperty,{},<id>)
		converse of EXT(Q(id)) is functional
   | ELEMENT(swol:TransitiveProperty,{},<id>)
		EXT(Q(id)) is transitive

   | ELEMENT(swol:sameIndividualAs,{},<id1,id2>)
		S(Q(id1)) in R	S(Q(id2)) in R	S(Q(id1)) = S(Q(id2))
   | ELEMENT(swol:differentIndividualFrom,{},<id1,id2>)
		S(Q(id1)) in R	S(Q(id2)) in R	S(Q(id1)) /= S(Q(id2))

resourceElement ::= 
     ELEMENT(name,{propertyAttribute*},{propertyElement*})
		A(|self|) in CEXT(S(name))

propertyAttribute ::=
     ATTRIBUTE(rdf:ID,id)
		A(|parent|) = S(Q(id))
   | ATTRIBUTE(rdf:about,id)
		A(|parent|) = S(Q(id))
   | ATTRIBUTE(name,text,type,value)
		< A(|parent|) , A(|self|) > in EXT(S(name))
		A(|self|) = value
   | ATTRIBUTE(name,text)
		< A(|parent|) , A(|self|) > in EXT(S(name))
		A(|self|) in LV(text)

propertyElement ::=
     ELEMENT(rdf:type,{},{desc})
		A(|parent|) in ID(desc)
   | ELEMENT(name,{rdf:resource,id},{})
		< A(|parent|),S(Q(id)) > in IR(name)
   | ELEMENT(name,{},{resourceElement})
		< A(|parent|),S(resourceElement) > in IR(name)
   | ELEMENT(name,{},{valueNode=TEXT(text)},type,value)
		< A(|parent|),A(valueNode) > in IR(name)
		A(valueNode) = value
   | ELEMENT(name,{},{valueNode=TEXT(text)})
		< A(|parent|),A(valueNode) > in IR(name)
		A(valueNode) in LV(text)

prop ::= resourceElement

5.1 Extensions for descriptions

Description	Extension(ID)

desc
 ::= ELEMENT(id)
		CEXT(Q(id)) ^ R
   | ELEMENT(swol:unionOf,{desc+})
		ID(desc1) v ... v ID(descn)
   | ELEMENT(swol:intersectionOf,{desc+})
		ID(desc1) ^ ... ^ ID(descn)
   | ELEMENT(swol:complementOf,{desc})
		R \ ID(desc)
   | ELEMENT(swol:oneOf,{id*})
		{ S(Q(id1)), ..., S(Q(id1n)) }
   | ELEMENT(swol:toClass,{},<prop,class>)
		{ x : <x,y> in EXT(prop) implies y in IC(class) }
   | ELEMENT(swol:hasValue,{},<prop,id>)
		{ x : <x,S(Q(id))> in EXT(Q(prop)) }
   | ELEMENT(swol:hasValue,{},<prop,TEXT(text)>,type,value>)
		{ x : <x,value> in EXT(Q(prop)) }
   | ELEMENT(swol:hasClass,{},<prop,class>)
		{ x : exists y <x,y> in EXT(Q(prop)) and y in IC(class) }
   | ELEMENT(swol:minCardinality,{},<prop,int>)
		{ x : >=int y  <x,y> in EXT(Q(prop)) }
   | ELEMENT(swol:maxCardinality,{},<prop,int>)
		{ x : <=int y  <x,y> in EXT(Q(prop)) }
   | ELEMENT(swol:cardinality,{},<prop,int>)
		{ x : =int y  <x,y> in EXT(Q(prop)) }
   | ELEMENT(swol:minCardinality,{},<prop,int,class>)
		{ x : >=int y  <x,y> in EXT(Q(prop)) and y in IC(class) }
   | ELEMENT(swol:maxCardinality,{},<prop,int,class>)
		{ x : <=int y  <x,y> in EXT(Q(prop)) and y in IC(class) }
   | ELEMENT(swol:cardinality,{},<prop,int,class>)
		{ x : =int y  <x,y> in EXT(Q(prop)) and y in IC(class) }

Class		Extension(IC)

class
 ::= desc
		ID(desc)
   | ELEMENT(id)
		L(Q(id)))		provided that Q(id) in DT





6. Models and entailment:

An interpretation is a model for an OWL' knowledge base if there is some
extension of the interpretation that satisfies the knowledge base.

An OWL' knowledge base, KB1, entails another, KB2, if all models of KB1
are also models of KB2.

Also needed are meta-theoretic notions of subsumption, as subsumption
cannot be directly determined via entailment.