<?xml version="1.0"?>


<!DOCTYPE rdf:RDF [
    <!ENTITY owl "http://www.w3.org/2002/07/owl#" >
    <!ENTITY p1 "http://purl.org/dc/elements/1.1/" >
    <!ENTITY xsd "http://www.w3.org/2001/XMLSchema#" >
    <!ENTITY rdfs "http://www.w3.org/2000/01/rdf-schema#" >
    <!ENTITY rdf "http://www.w3.org/1999/02/22-rdf-syntax-ns#" >
    <!ENTITY p2 "http://ontology.dumontierlab.com/annotation#" >
]>


<rdf:RDF xmlns="http://ontology.dumontierlab.com/bro-1.0.owl"
     xml:base="http://ontology.dumontierlab.com/bro-1.0.owl"
     xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
     xmlns:p2="http://ontology.dumontierlab.com/annotation#"
     xmlns:p1="http://purl.org/dc/elements/1.1/"
     xmlns:owl="http://www.w3.org/2002/07/owl#"
     xmlns:xsd="http://www.w3.org/2001/XMLSchema#"
     xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
    <owl:Ontology rdf:about="">
        <p1:description rdf:datatype="&xsd;string"
            >The BRO provides a set of domain-independent relations between OWL entities. It is inspired by the OBO&apos;s relationship ontology (RO) http://www.obofoundry.org/ro</p1:description>
        <p1:date rdf:datatype="&xsd;date">2007-01-01</p1:date>
        <p1:title rdf:datatype="&xsd;string"
            >Basic Relationship Ontology (BRO)</p1:title>
        <owl:versionInfo rdf:datatype="&xsd;string">1.0</owl:versionInfo>
        <p1:publisher rdf:datatype="&xsd;string">Dumontier Lab</p1:publisher>
        <p1:format rdf:datatype="&xsd;string"
            >application/rdf+xml</p1:format>
        <p1:creator rdf:datatype="&xsd;string"
            >Michel Dumontier</p1:creator>
        <p1:language rdf:datatype="&xsd;string">en</p1:language>
        <p1:identifier
            >http://ontology.dumontierlab.com/bro</p1:identifier>
        <owl:imports>
            <owl:Ontology rdf:about="http://ontology.dumontierlab.com/annotation-1.0"/>
        </owl:imports>
    </owl:Ontology>
    


    <!-- 
    ///////////////////////////////////////////////////////////////////////////
    //
    //   OWL Object Properties
    //
    ///////////////////////////////////////////////////////////////////////////
     -->

    


    <!-- Object property: http://ontology.dumontierlab.com/bro#bearerOf -->

    <owl:ObjectProperty rdf:about="#bearerOf">
        <rdfs:label rdf:datatype="&xsd;string">bearer of</rdfs:label>
        <rdfs:comment rdf:datatype="&xsd;string"
            >A relation between an entity and dependent continuant.</rdfs:comment>
        <owl:inverseOf>
            <owl:ObjectProperty rdf:about="#inheresIn"/>
        </owl:inverseOf>
    </owl:ObjectProperty>
    


    <!-- Object property: http://ontology.dumontierlab.com/bro#contains -->

    <owl:ObjectProperty rdf:about="#contains">
        <p1:source>PMID:15892874</p1:source>
        <rdfs:label rdf:datatype="&xsd;string">contains</rdfs:label>
        <rdfs:comment rdf:datatype="&xsd;string"
            >A spatial relation between two continuants such that one spatially contains the other with no overlap.</rdfs:comment>
        <p1:description rdf:datatype="&xsd;string"
            >C contains C&apos; if and only if: given any instance c that instantiates C at a time t, there is some c&apos; such that: c&apos; instantiates C&apos; at time t and c located_of c&apos; at t, and it is not the case that c *overlaps* c&apos; at t.</p1:description>
        <owl:inverseOf>
            <owl:ObjectProperty rdf:about="#isContainedIn"/>
        </owl:inverseOf>
    </owl:ObjectProperty>
    


    <!-- Object property: http://ontology.dumontierlab.com/bro#derivativeOf -->

    <owl:ObjectProperty rdf:about="#derivativeOf">
        <rdfs:comment rdf:datatype="&xsd;string"
            >A transitive, symmetric, temporal relation in which one continuant is the derivative of another non-identical continuant.</rdfs:comment>
        <rdfs:label rdf:datatype="&xsd;string">derivative of</rdfs:label>
        <rdf:type rdf:resource="&owl;SymmetricProperty"/>
        <rdf:type rdf:resource="&owl;TransitiveProperty"/>
    </owl:ObjectProperty>
    


    <!-- Object property: http://ontology.dumontierlab.com/bro#derivesFrom -->

    <owl:ObjectProperty rdf:about="#derivesFrom">
        <p2:example rdf:datatype="&xsd;string"
            >osteocyte derives_from osteoblast</p2:example>
        <rdfs:isDefinedBy
            >http://obofoundry.org/ro/derives_from</rdfs:isDefinedBy>
        <p1:source>PMID:15892874</p1:source>
        <rdfs:comment rdf:datatype="&xsd;string"
            >A transitive, temporal relation in which one continuant derives from another non-identical continuant.</rdfs:comment>
        <rdfs:label rdf:datatype="&xsd;string">derives from</rdfs:label>
        <p1:description rdf:datatype="&xsd;string"
            >C derives_from C&apos; if and only if: there is an chain of derivation relations connecting C to C&apos;.</p1:description>
        <rdf:type rdf:resource="&owl;TransitiveProperty"/>
        <owl:inverseOf>
            <owl:ObjectProperty rdf:about="#derivesInto"/>
        </owl:inverseOf>
    </owl:ObjectProperty>
    


    <!-- Object property: http://ontology.dumontierlab.com/bro#derivesInto -->

    <owl:ObjectProperty rdf:about="#derivesInto">
        <p1:source>PMID:15892874</p1:source>
        <rdfs:comment rdf:datatype="&xsd;string"
            >A transitive, temporal relation in which one continuant derives into another non-identical continuant.</rdfs:comment>
        <rdfs:label rdf:datatype="&xsd;string">derives into</rdfs:label>
        <rdf:type rdf:resource="&owl;TransitiveProperty"/>
        <owl:inverseOf>
            <owl:ObjectProperty rdf:about="#derivesFrom"/>
        </owl:inverseOf>
    </owl:ObjectProperty>
    


    <!-- Object property: http://ontology.dumontierlab.com/bro#hasAgent -->

    <owl:ObjectProperty rdf:about="#hasAgent">
        <rdfs:comment rdf:datatype="&xsd;string"
            >A relation between a process and a causally active participant.</rdfs:comment>
        <p1:source>PMID:15892874</p1:source>
        <p1:description rdf:datatype="&xsd;string"
            >As for has_participant, but with the additional condition that the component instance is causally active in the relevant process</p1:description>
        <rdfs:isDefinedBy
            >http://obofoundry.org/ro/has_agent</rdfs:isDefinedBy>
        <rdfs:label rdf:datatype="&xsd;string">has agent</rdfs:label>
        <owl:inverseOf>
            <owl:ObjectProperty rdf:about="#isAgentIn"/>
        </owl:inverseOf>
    </owl:ObjectProperty>
    


    <!-- Object property: http://ontology.dumontierlab.com/bro#hasDisposition -->

    <owl:ObjectProperty rdf:about="#hasDisposition">
        <rdfs:label rdf:datatype="&xsd;string">has disposition</rdfs:label>
        <rdfs:comment rdf:datatype="&xsd;string"
            >A relation between an entity and the disposition it realizes.</rdfs:comment>
        <owl:inverseOf>
            <owl:ObjectProperty rdf:about="#isDispositionOf"/>
        </owl:inverseOf>
    </owl:ObjectProperty>
    


    <!-- Object property: http://ontology.dumontierlab.com/bro#hasFunction -->

    <owl:ObjectProperty rdf:about="#hasFunction">
        <rdfs:label rdf:datatype="&xsd;string">has function</rdfs:label>
        <rdfs:comment rdf:datatype="&xsd;string"
            >A relation between an entity and the function it realizes.</rdfs:comment>
        <owl:inverseOf>
            <owl:ObjectProperty rdf:about="#isFunctionOf"/>
        </owl:inverseOf>
    </owl:ObjectProperty>
    


    <!-- Object property: http://ontology.dumontierlab.com/bro#hasImproperPart -->

    <owl:ObjectProperty rdf:about="#hasImproperPart">
        <rdfs:label rdf:datatype="&xsd;string"
            >has improper part</rdfs:label>
        <p1:source>PMID:15892874</p1:source>
        <p1:description rdf:datatype="&xsd;string"></p1:description>
        <rdfs:comment rdf:datatype="&xsd;string"
            >A reflexive, transitive parthood relation such that the entities are not distinct.</rdfs:comment>
        <p2:example rdf:datatype="&xsd;string"
            >cake has_improper_part slice of cake</p2:example>
        <rdf:type rdf:resource="&owl;TransitiveProperty"/>
        <owl:inverseOf>
            <owl:ObjectProperty rdf:about="#isImproperPartOf"/>
        </owl:inverseOf>
    </owl:ObjectProperty>
    


    <!-- Object property: http://ontology.dumontierlab.com/bro#hasIntegralPart -->

    <owl:ObjectProperty rdf:about="#hasIntegralPart">
        <rdfs:label rdf:datatype="&xsd;string"
            >has integral part</rdfs:label>
        <p1:description rdf:datatype="&xsd;string"
            >C has_integral_part C&apos; if and only if: C has_part C&apos; AND C&apos; part_of C</p1:description>
        <rdfs:comment rdf:datatype="&xsd;string"
            >A reflexive, anti-symmetric, transitive parthood relation between two entities such that one has_part the other, and the other has_part the one.</rdfs:comment>
        <p1:source>PMID:15892874</p1:source>
        <rdf:type rdf:resource="&owl;TransitiveProperty"/>
        <owl:inverseOf>
            <owl:ObjectProperty rdf:about="#isIntegralPartOf"/>
        </owl:inverseOf>
    </owl:ObjectProperty>
    


    <!-- Object property: http://ontology.dumontierlab.com/bro#hasPart -->

    <owl:ObjectProperty rdf:about="#hasPart">
        <rdfs:comment rdf:datatype="&xsd;string"
            >A reflexive, anti-symmetric, transitive relation between two entities such that one is part_of the other.</rdfs:comment>
        <rdfs:label rdf:datatype="&xsd;string">has part</rdfs:label>
        <p1:description rdf:datatype="&xsd;string"
            >Continuant: C has_part C&apos; = for all c, t, if Cct then there is some c&apos; such that C&apos;c&apos;t and c&apos; part_of c at t.
