vocabularies.daml+oil.daml Maven / Gradle / Ivy

Go to download





  $Id: daml+oil.daml,v 1.3 2003/07/24 15:27:55 ian_dickinson Exp $
  





  Class
  
    The class of all "object" classes
  
  



  Datatype
  
    The class of all datatype classes
  
  





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



  Nothing
  the class with no things in it.
  




 
  equivalentTo
  
    for equivalentTo(X, Y), read X is an equivalent term to Y.
  



  sameClassAs
  
    for sameClassAs(X, Y), read X is an equivalent class to Y.
    cf OIL Equivalent
  
  
  



  samePropertyAs
  
    for samePropertyAs(P, R), read P is an equivalent property to R.
  
  
  



  sameIndividualAs
  
    for sameIndividualAs(a, b), read a is the same individual as b.
  
  
  
  



  disjointWith
  
    for disjointWith(X, Y) read: X and Y have no members in common.
    cf OIL Disjoint
  
  
  



  differentIndividualFrom
  
    for differentIndividualFrom(a, b), read a is not the same individual as b.
  
  
  







  unionOf
  
    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
  
  
  



  disjointUnionOf
  
    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
  
  
  



  intersectionOf
  
    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
  
  
  



  complementOf
  
    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
  
  
  





  oneOf
  
     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
  
  
  





  Restriction
  
    something is in the class R if it satisfies the attached restrictions, 
    and vice versa.
  
  



  onProperty
  
    for onProperty(R, P), read:
    R is a restricted with respect to property P.
  
  
  



  toClass
  
    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
  
  
  



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



  hasClass
  
    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
  
  
  






  minCardinality
  
    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
  
  
  



  maxCardinality
  
    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
  
  
  



  cardinality
  
    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
  
  
  



  hasClassQ
  
    property for specifying class restriction with cardinalityQ constraints
  
  
  



  minCardinality
  
    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
  
  
  



  maxCardinality
  
    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
  
  
  



  cardinality
  
    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
  
  
  





  ObjectProperty
  
    if P is an ObjectProperty, and P(x, y), then y is an object.
  
  



  DatatypeProperty
  
    if P is a DatatypeProperty, and P(x, y), then y is a data value.
  
  



  inverseOf
  
    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
  
  
  



  TransitiveProperty
  
    if P is a TransitiveProperty, then if P(x, y) and P(y, z) then P(x, z).
    cf OIL TransitiveProperty.
  
  



  UniqueProperty
  
    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.
  
  



  UnambiguousProperty
  
    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.
  
  





  



  
     the empty list; this used to be called Empty.
  



  



  
  



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





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



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





  imports
  
    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".