# <![CDATA[
# KEHOME/xml/owl.ku
# Feb/8/2007
# Jun/10/2008 no "i:" for attributes
# OWL Web Ontology Language Reference
# W3C Working Draft 31 March 2003
# This version:
# http://www.w3.org/TR/2003/WD-owl-ref-20030331/
# some corrections from
# Editor's Draft document May 12, 2003
xmlns:owl := "http://www.w3.org/2002/07/owl";
xmlns:rdfxs := "http://www.w3.org/2000/10/XMLSchema#nonNegativeInteger";
#============================================================#
# from Appendix B: RDF Schema of OWL
<rdf:RDF
xmlns := "http://www.w3.org/2002/07/owl#";
xmlns:owl := "http://www.w3.org/2002/07/owl#";
xml:base := "http://www.w3.org/2002/07/owl";
xmlns:rdf := "http://www.w3.org/1999/02/22-rdf-syntax-ns#";
xmlns:rdfs := "http://www.w3.org/2000/01/rdf-schema#";
xmlns:dc := "http://purl.org/dc/elements/1.1/";
xmlns:xsd := "http://www.w3.org/2001/XMLschema#";
>
Ontology has rdf:about="",
versionInfo="March 18. 2003, GS",
imports rdf:resource="http://www.w3.org/2000/01/rdf-schema"/,
dc:title="Classes and properties for the Web Ontology Language OWL",
dc:creator="W3C Web Ontology (WebOnt) Working Group",
dc:subject="OWL; Web Ontology Language; Semantic Web",
dc:description=" This file specifies in RDF Schema format the\n
built-in classes and properties that together form the basis of\n
the RDF/XML syntax of OWL Full, OWL DL and OWL Lite with the help\n
of RDF Schema. We do not expect people to import this file\n
explicitly into their ontology. People that do import this file\n
should expect their ontology to be an OWL Full ontology.\n
",
dc:publisher="W3C",
dc:date="2003-02-10",
dc:format="text/xml",
dc:language="en",
dc:identifier="http://www.w3.org/2002/07/owl"
;
#============================================================#
# from Appendix C: OWL Quick Reference
sameAs is sameIndividualAs;
# Classes defined by OWL: rdfs:Class
ClassSet isu Set;
ClassSet isall
AllDifferent ,
Class ,
DatatypeProperty ,
DeprecatedClass ,
DeprecatedProperty ,
FunctionalProperty ,
InverseFunctionalProperty ,
Nothing ,
ObjectProperty ,
Ontology ,
OntologyProperty ,
Restriction ,
SymmetricProperty ,
Thing ;
# Properties defined by OWL: Property domain range
OWL Properties iss relation with
automatic = none,
format = [Property:1, domain:2, range:3],
meaning = {
$1 iss Property;
$1 has domain = $2;
$1 has range = $3;
$2 has $1;
};
begin relation OWL Properties;
allValuesFrom,Restriction,Class;
backwardCompatibleWith,Ontology,Ontology;
cardinality,Restriction,xsd:nonNegativeInteger;
complementOf,Class,Class;
differentFrom,Thing,Thing;
disjointWith,Class,Class;
distinctMembers,AllDifferent,List;
equivalentClass,Class,Class;
equivalentProperty,Property,Property;
imports,Ontology,Ontology; # corrected
incompatibleWith,Ontology,Ontology;
intersectionOf,Class,List;
inverseOf,ObjectProperty,ObjectProperty;
maxCardinality,Restriction,xsd:nonNegativeInteger;
minCardinality,Restriction,xsd:nonNegativeInteger;
oneOf,Class,List;
onProperty,Restriction,Property;
priorVersion,Ontology,Ontology;
sameAs,Thing,Thing;
sameIndividualAs,Thing,Thing;
someValuesFrom,Restriction,Class;
unionOf,Class,List;
end relation OWL Properties;
# Properties with no domain,range
Property isg
OntologyProperty;
Property isg
hasValue, # no range
versionInfo; # no domain or range
hasValue has domain = Restriction;
Restriction has hasValue;
#============================================================#
#============================================================#
# MKR statements
# OWL identities
#===============
Class ismem ClassSet;
Resource is Thing;
##existent is Thing;
##entity is Class;
##characteristic is Property;
##proposition isg Statement;
##nonexistent is Nothing;
# OWL hierarchy
#==============
begin hierarchy owlhi;
Property;
/ AnnotationProperty;
/ DatatypeProperty;
/ FunctionalProperty;
// InverseFunctionalProperty;
/ ObjectProperty;
// TransitiveProperty;
// SymmetricProperty;
/ OntologyProperty;
Class;
/ xsd:nonNegativeInteger;
end hierarchy owlhi;
begin hierarchy owlprim;
Property;
/ versionInfo;
/ imports;
/ allValuesFrom;
/ hasValue;
/ someValuesFrom;
/ cardinality;
/ minCardinality;
/ maxCardinality;
/ onProperty;
Property;
/ equivalentClass; # subject is object ???
/ equivalentProperty; # subject is object ???
/ sameAs; # subject is object
/ sameIndividualAs; # subject is object
/ inverseOf; # subject rel inverseOf=object
/ disjointWith; # subject rel disjointWith=object
/ differentFrom; # subject not is object
/ oneOf; # subject isany object
/ unionOf; # subject isor object
// disjointUnionOf;# subject isxor object
/ intersectionOf; # subject isand object
/ complementOf; # subject isnot object
AnnotationProperty;
/ label;
/ comment;
/ seeAlso;
/ isDefinedBy;
OntologyProperty;
/ imports;
/ priorVersion;
/ backwardCompatibleWith;
/ incompatibleWith;
end hierarchy owlprim;
imports
has chartype=action; # do import from source done;
versionInfo,
allValuesFrom,
hasValue,
someValuesFrom,
cardinality,
minCardinality,
maxCardinality,
onProperty
has chartype=attribute;
equivalentClass, # subject is object ???
equivalentProperty, # subject is object ???
sameAs, # subject is object
sameIndividualAs, # subject is object
inverseOf, # subject isinverse object
disjointWith, # subject disjointWith object
differentFrom, # subject not is object
oneOf, # subject isany object
unionOf, # subject isor object
disjointUnionOf, # subject isxor object
intersectionOf, # subject isand object
complementOf # subject is not object
has chartype=binary relation;
#============================================================#
# from old OWL Language Reference
# labels and comments
###<!-- (meta) classes of "object" and datatype classes -->
Class has
label="Class",
comment='The class of all "object" classes';
Datatype has
label="Datatype",
comment="The class of all datatype classes";
###<!-- Pre-defined top/bottom thing/nothing most/least-general (object) classes. -->
Thing has
label="Thing",
comment="\n
The most general (object) class in OWL.\n
This is equal to the union of any class and its complement.\n
";
nonexistent is Nothing ;
#### Thing isor
#### Nothing,
#### not Nothing;
Nothing has
label="Nothing",
comment="the class with no things in it.";
###<!-- Terms for building classes from other classes. -->
# X is Y
#####Thing has sameIndividualAs = Thing;
sameIndividualAs has
label="sameIndividualAs",
comment="for sameIndividualAs(a, b), read a is the same individual as b.";
# X xor Y
#####Class has disjointWith = Class;
disjointWith has
label="disjointWith",
comment="for disjointWith(X, Y) read: X and Y have no members in common.";
# X notis Y
#####Thing has differentFrom = Thing;
differentFrom has
label="differentFrom",
comment="for differentFrom(a, b), read a is not the same as b.";
# X isor Y,...
#####Class has unionOf = List;
unionOf has
label="unionOf",
comment="\n
for unionOf(X, Y) read: X is the union of the classes in the list Y;\n
i.e. if something is in any of the classes in Y, it's in X, and vice versa.\n
";
# X isxor Y,...
#####Class has disjointUnionOf = List;
disjointUnionOf has
domain=Class,
range=List,
label="disjointUnionOf",
comment="\n
for disjointUnionOf(X, Y) read: X is the disjoint union of the classes in\n
the list Y: (a) for any c1 and c2 in Y, disjointWith(c1, c2),\n
and (b) unionOf(X, Y). i.e. if something is in any of the classes in Y, it's\n
in X, and vice versa.\n
";
# X isand Y,...
#####Class has intersectionOf = List;
intersectionOf has
label="intersectionOf",
comment="\n
for intersectionOf(X, Y) read: X is the intersection of the classes in the list Y;\n
i.e. if something is in all the classes in Y, then it's in X, and vice versa.\n
";
# X is not Y
#####Class has complementOf = Class;
complementOf has
label="complementOf",
comment="\n
for complementOf(X, Y) read: X is the complement of Y; if something is in Y,\n
then it's not in X, and vice versa.\n
";
###<!-- Term for building classes by enumerating their elements -->
# X isany Y,...
#####Class has oneOf = List;
oneOf has
label="oneOf",
comment="\n
for oneOf(C, L) read everything in C is one of the\n
things in L;\n
This lets us define classes by enumerating the members.\n
";
###<!-- Terms for building classes by restricting their properties. -->
Restriction has
onProperty = Property,
allValuesFrom = Class,
hasValue,
someValuesFrom = Class;
Restriction has
label="Restriction",
comment="\n
something is in the class R if it satisfies the attached restrictions,\n
and vice versa.\n
";
onProperty has
label="onProperty",
comment="\n
for onProperty(R, P), read:\n
R is a restricted with respect to property P.\n
";
allValuesFrom has
label="allValuesFrom",
comment="\n
for onProperty(R, P) and allValuesFrom(R, X), read:\n
i is in class R if and only if for all j, P(i, j) implies type(j, X).\n
";
hasValue has
label="hasValue",
comment="\n
for onProperty(R, P) and hasValue(R, V), read:\n
i is in class R if and only if P(i, V).\n
";
someValuesFrom has
label="someValuesFrom",
comment="\n
for onProperty(R, P) and someValuesFrom(R, X), read:\n
i is in class R if and only if for some j, P(i, j) and type(j, X).\n
";
###<!-- Note that cardinality restrictions on transitive properties, or -->
###<!-- properties with transitive sub-properties, compromise decidability. -->
Restriction has
minCardinality = xsd:nonNegativeInteger,
maxCardinality = xsd:nonNegativeInteger,
cardinality = xsd:nonNegativeInteger;
minCardinality has
label="minCardinality",
comment="\n
for onProperty(R, P) and minCardinality(R, n), read:\n
i is in class R if and only if there are at least n distinct j with P(i, j).\n
";
maxCardinality has
label="maxCardinality",
comment="\n
for onProperty(R, P) and maxCardinality(R, n), read:\n
i is in class R if and only if there are at most n distinct j with P(i, j).\n
";
cardinality has
label="cardinality",
comment="\n
for onProperty(R, P) and cardinality(R, n), read:\n
i is in class R if and only if there are exactly n distinct j with P(i, j).\n
";
###<!-- Classes and Properties for different kinds of Property -->
Property isg
ObjectProperty,
DatatypeProperty,
FunctionalProperty,
InverseFunctionalProperty;
ObjectProperty isg
TransitiveProperty,
SymmetricProperty,
InverseFunctionalProperty;
ObjectProperty has
label="ObjectProperty",
comment="if P is an ObjectProperty, and P(x, y), then y is an object.";
DatatypeProperty has
label="DatatypeProperty",
comment="if P is a DatatypeProperty, and P(x, y), then y is a data value.";
#####ObjectProperty has inverseOf = ObjectProperty;
inverseOf has
label="inverseOf",
comment="\n
for inverseOf(R, S) read: R is the inverse of S; i.e.\n
if R(x, y) then S(y, x) and vice versa.\n
";
TransitiveProperty has
label="TransitiveProperty",
comment="if P is a TransitiveProperty, then if P(x, y) and P(y, z) then P(x, z).";
SymmetricProperty has
label="SymmetricProperty",
comment="if P is a SymmetricProperty, then if P(x, y) then P(y, x).";
FunctionalProperty has
label="FunctionalProperty",
comment="\n
compare with maxCardinality=1; e.g. integer successor:\n
if P is a FunctionalProperty, then if P(x, y) and P(x, z) then y=z.\n
";
InverseFunctionalProperty has
label="InverseFunctionalProperty",
comment="\n
if P is an InverseFunctionalProperty, then if P(x, y) and P(z, y) then x=z.\n
aka injective. e.g. if firstBorne(m, Susan)\n
and firstBorne(n, Susan) then m and n are the same.\n
";
###<!-- A class for ontologies themselves... -->
Ontology has
label="Ontology",
comment="\n
An Ontology is a document that describes\n
a vocabulary of terms for communication between\n
(human and) automated agents.\n
",
versionInfo,
imports;
versionInfo has
label="versionInfo",
comment="\n
generally, a string giving information about this\n
version; e.g. RCS/CVS keywords\n
";
###<!-- Importing, i.e. assertion by reference -->
imports has
label="imports",
comment="\n
for imports(X, Y) read: X imports Y;\n
i.e. X asserts the* contents of Y by reference;\n
i.e. if imports(X, Y) and you believe X and Y says something,\n
then you should believe it.\n
";
###<!-- Importing terms from RDF/RDFS -->
</rdf:RDF>
#]]>