Process: P has_part P&apos; = for all p, if Pp then there is some p&apos; such that P&apos;p&apos; and p&apos; part_of p.</p1:description>
        <rdf:type rdf:resource="&owl;TransitiveProperty"/>
        <owl:inverseOf>
            <owl:ObjectProperty rdf:about="#isPartOf"/>
        </owl:inverseOf>
    </owl:ObjectProperty>
    


    <!-- Object property: http://ontology.dumontierlab.com/bro#hasParticipant -->

    <owl:ObjectProperty rdf:about="#hasParticipant">
        <rdfs:comment rdf:datatype="&xsd;string"
            >A relation between a process and its a continuant participant.</rdfs:comment>
        <rdfs:isDefinedBy
            >http://obofoundry.org/ro/has_particpant</rdfs:isDefinedBy>
        <p1:description rdf:datatype="&xsd;string"
            >P has_participant C if and only if: given any process p that instantiates P there is some continuant c, and some time t, such that: c instantiates C at t and c participates in p at t</p1:description>
        <rdfs:label rdf:datatype="&xsd;string">has participant</rdfs:label>
        <p1:source>PMID:15892874</p1:source>
        <owl:inverseOf>
            <owl:ObjectProperty rdf:about="#isParticipantIn"/>
        </owl:inverseOf>
    </owl:ObjectProperty>
    


    <!-- Object property: http://ontology.dumontierlab.com/bro#hasProperPart -->

    <owl:ObjectProperty rdf:about="#hasProperPart">
        <rdfs:label rdf:datatype="&xsd;string">has proper part</rdfs:label>
        <p1:source>PMID:15892874</p1:source>
        <p1:description rdf:datatype="&xsd;string"></p1:description>
        <rdfs:comment rdf:datatype="&xsd;string"
            >A transitive parthood relation such that the entities are distinct.</rdfs:comment>
        <rdf:type rdf:resource="&owl;TransitiveProperty"/>
        <owl:inverseOf>
            <owl:ObjectProperty rdf:about="#isProperPartOf"/>
        </owl:inverseOf>
    </owl:ObjectProperty>
    


    <!-- Object property: http://ontology.dumontierlab.com/bro#hasQuality -->

    <owl:ObjectProperty rdf:about="#hasQuality">
        <rdfs:comment rdf:datatype="&xsd;string"
            >A relation between an entity and the quality that inheres in it.</rdfs:comment>
        <rdfs:label rdf:datatype="&xsd;string">has quality</rdfs:label>
        <owl:inverseOf>
            <owl:ObjectProperty rdf:about="#isQualityOf"/>
        </owl:inverseOf>
    </owl:ObjectProperty>
    


    <!-- Object property: http://ontology.dumontierlab.com/bro#hasRole -->

    <owl:ObjectProperty rdf:about="#hasRole">
        <rdfs:comment rdf:datatype="&xsd;string"
            >The relation between an entity and the role it realizes.</rdfs:comment>
        <rdfs:label rdf:datatype="&xsd;string">has role</rdfs:label>
        <owl:inverseOf>
            <owl:ObjectProperty rdf:about="#isRoleOf"/>
        </owl:inverseOf>
    </owl:ObjectProperty>
    


    <!-- Object property: http://ontology.dumontierlab.com/bro#immediatelyDerivesFrom -->

    <owl:ObjectProperty rdf:about="#immediatelyDerivesFrom">
        <rdfs:label rdf:datatype="&xsd;string"
            >immediately derives from</rdfs:label>
        <p1:description rdf:datatype="&xsd;string"
            >C immediately_derives_from C&apos; if and only if: given any c and any t, if c instantiates C at time t, then there is some c&apos; and some t&apos;, such that c&apos; instantiates C&apos; at t&apos; and t&apos; earlier-than t and c *derives_from* c&apos;.</p1:description>
        <rdfs:comment rdf:datatype="&xsd;string"
            >A non-transitive temporal relation in which one continuant immediately derives from a non-identical continuant such that there are no intermediate continuants between them.</rdfs:comment>
        <p2:example rdf:datatype="&xsd;string"
            >a molecule of alpha-D-glucose-6-phosphate immediately_derives_from D-glucose in glucose metabolism.</p2:example>
        <p1:source>PMID:15892874</p1:source>
        <owl:inverseOf>
            <owl:ObjectProperty rdf:about="#immediatelyDerivesInto"/>
        </owl:inverseOf>
    </owl:ObjectProperty>
    


    <!-- Object property: http://ontology.dumontierlab.com/bro#immediatelyDerivesInto -->

    <owl:ObjectProperty rdf:about="#immediatelyDerivesInto">
        <rdfs:comment rdf:datatype="&xsd;string"
            >A non-transitive temporal relation in which one continuant immediately derives into a non-identical continuant such that there are no intermediate steps between them.</rdfs:comment>
        <p1:description rdf:datatype="&xsd;string"
            >C immediately_derives_into C&apos; if and only if: given any c and any t, if c instantiates C at time t, then there is some c&apos; and some t&apos;, such that c&apos; instantiates C&apos; at t&apos; and t&apos; later-than t and c *derives_from* c&apos;.</p1:description>
        <rdfs:label rdf:datatype="&xsd;string"
            >immediately derives into</rdfs:label>
        <p2:example rdf:datatype="&xsd;string"
            >D-glucose immediately_derives_into alpha-D-glucose-6-phosphate.</p2:example>
        <p1:source>PMID:15892874</p1:source>
        <owl:inverseOf>
            <owl:ObjectProperty rdf:about="#immediatelyDerivesFrom"/>
        </owl:inverseOf>
    </owl:ObjectProperty>
    


    <!-- Object property: http://ontology.dumontierlab.com/bro#immediatelyPrecededBy -->

    <owl:ObjectProperty rdf:about="#immediatelyPrecededBy">
        <p1:description rdf:datatype="&xsd;string"
            >P immediately_preceded_by P&apos; if and only if: given any process p that instantiates P at a time t, there is some process p&apos; such that p&apos; instantiates P&apos; at time t&apos;, and t&apos; is earlier than t.</p1:description>
        <p1:source>PMID:15892874</p1:source>
        <rdfs:label rdf:datatype="&xsd;string"
            >immediately preceded by</rdfs:label>
        <rdfs:comment rdf:datatype="&xsd;string"
            >A non-transitive temporal relation in which one process is immediately preceded by another process, such that there is no interval of time between the two processes.</rdfs:comment>
        <owl:inverseOf>
            <owl:ObjectProperty rdf:about="#immediatelyPrecedes"/>
        </owl:inverseOf>
    </owl:ObjectProperty>
    


    <!-- Object property: http://ontology.dumontierlab.com/bro#immediatelyPrecedes -->

    <owl:ObjectProperty rdf:about="#immediatelyPrecedes">
        <p1:description rdf:datatype="&xsd;string"
            >P immediately_precedes P&apos; if and only if: given any process p that instantiates P at a time t, there is some process p&apos; such that p&apos; instantiates P&apos; at time t&apos;, and t&apos; is later than t.</p1:description>
        <rdfs:label rdf:datatype="&xsd;string"
            >immediately precedes</rdfs:label>
        <p1:source>PMID:15892874</p1:source>
        <rdfs:comment rdf:datatype="&xsd;string"
            >A non-transitive temporal relation in which one process is immediately precedes another process, such that there is no interval of time between the two processes.</rdfs:comment>
        <owl:inverseOf>
            <owl:ObjectProperty rdf:about="#immediatelyPrecededBy"/>
        </owl:inverseOf>
    </owl:ObjectProperty>
    


    <!-- Object property: http://ontology.dumontierlab.com/bro#immediatelyTransformsFrom -->

    <owl:ObjectProperty rdf:about="#immediatelyTransformsFrom">
        <p1:description rdf:datatype="&xsd;string"
            >C immediately_transforms_from C&apos; if and only if given any c and any t, if c instantiates C at time t, then for some t&apos;, c instantiates C&apos; at t&apos; and t&apos; later t, and there is no t2 such that c instantiates C at t2 and c instantiates C&apos; at t2.</p1:description>
        <rdfs:comment rdf:datatype="&xsd;string"
            >A non-transitive temporal relation between two continuants such that one continuant immediately transforms from another continuant such that there is no intermediate between them, while retaining their identity.</rdfs:comment>
        <p1:source>PMID:15892874</p1:source>
        <owl:inverseOf>
            <owl:ObjectProperty rdf:about="#immediatelyTransformsInto"/>
        </owl:inverseOf>
    </owl:ObjectProperty>
    


    <!-- Object property: http://ontology.dumontierlab.com/bro#immediatelyTransformsInto -->

    <owl:ObjectProperty rdf:about="#immediatelyTransformsInto">
        <p1:description rdf:datatype="&xsd;string"
            >C immediately_transformes_into C&apos; if and only if given any c and any t, if c instantiates C at time t, then for some t&apos;, c instantiates C&apos; at t&apos; and t&apos; later t, and there is no t2 such that c instantiates C at t2 and c instantiates C&apos; at t2.</p1:description>
        <p1:source>PMID:15892874</p1:source>
        <rdfs:comment rdf:datatype="&xsd;string"
            >A temporal relation in which one continuant immediately transforms into another continuant such that there is no intermediate continuant, and with which identity is maintained.</rdfs:comment>
        <rdfs:label rdf:datatype="&xsd;string"
            >immediately transforms into</rdfs:label>
        <owl:inverseOf>
            <owl:ObjectProperty rdf:about="#immediatelyTransformsFrom"/>
        </owl:inverseOf>
    </owl:ObjectProperty>
    


    <!-- Object property: http://ontology.dumontierlab.com/bro#inheresIn -->

    <owl:ObjectProperty rdf:about="#inheresIn">
        <rdfs:label rdf:datatype="&xsd;string">inheres in</rdfs:label>
        <rdfs:comment rdf:datatype="&xsd;string"
            >A relation between a dependent continuant and an entity.</rdfs:comment>
        <owl:inverseOf>
            <owl:ObjectProperty rdf:about="#bearerOf"/>
        </owl:inverseOf>
    </owl:ObjectProperty>
    


    <!-- Object property: http://ontology.dumontierlab.com/bro#isAdjacentTo -->

    <owl:ObjectProperty rdf:about="#isAdjacentTo">
        <p1:description rdf:datatype="&xsd;string"
            >C is adjacent to C&apos; if and only if: given any instance c that instantiates C at a time t, there is some c&apos; such that: c&apos; instantiates C&apos; at time t and c and c&apos; are in spatial proximity.</p1:description>
        <rdfs:comment rdf:datatype="&xsd;string"
            >A symmetric spatial relation between two continuants such that are adjacent to one another.</rdfs:comment>
        <rdfs:isDefinedBy
            >http://obofoundry.org/ro/adjacent_to</rdfs:isDefinedBy>
        <rdfs:label rdf:datatype="&xsd;string">is adjacent to</rdfs:label>
        <p1:source>PMID:15892874</p1:source>
        <rdf:type rdf:resource="&owl;SymmetricProperty"/>
    </owl:ObjectProperty>
    


    <!-- Object property: http://ontology.dumontierlab.com/bro#isAgentIn -->

    <owl:ObjectProperty rdf:about="#isAgentIn">
        <rdfs:label rdf:datatype="&xsd;string">is agent in</rdfs:label>
        <p1:description rdf:datatype="&xsd;string"
            >As for participates_in, but with the additional condition that the component instance is causally active in the relevant process.</p1:description>
        <p1:source>PMID:15892874</p1:source>
        <rdfs:comment rdf:datatype="&xsd;string"
            >A relation in which a continuant participates in a causally active way in the process.</rdfs:comment>
        <owl:inverseOf>
            <owl:ObjectProperty rdf:about="#hasAgent"/>
        </owl:inverseOf>
    </owl:ObjectProperty>
    


    <!-- Object property: http://ontology.dumontierlab.com/bro#isContainedIn -->

    <owl:ObjectProperty rdf:about="#isContainedIn">
        <rdfs:comment rdf:datatype="&xsd;string"
            >A spatial relation between two continuants such that one is contained in the other, but for which there is no overlap.</rdfs:comment>
        <p1:source>PMID:15892874</p1:source>
        <p1:description rdf:datatype="&xsd;string"
            >C is_contained_in C&apos; if and only if: given any instance c that instantiates C at a time t, there is some c&apos; such that: c&apos; instantiates C&apos; at time t and c located_in c&apos; at t, and it is not the case that c *overlaps* c&apos; at t. (c&apos; is a conduit or cavity)</p1:description>
        <rdfs:isDefinedBy
            >http://obofoundry.org/ro/contained_in</rdfs:isDefinedBy>
        <rdfs:label rdf:datatype="&xsd;string">is contained in</rdfs:label>
        <owl:inverseOf>
            <owl:ObjectProperty rdf:about="#contains"/>
        </owl:inverseOf>
    </owl:ObjectProperty>
    


    <!-- Object property: http://ontology.dumontierlab.com/bro#isDispositionOf -->

    <owl:ObjectProperty rdf:about="#isDispositionOf">
        <rdfs:comment rdf:datatype="&xsd;string"
            >A relation between a disposition and the entity that realizes it.</rdfs:comment>
        <rdfs:label rdf:datatype="&xsd;string"
            >is disposition of</rdfs:label>
    </owl:ObjectProperty>
    


    <!-- Object property: http://ontology.dumontierlab.com/bro#isFunctionOf -->

    <owl:ObjectProperty rdf:about="#isFunctionOf">
        <rdfs:comment rdf:datatype="&xsd;string"
            >A relation between a function and the entity that realizes it.</rdfs:comment>
        <rdfs:label rdf:datatype="&xsd;string">is function of</rdfs:label>
    </owl:ObjectProperty>
    


    <!-- Object property: http://ontology.dumontierlab.com/bro#isImproperPartOf -->

    <owl:ObjectProperty rdf:about="#isImproperPartOf">
        <rdfs:comment rdf:datatype="&xsd;string"
            >A reflexive, transitive parthood relation such that the entities are not distinct.</rdfs:comment>
        <p1:description rdf:datatype="&xsd;string"></p1:description>
        <p1:source>PMID:15892874</p1:source>
        <rdfs:label rdf:datatype="&xsd;string"
            >is improper part of</rdfs:label>
        <rdf:type rdf:resource="&owl;TransitiveProperty"/>
        <owl:inverseOf>
            <owl:ObjectProperty rdf:about="#hasImproperPart"/>
        </owl:inverseOf>
    </owl:ObjectProperty>
    


    <!-- Object property: http://ontology.dumontierlab.com/bro#isIntegralPartOf -->

    <owl:ObjectProperty rdf:about="#isIntegralPartOf">
        <rdfs:comment rdf:datatype="&xsd;string"
            >A reflexive, anti-symmetric, transitivie parthood relation between two entities such that one has_part the other, and the other has_part the one.</rdfs:comment>
        <rdfs:isDefinedBy
            >http://obofoundry.org/ro/integral_part_of</rdfs:isDefinedBy>
        <p1:description rdf:datatype="&xsd;string"
            >C integral_part_of C&apos; if and only if: C part_of C&apos; AND C&apos; has_part C</p1:description>
        <p1:source>PMID:15892874</p1:source>
        <rdfs:label rdf:datatype="&xsd;string"
            >is integral part of</rdfs:label>
        <rdf:type rdf:resource="&owl;TransitiveProperty"/>
        <owl:inverseOf>
            <owl:ObjectProperty rdf:about="#hasIntegralPart"/>
        </owl:inverseOf>
    </owl:ObjectProperty>
    


    <!-- Object property: http://ontology.dumontierlab.com/bro#isLocatedIn -->

    <owl:ObjectProperty rdf:about="#isLocatedIn">
        <p1:source>PMID:15892874</p1:source>
        <p1:description rdf:datatype="&xsd;string"
            >C is_located_in C&apos; if and only if: given any c that instantiates C at a time t, there is some c&apos; such that: c&apos; instantiates C&apos; at time t and c *is_located_in* c&apos;.</p1:description>
        <rdfs:isDefinedBy
            >http://obofoundry.org/ro/located_in</rdfs:isDefinedBy>
        <rdfs:comment rdf:datatype="&xsd;string"
            >A transitive, reflexive relation between two entities such that one is located in the other.</rdfs:comment>
        <rdfs:label rdf:datatype="&xsd;string">is located in</rdfs:label>
        <rdf:type rdf:resource="&owl;TransitiveProperty"/>
        <owl:inverseOf>
            <owl:ObjectProperty rdf:about="#isLocationOf"/>
        </owl:inverseOf>
    </owl:ObjectProperty>
    


    <!-- Object property: http://ontology.dumontierlab.com/bro#isLocationOf -->

    <owl:ObjectProperty rdf:about="#isLocationOf">
        <rdfs:comment rdf:datatype="&xsd;string"
            >A transitive, reflexive relation between two entities such that one is the location of another.</rdfs:comment>
        <p1:source>PMID:15892874</p1:source>
        <p1:description rdf:datatype="&xsd;string"
            >C is_location_of C&apos; if and only if: given any c that instantiates C at a time t, there is some c&apos; such that: c&apos; instantiates C&apos; at time t and c *is_location_of* c&apos;.</p1:description>
        <rdfs:label rdf:datatype="&xsd;string">is location of</rdfs:label>
        <rdf:type rdf:resource="&owl;TransitiveProperty"/>
        <owl:inverseOf>
            <owl:ObjectProperty rdf:about="#isLocatedIn"/>
        </owl:inverseOf>
    </owl:ObjectProperty>
    


    <!-- Object property: http://ontology.dumontierlab.com/bro#isPartOf -->

    <owl:ObjectProperty rdf:about="#isPartOf">
        <p2:example rdf:datatype="&xsd;string"
            >continuant: cell nucleus part_of cell</p2:example>
        <p2:example rdf:datatype="&xsd;string"
            >process: rhodopsin mediated phototransduction part_of visual perception</p2:example>
        <rdfs:comment rdf:datatype="&xsd;string"
            >A reflexive, anti-symmetric, transitive relation between two entities at which one is a part of the other.</rdfs:comment>
        <p1:description rdf:datatype="&xsd;string"
            >For continuants: C part_of C&apos; if and only if: given any c that instantiates C at a time t, there is some c&apos; such that c&apos; instantiates C&apos; at time t, and c *part_of* c&apos; at t. 
