Ontology
version info: $Id: daml-oil.rdf,v 1.2 2008-06-26 15:14:27 larsl Exp $
imports: rdf-schema

Class
comment: The class of all "object" classes
subclass of: Class

Datatype
type: Class
comment: The class of all datatype classes
subclass of: Class

Thing
type: Class
comment: The most general (object) class in DAML. This is equal to the union of any class and its complement.

Nothing
type: Class
comment: the class with no things in it.
complement of: Thing

equivalentTo
type: Property
comment: for equivalentTo(X, Y), read X is an equivalent term to Y.

sameClassAs
type: Property
comment: for sameClassAs(X, Y), read X is an equivalent class to Y. cf OIL Equivalent
sub property of: equivalentTo
sub property of: subClassOf
domain: Class
range: Class

samePropertyAs
type: Property
comment: for samePropertyAs(P, R), read P is an equivalent property to R.
sub property of: equivalentTo
sub property of: subPropertyOf

sameIndividualAs
type: Property
comment: for sameIndividualAs(a, b), read a is the same individual as b.
sub property of: equivalentTo
domain: Thing
range: Thing

disjointWith
type: Property
comment: for disjointWith(X, Y) read: X and Y have no members in common. cf OIL Disjoint
domain: Class
range: Class

differentIndividualFrom
type: Property
comment: for differentIndividualFrom(a, b), read a is not the same individual as b.
domain: Thing
range: Thing

unionOf
type: Property
comment: for unionOf(X, Y) read: X is the union of the classes in the list Y; i.e. if something is in any of the classes in Y, it's in X, and vice versa. cf OIL OR
domain: Class
range: List

disjointUnionOf
type: Property
comment: for disjointUnionOf(X, Y) read: X is the disjoint union of the classes in the list Y: (a) for any c1 and c2 in Y, disjointWith(c1, c2), and (b) unionOf(X, Y). i.e. if something is in any of the classes in Y, it's in X, and vice versa. cf OIL disjoint-covered
domain: Class
range: List

intersectionOf
type: Property
comment: for intersectionOf(X, Y) read: X is the intersection of the classes in the list Y; i.e. if something is in all the classes in Y, then it's in X, and vice versa. cf OIL AND
domain: Class
range: List

complementOf
type: Property
comment: for complementOf(X, Y) read: X is the complement of Y; if something is in Y, then it's not in X, and vice versa. cf OIL NOT
domain: Class
range: Class

oneOf
type: Property
comment: for oneOf(C, L) read everything in C is one of the things in L; This lets us define classes by enumerating the members. cf OIL OneOf
domain: Class
range: List

Restriction
type: Class
comment: something is in the class R if it satisfies the attached restrictions, and vice versa.
subclass of: Class

onProperty
type: Property
comment: for onProperty(R, P), read: R is a restricted with respect to property P.
domain: Restriction
range: Property

toClass
type: Property
comment: for onProperty(R, P) and toClass(R, X), read: i is in class R if and only if for all j, P(i, j) implies type(j, X). cf OIL ValueType
domain: Restriction
range: Class

hasValue
type: Property
comment: for onProperty(R, P) and hasValue(R, V), read: i is in class R if and only if P(i, V). cf OIL HasFiller
domain: Restriction

hasClass
type: Property
comment: for onProperty(R, P) and hasClass(R, X), read: i is in class R if and only if for some j, P(i, j) and type(j, X). cf OIL HasValue
domain: Restriction
range: Class

minCardinality
type: Property
comment: for onProperty(R, P) and minCardinality(R, n), read: i is in class R if and only if there are at least n distinct j with P(i, j). cf OIL MinCardinality
domain: Restriction
range: nonNegativeInteger

maxCardinality
type: Property
comment: for onProperty(R, P) and maxCardinality(R, n), read: i is in class R if and only if there are at most n distinct j with P(i, j). cf OIL MaxCardinality
domain: Restriction
range: nonNegativeInteger

cardinality
type: Property
comment: for onProperty(R, P) and cardinality(R, n), read: i is in class R if and only if there are exactly n distinct j with P(i, j). cf OIL Cardinality
domain: Restriction
range: nonNegativeInteger

hasClassQ
type: Property
comment: property for specifying class restriction with cardinalityQ constraints
domain: Restriction
range: Class

minCardinality
type: Property
comment: for onProperty(R, P), minCardinalityQ(R, n) and hasClassQ(R, X), read: i is in class R if and only if there are at least n distinct j with P(i, j) and type(j, X). cf OIL MinCardinality
domain: Restriction
range: nonNegativeInteger

maxCardinality
type: Property
comment: for onProperty(R, P), maxCardinalityQ(R, n) and hasClassQ(R, X), read: i is in class R if and only if there are at most n distinct j with P(i, j) and type(j, X). cf OIL MaxCardinality
domain: Restriction
range: nonNegativeInteger

cardinality
type: Property
comment: for onProperty(R, P), cardinalityQ(R, n) and hasClassQ(R, X), read: i is in class R if and only if there are exactly n distinct j with P(i, j) and type(j, X). cf OIL Cardinality
domain: Restriction
range: nonNegativeInteger

ObjectProperty
type: Class
comment: if P is an ObjectProperty, and P(x, y), then y is an object.
subclass of: Property

DatatypeProperty
type: Class
comment: if P is a DatatypeProperty, and P(x, y), then y is a data value.
subclass of: Property

inverseOf
type: Property
comment: for inverseOf(R, S) read: R is the inverse of S; i.e. if R(x, y) then S(y, x) and vice versa. cf OIL inverseRelationOf
domain: ObjectProperty
range: ObjectProperty

TransitiveProperty
type: Class
comment: if P is a TransitiveProperty, then if P(x, y) and P(y, z) then P(x, z). cf OIL TransitiveProperty.
subclass of: ObjectProperty

UniqueProperty
type: Class
comment: compare with maxCardinality=1; e.g. integer successor: if P is a UniqueProperty, then if P(x, y) and P(x, z) then y=z. cf OIL FunctionalProperty.
subclass of: Property

UnambiguousProperty
type: Class
comment: if P is an UnambiguousProperty, then if P(x, y) and P(z, y) then x=z. aka injective. e.g. if firstBorne(m, Susan) and firstBorne(n, Susan) then m and n are the same.
subclass of: ObjectProperty

nil
type: List
comment: the empty list; this used to be called Empty.

item
type: Property
comment: for item(L, I) read: I is an item in L; either first(L, I) or item(R, I) where rest(L, R).
domain: List

Ontology
type: Class
comment: An Ontology is a document that describes a vocabulary of terms for communication between (human and) automated agents.

versionInfo
type: Property
comment: generally, a string giving information about this version; e.g. RCS/CVS keywords

imports
type: Property
comment: for imports(X, Y) read: X imports Y; i.e. X asserts the* contents of Y by reference; i.e. if imports(X, Y) and you believe X and Y says something, then you should believe it. Note: "the contents" is, in the general case, an il-formed definite description. Different interactions with a resource may expose contents that vary with time, data format, preferred language, requestor credentials, etc. So for "the contents", read "any contents".