@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
    @prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
    @prefix daml: <http://www.daml.org/2001/03/daml+oil#> .
    @prefix : <http://www.daml.org/2000/12/daml+oil#> .
    
    <animal.rdf#Animal>     a rdfs:Class;
         rdfs:label "Animal" .
    
     @forSome <animal.rdf#_L10C8> .
    
    <animal.rdf#_L10C8>     a :Restriction .
    
    <animal.rdf#Animal>     :restrictedBy <animal.rdf#_L10C8> .
    
    <animal.rdf#_L10C8>     :onProperty <animal.rdf#parent>;
         :cardinality "2" .
    
    @prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
    @prefix : <http://www.w3.org/2002/07/owl#> .
    @prefix dpo: <http://www.w3.org/2002/07/owl#> .
    @prefix ex: <owl-ex.rdf#> .
    
    <owl-ex.rdf>     a dpo:Ontology;
         dpo:versionInfo "";
         dpo:comment "An example ontology";
         dpo:imports <http://www.daml.org/2000/10/daml-ont> .
    
    ex:Animal     a dpo:Class;
         dpo:label "Animal";
         dpo:comment """This class of animals is illustrative of a number of
	ontological idioms.""" .
    
    ex:Male     a dpo:Class;
         dpo:subClassOf ex:Animal .
    
    ex:Female     a dpo:Class;
         dpo:subClassOf ex:Animal;
         dpo:disjointFrom ex:Male .
    
    ex:parent     a dpo:Property;
         dpo:domain ex:Animal;
         dpo:cardinality "2" .
    
    ex:Person     a dpo:Class;
         dpo:subClassOf ex:Animal .
    
     @forSome ex:_L43C4 .
    
    ex:_L43C4     a dpo:Restriction .
    
    ex:Person     dpo:restrictedBy ex:_L43C4 .
    
    ex:_L43C4     dpo:onProperty ex:parent;
         dpo:toClass ex:Person .
    
    ex:father     a dpo:Property;
         dpo:subProperty ex:parent;
         dpo:range ex:Man;
         dpo:cardinality "1" .
    
    ex:mother     a dpo:UniqueProperty;
         dpo:subProperty ex:parent;
         dpo:range ex:Woman .
    
    ex:child     a dpo:Property;
         dpo:inverseOf ex:parent .
    
    ex:ancestor     a dpo:TransitiveProperty;
         dpo:label "ancestor" .
    
    ex:descendant     a dpo:TransitiveProperty .
    
    ex:mom     a dpo:Property;
         = ex:mother .
    
    ex:occupation     a dpo:Property;
         dpo:maxCardinality "1" .
    
    ex:Car     a dpo:Class;
         dpo:comment "no car is a person" .
    
     @forSome ex:_L84C4 .
    
    ex:_L84C4     a dpo:Class .
    
    ex:Car     dpo:subClassOf ex:_L84C4 .
    
    ex:_L84C4     dpo:complementOf ex:Person .
    
    ex:Man     a dpo:Class;
         dpo:subClassOf ex:Person,
                ex:Male .
    
    ex:Woman     a dpo:Class;
         dpo:subClassOf ex:Person,
                ex:Female .
    
    ex:Person     a dpo:Class;
         dpo:comment "every person is a man or a woman" .
    
     @forSome ex:_L103C4 .
    
    ex:Person     dpo:disjointUnionOf ex:_L103C4 .
    
    ex:Man     a dpo:Class .
    
    ex:_L103C4     rdf:first ex:Man .
    
     @forSome ex:_L104C4 .
    
    ex:_L103C4     rdf:rest ex:_L104C4 .
    
    ex:Woman     a dpo:Class .
    
    ex:_L104C4     rdf:first ex:Woman;
         rdf:rest () .
    
    ex:Adam     a dpo:Person;
         dpo:label "Adam";
         dpo:comment "Adam is a person." .
    
    ex:height     a dpo:Property;
         dpo:domain ex:Person;
         dpo:range ex:Height .
    
    ex:Height     a dpo:Class .
    
     @forSome ex:_L120C4 .
    
    ex:Height     dpo:oneOf ex:_L120C4 .
    
    ex:short     a dpo:Height .
    
    ex:_L120C4     rdf:first ex:short .
    
     @forSome ex:_L121C4 .
    
    ex:_L120C4     rdf:rest ex:_L121C4 .
    
    ex:medium     a dpo:Height .
    
    ex:_L121C4     rdf:first ex:medium .
    
     @forSome ex:_L122C4 .
    
    ex:_L121C4     rdf:rest ex:_L122C4 .
    
    ex:tall     a dpo:Height .
    
    ex:_L122C4     rdf:first ex:tall;
         rdf:rest () .
    
    ex:TallThing     a dpo:Class .
    
     @forSome ex:_L128C4 .
    
    ex:_L128C4     a dpo:Restriction .
    
    ex:TallThing     dpo:restrictedBy ex:_L128C4 .
    
    ex:_L128C4     dpo:onProperty ex:height;
         dpo:toValue ex:tall .
    
    ex:TallMan     a dpo:Class .
    
     @forSome ex:_L141C4 .
    
    ex:TallMan     dpo:intersectionOf ex:_L141C4 .
    
    ex:TallThing     a dpo:Class .
    
    ex:_L141C4     rdf:first ex:TallThing .
    
     @forSome ex:_L142C4 .
    
    ex:_L141C4     rdf:rest ex:_L142C4 .
    
    ex:Man     a dpo:Class .
    
    ex:_L142C4     rdf:first ex:Man;
         rdf:rest () .
    
    @prefix web: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
    @prefix : <http://example.com/xmlns/aggregation-demo#> .
    
     @forSome <smush-examples.rdf#_L8C0> .
    
    <smush-examples.rdf#_L8C0>     a :Company;
         :corporateHomepage <http://megacorp.example.com/>;
         :name "MegaCorp Inc.";
         :ticker "MEGA" .
    
     @forSome <smush-examples.rdf#_L13C2> .
    
    <smush-examples.rdf#_L13C2>     a :Person .
    
    <smush-examples.rdf#_L8C0>     :owner <smush-examples.rdf#_L13C2> .
    
    <smush-examples.rdf#_L13C2>     :name "Mr Mega";
         :personalMailbox <mailto:mega@megacorp.example.com>;
         :personalHomepage <http://megacorp.example.com/~mega>;
         :age "50" .
    
     @forSome <smush-examples.rdf#_L25C0> .
    
    <smush-examples.rdf#_L25C0>     a :User;
         :personalMailbox <mailto:mega@megacorp.example.com>;
         :technologyInterest <http://www.w3.org/XML/>,
                <http://www.w3.org/RDF/>,
                <http://www.mozilla.org/> .
    
     @forSome <smush-examples.rdf#_L35C0> .
    
    <smush-examples.rdf#_L35C0>     a :Organisation;
         :corporateHomepage <http://megacorp.example.com/> .
    
    <http://dotherightthing.example.org/policy.xhtml>     a :PolicyStatement .
    
    <smush-examples.rdf#_L35C0>     :ethicalPolicy <http://dotherightthing.example.org/policy.xhtml> .
    
    <http://dotherightthing.example.org/policy.xhtml>     :title "Ethical Business Shared Guidelines 1.1" .
    
     @prefix : <http://www.daml.org/2001/03/daml-ont#> .
    @prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
    @prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
    
    <daml-ont.n3>     :versionInfo "";
         :imports <http://www.w3.org/2000/01/rdf-schema>;
         a :Ontology .
    
    :first     a :Property;
         :domain :List .
    
    :UniqueProperty     a :Class;
         :label "UniqueProperty";
         :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.
	aka functional.
  """;
         :subClassOf :Property .
    
    :subClassOf     a :Property;
         :samePropertyAs rdfs:subClassOf .
    
    :unionOf     a :Property;
         :label "unionOf";
         :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 .
    
    :Disjoint     a :Class;
         :label "Disjoint";
         :subClassOf :List;
         :comment """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).
  """ .
    
    :UnambiguousProperty     a :Class;
         :label "UnambiguousProperty";
         :comment """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.
  """;
         :subClassOf :Property .
    
    :intersectionOf     a :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 .
    
    :restrictedBy     a :Property;
         :label "restrictedBy";
         :comment """for restrictedBy(C, R), read: C is restricted by R; i.e. the
	restriction R applies to c;

        if onProperty(R, P) and toValue(R, V)
        then for every i in C, we have P(i, V).

        if onProperty(R, P) and toClass(R, C2)
        then for every i in C and for all j, if P(i, j) then type(j, C2).
  """;
         :domain :Class;
         :range :Restriction .
    
    :minCardinality     a :Property;
         :comment """for minCardinality(P, N) read: P has minimum cardinality N; i.e.
    everything x in the domain of P has at least N things y such that P(x, y).
  """;
         :domain :Property .
    
    :item     a :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 .
    
    :value     a :Property;
         :samePropertyAs rdf:value .
    
    :cardinality     a :Property;
         :label "cardinality";
         :comment """for cardinality(P, N) read: P has cardinality N; i.e.
    everything x in the domain of P has N things y such that P(x, y).
  """;
         :domain :Property .
    
    :default     a :Property;
         :label "default";
         :comment """default(X, Y) suggests that Y be considered a/the default
	value for the X property. This can be considered
	documentation (ala label, comment) but we don't specify
	any logical impact.
  """ .
    
    :oneOf     a :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.
  """;
         :domain :Class;
         :range :List .
    
    :Restriction     a :Class .
    
    :disjointWith     a :Property;
         :label "disjointWith";
         :comment """for disjointWith(X, Y) read: X and Y have no members
	in common.
  """;
         :domain :Class;
         :range :Class .
    
    :equivalentTo     a :Property;
         :comment """for equivalentTo(X, Y), read X is an equivalent term to Y.
  """ .
    
    :TransitiveProperty     a :Class .
    
    :Property     a :Class;
         :sameClassAs rdf:Property .
    
    :Qualification     a :Class .
    
    :sameClassAs     a :Property;
         :subPropertyOf :equivalentTo,
                :subClassOf .
    
    :Thing     a :Class;
         :label "Thing";
         :comment "The most general class in DAML." .
    
    :List     a :Class;
         :subClassOf rdf:Seq .
    
    :versionInfo     a :Property;
         :label "versionInfo";
         :comment """generally, a string giving information about this
	version; e.g. RCS/CVS keywords
  """ .
    
    :range     a :Property;
         :samePropertyAs rdfs:range .
    
    :subPropertyOf     a :Property;
         :samePropertyAs rdfs:subPropertyOf;
         :subPropertyOf rdfs:subPropertyOf .
    
    :seeAlso     a :Property;
         :samePropertyAs rdfs:seeAlso .
    
    :Class     a :Class;
         :sameClassAs rdfs:Class .
    
    :type     a :Property;
         :samePropertyAs rdf:type .
    
    :Ontology     a :Class;
         :label "Ontology";
         :comment """An Ontology is a document that describes
	a vocabulary of terms for communication between
	(human and) automated agents.
  """ .
    
    :Nothing     a :Class;
         :comment "the class with no things in it.";
         :complementOf :Thing .
    
    :maxCardinality     a :Property;
         :label "maxCardinality";
         :comment """for maxCardinality(P, N) read: P has maximum cardinality N; i.e.
    everything x in the domain of P has at most N things y such that P(x, y).
  """;
         :domain :Property .
    
    :label     a :Property;
         :samePropertyAs rdfs:label .
    
    :onProperty     a :Property;
         :comment """for onProperty(R, P), read:
   R is a restriction/qualification on P.""";
         :domain :Restriction,
                :Qualification;
         :range :Property .
    
    :hasValue     a :Property;
         :label "hasValue";
         :comment """for hasValue(Q, C), read: Q is a hasValue
   qualification to C.""";
         :domain :Qualification;
         :range :Class .
    
    :inverseOf     a :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.""";
         :domain :Property;
         :range :Property .
    
    :toValue     a :Property;
         :comment "for toValue(R, V), read: R is a restriction to V.";
         :domain :Restriction;
         :range :Class .
    
    :Empty     a :Class;
         :asClass :Nothing .
    
    :isDefinedBy     a :Property;
         :samePropertyAs rdfs:isDefinedBy;
         :subPropertyOf :seeAlso .
    
    :qualifiedBy     a :Property;
         :label "qualifiedBy";
         :comment """for qualifiedBy(C, Q), read: C is qualified by Q; i.e. the
	qualification Q applies to C;

        if onProperty(Q, P) and hasValue(Q, C2)
        then for every i in C, there is some V
	so that type(V, C2) and P(i, V).
  """;
         :domain :Class;
         :range :Qualification .
    
    :samePropertyAs     a :Property;
         :subPropertyOf :equivalentTo,
                :subPropertyOf .
    
    :Literal     a :Class;
         :sameClassAs rdfs:Literal .
    
    :rest     a :Property;
         :domain :List;
         :range :List .
    
    :imports     a :Property;
         :label "imports";
         :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".
  """ .
    
    :complementOf     a :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 .
    
    :toClass     a :Property;
         :comment "for toClass(R, C), read: R is a restriction to C.";
         :domain :Restriction;
         :range :Class .
    
    :disjointUnionOf     a :Property;
         :label "disjointUnionOf";
         :domain :Class;
         :range :List;
         :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) i.e. if something is in any of the classes in Y, it's
    in X, and vice versa.

    cf OIL disjoint-covered
  """ .
    
    :domain     a :Property;
         :samePropertyAs rdfs:domain .
    
    :comment     a :Property;
         :samePropertyAs rdfs:comment .