vocabularies.daml+oil-2000-12.daml Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of jena Show documentation
Jena is a Java framework for building Semantic Web applications. It provides a programmatic environment for RDF, RDFS and OWL, SPARQL and includes a rule-based inference engine.
There is a newer version: 2.6.4
Show newest version



  $Id: daml+oil-2000-12.daml,v 1.1 2003/04/08 14:29:13 ian_dickinson Exp $
  





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



  the class with no things in it.
  




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



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



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



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



  Disjoint
  
  
    for type(L, Disjoint) read: the classes in L are pairwise disjoint.
    i.e. if type(L, Disjoint), and C1 in L and C2 in L, then disjointWith(C1, C2).
    cf OIL Disjoint
  



  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
  



  
    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
  
  
  



  
    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
  
  
  





  
     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.
  



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



  
    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
  
  
  



  
    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
  
  
  



  NonNegativeInteger
  
    Nonnegative integers are used in cardinality restrictions
  
  






  
    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 nameOfMonth(m, "Feb")
    and nameOfMonth(n, "Feb") then m and n are the same month.
  
  





  



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