For processes: P part_of P&apos; if and only if: given any p that instantiates P at a time t, there is some p&apos; such that p&apos; instantiates P&apos; at time t, and p *part_of* p&apos; at t.</p1:description>
        <p1:source>PMID:15892874</p1:source>
        <rdfs:isDefinedBy
            >http://obofoundry.org/ro/part_of</rdfs:isDefinedBy>
        <rdfs:label rdf:datatype="&xsd;string">part of</rdfs:label>
        <rdf:type rdf:resource="&owl;TransitiveProperty"/>
        <owl:inverseOf>
            <owl:ObjectProperty rdf:about="#hasPart"/>
        </owl:inverseOf>
    </owl:ObjectProperty>
    


    <!-- Object property: http://ontology.dumontierlab.com/bro#isParticipantIn -->

    <owl:ObjectProperty rdf:about="#isParticipantIn">
        <p1:description rdf:datatype="&xsd;string"
            >C participates in P if and only if: given any continuant c that instantiates C, some process p that instantiates P, and some time t, such that:c instantiates C at t and c participates in p at t&quot;</p1:description>
        <rdfs:comment rdf:datatype="&xsd;string"
            >A relation in which a continuant participates in some way in the process.</rdfs:comment>
        <rdfs:label rdf:datatype="&xsd;string"
            >is participant in</rdfs:label>
        <p1:source>PMID:15892874</p1:source>
        <owl:inverseOf>
            <owl:ObjectProperty rdf:about="#hasParticipant"/>
        </owl:inverseOf>
    </owl:ObjectProperty>
    


    <!-- Object property: http://ontology.dumontierlab.com/bro#isProperPartOf -->

    <owl:ObjectProperty rdf:about="#isProperPartOf">
        <rdfs:isDefinedBy
            >http://obofoundry.org/ro/proper_part_of</rdfs:isDefinedBy>
        <rdfs:comment rdf:datatype="&xsd;string"
            >A transitive parthood relation such that the entities are distinct.</rdfs:comment>
        <p1:source>PMID:15892874</p1:source>
        <rdfs:label rdf:datatype="&xsd;string"
            >is proper part of</rdfs:label>
        <p1:description rdf:datatype="&xsd;string"></p1:description>
        <rdf:type rdf:resource="&owl;TransitiveProperty"/>
        <owl:inverseOf>
            <owl:ObjectProperty rdf:about="#hasProperPart"/>
        </owl:inverseOf>
    </owl:ObjectProperty>
    


    <!-- Object property: http://ontology.dumontierlab.com/bro#isQualityOf -->

    <owl:ObjectProperty rdf:about="#isQualityOf">
        <rdfs:label rdf:datatype="&xsd;string">is quality of</rdfs:label>
        <rdfs:comment rdf:datatype="&xsd;string"
            >A relation between a quality and some entity.</rdfs:comment>
        <owl:inverseOf>
            <owl:ObjectProperty rdf:about="#hasQuality"/>
        </owl:inverseOf>
    </owl:ObjectProperty>
    


    <!-- Object property: http://ontology.dumontierlab.com/bro#isRelatedTo -->

    <owl:ObjectProperty rdf:about="#isRelatedTo">
        <rdfs:label rdf:datatype="&xsd;string">is related to</rdfs:label>
        <rdfs:comment rdf:datatype="&xsd;string"
            >A property between two entities.

