#Processed by Id: cwm.py,v 1.48 2001/05/26 17:28:07 timbl Exp 
        #    using base file:/web/infomesh/2001/05/sem/core.n3
        
#  Notation3 generation by
#       notation3.py,v 1.78 2001/05/23 01:39:38 timbl Exp

#   Base was: file:/web/infomesh/2001/05/sem/core.n3
     @prefix : <http://www.w3.org/2000/01/rdf-schema#> .
     @prefix daml: <http://www.daml.org/2001/03/daml+oil#> .
     @prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
    
    rdf:type     a rdf:Property;
         :comment "Identifies the Class of a resource",
                "Indicates membership of a class";
         :label "type";
         :range <rdfs.n3#Class> .
      [      a daml:Property;
             daml:ID "equivalentTo";
             daml:comment """
    for equivalentTo(X, Y), read X is an equivalent term to Y.
  """;
             :label "equivalentTo" ].
    
      [      a daml:Property;
             daml:ID "sameClassAs";
             daml:comment """
    for sameClassAs(X, Y), read X is an equivalent class to Y.
    cf OIL Equivalent
  """;
             :domain daml:Class;
             :label "sameClassAs";
             :range daml:Class;
             :subPropertyOf daml:equivalentTo,
                    :subClassOf ].
    
      [      a daml:Property;
             daml:ID "samePropertyAs";
             :comment """
    for samePropertyAs(P, R), read P is an equivalent property to R.
  """;
             :label "samePropertyAs";
             :subPropertyOf daml:equivalentTo,
                    :subPropertyOf ].
    
      [      a daml:Property;
             daml:ID "sameIndividualAs";
             :comment """
    for sameIndividualAs(a, b), read a is the same individual as b.
  """;
             :domain daml:Thing;
             :label "sameIndividualAs";
             :range daml:Thing;
             :subPropertyOf daml:equivalentTo ].
    
      [      a daml:Property;
             daml:ID "differentIndividualFrom";
             :comment """
    for differentIndividualFrom(a, b), read a is not the same individual as b.
  """;
             :domain daml:Thing;
             :label "differentIndividualFrom";
             :range daml:Thing ].
    
    <daml.n3>     a daml:Ontology;
         daml:imports <http://www.w3.org/2000/01/rdf-schema>;
         daml:versionInfo "$Id: daml+oil.daml,v 1.6 2001/03/28 00:45:00 pfps Exp $" .
    
    <rdfs.n3#Class>     a :Class;
         :comment "The concept of Class";
         :label "Class",
                "Classe";
         :subClassOf <rdfs.n3#Resource> .
    
    <rdfs.n3#ConstraintProperty>     a :Class;
         :comment "Properties used to express RDF Schema constraints.";
         :label "ConstraintProperty",
                "Proprixx'x'\351txx'x'\351Contrainte";
         :subClassOf <rdfs.n3#ConstraintResource>,
                rdf:Property .
    
    <rdfs.n3#ConstraintResource>     a <rdfs.n3#Class>,
                :Class;
         :comment "Resources used to express RDF Schema constraints.";
         :label "ConstraintResource",
                "RessourceContrainte";
         :subClassOf <rdfs.n3#Resource> .
    
    <rdfs.n3#Container>     a :Class;
         :comment "This represents the set Containers.";
         :label "Container",
                "Enveloppe";
         :subClassOf <rdfs.n3#Resource> .
    
    <rdfs.n3#ContainerMembershipProperty>     a :Class;
         :label "ContainerMembershipProperty";
         :subClassOf rdf:Property .
    
    <rdfs.n3#Literal>     a <rdfs.n3#Class>,
                :Class;
         :comment "This represents the set of atomic values, eg. textual strings.";
         :label "Literal",
                "Littxx'x'\351ral" .
    
    <rdfs.n3#Resource>     a :Class;
         :comment "The most general class";
         :label "Resource",
                "Ressource" .
    
    <rdfs.n3#comment>     a rdf:Property;
         :comment "Use this for descriptions";
         :domain <rdfs.n3#Resource>;
         :label "comment",
                "commentaire";
         :range <rdfs.n3#Literal> .
    
    <rdfs.n3#domain>     a :ConstraintProperty;
         :comment "This is how we associate a class with properties that its instances can have";
         :label "domain",
                "domaine" .
    
    <rdfs.n3#isDefinedBy>     a rdf:Property;
         :comment "Indicates a resource containing and defining the subject resource.";
         :domain <rdfs.n3#Resource>;
         :label "esDxx'x'\351finiPar",
                "isDefinedBy";
         :range <rdfs.n3#Resource>;
         :subPropertyOf <rdfs.n3#seeAlso> .
    
    <rdfs.n3#label>     a rdf:Property;
         :comment "Provides a human-readable version of a resource name.";
         :domain <rdfs.n3#Resource>;
         :label "label";
         :range <rdfs.n3#Literal> .
    
    <rdfs.n3#range>     a :ConstraintProperty;
         :comment "Properties that can be used in a schema to provide constraints";
         :domain rdf:Property;
         :label "range",
                "xx'x'\351tendue";
         :range <rdfs.n3#Class> .
    
    <rdfs.n3#seeAlso>     a rdf:Property;
         :comment "Indicates a resource that provides information about the subject resource.";
         :domain <rdfs.n3#Resource>;
         :label "seeAlso",
                "voirAussi";
         :range <rdfs.n3#Resource> .
    
    <rdfs.n3#subClassOf>     a rdf:Property;
         :comment "Indicates membership of a class";
         :domain <rdfs.n3#Class>;
         :label "sousClasseDe",
                "subClassOf";
         :range <rdfs.n3#Class> .
    
    <rdfs.n3#subPropertyOf>     a rdf:Property;
         :comment "Indicates specialization of properties";
         :domain rdf:Property;
         :label "sousProprixx'x'\351txx'x'\351De",
                "subPropertyOf";
         :range rdf:Property .
    
    daml:Class     a :Class;
         :comment """
    The class of all \"object\" classes
  """;
         :label "Class";
         :subClassOf :Class .
    
    daml:Datatype     a :Class;
         :comment """
    The class of all datatype classes
  """;
         :label "Datatype";
         :subClassOf :Class .
    
    daml:DatatypeProperty     a :Class;
         :comment """
    if P is a DatatypeProperty, and P(x, y), then y is a data value.
  """;
         :label "DatatypeProperty";
         :subClassOf rdf:Property .
    
    daml:List     a :Class;
         :subClassOf rdf:Seq .
    
    daml:Literal     a :Class;
         daml:sameClassAs :Literal .
    
    daml:Nothing     a daml:Class;
         daml:complementOf daml:Thing;
         :comment "the class with no things in it.";
         :label "Nothing" .
    
    daml:ObjectProperty     a :Class;
         :comment """
    if P is an ObjectProperty, and P(x, y), then y is an object.
  """;
         :label "ObjectProperty";
         :subClassOf rdf:Property .
    
    daml:Ontology     a :Class;
         :comment """
    An Ontology is a document that describes
    a vocabulary of terms for communication between
    (human and) automated agents.
  """;
         :label "Ontology" .
    
    daml:Property     a :Class;
         daml:sameClassAs rdf:Property .
    
    daml:Restriction     a :Class;
         :comment """
    something is in the class R if it satisfies the attached restrictions, 
    and vice versa.
  """;
         :label "Restriction";
         :subClassOf daml:Class .
    
    daml:Thing     a daml:Class;
         daml:unionOf  (
        daml:Nothing 
         [
                 daml:complementOf daml:Nothing ] );
         :comment """
    The most general (object) class in DAML.
    This is equal to the union of any class and its complement.
  """;
         :label "Thing" .
    
    daml:TransitiveProperty     a :Class;
         :comment """
    if P is a TransitiveProperty, then if P(x, y) and P(y, z) then P(x, z).
    cf OIL TransitiveProperty.
  """;
         :label "TransitiveProperty";
         :subClassOf daml:ObjectProperty .
    
    daml:UnambiguousProperty     a :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.
  """;
         :label "UnambiguousProperty";
         :subClassOf daml:ObjectProperty .
    
    daml:UniqueProperty     a :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.
  """;
         :label "UniqueProperty";
         :subClassOf rdf:Property .
    
    daml:cardinality     a rdf: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 daml:Restriction;
         :label "cardinality";
         :range <http://www.w3.org/2000/10/XMLSchema#nonNegativeInteger> .
    
    daml:cardinalityQ     a rdf: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 daml:Restriction;
         :label "cardinality";
         :range <http://www.w3.org/2000/10/XMLSchema#nonNegativeInteger> .
    
    daml:comment     a rdf:Property;
         daml:samePropertyAs :comment .
    
    daml:complementOf     a rdf: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 daml:Class;
         :label "complementOf";
         :range daml:Class .
    
    daml:disjointUnionOf     a rdf: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 daml:Class;
         :label "disjointUnionOf";
         :range daml:List .
    
    daml:disjointWith     a rdf:Property;
         :comment """
    for disjointWith(X, Y) read: X and Y have no members in common.
    cf OIL Disjoint
  """;
         :domain daml:Class;
         :label "disjointWith";
         :range daml:Class .
    
    daml:domain     a rdf:Property;
         daml:samePropertyAs :domain .
    
    daml:first     a rdf:Property;
         :domain daml:List .
    
    daml:hasClass     a rdf: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 daml:Restriction;
         :label "hasClass";
         :range :Class .
    
    daml:hasClassQ     a rdf:Property;
         :comment """
    property for specifying class restriction with cardinalityQ constraints
  """;
         :domain daml:Restriction;
         :label "hasClassQ";
         :range :Class .
    
    daml:hasValue     a rdf: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 daml:Restriction;
         :label "hasValue" .
    
    daml:imports     a rdf: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\".
  """;
         :label "imports" .
    
    daml:intersectionOf     a rdf: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 daml:Class;
         :label "intersectionOf";
         :range daml:List .
    
    daml:inverseOf     a rdf: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 daml:ObjectProperty;
         :label "inverseOf";
         :range daml:ObjectProperty .
    
    daml:isDefinedBy     a rdf:Property;
         daml:samePropertyAs :isDefinedBy;
         :subPropertyOf daml:seeAlso .
    
    daml:item     a rdf: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 daml:List .
    
    daml:label     a rdf:Property;
         daml:samePropertyAs :label .
    
    daml:maxCardinality     a rdf: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 daml:Restriction;
         :label "maxCardinality";
         :range <http://www.w3.org/2000/10/XMLSchema#nonNegativeInteger> .
    
    daml:maxCardinalityQ     a rdf: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 daml:Restriction;
         :label "maxCardinality";
         :range <http://www.w3.org/2000/10/XMLSchema#nonNegativeInteger> .
    
    daml:minCardinality     a rdf: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 daml:Restriction;
         :label "minCardinality";
         :range <http://www.w3.org/2000/10/XMLSchema#nonNegativeInteger> .
    
    daml:minCardinalityQ     a rdf: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 daml:Restriction;
         :label "minCardinality";
         :range <http://www.w3.org/2000/10/XMLSchema#nonNegativeInteger> .
    
    ()     a daml:List;
         :comment """
     the empty list; this used to be called Empty.
  """ .
    
    daml:onProperty     a rdf:Property;
         :comment """
    for onProperty(R, P), read:
    R is a restricted with respect to property P.
  """;
         :domain daml:Restriction;
         :label "onProperty";
         :range rdf:Property .
    
    daml:oneOf     a rdf: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 daml:Class;
         :label "oneOf";
         :range daml:List .
    
    daml:range     a rdf:Property;
         daml:samePropertyAs :range .
    
    daml:rest     a rdf:Property;
         :domain daml:List;
         :range daml:List .
    
    daml:seeAlso     a rdf:Property;
         daml:samePropertyAs :seeAlso .
    
    daml:subClassOf     a rdf:Property;
         daml:samePropertyAs :subClassOf .
    
    daml:subPropertyOf     a rdf:Property;
         daml:samePropertyAs :subPropertyOf .
    
    daml:toClass     a rdf: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 daml:Restriction;
         :label "toClass";
         :range :Class .
    
    daml:type     a rdf:Property;
         daml:samePropertyAs rdf:type .
    
    daml:unionOf     a rdf: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 daml:Class;
         :label "unionOf";
         :range daml:List .
    
    daml:value     a rdf:Property;
         daml:samePropertyAs rdf:value .
    
    daml:versionInfo     a rdf:Property;
         :comment """
    generally, a string giving information about this
    version; e.g. RCS/CVS keywords
  """;
         :label "versionInfo" .
    
    rdf:Alt     a :Class;
         :comment "A collection of alternatives";
         :label "Alt",
                "Choix";
         :subClassOf <rdfs.n3#Container> .
    
    rdf:Bag     a :Class;
         :comment "An unordered collection";
         :label "Bag",
                "Ensemble";
         :subClassOf <rdfs.n3#Container> .
    
    rdf:Property     a :Class;
         :comment "A name of a property, defining specific meaning for the property",
                "The concept of a property.";
         :label "Property",
                "Proprixx'x'\351txx'x'\351";
         :subClassOf <rdfs.n3#Resource> .
    
    rdf:Seq     a :Class;
         :comment "An ordered collection";
         :label "Sequence",
                "Sxx'x'\351quence";
         :subClassOf <rdfs.n3#Container> .
    
    rdf:Statement     a :Class;
         :comment "A triple consisting of a predicate, a subject, and an object.",
                "This represents the set of reified statements.";
         :label "Dxx'x'\351claration",
                "Statement";
         :subClassOf <rdfs.n3#Resource> .
    
    rdf:object     a rdf:Property;
         :comment "Identifies the object of a statement when representing the statement in reified form";
         :domain rdf:Statement;
         :label "object",
                "objet" .
    
    rdf:predicate     a rdf:Property;
         :comment "Identifies the property used in a statement when representing the statement in reified form";
         :domain rdf:Statement;
         :label "predicate",
                "prxx'x'\351dicat";
         :range rdf:Property .
    
    rdf:subject     a rdf:Property;
         :comment "Identifies the resource that a statement is describing when representing the statement in reified form";
         :domain rdf:Statement;
         :label "subject",
                "sujet";
         :range <rdfs.n3#Resource> .
    
    rdf:value     a rdf:Property;
         :comment "Identifies the principal value (usually a string) of a property when the property value is a structured resource";
         :label "object",
                "value" .
    
    <http://www.w3.org/2000/01/rdf-schema>     :seeAlso <http://www.w3.org/2000/01/rdf-schema-more> .
    
#ENDS