With the exception of temporal relations, it is understood that these relations must occur between instances of occurents at the same time.</rdfs:comment>
        <rdf:type rdf:resource="&owl;SymmetricProperty"/>
    </owl:ObjectProperty>
    


    <!-- Object property: http://ontology.dumontierlab.com/bro#isRoleOf -->

    <owl:ObjectProperty rdf:about="#isRoleOf">
        <rdfs:comment rdf:datatype="&xsd;string"
            >A relation between a role and the entity that realizes it.</rdfs:comment>
        <rdfs:label rdf:datatype="&xsd;string">is role of</rdfs:label>
    </owl:ObjectProperty>
    


    <!-- Object property: http://ontology.dumontierlab.com/bro#isSpatialLocationOf -->

    <owl:ObjectProperty rdf:about="#isSpatialLocationOf">
        <rdfs:label rdf:datatype="&xsd;string"
            >is spatial location of</rdfs:label>
        <rdfs:comment rdf:datatype="&xsd;string"
            >A relation between a region of space and an oject that occupies that space.</rdfs:comment>
        <owl:inverseOf>
            <owl:ObjectProperty rdf:about="#isSpatiallyLocatedIn"/>
        </owl:inverseOf>
    </owl:ObjectProperty>
    


    <!-- Object property: http://ontology.dumontierlab.com/bro#isSpatiallyLocatedIn -->

    <owl:ObjectProperty rdf:about="#isSpatiallyLocatedIn">
        <rdfs:comment rdf:datatype="&xsd;string"
            >A relation between an object and a region of space.</rdfs:comment>
        <rdfs:label rdf:datatype="&xsd;string"
            >is spatially located in</rdfs:label>
        <rdf:type rdf:resource="&owl;TransitiveProperty"/>
        <owl:inverseOf>
            <owl:ObjectProperty rdf:about="#isSpatialLocationOf"/>
        </owl:inverseOf>
    </owl:ObjectProperty>
    


    <!-- Object property: http://ontology.dumontierlab.com/bro#isSpatiallyRelatedTo -->

    <owl:ObjectProperty rdf:about="#isSpatiallyRelatedTo">
        <rdfs:label rdf:datatype="&xsd;string"
            >is spatially related to</rdfs:label>
        <rdfs:comment rdf:datatype="&xsd;string"
            >A relation between continuants with respect to the spatial regions they occupy.</rdfs:comment>
        <rdf:type rdf:resource="&owl;SymmetricProperty"/>
    </owl:ObjectProperty>
    


    <!-- Object property: http://ontology.dumontierlab.com/bro#isSpatioTemporalLocationOf -->

    <owl:ObjectProperty rdf:about="#isSpatioTemporalLocationOf">
        <rdfs:comment rdf:datatype="&xsd;string"
            >A relation between aa spatial temporal region and a process.</rdfs:comment>
        <rdfs:label rdf:datatype="&xsd;string"
            >is spatiotemporal location of</rdfs:label>
        <owl:inverseOf>
            <owl:ObjectProperty rdf:about="#isSpatioTemporallyLocatedIn"/>
        </owl:inverseOf>
    </owl:ObjectProperty>
    


    <!-- Object property: http://ontology.dumontierlab.com/bro#isSpatioTemporallyLocatedIn -->

    <owl:ObjectProperty rdf:about="#isSpatioTemporallyLocatedIn">
        <rdfs:comment rdf:datatype="&xsd;string"
            >A relation between an entity and a spatial temporal region.</rdfs:comment>
        <rdfs:label rdf:datatype="&xsd;string"
            >is spatiotemporally located in</rdfs:label>
        <rdf:type rdf:resource="&owl;TransitiveProperty"/>
        <owl:inverseOf>
            <owl:ObjectProperty rdf:about="#isSpatioTemporalLocationOf"/>
        </owl:inverseOf>
    </owl:ObjectProperty>
    


    <!-- Object property: http://ontology.dumontierlab.com/bro#isTemporalLocationOf -->

    <owl:ObjectProperty rdf:about="#isTemporalLocationOf">
        <rdfs:label rdf:datatype="&xsd;string"
            >is temporal location of</rdfs:label>
        <rdfs:comment rdf:datatype="&xsd;string"
            >A relation between two temporal entities such that a temporal region is the location of a temporal entity.</rdfs:comment>
        <owl:inverseOf>
            <owl:ObjectProperty rdf:about="#isTemporallyLocatedIn"/>
        </owl:inverseOf>
    </owl:ObjectProperty>
    


    <!-- Object property: http://ontology.dumontierlab.com/bro#isTemporallyLocatedIn -->

    <owl:ObjectProperty rdf:about="#isTemporallyLocatedIn">
        <rdfs:comment rdf:datatype="&xsd;string"
            >A relation between two temporal entities such that one is located in a region of time.</rdfs:comment>
        <rdfs:label rdf:datatype="&xsd;string"
            >is temporally located in</rdfs:label>
        <rdf:type rdf:resource="&owl;TransitiveProperty"/>
        <owl:inverseOf>
            <owl:ObjectProperty rdf:about="#isTemporalLocationOf"/>
        </owl:inverseOf>
    </owl:ObjectProperty>
    


    <!-- Object property: http://ontology.dumontierlab.com/bro#isTemporallyRelatedTo -->

    <owl:ObjectProperty rdf:about="#isTemporallyRelatedTo">
        <rdfs:comment rdf:datatype="&xsd;string"
            >A relation between entities at different times.</rdfs:comment>
        <rdfs:label rdf:datatype="&xsd;string"
            >is temporally related to</rdfs:label>
        <rdf:type rdf:resource="&owl;SymmetricProperty"/>
    </owl:ObjectProperty>
    


    <!-- Object property: http://ontology.dumontierlab.com/bro#precededBy -->

    <owl:ObjectProperty rdf:about="#precededBy">
        <p2:example rdf:datatype="&xsd;string"
            >translation preceded_by transcription</p2:example>
        <p1:source>PMID:15892874</p1:source>
        <rdfs:isDefinedBy
            >http://obofoundry.org/ro/preceded_by</rdfs:isDefinedBy>
        <rdfs:comment rdf:datatype="&xsd;string"
            >A transitive, temporal relation in which one process is preceded by (has occured later than) another process.</rdfs:comment>
        <p1:description rdf:datatype="&xsd;string"
            >P preceded_by P&apos; if and only if: given any process p that instantiates P at a time t, there is some process p&apos; such that p&apos; instantiates P&apos; at time t&apos;, and t&apos; is earlier than t.</p1:description>
        <p2:example rdf:datatype="&xsd;string"
            >aging preceded_by development (not however death preceded_by aging).</p2:example>
        <rdfs:label rdf:datatype="&xsd;string">preceded by</rdfs:label>
        <rdf:type rdf:resource="&owl;TransitiveProperty"/>
        <owl:inverseOf>
            <owl:ObjectProperty rdf:about="#precedes"/>
        </owl:inverseOf>
    </owl:ObjectProperty>
    


    <!-- Object property: http://ontology.dumontierlab.com/bro#precedes -->

    <owl:ObjectProperty rdf:about="#precedes">
        <p1:description rdf:datatype="&xsd;string"
            >P precedes P&apos; if and only if: given any process p that instantiates P at a time t, there is some process p&apos; such that p&apos; instantiates P&apos; at time t&apos;, and t&apos; is later than t.</p1:description>
        <p1:source>PMID:15892874</p1:source>
        <rdfs:label rdf:datatype="&xsd;string">precedes</rdfs:label>
        <rdfs:comment rdf:datatype="&xsd;string"
            >A transitive, temporal relation in which one process precedes (has occured earlier than) another process.</rdfs:comment>
        <rdf:type rdf:resource="&owl;TransitiveProperty"/>
        <owl:inverseOf>
            <owl:ObjectProperty rdf:about="#precededBy"/>
        </owl:inverseOf>
    </owl:ObjectProperty>
    


    <!-- Object property: http://ontology.dumontierlab.com/bro#transformationOf -->

    <owl:ObjectProperty rdf:about="#transformationOf">
        <rdfs:comment rdf:datatype="&xsd;string"
            >A transitive, symmetric, temporal relation in which one continuant is the transformation of itself at another time.</rdfs:comment>
        <rdfs:label rdf:datatype="&xsd;string"
            >transformation of</rdfs:label>
        <rdfs:isDefinedBy
            >http://obofoundry.org/ro/transformation_of</rdfs:isDefinedBy>
        <rdf:type rdf:resource="&owl;SymmetricProperty"/>
        <rdf:type rdf:resource="&owl;TransitiveProperty"/>
    </owl:ObjectProperty>
    


    <!-- Object property: http://ontology.dumontierlab.com/bro#transformsFrom -->

    <owl:ObjectProperty rdf:about="#transformsFrom">
        <p1:source>PMID:15892874</p1:source>
        <rdfs:label rdf:datatype="&xsd;string">transforms from</rdfs:label>
        <p1:description rdf:datatype="&xsd;string"
            >C transforms_from C&apos; if and only if given any c and any t, if c instantiates C at time t, then for some t&apos;, c instantiates C&apos; at t&apos; and t&apos; later t, and there is no t2 such that c instantiates C at t2 and c instantiates C&apos; at t2.</p1:description>
        <rdfs:comment rdf:datatype="&xsd;string"
            >A transitive, temporal relation between two continuants such that one continuant transforms from itself at an earlier time while retaining their identity.</rdfs:comment>
        <rdf:type rdf:resource="&owl;TransitiveProperty"/>
        <owl:inverseOf>
            <owl:ObjectProperty rdf:about="#transformsInto"/>
        </owl:inverseOf>
    </owl:ObjectProperty>
    


    <!-- Object property: http://ontology.dumontierlab.com/bro#transformsInto -->

    <owl:ObjectProperty rdf:about="#transformsInto">
        <p1:description rdf:datatype="&xsd;string"
            >C transforms_into C&apos; if and only if given any c and any t, if c instantiates C at time t, then for some t&apos;, c instantiates C&apos; at t&apos; and t&apos; later t, and there is no t2 such that c instantiates C at t2 and c instantiates C&apos; at t2.</p1:description>
        <rdfs:comment rdf:datatype="&xsd;string"
            >A transitive, temporal relation between two continuants such that one continuant transforms into another continuant at a later time while retaining their identity.</rdfs:comment>
        <p1:source>PMID:15892874</p1:source>
        <p2:example rdf:datatype="&xsd;string"
            >an embryonic oenocyte (a type of insect cell) transforms into a larval oenocyte</p2:example>
        <rdfs:label rdf:datatype="&xsd;string">transforms into</rdfs:label>
        <rdf:type rdf:resource="&owl;TransitiveProperty"/>
        <owl:inverseOf>
            <owl:ObjectProperty rdf:about="#transformsFrom"/>
        </owl:inverseOf>
    </owl:ObjectProperty>
    


    <!-- 
    ///////////////////////////////////////////////////////////////////////////
    //
    //   OWL Data Properties
    //
    ///////////////////////////////////////////////////////////////////////////
     -->

    


    <!-- Data property: http://ontology.dumontierlab.com/bro#begins -->

    <owl:DatatypeProperty rdf:about="#begins">
        <rdfs:comment rdf:datatype="&xsd;string"
            >A data property that marks the beginning of a temporal entity.</rdfs:comment>
        <rdfs:label rdf:datatype="&xsd;string">begins</rdfs:label>
    </owl:DatatypeProperty>
    


    <!-- Data property: http://ontology.dumontierlab.com/bro#ends -->

    <owl:DatatypeProperty rdf:about="#ends">
        <rdfs:label rdf:datatype="&xsd;string">end</rdfs:label>
        <rdfs:comment rdf:datatype="&xsd;string"
            >A data property that marks the end of a temporal entity.</rdfs:comment>
    </owl:DatatypeProperty>
    


    <!-- Data property: http://ontology.dumontierlab.com/bro#hasValue -->

    <owl:DatatypeProperty rdf:about="#hasValue">
        <rdfs:comment rdf:datatype="&xsd;string"
            >A data type property to store a value.</rdfs:comment>
        <rdfs:label rdf:datatype="&xsd;string">has value</rdfs:label>
    </owl:DatatypeProperty>
    


    <!-- 
    ///////////////////////////////////////////////////////////////////////////
    //
    //   OWL Annotation Properties
    //
    ///////////////////////////////////////////////////////////////////////////
     -->

    <owl:AnnotationProperty rdf:about="&p1;date"/>
    <owl:AnnotationProperty rdf:about="&p1;title"/>
    <owl:AnnotationProperty rdf:about="&p1;format"/>
    <owl:AnnotationProperty rdf:about="&p1;creator"/>
    <owl:AnnotationProperty rdf:about="&p1;source"/>
    <owl:AnnotationProperty rdf:about="&p1;publisher"/>
    <owl:AnnotationProperty rdf:about="&p2;example"/>
    <owl:AnnotationProperty rdf:about="&p1;identifier"/>
    <owl:AnnotationProperty rdf:about="&p1;description"/>
    <owl:AnnotationProperty rdf:about="&p1;language"/>
    


    <!-- 
    ///////////////////////////////////////////////////////////////////////////
    //
    //   OWL Axioms
    //
    ///////////////////////////////////////////////////////////////////////////
     -->

    <rdf:Description rdf:about="#immediatelyPrecedes">
        <rdfs:subPropertyOf rdf:resource="#precedes"/>
    </rdf:Description>
    <rdf:Description rdf:about="#immediatelyPrecededBy">
        <rdfs:subPropertyOf rdf:resource="#precededBy"/>
    </rdf:Description>
    <rdf:Description rdf:about="#isSpatiallyRelatedTo">
        <rdfs:subPropertyOf rdf:resource="#isRelatedTo"/>
    </rdf:Description>
    <rdf:Description rdf:about="#immediatelyTransformsInto">
        <rdfs:subPropertyOf rdf:resource="#transformsInto"/>
    </rdf:Description>
    <rdf:Description rdf:about="#immediatelyTransformsFrom">
        <rdfs:subPropertyOf rdf:resource="#transformsFrom"/>
    </rdf:Description>
    <rdf:Description rdf:about="#precededBy">
        <rdfs:subPropertyOf rdf:resource="#isTemporallyRelatedTo"/>
    </rdf:Description>
    <rdf:Description rdf:about="#isSpatioTemporalLocationOf">
        <rdfs:subPropertyOf rdf:resource="#isLocationOf"/>
    </rdf:Description>
    <rdf:Description rdf:about="#derivativeOf">
        <rdfs:subPropertyOf rdf:resource="#isTemporallyRelatedTo"/>
    </rdf:Description>
    <rdf:Description rdf:about="#isTemporallyLocatedIn">
        <rdfs:subPropertyOf rdf:resource="#isLocatedIn"/>
    </rdf:Description>
    <rdf:Description rdf:about="#hasAgent">
        <rdfs:subPropertyOf rdf:resource="#hasParticipant"/>
    </rdf:Description>
    <rdf:Description rdf:about="#isDispositionOf">
        <rdfs:subPropertyOf rdf:resource="#inheresIn"/>
    </rdf:Description>
    <rdf:Description rdf:about="#isQualityOf">
        <rdfs:subPropertyOf rdf:resource="#inheresIn"/>
    </rdf:Description>
    <rdf:Description rdf:about="#isImproperPartOf">
        <rdfs:subPropertyOf rdf:resource="#isPartOf"/>
    </rdf:Description>
    <rdf:Description rdf:about="#isSpatiallyLocatedIn">
        <rdfs:subPropertyOf rdf:resource="#isLocatedIn"/>
    </rdf:Description>
    <rdf:Description rdf:about="#derivesFrom">
        <rdfs:subPropertyOf rdf:resource="#derivativeOf"/>
    </rdf:Description>
    <rdf:Description rdf:about="#hasFunction">
        <rdfs:subPropertyOf rdf:resource="#bearerOf"/>
    </rdf:Description>
    <rdf:Description rdf:about="#isTemporalLocationOf">
        <rdfs:subPropertyOf rdf:resource="#isLocationOf"/>
    </rdf:Description>
    <rdf:Description rdf:about="#isTemporallyRelatedTo">
        <rdfs:subPropertyOf rdf:resource="#isRelatedTo"/>
    </rdf:Description>
    <rdf:Description rdf:about="#isIntegralPartOf">
        <rdfs:subPropertyOf rdf:resource="#isPartOf"/>
    </rdf:Description>
    <rdf:Description rdf:about="#hasPart">
        <rdfs:subPropertyOf rdf:resource="#isRelatedTo"/>
    </rdf:Description>
    <rdf:Description rdf:about="#isParticipantIn">
        <rdfs:subPropertyOf rdf:resource="#isRelatedTo"/>
    </rdf:Description>
    <rdf:Description rdf:about="#hasParticipant">
        <rdfs:subPropertyOf rdf:resource="#isRelatedTo"/>
    </rdf:Description>
    <rdf:Description rdf:about="#isLocatedIn">
        <rdfs:subPropertyOf rdf:resource="#isRelatedTo"/>
    </rdf:Description>
    <rdf:Description rdf:about="#isAgentIn">
        <rdfs:subPropertyOf rdf:resource="#isParticipantIn"/>
    </rdf:Description>
    <rdf:Description rdf:about="#immediatelyDerivesFrom">
        <rdfs:subPropertyOf rdf:resource="#derivesFrom"/>
    </rdf:Description>
    <rdf:Description rdf:about="#isAdjacentTo">
        <rdfs:subPropertyOf rdf:resource="#isSpatiallyRelatedTo"/>
    </rdf:Description>
    <rdf:Description rdf:about="#isContainedIn">
        <rdfs:subPropertyOf rdf:resource="#isSpatiallyRelatedTo"/>
    </rdf:Description>
    <rdf:Description rdf:about="#hasIntegralPart">
        <rdfs:subPropertyOf rdf:resource="#hasPart"/>
    </rdf:Description>
    <rdf:Description rdf:about="#transformsInto">
        <rdfs:subPropertyOf rdf:resource="#transformationOf"/>
    </rdf:Description>
    <rdf:Description rdf:about="#hasRole">
        <rdfs:subPropertyOf rdf:resource="#bearerOf"/>
    </rdf:Description>
    <rdf:Description rdf:about="#precedes">
        <rdfs:subPropertyOf rdf:resource="#isTemporallyRelatedTo"/>
    </rdf:Description>
    <rdf:Description rdf:about="#isPartOf">
        <rdfs:subPropertyOf rdf:resource="#isRelatedTo"/>
    </rdf:Description>
    <rdf:Description rdf:about="#isSpatialLocationOf">
        <rdfs:subPropertyOf rdf:resource="#isLocationOf"/>
    </rdf:Description>
    <rdf:Description rdf:about="#isLocationOf">
        <rdfs:subPropertyOf rdf:resource="#isRelatedTo"/>
    </rdf:Description>
    <rdf:Description rdf:about="#transformsFrom">
        <rdfs:subPropertyOf rdf:resource="#transformationOf"/>
    </rdf:Description>
    <rdf:Description rdf:about="#bearerOf">
        <rdfs:subPropertyOf rdf:resource="#isRelatedTo"/>
    </rdf:Description>
    <rdf:Description rdf:about="#immediatelyDerivesInto">
        <rdfs:subPropertyOf rdf:resource="#derivesInto"/>
    </rdf:Description>
    <rdf:Description rdf:about="#isRoleOf">
        <rdfs:subPropertyOf rdf:resource="#inheresIn"/>
    </rdf:Description>
    <rdf:Description rdf:about="#inheresIn">
        <rdfs:subPropertyOf rdf:resource="#isRelatedTo"/>
    </rdf:Description>
    <rdf:Description rdf:about="#hasQuality">
        <rdfs:subPropertyOf rdf:resource="#bearerOf"/>
    </rdf:Description>
    <rdf:Description rdf:about="#hasImproperPart">
        <rdfs:subPropertyOf rdf:resource="#hasPart"/>
    </rdf:Description>
    <rdf:Description rdf:about="#isFunctionOf">
        <rdfs:subPropertyOf rdf:resource="#inheresIn"/>
    </rdf:Description>
    <rdf:Description rdf:about="#isSpatioTemporallyLocatedIn">
        <rdfs:subPropertyOf rdf:resource="#isLocatedIn"/>
    </rdf:Description>
    <rdf:Description rdf:about="#transformationOf">
        <rdfs:subPropertyOf rdf:resource="#isTemporallyRelatedTo"/>
    </rdf:Description>
    <rdf:Description rdf:about="#isProperPartOf">
        <rdfs:subPropertyOf rdf:resource="#isPartOf"/>
    </rdf:Description>
    <rdf:Description rdf:about="#hasProperPart">
        <rdfs:subPropertyOf rdf:resource="#hasPart"/>
    </rdf:Description>
    <rdf:Description rdf:about="#derivesInto">
        <rdfs:subPropertyOf rdf:resource="#derivativeOf"/>
    </rdf:Description>
    <rdf:Description rdf:about="#hasDisposition">
        <rdfs:subPropertyOf rdf:resource="#bearerOf"/>
    </rdf:Description>
    <rdf:Description rdf:about="#contains">
        <rdfs:subPropertyOf rdf:resource="#isSpatiallyRelatedTo"/>
    </rdf:Description>
</rdf:RDF>
