<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE rdf:RDF [
    <!ENTITY a 'http://www.loa-cnr.it/ontologies/CommonSenseMapping#'>
    <!ENTITY b 'http://www.loa-cnr.it/ontologies/ExtendedDnS#'>
    <!ENTITY c 'http://www.loa-cnr.it/ontologies/FunctionalParticipation#'>
    <!ENTITY d 'http://www.loa-cnr.it/ontologies/DOLCE-Lite#'>
    <!ENTITY e 'http://www.loa-cnr.it/ontologies/ModalDescriptions#'>
    <!ENTITY f 'http://www.loa-cnr.it/ontologies/TemporalRelations#'>
    <!ENTITY g 'http://www.loa-cnr.it/ontologies/MentalObjects#'>
    <!ENTITY owl 'http://www.w3.org/2002/07/owl#'>
    <!ENTITY xsd 'http://www.w3.org/2001/XMLSchema#'>
]>

<rdf:RDF
    xml:base="http://www.loa-cnr.it/Files/DLPOnts/DOLCE"
    xmlns:owl="http://www.w3.org/2002/07/owl#"
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#">

<owl:Ontology rdf:about=""/>

<owl:Class rdf:about="&a;biological-object">
    <rdfs:comment rdf:datatype="&xsd;string">Any physical body at the biological granularity level. They are (generically) constituted by chemical objects.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&a;physical-body"/>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;generic-constituent"/>
            <owl:someValuesFrom rdf:resource="&a;chemical-object"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <owl:disjointWith rdf:resource="&a;chemical-object"/>
</owl:Class>

<owl:Class rdf:about="&a;causal-role">
    <rdfs:comment rdf:datatype="&xsd;string">A role defined (not just used!) by a causal description, and exploited to conceptualize some causation invariants.Causal notions are still primitive in this version of DLP.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&b;role"/>
</owl:Class>

<owl:Class rdf:about="&a;chemical-object">
    <rdfs:comment rdf:datatype="&xsd;string">Any physical body at the chemical granularity level.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&a;physical-body"/>
</owl:Class>

<owl:Class rdf:about="&a;collection-role">
    <rdfs:comment rdf:datatype="&xsd;string">A role only played by collections.</rdfs:comment>
    <owl:equivalentClass>
        <owl:Class>
            <owl:intersectionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&b;role"/>
                <owl:Restriction>
                    <owl:onProperty rdf:resource="&b;played-by"/>
                    <owl:allValuesFrom rdf:resource="&b;collection"/>
                </owl:Restriction>
            </owl:intersectionOf>
        </owl:Class>
    </owl:equivalentClass>
</owl:Class>

<owl:Class rdf:about="&a;commerce-role">
    <rdfs:comment rdf:datatype="&xsd;string">A role played by some substance or object within a commercial transaction description.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&b;social-role"/>
</owl:Class>

<owl:Class rdf:about="&a;contract">
    <rdfs:comment rdf:datatype="&xsd;string">A binding agreement that is possibly enforceable by law.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&b;regulation"/>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;part"/>
            <owl:someValuesFrom rdf:resource="&e;promise"/>
        </owl:Restriction>
    </rdfs:subClassOf>
</owl:Class>

<owl:Class rdf:about="&a;country">
    <rdfs:comment rdf:datatype="&xsd;string">A political geographic object that is (generically) dependent on some physical place (in principle, countries can change their borders).</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&a;political-geographic-object"/>
</owl:Class>

<owl:Class rdf:about="&a;creative-object">
    <rdfs:comment rdf:datatype="&xsd;string">The information realized by an entity for creative purposes. Here mainly for mapping purpose from WordNet.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&b;information-object"/>
</owl:Class>

<owl:Class rdf:about="&a;feature-role">
    <rdfs:comment rdf:datatype="&xsd;string">A role played by some feature of a physical object.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&b;role"/>
</owl:Class>

<owl:Class rdf:about="&a;functional-matter">
    <rdfs:comment rdf:datatype="&xsd;string">Amount of matter playing a typically 'functional' role at some time in some situation.</rdfs:comment>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&c;used-in"/>
            <owl:someValuesFrom rdf:resource="&b;activity"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <owl:equivalentClass>
        <owl:Class>
            <owl:intersectionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&d;amount-of-matter"/>
                <owl:Restriction>
                    <owl:onProperty rdf:resource="&b;plays"/>
                    <owl:someValuesFrom rdf:resource="&b;role"/>
                </owl:Restriction>
            </owl:intersectionOf>
        </owl:Class>
    </owl:equivalentClass>
</owl:Class>

<owl:Class rdf:about="&a;geographical-object">
    <rdfs:comment rdf:datatype="&xsd;string">A physical place whose spatial quality is q-located in geographical coordinates.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&a;physical-place"/>
</owl:Class>

<owl:Class rdf:about="&a;geographical-place">
    <rdfs:comment rdf:datatype="&xsd;string">A non-physical place, generically dependent on some (physical) geographical object.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&a;non-physical-place"/>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&b;hypostasis-of"/>
            <owl:someValuesFrom rdf:resource="&a;geographical-object"/>
        </owl:Restriction>
    </rdfs:subClassOf>
</owl:Class>

<owl:Class rdf:about="&a;legal-possession-entity">
    <rdfs:comment rdf:datatype="&xsd;string">A role played by assets involved in a legal possession description.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&b;social-role"/>
</owl:Class>

<owl:Class rdf:about="&a;locative-role">
    <rdfs:comment rdf:datatype="&xsd;string">This is a role (e.g. closed area) for places. Locative roles are played by physical objects (in locational cases, physical places), as well as non-physical places (individual places depending on a physical object).</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&b;role"/>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&b;played-by"/>
            <owl:allValuesFrom>
                <owl:Class>
                    <owl:unionOf rdf:parseType="Collection">
                        <owl:Class rdf:about="&a;non-physical-place"/>
                        <owl:Class rdf:about="&d;physical-object"/>
                    </owl:unionOf>
                </owl:Class>
            </owl:allValuesFrom>
        </owl:Restriction>
    </rdfs:subClassOf>
</owl:Class>

<owl:Class rdf:about="&a;measurement-unit">
    <rdfs:comment rdf:datatype="&xsd;string">A quality space used as a reference metrics ("measurement space") for other spaces. It is usually "counted by" some number.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&d;abstract-region"/>
</owl:Class>

<owl:Class rdf:about="&a;non-physical-place">
    <rdfs:comment rdf:datatype="&xsd;string">A non-agentive figure (e.g. Italy) for non-physical (i.e. socially- or cognitively-constructed) places.Non-physical places generically depend on physical places.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&b;non-agentive-figure"/>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&b;hypostasis-of"/>
            <owl:someValuesFrom rdf:resource="&a;physical-place"/>
        </owl:Restriction>
    </rdfs:subClassOf>
</owl:Class>

<owl:Class rdf:about="&a;norm">
    <rdfs:comment rdf:datatype="&xsd;string">A regulation having a cognitive modal description as part.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&b;regulation"/>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&b;involves"/>
            <owl:someValuesFrom rdf:resource="&b;rational-agent"/>
        </owl:Restriction>
    </rdfs:subClassOf>
</owl:Class>

<owl:Class rdf:about="&a;phase-role">
    <rdfs:comment rdf:datatype="&xsd;string">Formerly: (non-) agentive temporary role.A role for talking of someone or something at certain phases of own life. It can be used also to map temporal parts of agentive objects from a 4D ontology.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&b;role"/>
</owl:Class>

<owl:Class rdf:about="&a;physical-body">
    <rdfs:comment rdf:datatype="&xsd;string">A physical body is a non-agentive physical object whose primary identity criterion is not given by its artefactual origin, if any. For example, a rock or a tree can be considered physical bodies unless or until they are not viewed as artifacts. As a matter of fact, no easy definition of artifactual properties is possible, hence it is better to rely on alternative descriptions and roles: a physical object that shows or is known to have an artifactual origin that counts in the tasks an ontology is supposed to support, will be a material artifact. On the other hand, physical objects that do not show that origin, or that origin is unimportant for the task of the ontology, will be physical bodies. Formally, a restriction is provided here that requires that the collection whose members are proper parts of a physical body is not *unified* by a plan or project. BTW, a physical body can still be a *device*, can be 'used' and have 'functions' (roles), e.g. a stone used as a weapon, but it plays no role like being produced, as material artifacts do. Moreover, a collection whose members are proper parts of a physical body can still be unified by a description (e.g. a biochemical model). Physical bodies can have several granularity levels: geological, chemical, physical, biological, etc.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&b;non-agentive-physical-object"/>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;proper-part"/>
            <owl:allValuesFrom>
                <owl:Restriction>
                    <owl:onProperty rdf:resource="&b;member-of"/>
                    <owl:someValuesFrom>
                        <owl:Class>
                            <owl:intersectionOf rdf:parseType="Collection">
                                <owl:Restriction>
                                    <owl:onProperty rdf:resource="&b;unified-by"/>
                                    <owl:allValuesFrom>
                                        <owl:Class>
                                            <owl:complementOf>
                                                <owl:Class>
                                                    <owl:unionOf rdf:parseType="Collection">
                                                        <owl:Class rdf:about="&b;project"/>
                                                        <owl:Class rdf:about="&b;plan"/>
                                                    </owl:unionOf>
                                                </owl:Class>
                                            </owl:complementOf>
                                        </owl:Class>
                                    </owl:allValuesFrom>
                                </owl:Restriction>
                                <owl:Class rdf:about="&b;collection"/>
                            </owl:intersectionOf>
                        </owl:Class>
                    </owl:someValuesFrom>
                </owl:Restriction>
            </owl:allValuesFrom>
        </owl:Restriction>
    </rdfs:subClassOf>
</owl:Class>

<owl:Class rdf:about="&a;physical-place">
    <rdfs:comment rdf:datatype="&xsd;string">A placeholder for physical objects that are conceived primarily as places, e.g. wrt their spatial quality.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&b;non-agentive-physical-object"/>
</owl:Class>

<owl:Class rdf:about="&a;political-geographic-object">
    <rdfs:comment rdf:datatype="&xsd;string">A geographical place, conventionally accepted by a community.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&a;geographical-place"/>
</owl:Class>

<owl:Class rdf:about="&a;qualitative-role">
    <rdfs:comment rdf:datatype="&xsd;string">A placeholder for some roles in common sense that do not easily map to other types of roles. More work is needed here.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&b;role"/>
</owl:Class>

<owl:Class rdf:about="&a;spatial-feature">
    <rdfs:comment rdf:datatype="&xsd;string">A feature related to spatial properties.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&d;relevant-part"/>
</owl:Class>

<owl:Class rdf:about="&a;substance-role">
    <rdfs:comment rdf:datatype="&xsd;string">A role played by some substance.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&b;role"/>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&b;played-by"/>
            <owl:allValuesFrom rdf:resource="&d;amount-of-matter"/>
        </owl:Restriction>
    </rdfs:subClassOf>
</owl:Class>

<owl:Class rdf:about="&d;abstract">
    <rdfs:comment rdf:datatype="&xsd;string">The main characteristic of abstract entities is that  they do not have spatial nor temporal qualities, and they are not qualities themselves.  The only class of abstract entities we consider in the present version of the upper  ontology is that of quality regions (or simply regions). Quality spaces are special  kinds of quality regions, being mereological sums of all the regions related to a certain quality type. The other examples of abstract entities (sets and facts) are only  indicative.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&d;particular"/>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;has-quality"/>
            <owl:allValuesFrom>
                <owl:Class>
                    <owl:complementOf>
                        <owl:Class rdf:about="&d;spatial-location_q"/>
                    </owl:complementOf>
                </owl:Class>
            </owl:allValuesFrom>
        </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;has-quality"/>
            <owl:allValuesFrom>
                <owl:Class>
                    <owl:complementOf>
                        <owl:Class rdf:about="&d;temporal-location_q"/>
                    </owl:complementOf>
                </owl:Class>
            </owl:allValuesFrom>
        </owl:Restriction>
    </rdfs:subClassOf>
    <owl:disjointWith rdf:resource="&d;endurant"/>
    <owl:disjointWith rdf:resource="&d;perdurant"/>
    <owl:disjointWith rdf:resource="&d;quality"/>
</owl:Class>

<owl:Class rdf:about="&d;abstract-quality">
    <rdfs:comment rdf:datatype="&xsd;string">A quality inherent in a non-physical endurant.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&d;quality"/>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;has-quality"/>
            <owl:allValuesFrom rdf:resource="&d;abstract-quality"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;q-location"/>
            <owl:allValuesFrom rdf:resource="&d;abstract-region"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;inherent-in"/>
            <owl:someValuesFrom rdf:resource="&d;non-physical-endurant"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <owl:disjointWith rdf:resource="&d;physical-quality"/>
    <owl:disjointWith rdf:resource="&d;temporal-quality"/>
</owl:Class>

<owl:Class rdf:about="&d;abstract-region">
    <rdfs:comment rdf:datatype="&xsd;string">A region at which only abstract qualities can be directly located. It assumes some metrics for abstract (neither physical nor temporal) properties.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&d;region"/>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;part"/>
            <owl:allValuesFrom rdf:resource="&d;abstract-region"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;q-location-of"/>
            <owl:allValuesFrom rdf:resource="&d;abstract-quality"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <owl:disjointWith rdf:resource="&d;physical-region"/>
    <owl:disjointWith rdf:resource="&d;temporal-region"/>
</owl:Class>

<owl:Class rdf:about="&d;accomplishment">
    <rdfs:comment rdf:datatype="&xsd;string">Eventive occurrences (events) are called achievements if they are atomic, otherwise they are accomplishments.Further developments: being 'achievement', 'accomplishment', 'state', 'event', etc. can be also considered 'aspects' of processes or of parts of them. For example, the same process 'rock erosion in the Sinni valley' can be seen as an accomplishment (what has brought the current state that e.g. we are trying to explain), as an achievement (the erosion process as the result of a previous accomplishment), as a state (collapsing the time interval of the erosion into a time point), as an event (what has changed our focus from a state to another).In the erosion case, we could have good motivations to shift from one aspect to another: a) causation focus, b) effectual focus, c) condensation d) transition (causality).</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&d;event"/>
</owl:Class>

<owl:Class rdf:about="&d;achievement">
    <rdfs:comment rdf:datatype="&xsd;string">Eventive occurrences (events) are called achievements  if they are atomic, otherwise they are accomplishments.Further developments: being 'achievement', 'accomplishment', 'state', 'event', etc. can be also considered 'aspects' of processes or of parts of them. For example, the same process 'rock erosion in the Sinni valley' can be seen as an accomplishment (what has brought the current state that e.g. we are trying to explain), as an achievement (the erosion process as the result of a previous accomplishment), as a state (collapsing the time interval of the erosion into a time point), as an event (what has changed our focus from a state to another).In the erosion case, we could have good motivations to shift from one aspect to another: a) causation focus, b) effectual focus, c) condensation d) transition (causality).</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&d;event"/>
</owl:Class>

<owl:Class rdf:about="&d;amount-of-matter">
    <rdfs:comment rdf:datatype="&xsd;string">The common trait of amounts of matter is that they are endurants with no unity (according to Gangemi et a. 2001 none of them is an essential  whole). Amounts of matter - 'stuffs' referred to by mass nouns like 'gold', 'iron', 'wood',  'sand', 'meat', etc. - are mereologically  invariant, in the sense that they change their  identity when they change some parts.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&d;physical-endurant"/>
    <owl:disjointWith rdf:resource="&d;feature"/>
    <owl:disjointWith rdf:resource="&d;physical-object"/>
</owl:Class>

<owl:Class rdf:about="&d;arbitrary-sum">
    <rdfs:comment rdf:datatype="&xsd;string">AKA arbitrary-collection.The mereological sum of any two or more endurants (physical or not). Arbitrary sums have no unity criterion (they are 'extensional').</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&d;endurant"/>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;part"/>
            <owl:someValuesFrom rdf:resource="&d;endurant"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <owl:disjointWith rdf:resource="&d;non-physical-endurant"/>
    <owl:disjointWith rdf:resource="&d;physical-endurant"/>
</owl:Class>

<owl:Class rdf:about="&d;dependent-place">
    <rdfs:comment rdf:datatype="&xsd;string">A feature that is not part of its host, like a hole in a piece of cheese, the underneath of a table, the front of a house, or the shadow of a tree.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&d;feature"/>
</owl:Class>

<owl:Class rdf:about="&d;endurant">
    <rdfs:comment rdf:datatype="&xsd;string">The main characteristic of endurants is that all of them are independent essential wholes. This does not mean that the corresponding property (being an endurant) carries proper unity, since there is  no common unity criterion for endurants. Endurants can 'genuinely' change in time,  in the sense that the very same endurant as a whole can have incompatible properties at different times. To see this, suppose that an endurant - say 'this paper' - has a  property at a time t 'it's white', and a different, incompatible property at time t'  'it's yellow': in both cases we refer to the whole object, without picking up any  particular part of it. Within endurants, we distinguish between physical and non-physical  endurants, according to whether they have direct spatial qualities. Within physical  endurants, we distinguish between amounts of matter, objects, and features.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&d;spatio-temporal-particular"/>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;part"/>
            <owl:allValuesFrom rdf:resource="&d;endurant"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;specific-constant-constituent"/>
            <owl:allValuesFrom rdf:resource="&d;endurant"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;participant-in"/>
            <owl:someValuesFrom rdf:resource="&d;perdurant"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <owl:disjointWith rdf:resource="&d;perdurant"/>
    <owl:disjointWith rdf:resource="&d;quality"/>
</owl:Class>

<owl:Class rdf:about="&d;event">
    <rdfs:comment rdf:datatype="&xsd;string">An occurrence-type is stative or eventive according  to whether it holds of the mereological sum of two of its instances, i.e. if it is cumulative or not. A sitting occurrence is stative since the sum of two sittings is still a sitting occurrence.In general, events differ from situations because they are not assumed to have a description from which they depend. They can be sequenced by some course, but they do not require a description as a unifying criterion.On the other hand, at any time, one can conceive a description that asserts the constraints by which an event of a certian type is such, and in this case, it becomes a situation.Since the decision of designing an explicit description that unifies a perdurant depends on context, task, interest, application, etc., when aligning an ontology do DLP, there can be indecision on where to align an event-oriented class. For example, in the WordNet alignment, we have decided to put only some physical events under 'event', e.g. 'discharge', in order to stress the social orientedness of DLP. But whereas we need to talk explicitly of the criteria by which we conceive discharge events, these will be put under 'situation'.Similar considerations are made for the other types of perdurants in DOLCE.A different notion of event (dealing with change) is currently investigated for further developments: being 'achievement', 'accomplishment', 'state', 'event', etc. can be also considered 'aspects' of processes or of parts of them. For example, the same process 'rock erosion in the Sinni valley' can be conceptualized as an accomplishment (what has brought the current state that e.g. we are trying to explain), as an achievement (the erosion process as the result of a previous accomplishment), as a state (if we collapse the time interval of the erosion into a time point), or as an event (what has changed our focus from a state to another).In the erosion case, we could have good motivations to shift from one aspect to another: a) causation focus, b) effectual focus, c) condensation d) transition (causality).If we want to consider all the aspects of a process together, we need to postulate a unifying descriptive set of criteria (i.e. a 'description'), according to which that process is circumstantiated in a 'situation'. The different aspects will arise as a parts of a same situation.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&d;perdurant"/>
</owl:Class>

<owl:Class rdf:about="&d;feature">
    <rdfs:comment rdf:datatype="&xsd;string">Features are 'parasitic entities', that exist insofar their host exists. Typical examples of features are holes, bumps, boundaries, or spots of color. Features may be relevant parts of their host, like a bump or an edge, or dependent regions like a hole in a piece of cheese, the underneath of a table, the front of a house, or the shadow of a tree, which are not parts of their host. All features are essential wholes, but no common unity criterion may exist for all of them. However, typical features have a topological unity, as they are singular entities.Here only features of physical endurants are considered.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&d;physical-endurant"/>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;host"/>
            <owl:someValuesFrom rdf:resource="&d;physical-endurant"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <owl:disjointWith rdf:resource="&d;physical-object"/>
</owl:Class>

<owl:Class rdf:about="&d;non-physical-endurant">
    <rdfs:comment rdf:datatype="&xsd;string">An endurant with no mass, generically constantly depending on some agent. Non-physical endurants can have physical constituents (e.g. in the case of members of a collection).</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&d;endurant"/>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;has-quality"/>
            <owl:allValuesFrom rdf:resource="&d;abstract-quality"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;part"/>
            <owl:allValuesFrom rdf:resource="&d;non-physical-endurant"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <owl:disjointWith rdf:resource="&d;physical-endurant"/>
</owl:Class>

<owl:Class rdf:about="&d;non-physical-object">
    <rdfs:comment rdf:datatype="&xsd;string">Formerly known as description. A unitary endurant with no mass (non-physical), generically constantly depending on some agent, on some communication act, and indirectly on some agent participating in that act. Both descriptions (in the now current sense) and concepts are non-physical objects.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&d;non-physical-endurant"/>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;part"/>
            <owl:allValuesFrom rdf:resource="&d;non-physical-object"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;generically-dependent-on"/>
            <owl:someValuesFrom rdf:resource="&d;physical-endurant"/>
        </owl:Restriction>
    </rdfs:subClassOf>
</owl:Class>

<owl:Class rdf:about="&d;particular">
    <rdfs:comment rdf:datatype="&xsd;string">AKA 'entity'.Any individual in the DOLCE domain of discourse. The extensional coverage of DOLCE is as large as possible, since it ranges on 'possibilia', i.e all possible individuals that can be postulated by means of DOLCE axioms. Possibilia include physical objects, substances, processes, qualities,  conceptual regions, non-physical objects, collections and even arbitrary sums of objects.The class 'particular' features a covering partition that includes: endurant, perdurant, quality, and abstract. There are also some subclasses defined as unions of subclasses of 'particular' for special purposes: spatio-temporal-particular (any particular except abstracts)- physical-realization (any realization of an information object, defined in the ExtendedDnS ontology).</rdfs:comment>
</owl:Class>

<owl:Class rdf:about="&d;perdurant">
    <rdfs:comment rdf:datatype="&xsd;string">Perdurants (AKA occurrences) comprise what are variously called events, processes, phenomena, activities and states. They can have temporal parts or spatial parts. For instance, the first movement of (an execution of) a symphony is a temporal part of the symphony. On the other hand, the play performed by the left side of the orchestra is a spatial part. In both cases, these parts are occurrences themselves. We assume that objects cannot be parts of occurrences, but rather they participate in them. Perdurants extend in time by accumulating different temporal parts, so that, at any time they are present, they are only partially present, in  the sense that some of their proper temporal parts (e.g., their previous or future phases) may be not present. E.g., the piece of paper you are reading now is wholly present, while some temporal parts of your reading are not present yet, or any more. Philosophers say that endurants are entities that are in time, while lacking temporal parts (so to speak, all their parts flow with them in time). Perdurants, on the contrary, are entities that happen in time, and can have temporal parts (all their parts are fixed in time).</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&d;spatio-temporal-particular"/>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;has-quality"/>
            <owl:allValuesFrom rdf:resource="&d;temporal-quality"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;part"/>
            <owl:allValuesFrom rdf:resource="&d;perdurant"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;specific-constant-constituent"/>
            <owl:allValuesFrom rdf:resource="&d;perdurant"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;has-quality"/>
            <owl:someValuesFrom rdf:resource="&d;temporal-location_q"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;participant"/>
            <owl:someValuesFrom rdf:resource="&d;endurant"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <owl:disjointWith rdf:resource="&d;quality"/>
</owl:Class>

<owl:Class rdf:about="&d;physical-endurant">
    <rdfs:comment rdf:datatype="&xsd;string">An endurant having a direct physical (at least spatial) quality.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&d;endurant"/>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;has-quality"/>
            <owl:allValuesFrom rdf:resource="&d;physical-quality"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;part"/>
            <owl:allValuesFrom rdf:resource="&d;physical-endurant"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;specific-constant-constituent"/>
            <owl:allValuesFrom rdf:resource="&d;physical-endurant"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;has-quality"/>
            <owl:someValuesFrom rdf:resource="&d;physical-quality"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;has-quality"/>
            <owl:someValuesFrom rdf:resource="&d;spatial-location_q"/>
        </owl:Restriction>
    </rdfs:subClassOf>
</owl:Class>

<owl:Class rdf:about="&d;physical-object">
    <rdfs:comment rdf:datatype="&xsd;string">The main characteristic of physical objects is that  they are endurants with unity. However, they have no common unity criterion, since  different subtypes of objects may  have different unity criteria. Differently from  aggregates, (most) physical objects change some of their parts while keeping their  identity, they can have therefore temporary parts. Often physical objects (indeed,  all endurants) are ontologically independent from occurrences (discussed below).  However, if we admit that every object has a life, it is hard to exclude a mutual  specific constant dependence between the two. Nevertheless, we may still use the  notion of dependence to (weakly) characterize objects as being not specifically  constantly dependent on other objects.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&d;physical-endurant"/>
</owl:Class>

<owl:Class rdf:about="&d;physical-quality">
    <rdfs:comment rdf:datatype="&xsd;string">A quality inherent in a physical endurant.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&d;quality"/>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;has-quality"/>
            <owl:allValuesFrom rdf:resource="&d;physical-quality"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;q-location"/>
            <owl:allValuesFrom rdf:resource="&d;physical-region"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;inherent-in"/>
            <owl:someValuesFrom rdf:resource="&d;physical-endurant"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <owl:disjointWith rdf:resource="&d;temporal-quality"/>
</owl:Class>

<owl:Class rdf:about="&d;physical-region">
    <rdfs:comment rdf:datatype="&xsd;string">A region at which only physical qualities can be  directly located. It assumes some metrics for physical properties.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&d;region"/>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;part"/>
            <owl:allValuesFrom rdf:resource="&d;physical-region"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;q-location-of"/>
            <owl:allValuesFrom rdf:resource="&d;physical-quality"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <owl:disjointWith rdf:resource="&d;temporal-region"/>
</owl:Class>

<owl:Class rdf:about="&d;process">
    <rdfs:comment rdf:datatype="&xsd;string">Within stative occurrences, we distinguish between states and processes     according to homeomericity: sitting is classified as a state but running     is classified as a process, since there are (very short) temporal parts of     a running that are not themselves runnings. In general, processes differ     from situations because they are not assumed to have a description from     which they depend. They can be sequenced by some course, but they do not     require a description as a unifying criterion. On the other hand, at any     time, one can conceive a description that asserts the constraints by which     a process of a certian type is such, and in this case, it becomes a     situation. Since the decision of designing an explicit description that     unifies a perdurant depends on context, task, interest, application, etc.,     when aligning an ontology do DLP, there can be indecision on where to     align a process-oriented class. For example, in the WordNet alignment, we     have decided to put only some physical processes under 'process', e.g.     'organic process', in order to stress the social orientedness of DLP. But     whereas we need to talk explicitly of the criteria by which we conceive     organic processes, these will be put under 'situation'. Similar     considerations are made for the other types of perdurants in DOLCE. A     different notion of event (dealing with change) is currently investigated     for further developments: being 'achievement', 'accomplishment', 'state',     'event', etc. can be also considered 'aspects' of processes or of parts of     them. For example, the same process 'rock erosion in the Sinni valley' can     be conceptualized as an accomplishment (what has brought the current state     that e.g. we are trying to explain), as an achievement (the erosion     process as the result of a previous accomplishment), as a state (if we     collapse the time interval of the erosion into a time point), or as an     event (what has changed our focus from a state to another). In the erosion     case, we could have good motivations to shift from one aspect to another:     a) causation focus, b) effectual focus, c) condensation d) transition     (causality). If we want to consider all the aspects of a process together,     we need to postulate a unifying descriptive set of criteria (i.e. a     'description'), according to which that process is circumstantiated in a     'situation'. The different aspects will arise as a parts of a same situation.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&d;stative"/>
</owl:Class>

<owl:Class rdf:about="&d;proposition">
    <rdfs:comment rdf:datatype="&xsd;string">The abstract content of a proposition. Abstract content is purely combinatorial: from this viewpoint, any content that can be generated by means of combinatorial rules is assumed to exist in the domain of quantification (reified abstracts).</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&d;abstract"/>
</owl:Class>

<owl:Class rdf:about="&d;quale">
    <rdfs:comment rdf:datatype="&xsd;string">An atomic region.</rdfs:comment>
    <owl:equivalentClass>
        <owl:Class>
            <owl:intersectionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&d;region"/>
                <owl:Restriction>
                    <owl:onProperty rdf:resource="&d;atomic-part-of"/>
                    <owl:someValuesFrom rdf:resource="&d;region"/>
                </owl:Restriction>
            </owl:intersectionOf>
        </owl:Class>
    </owl:equivalentClass>
</owl:Class>

<owl:Class rdf:about="&d;quality">
    <rdfs:comment rdf:datatype="&xsd;string">Qualities can be seen as the basic entities we can  perceive or measure: shapes, colors, sizes, sounds, smells, as well as weights, lengths,  electrical charges... 'Quality' is often used as a synonymous of 'property', but this is  not the case in this upper ontology: qualities are particulars, properties are universals.  Qualities inhere to entities: every entity (including qualities themselves) comes with  certain qualities, which exist as long as the entity exists.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&d;spatio-temporal-particular"/>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;inherent-in"/>
            <owl:someValuesFrom rdf:resource="&d;particular"/>
        </owl:Restriction>
    </rdfs:subClassOf>
</owl:Class>

<owl:Class rdf:about="&d;quality-space">
    <rdfs:comment rdf:datatype="&xsd;string">A quality space is a topologically maximal region. The constraint of maximality cannot be given completely in OWL, but a constraint is given that creates a partition out of all quality spaces (e.g. no two quality spaces can overlap mereologically).</rdfs:comment>
    <owl:equivalentClass>
        <owl:Class>
            <owl:intersectionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&d;region"/>
                <owl:Restriction>
                    <owl:onProperty rdf:resource="&d;overlaps"/>
                    <owl:allValuesFrom>
                        <owl:Class>
                            <owl:complementOf>
                                <owl:Class rdf:about="&d;quality-space"/>
                            </owl:complementOf>
                        </owl:Class>
                    </owl:allValuesFrom>
                </owl:Restriction>
            </owl:intersectionOf>
        </owl:Class>
    </owl:equivalentClass>
</owl:Class>

<owl:Class rdf:about="&d;region">
    <rdfs:comment rdf:datatype="&xsd;string">We distinguish between a quality (e.g., the color  of a specific rose), and its value (e.g., a particular shade of red). The latter  is called quale, and describes the position of an individual quality within a certain  conceptual space (called here quality space) Gardenfors (2000). So when we say that  two roses have (exactly) the same color, we mean that their color qualities, which  are distinct, have the same position in the color space, that is they have the same  color quale.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&d;abstract"/>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;part"/>
            <owl:allValuesFrom rdf:resource="&d;region"/>
        </owl:Restriction>
    </rdfs:subClassOf>
</owl:Class>

<owl:Class rdf:about="&d;relevant-part">
    <rdfs:comment rdf:datatype="&xsd;string">Features that are relevant parts of their host, like a bump or an edge.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&d;feature"/>
</owl:Class>

<owl:Class rdf:about="&d;set">
    <rdfs:comment rdf:datatype="&xsd;string">A mathematical set.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&d;abstract"/>
</owl:Class>

<owl:Class rdf:about="&d;space-region">
    <rdfs:comment rdf:datatype="&xsd;string">An ordinary space: geographical, cosmological, anatomical, topographic, etc.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&d;physical-region"/>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;part"/>
            <owl:allValuesFrom rdf:resource="&d;space-region"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;q-location-of"/>
            <owl:allValuesFrom rdf:resource="&d;spatial-location_q"/>
        </owl:Restriction>
    </rdfs:subClassOf>
</owl:Class>

<owl:Class rdf:about="&d;spatial-location_q">
    <rdfs:comment rdf:datatype="&xsd;string">A physical quality, q-located in (whose value is given within) ordinary spaces (geographical coordinates, cosmological positions, anatomical axes, etc.).</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&d;physical-quality"/>
</owl:Class>

<owl:Class rdf:about="&d;spatio-temporal-particular">
    <rdfs:comment rdf:datatype="&xsd;string">Dummy class for optimizing some property universes. It includes all entities that are not reifications of universals ('abstracts'), i.e. those entities that are in space-time.</rdfs:comment>
    <owl:equivalentClass>
        <owl:Class>
            <owl:intersectionOf rdf:parseType="Collection">
                <owl:Class>
                    <owl:unionOf rdf:parseType="Collection">
                        <owl:Class rdf:about="&d;endurant"/>
                        <owl:Class rdf:about="&d;perdurant"/>
                        <owl:Class rdf:about="&d;quality"/>
                    </owl:unionOf>
                </owl:Class>
                <owl:Class rdf:about="&d;particular"/>
            </owl:intersectionOf>
        </owl:Class>
    </owl:equivalentClass>
</owl:Class>

<owl:Class rdf:about="&d;spatio-temporal-region">
    <rdfs:comment rdf:datatype="&xsd;string">Any region resulting from the composition of a space region with a temporal region, i.e. being present in region r at time t.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&d;space-region"/>
</owl:Class>

<owl:Class rdf:about="&d;state">
    <rdfs:comment rdf:datatype="&xsd;string">Within stative occurrences, we distinguish between  states and processes according to homeomericity: sitting is classified as a state  but running is classified as a process, since there are (very short) temporal parts  of a running that are not themselves runnings.In general, states differ from situations because they are not assumed to have a description from which they depend. They can be sequenced by some course, but they do not require a description as a unifying criterion.On the other hand, at any time, one can conceive a description that asserts the constraints by which a state of a certian type is such, and in this case, it becomes a situation.Since the decision of designing an explicit description that unifies a perdurant depends on context, task, interest, application, etc., when aligning an ontology do DLP, there can be indecision on where to align a state-oriented class. For example, in the WordNet alignment, we have decided to put only some physical states under 'state', e.g. 'turgor', in order to stress the social orientedness of DLP. But whereas we need to talk explicitly of the criteria by which we conceive turgor states, these will be put under 'situation'.Similar considerations are made for the other types of perdurants in DOLCE.A different notion of event (dealing with change) is currently investigated for further developments: being 'achievement', 'accomplishment', 'state', 'event', etc. can be also considered 'aspects' of processes or of parts of them. For example, the same process 'rock erosion in the Sinni valley' can be conceptualized as an accomplishment (what has brought the current state that e.g. we are trying to explain), as an achievement (the erosion process as the result of a previous accomplishment), as a state (if we collapse the time interval of the erosion into a time point), or as an event (what has changed our focus from a state to another).In the erosion case, we could have good motivations to shift from one aspect to another: a) causation focus, b) effectual focus, c) condensation d) transition (causality).If we want to consider all the aspects of a process together, we need to postulate a unifying descriptive set of criteria (i.e. a 'description'), according to which that process is circumstantiated in a 'situation'. The different aspects will arise as a parts of a same situation.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&d;stative"/>
</owl:Class>

<owl:Class rdf:about="&d;stative">
    <rdfs:comment rdf:datatype="&xsd;string">An occurrence-type is stative or eventive according  to whether it holds of the mereological sum of two of its instances, i.e. if it is  cumulative or not. A sitting occurrence is stative since the sum of two sittings  is still a sitting occurrence.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&d;perdurant"/>
</owl:Class>

<owl:Class rdf:about="&d;temporal-location_q">
    <rdfs:comment rdf:datatype="&xsd;string">A temporal location quality.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&d;temporal-quality"/>
</owl:Class>

<owl:Class rdf:about="&d;temporal-quality">
    <rdfs:comment rdf:datatype="&xsd;string">A quality inherent in a perdurant.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&d;quality"/>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;has-quality"/>
            <owl:allValuesFrom rdf:resource="&d;temporal-quality"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;q-location"/>
            <owl:allValuesFrom rdf:resource="&d;temporal-region"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;inherent-in"/>
            <owl:someValuesFrom rdf:resource="&d;perdurant"/>
        </owl:Restriction>
    </rdfs:subClassOf>
</owl:Class>

<owl:Class rdf:about="&d;temporal-region">
    <rdfs:comment rdf:datatype="&xsd;string">A region at which only temporal qualities can be  directly located. It assumes a metrics for time.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&d;region"/>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;part"/>
            <owl:allValuesFrom rdf:resource="&d;temporal-region"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;q-location-of"/>
            <owl:allValuesFrom rdf:resource="&d;temporal-quality"/>
        </owl:Restriction>
    </rdfs:subClassOf>
</owl:Class>

<owl:Class rdf:about="&d;time-interval">
    <rdfs:comment rdf:datatype="&xsd;string">A temporal region, measured according to a calendar.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&d;temporal-region"/>
</owl:Class>

<owl:Class rdf:about="&b;action">
    <rdfs:comment rdf:datatype="&xsd;string">A Perdurant that exemplifies the intentionality of an agent. Could it be aborted, incomplete, mislead, while remaining a (potential) accomplishment ... The point here is that having a result depends on a method, then an action remains an action under incomplete results. As a matter of fact, if we neutralize intentionality, a purely topological, post-hoc view is at odds with the notion of incomplete accomplishments.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&d;accomplishment"/>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;generically-dependent-on"/>
            <owl:someValuesFrom rdf:resource="&b;cognitive-state"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;participant"/>
            <owl:someValuesFrom rdf:resource="&b;agent"/>
        </owl:Restriction>
    </rdfs:subClassOf>
</owl:Class>

<owl:Class rdf:about="&b;activity">
    <rdfs:comment rdf:datatype="&xsd;string">In dependency terms, an activity is an action that is generically constantly dependent on a (at least partly) shared plan adopted by participants. This condition implies that an action must be sequenced by a task.Intuitively, activities are complex actions that are at least partly conventionally planned.</rdfs:comment>
    <owl:equivalentClass>
        <owl:Class>
            <owl:intersectionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&b;action"/>
                <owl:Restriction>
                    <owl:onProperty rdf:resource="&d;generically-dependent-on"/>
                    <owl:someValuesFrom rdf:resource="&b;plan"/>
                </owl:Restriction>
                <owl:Restriction>
                    <owl:onProperty rdf:resource="&b;sequenced-by"/>
                    <owl:someValuesFrom rdf:resource="&b;task"/>
                </owl:Restriction>
                <owl:Restriction>
                    <owl:onProperty rdf:resource="&d;part"/>
                    <owl:someValuesFrom rdf:resource="&b;action"/>
                </owl:Restriction>
            </owl:intersectionOf>
        </owl:Class>
    </owl:equivalentClass>
</owl:Class>

<owl:Class rdf:about="&b;agent">
    <rdfs:comment rdf:datatype="&xsd;string">A catch-all class used to join agentive objects (either physical or social). Agents are dispositionally so, in the sense that they internally represent descriptions, and in particular plans, goals and possible actions, but they do not necessarily act. In everyday language, agent is used in this sense, but also to tell that something has acted in a certain way, or to say that something has an initiator or leading role in some action. In DLP, the performs relation encodes these notions.</rdfs:comment>
    <owl:equivalentClass>
        <owl:Class>
            <owl:intersectionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&d;endurant"/>
                <owl:Class>
                    <owl:unionOf rdf:parseType="Collection">
                        <owl:Class rdf:about="&b;agentive-physical-object"/>
                        <owl:Class rdf:about="&b;agentive-social-object"/>
                    </owl:unionOf>
                </owl:Class>
            </owl:intersectionOf>
        </owl:Class>
    </owl:equivalentClass>
</owl:Class>

<owl:Class rdf:about="&b;agent-driven-role">
    <rdfs:comment rdf:datatype="&xsd;string">AKA Agentive-role.A role that can only be played by agents.</rdfs:comment>
    <owl:equivalentClass>
        <owl:Class>
            <owl:intersectionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&b;role"/>
                <owl:Restriction>
                    <owl:onProperty rdf:resource="&b;played-by"/>
                    <owl:allValuesFrom rdf:resource="&b;agent"/>
                </owl:Restriction>
            </owl:intersectionOf>
        </owl:Class>
    </owl:equivalentClass>
</owl:Class>

<owl:Class rdf:about="&b;agentive-figure">
    <rdfs:comment rdf:datatype="&xsd;string">Agentive figures are those which are assigned (agentive) roles from a society or community; hence, they can act like a physical agent. Typical agentive figures are societies, organizations, and in general all socially constructed persons. Agentive figures are not dependent on roles defined or used in the same descriptions they are defined or used, but they can act because they depute some powers to some of those roles. In other words, a figure classified by some agentive role can play that role because there are other roles in the descriptions that define or use the figure. Those roles classifies endurants that result to act for the figure. For example, an employee acts for an organization that deputes the role (e.g. turner) that classifies the employee. Simply put, a guy working as a turner at FIAT acts for (or on behalf of) FIAT. In complex figures, like organizations or companies, a total agency is possible when an endurant plays a delegate or representative role of the figure. Since figures are social objects, it is conceivable to find agentive figures that act for other agentive figures.</rdfs:comment>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&b;refined-by"/>
            <owl:allValuesFrom rdf:resource="&b;agentive-figure"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <owl:equivalentClass>
        <owl:Class>
            <owl:intersectionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&b;agentive-social-object"/>
                <owl:Class rdf:about="&b;figure"/>
                <owl:Restriction>
                    <owl:onProperty rdf:resource="&b;plays"/>
                    <owl:someValuesFrom rdf:resource="&b;role"/>
                </owl:Restriction>
                <owl:Restriction>
                    <owl:onProperty rdf:resource="&b;hypostasis-of"/>
                    <owl:someValuesFrom rdf:resource="&d;particular"/>
                </owl:Restriction>
                <owl:Restriction>
                    <owl:onProperty rdf:resource="&b;defined-by"/>
                    <owl:someValuesFrom rdf:resource="&b;constitutive-description"/>
                </owl:Restriction>
            </owl:intersectionOf>
        </owl:Class>
    </owl:equivalentClass>
</owl:Class>

<owl:Class rdf:about="&b;agentive-physical-object">
    <rdfs:comment rdf:datatype="&xsd;string">Within Physical objects, a special place have those to which we ascribe generic intentionality (compatibly to Brentano's distinction, the ability to internally represent a description). These are called Agentive, as opposite to Non-agentive. In general, we assume that agentive objects are constituted by non-agentive objects: an organism is constituted by bodily organs, a robot is constituted by some machinery, and so on. Among non-agentive physical objects we have for example houses, bodily organs, pieces of wood, etc. Generic agentivity is defined here in a wide sense as implying representation or conception (to be characterized in a dedicated - but not developed as yet - ontology of mind). A representation or conception only requires intentionality in Brentano's terms (i.e., the ability to represent something to oneself). See also 'rational physical object'.</rdfs:comment>
    <owl:equivalentClass>
        <owl:Class>
            <owl:intersectionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&d;physical-object"/>
                <owl:Class rdf:about="&b;agent"/>
                <owl:Restriction>
                    <owl:onProperty rdf:resource="&b;internally-represents"/>
                    <owl:someValuesFrom rdf:resource="&b;plan"/>
                </owl:Restriction>
            </owl:intersectionOf>
        </owl:Class>
    </owl:equivalentClass>
    <owl:disjointWith rdf:resource="&b;non-agentive-physical-object"/>
</owl:Class>

<owl:Class rdf:about="&b;agentive-social-object">
    <rdfs:comment rdf:datatype="&xsd;string">A social object that is assumed to internally represent a plan. Since social objects are dependent on physical ones, it is not trivial to interpret the local sense in which a social object 'internally represents' a plan. For example, an institution can have the plan to promote or regulate some activities, but this is possible by means of the powers conferred to it by some legal system, through its representatives, and that plan has to be executed by means of the physical agents that 'act for' the institution.</rdfs:comment>
    <owl:equivalentClass>
        <owl:Class>
            <owl:intersectionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&b;agent"/>
                <owl:Class rdf:about="&b;social-object"/>
                <owl:Restriction>
                    <owl:onProperty rdf:resource="&b;internally-represents"/>
                    <owl:someValuesFrom rdf:resource="&b;plan"/>
                </owl:Restriction>
            </owl:intersectionOf>
        </owl:Class>
    </owl:equivalentClass>
    <owl:disjointWith rdf:resource="&b;non-agentive-social-object"/>
</owl:Class>

<owl:Class rdf:about="&b;cognitive-event">
    <rdfs:comment rdf:datatype="&xsd;string">An event occurring in the (embodied) mind.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&d;event"/>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;total-constant-participant"/>
            <owl:someValuesFrom rdf:resource="&b;agentive-physical-object"/>
        </owl:Restriction>
    </rdfs:subClassOf>
</owl:Class>

<owl:Class rdf:about="&b;cognitive-modal-description">
    <rdfs:comment rdf:datatype="&xsd;string">The modal descriptions depending on some mental attitude, represented here by means of a relation between roles and tasks.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&b;modal-description"/>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&b;d-uses"/>
            <owl:someValuesFrom rdf:resource="&b;task"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&b;d-uses"/>
            <owl:someValuesFrom>
                <owl:Class>
                    <owl:intersectionOf rdf:parseType="Collection">
                        <owl:Class rdf:about="&b;role"/>
                        <owl:Restriction>
                            <owl:onProperty rdf:resource="&b;attitude-towards"/>
                            <owl:someValuesFrom rdf:resource="&b;task"/>
                        </owl:Restriction>
                    </owl:intersectionOf>
                </owl:Class>
            </owl:someValuesFrom>
        </owl:Restriction>
    </rdfs:subClassOf>
</owl:Class>

<owl:Class rdf:about="&b;cognitive-state">
    <rdfs:comment rdf:datatype="&xsd;string">A state of the (embodied) mind</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&d;state"/>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;total-constant-participant"/>
            <owl:someValuesFrom rdf:resource="&b;agentive-physical-object"/>
        </owl:Restriction>
    </rdfs:subClassOf>
</owl:Class>

<owl:Class rdf:about="&b;collection">
    <rdfs:comment rdf:datatype="&xsd;string">Collections are social objects which, although not defined by a description, depend both on member entities and on some concepts or figures, hence indirectly on descriptions. While we could talk in general of collections of any kind of entities (events, objects, abstracts, etc.), we restrict here our attention to collections of endurants, and to the concepts that classify them (i.e. roles).</rdfs:comment>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;part"/>
            <owl:allValuesFrom rdf:resource="&b;collection"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&b;refined-by"/>
            <owl:allValuesFrom rdf:resource="&b;collection"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&b;specialized-by"/>
            <owl:allValuesFrom rdf:resource="&b;collection"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&b;unified-by"/>
            <owl:someValuesFrom rdf:resource="&b;description"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <owl:equivalentClass>
        <owl:Class>
            <owl:intersectionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&b;non-agentive-social-object"/>
                <owl:Restriction>
                    <owl:onProperty rdf:resource="&b;covered-by"/>
                    <owl:someValuesFrom rdf:resource="&b;role"/>
                </owl:Restriction>
            </owl:intersectionOf>
        </owl:Class>
    </owl:equivalentClass>
    <owl:disjointWith rdf:resource="&b;concept"/>
    <owl:disjointWith rdf:resource="&b;description"/>
    <owl:disjointWith rdf:resource="&b;figure"/>
    <owl:disjointWith rdf:resource="&b;information-object"/>
    <owl:disjointWith rdf:resource="&b;non-agentive-figure"/>
    <owl:disjointWith rdf:resource="&b;situation"/>
</owl:Class>

<owl:Class rdf:about="&b;collective">
    <rdfs:comment rdf:datatype="&xsd;string">A collection with only agents as members.</rdfs:comment>
    <owl:equivalentClass>
        <owl:Class>
            <owl:intersectionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&b;collection"/>
                <owl:Restriction>
                    <owl:onProperty rdf:resource="&b;member"/>
                    <owl:allValuesFrom rdf:resource="&b;agent"/>
                </owl:Restriction>
            </owl:intersectionOf>
        </owl:Class>
    </owl:equivalentClass>
</owl:Class>

<owl:Class rdf:about="&b;communication-event">
    <rdfs:comment rdf:datatype="&xsd;string">Here communication is taken in a rather wide sense, being possible as an (intentional) activity as well as a phenomenon.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&d;accomplishment"/>
</owl:Class>

<owl:Class rdf:about="&b;concept">
    <rdfs:comment rdf:datatype="&xsd;string">AKA C-Description. A non-physical object that is defined by a description s, and whose function is classifying entities from a ground ontology in order to build situations that can satisfy s.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&b;non-agentive-social-object"/>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;part"/>
            <owl:allValuesFrom rdf:resource="&b;concept"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&b;refined-by"/>
            <owl:allValuesFrom rdf:resource="&b;concept"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&b;specialized-by"/>
            <owl:allValuesFrom rdf:resource="&b;concept"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&b;defined-by"/>
            <owl:someValuesFrom rdf:resource="&b;description"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <owl:disjointWith rdf:resource="&b;description"/>
    <owl:disjointWith rdf:resource="&b;information-object"/>
    <owl:disjointWith rdf:resource="&b;non-agentive-figure"/>
    <owl:disjointWith rdf:resource="&b;situation"/>
</owl:Class>

<owl:Class rdf:about="&b;constitutive-description">
    <rdfs:comment rdf:datatype="&xsd;string">A description whose purpose is defining a figure.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&b;description"/>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&b;defines"/>
            <owl:someValuesFrom>
                <owl:Class>
                    <owl:unionOf rdf:parseType="Collection">
                        <owl:Class rdf:about="&b;role"/>
                        <owl:Class rdf:about="&b;figure"/>
                    </owl:unionOf>
                </owl:Class>
            </owl:someValuesFrom>
        </owl:Restriction>
    </rdfs:subClassOf>
</owl:Class>

<owl:Class rdf:about="&b;course">
    <rdfs:comment rdf:datatype="&xsd;string">A concept that classifies (in particular, it 'sequences') perdurants (processes, events, or states), as a component of some description. Courses are the descriptive counterpart of perdurants, and, since perdurants have endurants as participants, they are usually the function of some role.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&b;concept"/>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;part"/>
            <owl:allValuesFrom rdf:resource="&b;course"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&b;defined-by"/>
            <owl:someValuesFrom rdf:resource="&b;description"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&b;specialized-by"/>
            <owl:someValuesFrom rdf:resource="&b;course"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <owl:disjointWith rdf:resource="&b;parameter"/>
    <owl:disjointWith rdf:resource="&b;role"/>
</owl:Class>

<owl:Class rdf:about="&b;description">
    <rdfs:comment rdf:datatype="&xsd;string">A description is a social object which represents a conceptualization (e.g. a mental object or state), hence it is generically dependent on some agent and communicable. Descriptions define or use concepts or figures, are expressed by an information object and can be satisfied by situations. The typology of descriptions is still preliminary.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&b;non-agentive-social-object"/>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&b;refined-by"/>
            <owl:allValuesFrom rdf:resource="&b;description"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&b;specialized-by"/>
            <owl:allValuesFrom rdf:resource="&b;description"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&b;d-uses"/>
            <owl:someValuesFrom>
                <owl:Class>
                    <owl:unionOf rdf:parseType="Collection">
                        <owl:Class rdf:about="&b;concept"/>
                        <owl:Class rdf:about="&b;figure"/>
                    </owl:unionOf>
                </owl:Class>
            </owl:someValuesFrom>
        </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&b;expressed-by"/>
            <owl:someValuesFrom rdf:resource="&b;information-object"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&b;internally-represented-in"/>
            <owl:someValuesFrom rdf:resource="&b;agentive-physical-object"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <owl:disjointWith rdf:resource="&b;information-object"/>
    <owl:disjointWith rdf:resource="&b;non-agentive-figure"/>
    <owl:disjointWith rdf:resource="&b;situation"/>
</owl:Class>

<owl:Class rdf:about="&b;description-role">
    <rdfs:comment rdf:datatype="&xsd;string">A role played by descriptions only. Usable for metalinguistic notions, like those that deal with granular partitions of knowledge, strata of reality, argumentation, etc.</rdfs:comment>
    <owl:equivalentClass>
        <owl:Class>
            <owl:intersectionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&b;role"/>
                <owl:Restriction>
                    <owl:onProperty rdf:resource="&b;played-by"/>
                    <owl:allValuesFrom rdf:resource="&b;description"/>
                </owl:Restriction>
            </owl:intersectionOf>
        </owl:Class>
    </owl:equivalentClass>
</owl:Class>

<owl:Class rdf:about="&b;desire">
    <rdfs:comment rdf:datatype="&xsd;string">Desires are characterized here as modal description dependent on the cognitive (or 'mental') states of an agent. It is difficult to say more than that without reusing an ontology of cognitive states.Informally: a desire is a description that involves some (possible or actual) 'desire towards' attitude by an agent, and is ultimately motivated by evolutionary features of an organism (or by built-in features if the agent is artificial), which are (or used to be) an advantage for it.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&b;cognitive-modal-description"/>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&b;internally-represented-in"/>
            <owl:someValuesFrom rdf:resource="&b;agent"/>
        </owl:Restriction>
    </rdfs:subClassOf>
</owl:Class>

<owl:Class rdf:about="&b;figure">
    <rdfs:comment rdf:datatype="&xsd;string">a.k.a. 'social individual'. Figures are social objects defined or used by descriptions, but differently from concepts, they do not classify entities. Examples of figures are organizations, political-geographic objects, sacred symbols, etc.</rdfs:comment>
    <owl:equivalentClass>
        <owl:Class>
            <owl:intersectionOf rdf:parseType="Collection">
                <owl:Class>
                    <owl:unionOf rdf:parseType="Collection">
                        <owl:Class rdf:about="&b;non-agentive-figure"/>
                        <owl:Class rdf:about="&b;agentive-figure"/>
                    </owl:unionOf>
                </owl:Class>
                <owl:Class rdf:about="&b;social-object"/>
            </owl:intersectionOf>
        </owl:Class>
    </owl:equivalentClass>
    <owl:disjointWith rdf:resource="&b;information-object"/>
    <owl:disjointWith rdf:resource="&b;situation"/>
</owl:Class>

<owl:Class rdf:about="&b;flux">
    <rdfs:comment rdf:datatype="&xsd;string">Fluxes are processes that (also) contain accomplishments as constituents. In other words, fluxes emerge out of accomplishments.</rdfs:comment>
    <owl:equivalentClass>
        <owl:Class>
            <owl:intersectionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&d;process"/>
                <owl:Restriction>
                    <owl:onProperty rdf:resource="&d;specific-constant-constituent"/>
                    <owl:someValuesFrom rdf:resource="&d;accomplishment"/>
                </owl:Restriction>
            </owl:intersectionOf>
        </owl:Class>
    </owl:equivalentClass>
</owl:Class>

<owl:Class rdf:about="&b;gestalt">
    <rdfs:comment rdf:datatype="&xsd;string">A perceptual structure, from the descriptive viewpoint. In other words, this encodes the conditions by which a configuration, structure, or arrangement is perceived as a meaningful whole by a perceiving agent.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&b;theory"/>
</owl:Class>

<owl:Class rdf:about="&b;goal">
    <rdfs:comment rdf:datatype="&xsd;string">We are proposing here a restrictive notion of goal that relies upon its desirability by some agent, which does not necessarily play a role in the execution of the plan the goal is a part of. For example, an agent can have an attitude towards some task defined in a plan, e.g. duty towards, which is different from desiring it (desire towards). We might say that a goal is usually desired by the creator or beneficiary of a plan. The minimal constraint for a goal is that it is a proper part of a plan.For example, a desire to start a relationship can become a goal if someone takes action (or lets someone else take it for her sake) to obtain it.</rdfs:comment>
    <owl:equivalentClass>
        <owl:Class>
            <owl:intersectionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&b;desire"/>
                <owl:Restriction>
                    <owl:onProperty rdf:resource="&d;proper-part-of"/>
                    <owl:someValuesFrom rdf:resource="&b;method"/>
                </owl:Restriction>
            </owl:intersectionOf>
        </owl:Class>
    </owl:equivalentClass>
</owl:Class>

<owl:Class rdf:about="&b;indicator">
    <rdfs:comment rdf:datatype="&xsd;string">A parameter valued by regions that are used asindicators for some behaviour or event to be checked.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&b;parameter"/>
</owl:Class>

<owl:Class rdf:about="&b;information-encoding-system">
    <rdfs:comment rdf:datatype="&xsd;string">An information encoding system is a description that involves information objects. They can be divided into 1) axiomatic systems, which provide roles and operations to define formal descriptions (e.g. theories), 2) combinatorial systems, which provide roles and operations to create valid information objects (e.g. grammars), 3) classification systems, which are contexts of (ev. ordered) lists of information objects, and 4) informal encoding systems, which provide roles and operations to define informal descriptions (e.g. narratives).</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&b;description"/>
</owl:Class>

<owl:Class rdf:about="&b;information-object">
    <rdfs:comment rdf:datatype="&xsd;string">Information objects are social objects. They are realized by some entity. They are ordered (expressed according to) by some system for information encoding. Consequently, they are dependent from an encoding as well as from a concrete realization.They can express a description (the ontological equivalent of a meaning/conceptualization), can be about any entity, and can be interpreted by an agent.From a communication perspective, an information object can play the role of "message". From a semiotic perspective, it playes the role of "expression".</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&b;non-agentive-social-object"/>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;part"/>
            <owl:allValuesFrom rdf:resource="&b;information-object"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&b;refined-by"/>
            <owl:allValuesFrom rdf:resource="&b;information-object"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&b;ordered-by"/>
            <owl:someValuesFrom rdf:resource="&b;description"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&b;realized-by"/>
            <owl:someValuesFrom rdf:resource="&b;physical-realization"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <owl:disjointWith rdf:resource="&b;non-agentive-figure"/>
    <owl:disjointWith rdf:resource="&b;situation"/>
</owl:Class>

<owl:Class rdf:about="&b;life-cycle">
    <rdfs:comment rdf:datatype="&xsd;string">The course of events typical of the life of an object (kind).</rdfs:comment>
    <owl:equivalentClass>
        <owl:Class>
            <owl:intersectionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&b;course"/>
                <owl:Restriction>
                    <owl:onProperty rdf:resource="&b;sequences"/>
                    <owl:allValuesFrom>
                        <owl:Restriction>
                            <owl:onProperty rdf:resource="&d;life-of"/>
                            <owl:someValuesFrom rdf:resource="&d;endurant"/>
                        </owl:Restriction>
                    </owl:allValuesFrom>
                </owl:Restriction>
            </owl:intersectionOf>
        </owl:Class>
    </owl:equivalentClass>
</owl:Class>

<owl:Class rdf:about="&b;logical-role">
    <rdfs:comment rdf:datatype="&xsd;string">A role used to express logical levels within some layering description or granular partition. A typical example is the Linnean taxonomic ordering, where Phylum or Species are hierarchical roles.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&b;description-role"/>
</owl:Class>

<owl:Class rdf:about="&b;material-artifact">
    <rdfs:comment rdf:datatype="&xsd;string">No easy definition of artifactual properties is possible, hence it is better to rely on alternative descriptions and roles: a physical object that shows or is known to have an artifactual origin that counts in the tasks an ontology is supposed to support, will be a material artifact. On the other hand, physical objects that do not show that origin, or that origin is unimportant for the task of the ontology, will be physical bodies. Formally, a restriction is provided here that requires that the collection whose members are (at least some of the) proper parts of a material artifact is *unified* by a plan or project.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&b;non-agentive-physical-object"/>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;proper-part"/>
            <owl:someValuesFrom>
                <owl:Restriction>
                    <owl:onProperty rdf:resource="&b;member-of"/>
                    <owl:someValuesFrom>
                        <owl:Class>
                            <owl:intersectionOf rdf:parseType="Collection">
                                <owl:Restriction>
                                    <owl:onProperty rdf:resource="&b;unified-by"/>
                                    <owl:someValuesFrom>
                                        <owl:Class>
                                            <owl:unionOf rdf:parseType="Collection">
                                                <owl:Class rdf:about="&b;project"/>
                                                <owl:Class rdf:about="&b;plan"/>
                                            </owl:unionOf>
                                        </owl:Class>
                                    </owl:someValuesFrom>
                                </owl:Restriction>
                                <owl:Class rdf:about="&b;collection"/>
                            </owl:intersectionOf>
                        </owl:Class>
                    </owl:someValuesFrom>
                </owl:Restriction>
            </owl:someValuesFrom>
        </owl:Restriction>
    </rdfs:subClassOf>
</owl:Class>

<owl:Class rdf:about="&b;method">
    <rdfs:comment rdf:datatype="&xsd;string">A description that contains a specification to do, realize, behave, etc. Subclasses are plan, technique, practice, project, etc.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&b;description"/>
</owl:Class>

<owl:Class rdf:about="&b;modal-description">
    <rdfs:comment rdf:datatype="&xsd;string">A modal description is any part of a description that has a unity criterion consisting in the specification of a modal target (some course), and it can be a right, power, duty, etc. Notice that modal descriptions can appear in conventionalized descriptions as well as in idiosyncratic assessements, narratives, promises, etc. From the formal semantic viewpoint, a modal description is the reification of a relation involving a modal logic operator.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&b;description"/>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;part-of"/>
            <owl:someValuesFrom rdf:resource="&b;description"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&b;d-uses"/>
            <owl:someValuesFrom rdf:resource="&b;course"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&b;d-uses"/>
            <owl:someValuesFrom>
                <owl:Class>
                    <owl:intersectionOf rdf:parseType="Collection">
                        <owl:Restriction>
                            <owl:onProperty rdf:resource="&b;modal-target"/>
                            <owl:someValuesFrom rdf:resource="&b;course"/>
                        </owl:Restriction>
                        <owl:Class rdf:about="&b;role"/>
                    </owl:intersectionOf>
                </owl:Class>
            </owl:someValuesFrom>
        </owl:Restriction>
    </rdfs:subClassOf>
</owl:Class>

<owl:Class rdf:about="&b;non-agentive-figure">
    <rdfs:comment rdf:datatype="&xsd;string">A tipology of non-agentive figures is currently under investigation.</rdfs:comment>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&b;refined-by"/>
            <owl:allValuesFrom rdf:resource="&b;non-agentive-figure"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <owl:equivalentClass>
        <owl:Class>
            <owl:intersectionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&b;non-agentive-social-object"/>
                <owl:Class rdf:about="&b;figure"/>
                <owl:Restriction>
                    <owl:onProperty rdf:resource="&b;plays"/>
                    <owl:someValuesFrom rdf:resource="&b;role"/>
                </owl:Restriction>
                <owl:Restriction>
                    <owl:onProperty rdf:resource="&b;defined-by"/>
                    <owl:someValuesFrom rdf:resource="&b;constitutive-description"/>
                </owl:Restriction>
                <owl:Restriction>
                    <owl:onProperty rdf:resource="&b;hypostasis-of"/>
                    <owl:someValuesFrom rdf:resource="&d;particular"/>
                </owl:Restriction>
            </owl:intersectionOf>
        </owl:Class>
    </owl:equivalentClass>
    <owl:disjointWith rdf:resource="&b;situation"/>
</owl:Class>

<owl:Class rdf:about="&b;non-agentive-physical-object">
    <rdfs:comment rdf:datatype="&xsd;string">Within Physical objects, a special place have those to which we ascribe intentions, beliefs, and desires. These are called Agentive, as opposite to Non-agentive. Intentionality is understood here as the capability of heading for/dealing with objects or states of the world. This is an important area of ontological investigation we haven't properly explored yet, so our suggestions are really very preliminary. A possible modelling of case roles has been started within the descriptions plugin that could be embedded within basic DOLCE. In general, we assume that agentive objects are constituted by non-agentive objects: an organism is constituted by bodily organs, a robot is constituted by some machinery, and so on. Among non-agentive physical objects we have for example houses, body organs, pieces of wood, etc.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&d;physical-object"/>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&b;internally-represents"/>
            <owl:cardinality rdf:datatype="&xsd;nonNegativeInteger">0</owl:cardinality>
        </owl:Restriction>
    </rdfs:subClassOf>
</owl:Class>

<owl:Class rdf:about="&b;non-agentive-social-object">
    <rdfs:comment rdf:datatype="&xsd;string">A social object that is not assumed to internally represent a description. Since social objects are dependent on physical ones, it is not trivial to interpret the local sense in which a social object 'internally represents' a plan. See 'agentive-social-object' for some discussion.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&b;social-object"/>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&b;internally-represents"/>
            <owl:cardinality rdf:datatype="&xsd;nonNegativeInteger">0</owl:cardinality>
        </owl:Restriction>
    </rdfs:subClassOf>
</owl:Class>

<owl:Class rdf:about="&b;parameter">
    <rdfs:comment rdf:datatype="&xsd;string">A concept that classifies (in particular, it is 'valued by') regions, as defined by some description. Parameters are the descriptive counterpart of regions, and, as regions represent the qualities of perdurants or endurants, they can be requisites for some role or course.A parameter has at least one region that is a value for it.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&b;concept"/>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&b;specialized-by"/>
            <owl:allValuesFrom rdf:resource="&b;parameter"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&b;defined-by"/>
            <owl:someValuesFrom rdf:resource="&b;description"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&b;valued-by"/>
            <owl:someValuesFrom rdf:resource="&d;region"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <owl:disjointWith rdf:resource="&b;role"/>
</owl:Class>

<owl:Class rdf:about="&b;path">
    <rdfs:comment rdf:datatype="&xsd;string">A course used to sequence phenomena (non-intentional processes).</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&b;course"/>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&b;sequences"/>
            <owl:someValuesFrom rdf:resource="&b;phenomenon"/>
        </owl:Restriction>
    </rdfs:subClassOf>
</owl:Class>

<owl:Class rdf:about="&b;phenomenon">
    <rdfs:comment rdf:datatype="&xsd;string">A phenomenon is basically a process that does not include any intentional active participation. Therefore, it cannot be sequenced by a task.It can be seen as an accomplishment when some intentionality puts boundaries on it (although it is not claimed to be inherently intentional). On the other hand, a purely physical phenomenon does not seem to have inherent boundaries either ... and also for biological processes as well as economic processes this seems to be disputable. If the boundary hypothesis is discarded, phenomenon should migrate under process.</rdfs:comment>
    <owl:equivalentClass>
        <owl:Class>
            <owl:intersectionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&d;accomplishment"/>
                <owl:Restriction>
                    <owl:onProperty rdf:resource="&d;specifically-constantly-dependent-on"/>
                    <owl:allValuesFrom>
                        <owl:Class>
                            <owl:complementOf>
                                <owl:Class rdf:about="&b;cognitive-state"/>
                            </owl:complementOf>
                        </owl:Class>
                    </owl:allValuesFrom>
                </owl:Restriction>
                <owl:Restriction>
                    <owl:onProperty rdf:resource="&b;sequenced-by"/>
                    <owl:allValuesFrom>
                        <owl:Class>
                            <owl:complementOf>
                                <owl:Class rdf:about="&b;task"/>
                            </owl:complementOf>
                        </owl:Class>
                    </owl:allValuesFrom>
                </owl:Restriction>
            </owl:intersectionOf>
        </owl:Class>
    </owl:equivalentClass>
</owl:Class>

<owl:Class rdf:about="&b;physical-phenomenon">
    <rdfs:comment rdf:datatype="&xsd;string">A phenomenon having a physical endurant as participant.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&b;phenomenon"/>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;participant"/>
            <owl:someValuesFrom rdf:resource="&d;physical-endurant"/>
        </owl:Restriction>
    </rdfs:subClassOf>
</owl:Class>

<owl:Class rdf:about="&b;physical-realization">
    <rdfs:comment rdf:datatype="&xsd;string">Any physical particular that realizes a non-physical endurant. Such physical particulars can be either physical endurants, physical qualities, physical regions, perdurants with at least one physical participant, or a situation with one physical entity in its setting.Ultimately, a physical realization depends on at least one physical endurant (each of the others physical entity types depend on a physical endurant to be considered as such).</rdfs:comment>
    <owl:equivalentClass>
        <owl:Class>
            <owl:intersectionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&d;spatio-temporal-particular"/>
                <owl:Class>
                    <owl:unionOf rdf:parseType="Collection">
                        <owl:Class rdf:about="&d;physical-endurant"/>
                        <owl:Class rdf:about="&d;physical-quality"/>
                        <owl:Class>
                            <owl:intersectionOf rdf:parseType="Collection">
                                <owl:Restriction>
                                    <owl:onProperty rdf:resource="&d;participant"/>
                                    <owl:someValuesFrom rdf:resource="&d;physical-endurant"/>
                                </owl:Restriction>
                                <owl:Class rdf:about="&d;perdurant"/>
                            </owl:intersectionOf>
                        </owl:Class>
                        <owl:Class>
                            <owl:intersectionOf rdf:parseType="Collection">
                                <owl:Restriction>
                                    <owl:onProperty rdf:resource="&b;setting-for"/>
                                    <owl:someValuesFrom>
                                        <owl:Class>
                                            <owl:unionOf rdf:parseType="Collection">
                                                <owl:Class rdf:about="&d;physical-endurant"/>
                                                <owl:Class rdf:about="&d;physical-quality"/>
                                                <owl:Restriction>
                                                    <owl:onProperty rdf:resource="&d;participant"/>
                                                    <owl:someValuesFrom rdf:resource="&d;physical-endurant"/>
                                                </owl:Restriction>
                                            </owl:unionOf>
                                        </owl:Class>
                                    </owl:someValuesFrom>
                                </owl:Restriction>
                                <owl:Class rdf:about="&b;situation"/>
                            </owl:intersectionOf>
                        </owl:Class>
                    </owl:unionOf>
                </owl:Class>
                <owl:Restriction>
                    <owl:onProperty rdf:resource="&b;realizes"/>
                    <owl:someValuesFrom rdf:resource="&d;non-physical-object"/>
                </owl:Restriction>
            </owl:intersectionOf>
        </owl:Class>
    </owl:equivalentClass>
</owl:Class>

<owl:Class rdf:about="&b;plan">
    <rdfs:comment rdf:datatype="&xsd;string">A plan is a method for executing or performing a procedure or a stage of a procedure.A plan must use both at least one role played by an agent, and at least one task.Finally, a plan has a goal as proper part, and can also have regulations and other descriptions as proper parts.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&b;method"/>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;proper-part"/>
            <owl:someValuesFrom rdf:resource="&b;goal"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&b;d-uses"/>
            <owl:someValuesFrom rdf:resource="&b;role"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&b;d-uses"/>
            <owl:someValuesFrom rdf:resource="&b;task"/>
        </owl:Restriction>
    </rdfs:subClassOf>
</owl:Class>

<owl:Class rdf:about="&b;practice">
    <rdfs:comment rdf:datatype="&xsd;string">A social method carried out explicitly or by tradition, spontaneously emerged, or moderately or strongly regulated.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&b;method"/>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&b;internally-represented-in"/>
            <owl:someValuesFrom rdf:resource="&b;agentive-social-object"/>
        </owl:Restriction>
    </rdfs:subClassOf>
</owl:Class>

<owl:Class rdf:about="&b;project">
    <rdfs:comment rdf:datatype="&xsd;string">A project is a proactively satisfied method. Differently from a plan, a project includes at least one 'product' role to be played by some endurant (e.g. a house), or one 'result' role played by a perdurant with a definite participant (e.g. a restored state of a house).</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&b;method"/>
</owl:Class>

<owl:Class rdf:about="&b;rational-agent">
    <rdfs:comment rdf:datatype="&xsd;string">Either a rational physical object (e.g. an animal capable of meta-representations), or a social object acted by a rational physical object (e.g. an organization).</rdfs:comment>
    <owl:equivalentClass>
        <owl:Class>
            <owl:intersectionOf rdf:parseType="Collection">
                <owl:Class>
                    <owl:unionOf rdf:parseType="Collection">
                        <owl:Class rdf:about="&b;rational-physical-object"/>
                        <owl:Class>
                            <owl:intersectionOf rdf:parseType="Collection">
                                <owl:Restriction>
                                    <owl:onProperty rdf:resource="&b;acted-by"/>
                                    <owl:someValuesFrom rdf:resource="&b;rational-physical-object"/>
                                </owl:Restriction>
                                <owl:Class rdf:about="&b;agentive-social-object"/>
                            </owl:intersectionOf>
                        </owl:Class>
                    </owl:unionOf>
                </owl:Class>
                <owl:Class rdf:about="&b;agent"/>
            </owl:intersectionOf>
        </owl:Class>
    </owl:equivalentClass>
</owl:Class>

<owl:Class rdf:about="&b;rational-physical-object">
    <rdfs:comment rdf:datatype="&xsd;string">In this ontology, a rational object is encoded as having the ability to internally represent meta-descriptions (descriptions that have other descriptions playing roles used by them). Other theories of rational agency assume desires and intentions for these objects, but in principle any agent can have desires and intentions: the very difference seems to be the ability to choose among different desires or intentions by going 'meta-level'.</rdfs:comment>
    <owl:equivalentClass>
        <owl:Class>
            <owl:intersectionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&b;agentive-physical-object"/>
                <owl:Class rdf:about="&b;rational-agent"/>
                <owl:Restriction>
                    <owl:onProperty rdf:resource="&b;internally-represents"/>
                    <owl:someValuesFrom>
                        <owl:Class>
                            <owl:intersectionOf rdf:parseType="Collection">
                                <owl:Class rdf:about="&b;description"/>
                                <owl:Restriction>
                                    <owl:onProperty rdf:resource="&b;involves"/>
                                    <owl:someValuesFrom rdf:resource="&b;description"/>
                                </owl:Restriction>
                            </owl:intersectionOf>
                        </owl:Class>
                    </owl:someValuesFrom>
                </owl:Restriction>
            </owl:intersectionOf>
        </owl:Class>
    </owl:equivalentClass>
</owl:Class>

<owl:Class rdf:about="&b;reconstructed-flux">
    <rdfs:comment rdf:datatype="&xsd;string">Reconstructed fluxes are fluxes that only contain accomplishments as members.</rdfs:comment>
    <owl:equivalentClass>
        <owl:Class>
            <owl:intersectionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&b;flux"/>
                <owl:Restriction>
                    <owl:onProperty rdf:resource="&d;part"/>
                    <owl:allValuesFrom rdf:resource="&d;accomplishment"/>
                </owl:Restriction>
            </owl:intersectionOf>
        </owl:Class>
    </owl:equivalentClass>
</owl:Class>

<owl:Class rdf:about="&b;regulation">
    <rdfs:comment rdf:datatype="&xsd;string">A description usually requiring a C-SAT satisfaction for a situation. Norms, codes of practice, etc. are examples.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&b;social-description"/>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;proper-part"/>
            <owl:someValuesFrom rdf:resource="&b;cognitive-modal-description"/>
        </owl:Restriction>
    </rdfs:subClassOf>
</owl:Class>

<owl:Class rdf:about="&b;relation">
    <rdfs:comment rdf:datatype="&xsd;string">A non-social relation(ship): formal, linguistic, etc. It is considered here a theory, because relations are established in order to give an ordering to some reality.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&b;theory"/>
</owl:Class>

<owl:Class rdf:about="&b;role">
    <rdfs:comment rdf:datatype="&xsd;string">Also known as 'functional role'.A concept that classifies (in particular, it is 'played by') endurants, as used in some description. Roles are the descriptive counterpart of endurants, and, as endurants participate in perdurants, they usually have courses as modal targets (see).The typology of roles is still preliminary.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&b;concept"/>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&b;specialized-by"/>
            <owl:allValuesFrom rdf:resource="&b;role"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&b;defined-by"/>
            <owl:someValuesFrom rdf:resource="&b;description"/>
        </owl:Restriction>
    </rdfs:subClassOf>
</owl:Class>

<owl:Class rdf:about="&b;situation">
    <rdfs:comment rdf:datatype="&xsd;string">A situation is a social object that appears in the domain of an ontology only because there is a description whose components can 'carve up' a view (setting) on that domain. A situation has to satisfy a description (see below for ways of defining the satisfies relation), and it has to be setting for at least one entity.In other words, it is the ontological counterpart (with due local differences or restrictions) of settings (situations from SC, contexts, episodes, states of affairs, structures, configurations, cases, etc.).A perdurant is usually the only mandatory constituent of a setting.Two descriptions of a same situation are possible, otherwise we would result in a solipsistic ontology. The time and space (and possibly other qualities) of a situation are the time and space of the perdurants in the setting.</rdfs:comment>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;part"/>
            <owl:allValuesFrom rdf:resource="&b;situation"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&b;refined-by"/>
            <owl:allValuesFrom rdf:resource="&b;situation"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <owl:equivalentClass>
        <owl:Class>
            <owl:intersectionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&b;non-agentive-social-object"/>
                <owl:Restriction>
                    <owl:onProperty rdf:resource="&b;setting-for"/>
                    <owl:someValuesFrom rdf:resource="&d;particular"/>
                </owl:Restriction>
                <owl:Restriction>
                    <owl:onProperty rdf:resource="&b;satisfies"/>
                    <owl:someValuesFrom rdf:resource="&b;description"/>
                </owl:Restriction>
            </owl:intersectionOf>
        </owl:Class>
    </owl:equivalentClass>
</owl:Class>

<owl:Class rdf:about="&b;social-description">
    <rdfs:comment rdf:datatype="&xsd;string">Examples of Social Descriptions are laws, norms, shares, peace treaties, etc., which are generically dependent on societies.Social descriptions are dependent on a community of agents.</rdfs:comment>
    <owl:equivalentClass>
        <owl:Class>
            <owl:intersectionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&b;description"/>
                <owl:Restriction>
                    <owl:onProperty rdf:resource="&d;generically-dependent-on"/>
                    <owl:someValuesFrom rdf:resource="&b;collective"/>
                </owl:Restriction>
            </owl:intersectionOf>
        </owl:Class>
    </owl:equivalentClass>
</owl:Class>

<owl:Class rdf:about="&b;social-object">
    <rdfs:comment rdf:datatype="&xsd;string">A catch-all class for entities from the social world. It includes agentive and non-agentive socially-constructed objects: descriptions, concepts, figures, collections, information objects. It could be equivalent to 'non-physical object', but we leave the possibility open of 'private' non-physical objects.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&d;non-physical-object"/>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;generically-dependent-on"/>
            <owl:someValuesFrom rdf:resource="&b;communication-event"/>
        </owl:Restriction>
    </rdfs:subClassOf>
</owl:Class>

<owl:Class rdf:about="&b;social-relationship">
    <rdfs:comment rdf:datatype="&xsd;string">A social description defining roles for the interaction of rational agents.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&b;social-description"/>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&b;involves"/>
            <owl:someValuesFrom rdf:resource="&b;rational-agent"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&b;involves"/>
            <owl:minCardinality rdf:datatype="&xsd;nonNegativeInteger">2</owl:minCardinality>
        </owl:Restriction>
    </rdfs:subClassOf>
</owl:Class>

<owl:Class rdf:about="&b;social-role">
    <rdfs:comment rdf:datatype="&xsd;string">A role created and maintained by a society.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&b;role"/>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&d;generically-dependent-on"/>
            <owl:someValuesFrom rdf:resource="&b;collective"/>
        </owl:Restriction>
    </rdfs:subClassOf>
</owl:Class>

<owl:Class rdf:about="&b;status">
    <rdfs:comment rdf:datatype="&xsd;string">A role that involves responsibility, e.g. both duties and rights, in order to perform some task. It usually involves additional rights and/or powers in contexts (descriptions) different from the one that defines the status.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&b;agent-driven-role"/>
    <rdfs:subClassOf rdf:resource="&b;social-role"/>
</owl:Class>

<owl:Class rdf:about="&b;symmetric-role">
    <rdfs:comment rdf:datatype="&xsd;string">A role played exactly by two objects at the same time, e.g.: brother, sibling.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&b;role"/>
</owl:Class>

<owl:Class rdf:about="&b;task">
    <rdfs:comment rdf:datatype="&xsd;string">A course used to sequence activities or other controllable perdurants (some states, processes), usually within methods. They must be defined by a method, but can be *used* by other kinds of descriptions. They are desire targets of some role played by an agent. Tasks can be complex, and ordered according to an abstract succession relation. Tasks can relate to ground activities or decision making; the last kind deals with typical flowchart content. A task is different both from a flowchart node, and from an action or action type.Tasks can be considered shortcuts for plans, since at least one role played by an agent has a desire attitude towards them (possibly different from the one that puts the task into action). In principle, tasks could be transformed into explicit plans.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&b;course"/>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&b;defined-by"/>
            <owl:someValuesFrom rdf:resource="&b;method"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&b;specialized-by"/>
            <owl:someValuesFrom rdf:resource="&b;task"/>
        </owl:Restriction>
    </rdfs:subClassOf>
</owl:Class>

<owl:Class rdf:about="&b;technique">
    <rdfs:comment rdf:datatype="&xsd;string">A technique is a practical method to obtain some modification in the environment (or evaluation of an environment) that fulfils some task.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&b;method"/>
</owl:Class>

<owl:Class rdf:about="&b;theory">
    <rdfs:comment rdf:datatype="&xsd;string">This is used in a wide cultural sense: a theory about something, expressed in a rather systematic way, but not necessarily public (although communicable in principle). An axiomatic theory is not a theory in this sense, although we can expect an axiomatic theory to be the formal representation of a generic theory.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&b;description"/>
</owl:Class>

<owl:Class rdf:about="&g;mental-object">
    <rdfs:comment rdf:datatype="&xsd;string">AKA "internal description". Mental objects are dependent on agents which are assumed to be intentional (in the wider sense of conceiving some description). This class is just a pointer to a complex ontology of mental entities that is currently under development.</rdfs:comment>
    <owl:equivalentClass>
        <owl:Class>
            <owl:intersectionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&d;non-physical-object"/>
                <owl:Restriction>
                    <owl:onProperty rdf:resource="&d;specifically-constantly-dependent-on"/>
                    <owl:someValuesFrom rdf:resource="&b;agentive-physical-object"/>
                </owl:Restriction>
            </owl:intersectionOf>
        </owl:Class>
    </owl:equivalentClass>
</owl:Class>

<owl:Class rdf:about="&e;commitment">
    <rdfs:comment rdf:datatype="&xsd;string">A commitment is a cognitive modal description, characterized by certain obligations and rights targeted by at least one of its roles.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&b;cognitive-modal-description"/>
</owl:Class>

<owl:Class rdf:about="&e;promise">
    <rdfs:comment rdf:datatype="&xsd;string">A commitment in which an obligation to some future result is expressed.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&e;commitment"/>
</owl:Class>

<owl:Class rdf:about="&e;responsibility">
    <rdfs:comment rdf:datatype="&xsd;string">Responsibility is preliminarily described here as a commitment that includes a status, which has some rights and duties towards some task (see related axioms).</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&e;commitment"/>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&b;d-uses"/>
            <owl:someValuesFrom rdf:resource="&b;status"/>
        </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="&b;d-uses"/>
            <owl:someValuesFrom rdf:resource="&b;task"/>
        </owl:Restriction>
    </rdfs:subClassOf>
</owl:Class>

<owl:DatatypeProperty rdf:about="&a;counted-by">
    <rdfs:comment rdf:datatype="&xsd;string">A relation to compose a quality space with a numeric ordering at the symbol level. In practice, it enables to associate an instance of a numeric data type (currently float data types have been chosen) to a region.</rdfs:comment>
    <rdfs:domain rdf:resource="&d;region"/>
    <rdfs:range rdf:resource="&xsd;decimal"/>
</owl:DatatypeProperty>

<owl:DatatypeProperty rdf:about="&a;has-informal-description">
    <rdfs:comment rdf:datatype="&xsd;string">Similar to a generic annotation property. To be used when annotations can be incompatible with an ontology project.</rdfs:comment>
    <rdfs:domain rdf:resource="&d;particular"/>
    <rdfs:range rdf:resource="&xsd;string"/>
</owl:DatatypeProperty>

<owl:ObjectProperty rdf:about="&a;duration">
    <rdfs:comment rdf:datatype="&xsd;string">The time interval of duration of a perdurant.</rdfs:comment>
    <owl:inverseOf rdf:resource="&a;duration-of"/>
    <rdfs:subPropertyOf rdf:resource="&f;temporal-location"/>
    <rdfs:domain rdf:resource="&d;perdurant"/>
    <rdfs:range rdf:resource="&d;time-interval"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&a;duration-of">
    <owl:inverseOf rdf:resource="&a;duration"/>
    <rdfs:subPropertyOf rdf:resource="&f;temporal-location-of"/>
    <rdfs:domain rdf:resource="&d;time-interval"/>
    <rdfs:range rdf:resource="&d;perdurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&a;geographic-part">
    <rdf:type rdf:resource="&owl;TransitiveProperty"/>
    <owl:inverseOf rdf:resource="&a;geographic-part-of"/>
    <rdfs:subPropertyOf rdf:resource="&d;proper-part"/>
    <rdfs:domain rdf:resource="&a;political-geographic-object"/>
    <rdfs:range rdf:resource="&a;political-geographic-object"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&a;geographic-part-of">
    <rdfs:comment rdf:datatype="&xsd;string"><![CDATA[The transitive proper part relation between political (non-physical) 
    geographic objects. It is a primitive proper-part, and not a composed 
    relation through the physical depend-ons of political places, since 
    geographical parts can be dependent on disconnected physical places.]]></rdfs:comment>
    <rdf:type rdf:resource="&owl;TransitiveProperty"/>
    <owl:inverseOf rdf:resource="&a;geographic-part"/>
    <rdfs:subPropertyOf rdf:resource="&d;proper-part-of"/>
    <rdfs:domain rdf:resource="&a;political-geographic-object"/>
    <rdfs:range rdf:resource="&a;political-geographic-object"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&a;happens-at">
    <rdfs:comment rdf:datatype="&xsd;string">Perdurant presence (happening) is axiomatized as  being temporally located at a point in one's life.</rdfs:comment>
    <owl:inverseOf rdf:resource="&a;time-of-happening-of"/>
    <rdfs:subPropertyOf rdf:resource="&f;temporal-location"/>
    <rdfs:domain rdf:resource="&d;perdurant"/>
    <rdfs:range rdf:resource="&d;time-interval"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&a;time-of-happening-of">
    <owl:inverseOf rdf:resource="&a;happens-at"/>
    <rdfs:subPropertyOf rdf:resource="&f;temporal-location-of"/>
    <rdfs:domain rdf:resource="&d;time-interval"/>
    <rdfs:range rdf:resource="&d;perdurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&a;unit">
    <rdfs:comment rdf:datatype="&xsd;string">A relation for composing regions by means of a reference metrics. One of them (the measurement unit) should be explicitly used to represent a measurement space.</rdfs:comment>
    <owl:inverseOf rdf:resource="&a;unit-of"/>
    <rdfs:subPropertyOf rdf:resource="&d;r-location"/>
    <rdfs:domain rdf:resource="&d;region"/>
    <rdfs:range rdf:resource="&a;measurement-unit"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&a;unit-of">
    <owl:inverseOf rdf:resource="&a;unit"/>
    <rdfs:subPropertyOf rdf:resource="&d;r-location-of"/>
    <rdfs:domain rdf:resource="&a;measurement-unit"/>
    <rdfs:range rdf:resource="&d;region"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;abstract-location">
    <rdfs:comment rdf:datatype="&xsd;string">Analytical location holding between non-physical endurants and abstract regions.</rdfs:comment>
    <owl:inverseOf rdf:resource="&d;abstract-location-of"/>
    <rdfs:subPropertyOf rdf:resource="&d;exact-location"/>
    <rdfs:domain rdf:resource="&d;non-physical-endurant"/>
    <rdfs:range rdf:resource="&d;abstract-region"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;abstract-location-of">
    <owl:inverseOf rdf:resource="&d;abstract-location"/>
    <rdfs:subPropertyOf rdf:resource="&d;exact-location-of"/>
    <rdfs:domain rdf:resource="&d;abstract-region"/>
    <rdfs:range rdf:resource="&d;non-physical-endurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;atomic-part">
    <rdfs:comment rdf:datatype="&xsd;string">The part relation between a particular and an atom.</rdfs:comment>
    <owl:inverseOf rdf:resource="&d;atomic-part-of"/>
    <rdfs:subPropertyOf rdf:resource="&d;part"/>
    <rdfs:domain rdf:resource="&d;particular"/>
    <rdfs:range rdf:resource="&d;particular"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;atomic-part-of">
    <owl:inverseOf rdf:resource="&d;atomic-part"/>
    <rdfs:subPropertyOf rdf:resource="&d;part-of"/>
    <rdfs:domain rdf:resource="&d;particular"/>
    <rdfs:range rdf:resource="&d;particular"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;boundary">
    <owl:inverseOf rdf:resource="&d;boundary-of"/>
    <rdfs:subPropertyOf rdf:resource="&d;proper-part"/>
    <rdfs:domain rdf:resource="&d;particular"/>
    <rdfs:range rdf:resource="&d;particular"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;boundary-of">
    <rdfs:comment rdf:datatype="&xsd;string">A boundary here is taken to be a part (mereological treatment). Consequently, in the case of endurants, (reified) boundaries are features.</rdfs:comment>
    <owl:inverseOf rdf:resource="&d;boundary"/>
    <rdfs:subPropertyOf rdf:resource="&d;proper-part-of"/>
    <rdfs:domain rdf:resource="&d;particular"/>
    <rdfs:range rdf:resource="&d;particular"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;constant-participant">
    <rdfs:comment rdf:datatype="&xsd;string">Anytime x is present, x has participant y. In other words, all parts of x have a same participant.Participation can be constant (in all parts of the perdurant, e.g. in 'the car is running'), or temporary (in only some parts, e.g. in 'I'm electing the president').</rdfs:comment>
    <owl:inverseOf rdf:resource="&d;constant-participant-in"/>
    <rdfs:subPropertyOf rdf:resource="&d;participant"/>
    <rdfs:domain rdf:resource="&d;perdurant"/>
    <rdfs:range rdf:resource="&d;endurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;constant-participant-in">
    <owl:inverseOf rdf:resource="&d;constant-participant"/>
    <rdfs:subPropertyOf rdf:resource="&d;participant-in"/>
    <rdfs:domain rdf:resource="&d;endurant"/>
    <rdfs:range rdf:resource="&d;perdurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;exact-location">
    <rdfs:comment rdf:datatype="&xsd;string">A location relation bounded to regions and defined analytically through the composition of inherence and q-location. This is the analytical version of 'generic location'.</rdfs:comment>
    <owl:inverseOf rdf:resource="&d;exact-location-of"/>
    <rdfs:subPropertyOf rdf:resource="&d;generic-location"/>
    <rdfs:domain rdf:resource="&d;particular"/>
    <rdfs:range rdf:resource="&d;region"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;exact-location-of">
    <owl:inverseOf rdf:resource="&d;exact-location"/>
    <rdfs:subPropertyOf rdf:resource="&d;generic-location-of"/>
    <rdfs:domain rdf:resource="&d;region"/>
    <rdfs:range rdf:resource="&d;particular"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;generic-constituent">
    <rdfs:comment rdf:datatype="&xsd;string">'Constituent' should depend on some layering of  the ontology. For example, scientific granularities or ontological 'strata' are  typical layerings. A constituent is a part belonging to a lower layer. Since layering is actually a partition of the ontology, constituents are not properly classified as parts, although this kinship can be intuitive for common sense. Example of specific constant constituents are the entities constituting a setting (a situation), whilethe entities constituting a collection are examples of generic constant constituents.</rdfs:comment>
    <owl:inverseOf rdf:resource="&d;generic-constituent-of"/>
    <rdfs:subPropertyOf rdf:resource="&d;immediate-relation"/>
    <rdfs:domain rdf:resource="&d;particular"/>
    <rdfs:range rdf:resource="&d;particular"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;generic-constituent-of">
    <owl:inverseOf rdf:resource="&d;generic-constituent"/>
    <rdfs:subPropertyOf rdf:resource="&d;immediate-relation-i"/>
    <rdfs:domain rdf:resource="&d;particular"/>
    <rdfs:range rdf:resource="&d;particular"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;generic-dependent">
    <rdfs:comment rdf:datatype="&xsd;string">The dependence on an individual of a given type at some time. This is traditionally a relation between particulars and universals, but this one states that x generically depends on y if a z different from y, but with the same properties, can be equivalently its depend-on.This is a temporally-indexed relation (embedded in this syntax).</rdfs:comment>
    <owl:inverseOf rdf:resource="&d;generically-dependent-on"/>
    <rdfs:subPropertyOf rdf:resource="&d;immediate-relation"/>
    <rdfs:domain rdf:resource="&d;particular"/>
    <rdfs:range rdf:resource="&d;particular"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;generic-location">
    <rdfs:comment rdf:datatype="&xsd;string">The most generic location relation, probably equivalent to more than one image schema in a cognitive system (e.g. containment for exact location, proximity for approximate location).This is meant to reason on generalized, common sense as well as formal locations, including naive localization, between any kinds of entities. Generic location is branched into 'exact' location, ranging on regions, and 'approximate' (naive) location, ranging on non-regions.</rdfs:comment>
    <owl:inverseOf rdf:resource="&d;generic-location-of"/>
    <rdfs:subPropertyOf rdf:resource="&d;mediated-relation"/>
    <rdfs:domain rdf:resource="&d;particular"/>
    <rdfs:range rdf:resource="&d;particular"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;generic-location-of">
    <owl:inverseOf rdf:resource="&d;generic-location"/>
    <rdfs:subPropertyOf rdf:resource="&d;mediated-relation-i"/>
    <rdfs:domain rdf:resource="&d;particular"/>
    <rdfs:range rdf:resource="&d;particular"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;generically-dependent-on">
    <owl:inverseOf rdf:resource="&d;generic-dependent"/>
    <rdfs:subPropertyOf rdf:resource="&d;immediate-relation-i"/>
    <rdfs:domain rdf:resource="&d;particular"/>
    <rdfs:range rdf:resource="&d;particular"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;has-quale">
    <rdfs:comment rdf:datatype="&xsd;string">A quality having a q-location at an atomic region.</rdfs:comment>
    <owl:inverseOf rdf:resource="&d;quale-of"/>
    <rdfs:subPropertyOf rdf:resource="&d;q-location"/>
    <rdfs:domain rdf:resource="&d;quality"/>
    <rdfs:range rdf:resource="&d;quale"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;has-quality">
    <owl:inverseOf rdf:resource="&d;inherent-in"/>
    <rdfs:subPropertyOf rdf:resource="&d;immediate-relation-i"/>
    <rdfs:domain rdf:resource="&d;particular"/>
    <rdfs:range rdf:resource="&d;quality"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;has-t-quality">
    <owl:inverseOf rdf:resource="&d;t-inherent-in"/>
    <rdfs:subPropertyOf rdf:resource="&d;has-quality"/>
    <rdfs:domain rdf:resource="&d;particular"/>
    <rdfs:range rdf:resource="&d;quality"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;host">
    <rdfs:comment rdf:datatype="&xsd;string">The immediate relation holding for features and entities.</rdfs:comment>
    <owl:inverseOf rdf:resource="&d;host-of"/>
    <rdfs:subPropertyOf rdf:resource="&d;specifically-constantly-dependent-on"/>
    <rdfs:domain rdf:resource="&d;feature"/>
    <rdfs:range rdf:resource="&d;physical-endurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;host-of">
    <owl:inverseOf rdf:resource="&d;host"/>
    <rdfs:subPropertyOf rdf:resource="&d;specific-constant-dependent"/>
    <rdfs:domain rdf:resource="&d;physical-endurant"/>
    <rdfs:range rdf:resource="&d;feature"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;identity-c">
    <rdfs:comment rdf:datatype="&xsd;string">Any pair of individuals are ontologically identical if they are identical to themselves. Reflexive, symmetric, and transitive.</rdfs:comment>
    <rdf:type rdf:resource="&owl;TransitiveProperty"/>
    <owl:inverseOf rdf:resource="&d;identity-c"/>
    <rdfs:subPropertyOf rdf:resource="&d;immediate-relation"/>
    <rdfs:domain rdf:resource="&d;particular"/>
    <rdfs:range rdf:resource="&d;particular"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;identity-n">
    <rdfs:comment rdf:datatype="&xsd;string">Any pair of individuals are notionally identical iff they instantiate all and only the same concepts.</rdfs:comment>
    <rdf:type rdf:resource="&owl;TransitiveProperty"/>
    <owl:inverseOf rdf:resource="&d;identity-n"/>
    <rdfs:subPropertyOf rdf:resource="&d;immediate-relation"/>
    <rdfs:domain rdf:resource="&d;particular"/>
    <rdfs:range rdf:resource="&d;particular"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;immediate-relation">
    <rdfs:comment rdf:datatype="&xsd;string">A relation that holds without  additional mediating individuals. In logical terms, a non-composed relation.</rdfs:comment>
    <owl:inverseOf rdf:resource="&d;immediate-relation-i"/>
    <rdfs:domain rdf:resource="&d;particular"/>
    <rdfs:range rdf:resource="&d;particular"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;immediate-relation-i">
    <rdfs:comment rdf:datatype="&xsd;string">A relation that holds without additional mediating individuals. In logical terms, a non-composed relation.</rdfs:comment>
    <owl:inverseOf rdf:resource="&d;immediate-relation"/>
    <rdfs:domain rdf:resource="&d;particular"/>
    <rdfs:range rdf:resource="&d;particular"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;inherent-in">
    <rdfs:comment rdf:datatype="&xsd;string">The immediate relation holding for qualities and entities.</rdfs:comment>
    <owl:inverseOf rdf:resource="&d;has-quality"/>
    <rdfs:subPropertyOf rdf:resource="&d;immediate-relation"/>
    <rdfs:domain rdf:resource="&d;quality"/>
    <rdfs:range rdf:resource="&d;particular"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;life">
    <rdfs:comment rdf:datatype="&xsd;string">Total constant participation applied to the mereological sum of the perdurants in which an endurant participates.</rdfs:comment>
    <rdf:type rdf:resource="&owl;FunctionalProperty"/>
    <owl:inverseOf rdf:resource="&d;life-of"/>
    <rdfs:subPropertyOf rdf:resource="&d;constant-participant-in"/>
    <rdfs:domain rdf:resource="&d;endurant"/>
    <rdfs:range rdf:resource="&d;perdurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;life-of">
    <rdf:type rdf:resource="&owl;InverseFunctionalProperty"/>
    <owl:inverseOf rdf:resource="&d;life"/>
    <rdfs:subPropertyOf rdf:resource="&d;constant-participant"/>
    <rdfs:domain rdf:resource="&d;perdurant"/>
    <rdfs:range rdf:resource="&d;endurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;mediated-relation">
    <rdfs:comment rdf:datatype="&xsd;string">A relation that composes other  relations. For example, a participation relation composed with a representation relation.Composed relation cannot be directly expressed in OWL-DL, then (at least some) compositions are expressed as class or restriction axioms.</rdfs:comment>
    <owl:inverseOf rdf:resource="&d;mediated-relation-i"/>
    <rdfs:domain rdf:resource="&d;particular"/>
    <rdfs:range rdf:resource="&d;particular"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;mediated-relation-i">
    <rdfs:comment rdf:datatype="&xsd;string">A relation that composes other relations. For example, a participation relation composed with a representation relation. Composed relation cannot be directly expressed in OWL-DL, then (at least some) compositions are expressed as class or restriction axioms.</rdfs:comment>
    <owl:inverseOf rdf:resource="&d;mediated-relation"/>
    <rdfs:domain rdf:resource="&d;particular"/>
    <rdfs:range rdf:resource="&d;particular"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;mereologically-coincides">
    <rdfs:comment rdf:datatype="&xsd;string">Having the same parts at time t.</rdfs:comment>
    <owl:inverseOf rdf:resource="&d;mereologically-coincides"/>
    <rdfs:subPropertyOf rdf:resource="&d;temporary-part"/>
    <rdfs:domain rdf:resource="&d;endurant"/>
    <rdfs:range rdf:resource="&d;endurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;overlaps">
    <rdfs:comment rdf:datatype="&xsd;string">Mereological overlap: having a common part.</rdfs:comment>
    <owl:inverseOf rdf:resource="&d;overlaps"/>
    <rdfs:subPropertyOf rdf:resource="&d;mediated-relation"/>
    <rdfs:domain rdf:resource="&d;particular"/>
    <rdfs:range rdf:resource="&d;particular"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;part">
    <rdfs:comment rdf:datatype="&xsd;string">The most generic part relation, reflexive, asymmetric, and transitive.</rdfs:comment>
    <rdf:type rdf:resource="&owl;TransitiveProperty"/>
    <owl:inverseOf rdf:resource="&d;part-of"/>
    <rdfs:subPropertyOf rdf:resource="&d;immediate-relation"/>
    <rdfs:domain rdf:resource="&d;particular"/>
    <rdfs:range rdf:resource="&d;particular"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;part-of">
    <rdf:type rdf:resource="&owl;TransitiveProperty"/>
    <owl:inverseOf rdf:resource="&d;part"/>
    <rdfs:subPropertyOf rdf:resource="&d;immediate-relation-i"/>
    <rdfs:domain rdf:resource="&d;particular"/>
    <rdfs:range rdf:resource="&d;particular"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;participant">
    <rdfs:comment rdf:datatype="&xsd;string">The immediate relation holding between endurants and perdurants (e.g. in 'the car is running').Participation can be constant (in all parts of the perdurant, e.g. in 'the car is running'), or temporary (in only some parts, e.g. in 'I'm electing the president').A 'functional' participant is specialized for those forms of participation that depend on the nature of participants, processes, or on the intentionality of agentive participants. Traditional 'thematic role' should be mapped to functional participation.For relations holding between participants in a same perdurant, see the co-participates relation.</rdfs:comment>
    <owl:inverseOf rdf:resource="&d;participant-in"/>
    <rdfs:subPropertyOf rdf:resource="&d;immediate-relation"/>
    <rdfs:domain rdf:resource="&d;perdurant"/>
    <rdfs:range rdf:resource="&d;endurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;participant-in">
    <owl:inverseOf rdf:resource="&d;participant"/>
    <rdfs:subPropertyOf rdf:resource="&d;immediate-relation-i"/>
    <rdfs:domain rdf:resource="&d;endurant"/>
    <rdfs:range rdf:resource="&d;perdurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;partly-compresent">
    <rdfs:comment rdf:datatype="&xsd;string">A composed (mediated) relation used here to make relations 'temporary': by adding it as a superrelation, the effect is that the two related endurants cannot be present at all the same time intervals, but are compresent at least at some time interval (see related axiom).In FOL, the same constraint can be stated directly by coreference.This workaround can be used to index time of relations that involve reciprocal dependency, but it cannot be used in general with relations involving multiple strata of reality. For example, _about_ relation can be temporally indexed, without involving that the time of the information object overlaps with the time of the entity the information is about (but this works for e.g. the _realizes_ relation between information objects and entities whatsoever). The different temporal constraints of about vs. expresses probably derive from the dependency of aboutness from conception (to be about x, an information object should also express a description d that is satisfied by a situation including x, then temporal overlapping of _about_ is true in virtue of d). On the other hand, even conceives cannot be indexed in this way, because overlapping does not hold between the time og the conceiving agent, and the conceived description (or situation).</rdfs:comment>
    <owl:inverseOf rdf:resource="&d;partly-compresent"/>
    <rdfs:subPropertyOf rdf:resource="&d;mediated-relation"/>
    <rdfs:domain rdf:resource="&d;particular"/>
    <rdfs:range rdf:resource="&d;particular"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;physical-location">
    <rdfs:comment rdf:datatype="&xsd;string">Analytical location holding between physical endurants and physical regions.</rdfs:comment>
    <owl:inverseOf rdf:resource="&d;physical-location-of"/>
    <rdfs:subPropertyOf rdf:resource="&d;exact-location"/>
    <rdfs:domain rdf:resource="&d;physical-endurant"/>
    <rdfs:range rdf:resource="&d;physical-region"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;physical-location-of">
    <owl:inverseOf rdf:resource="&d;physical-location"/>
    <rdfs:subPropertyOf rdf:resource="&d;exact-location-of"/>
    <rdfs:domain rdf:resource="&d;physical-region"/>
    <rdfs:range rdf:resource="&d;physical-endurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;proper-part">
    <rdfs:comment rdf:datatype="&xsd;string">The proper part relation: irreflexive, antisymmetric, and transitive.</rdfs:comment>
    <rdf:type rdf:resource="&owl;TransitiveProperty"/>
    <owl:inverseOf rdf:resource="&d;proper-part-of"/>
    <rdfs:subPropertyOf rdf:resource="&d;part"/>
    <rdfs:domain rdf:resource="&d;particular"/>
    <rdfs:range rdf:resource="&d;particular"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;proper-part-of">
    <rdf:type rdf:resource="&owl;TransitiveProperty"/>
    <owl:inverseOf rdf:resource="&d;proper-part"/>
    <rdfs:subPropertyOf rdf:resource="&d;part-of"/>
    <rdfs:domain rdf:resource="&d;particular"/>
    <rdfs:range rdf:resource="&d;particular"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;q-location">
    <rdfs:comment rdf:datatype="&xsd;string">The immediate relation holding for qualities and regions. See 'generic location' branching for the various mediated relations that embed q-location.</rdfs:comment>
    <owl:inverseOf rdf:resource="&d;q-location-of"/>
    <rdfs:subPropertyOf rdf:resource="&d;immediate-relation"/>
    <rdfs:domain rdf:resource="&d;quality"/>
    <rdfs:range rdf:resource="&d;region"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;q-location-of">
    <owl:inverseOf rdf:resource="&d;q-location"/>
    <rdfs:subPropertyOf rdf:resource="&d;immediate-relation-i"/>
    <rdfs:domain rdf:resource="&d;region"/>
    <rdfs:range rdf:resource="&d;quality"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;q-present-at">
    <rdfs:comment rdf:datatype="&xsd;string">Presence of a physical quality when inheres in  an endurant.</rdfs:comment>
    <owl:inverseOf rdf:resource="&d;time-of-q-presence-of"/>
    <rdfs:subPropertyOf rdf:resource="&d;mediated-relation"/>
    <rdfs:domain rdf:resource="&d;physical-quality"/>
    <rdfs:range rdf:resource="&d;time-interval"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;quale-of">
    <owl:inverseOf rdf:resource="&d;has-quale"/>
    <rdfs:subPropertyOf rdf:resource="&d;q-location-of"/>
    <rdfs:domain rdf:resource="&d;quale"/>
    <rdfs:range rdf:resource="&d;quality"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;r-location">
    <rdfs:comment rdf:datatype="&xsd;string">A relation for representing regions within other regions, e.g. in measurement spaces (space composition).The result of r-location composition is a new 'composed region', which can either preserve the same region type (e.g. physical+physical->physical, or  physical+abstract->physical), or not (e.g. physical+abstract->abstract). See 'composition description' for more details.In some cases, space composition is conventional, i.e. a space is just 'located' at another space, as in the case of measurement spaces:(direct composition):   r r-location r1In other cases, r-location implies a complex path, e.g. :(homogeneous composition):   r q-location-of q inherent-in x has-quality q1 q-location r1(heterogeneous composition across endurants and perdurants):   r q-location-of q inherent-in e participant-in p has-quality q1 q-location r1(heterogeneous composition across physical and non-physical endurants):   r q-location-of q inherent-in pe specific-constant-dependent npe has-quality q1 q-location r1</rdfs:comment>
    <owl:inverseOf rdf:resource="&d;r-location-of"/>
    <rdfs:subPropertyOf rdf:resource="&d;immediate-relation"/>
    <rdfs:domain rdf:resource="&d;region"/>
    <rdfs:range rdf:resource="&d;region"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;r-location-of">
    <owl:inverseOf rdf:resource="&d;r-location"/>
    <rdfs:subPropertyOf rdf:resource="&d;immediate-relation-i"/>
    <rdfs:domain rdf:resource="&d;region"/>
    <rdfs:range rdf:resource="&d;region"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;sibling-part">
    <rdfs:comment rdf:datatype="&xsd;string">Mereological sibling: having a common whole</rdfs:comment>
    <owl:inverseOf rdf:resource="&d;sibling-part"/>
    <rdfs:subPropertyOf rdf:resource="&d;mediated-relation"/>
    <rdfs:domain rdf:resource="&d;particular"/>
    <rdfs:range rdf:resource="&d;particular"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;spatio-temporal-presence-of">
    <owl:inverseOf rdf:resource="&d;spatio-temporally-present-at"/>
    <rdfs:subPropertyOf rdf:resource="&d;exact-location-of"/>
    <rdfs:domain rdf:resource="&d;spatio-temporal-region"/>
    <rdfs:range rdf:resource="&d;particular"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;spatio-temporally-present-at">
    <owl:inverseOf rdf:resource="&d;spatio-temporal-presence-of"/>
    <rdfs:subPropertyOf rdf:resource="&d;exact-location"/>
    <rdfs:domain rdf:resource="&d;particular"/>
    <rdfs:range rdf:resource="&d;spatio-temporal-region"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;specific-constant-constituent">
    <rdfs:comment rdf:datatype="&xsd;string">'Constituent' should depend on some layering of  the ontology. For example, scientific granularities or ontological 'strata' are  typical layerings. A constituent is a part belonging to a lower layer. Since layering is actually a partition of the ontology, constituents are not properly classified as parts, although this kinship can be intuitive for common sense. Example of specific constant constituents are the entities constituting a setting (a situation), whilethe entities constituting a collection are examples of generic constant constituents.</rdfs:comment>
    <owl:inverseOf rdf:resource="&d;specific-constant-constituent-of"/>
    <rdfs:subPropertyOf rdf:resource="&d;immediate-relation"/>
    <rdfs:domain rdf:resource="&d;particular"/>
    <rdfs:range rdf:resource="&d;particular"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;specific-constant-constituent-of">
    <owl:inverseOf rdf:resource="&d;specific-constant-constituent"/>
    <rdfs:subPropertyOf rdf:resource="&d;immediate-relation-i"/>
    <rdfs:domain rdf:resource="&d;particular"/>
    <rdfs:range rdf:resource="&d;particular"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;specific-constant-dependent">
    <rdfs:comment rdf:datatype="&xsd;string">The constant dependence between two individuals. Taken here as primitive.</rdfs:comment>
    <owl:inverseOf rdf:resource="&d;specifically-constantly-dependent-on"/>
    <rdfs:subPropertyOf rdf:resource="&d;immediate-relation"/>
    <rdfs:domain rdf:resource="&d;particular"/>
    <rdfs:range rdf:resource="&d;particular"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;specifically-constantly-dependent-on">
    <owl:inverseOf rdf:resource="&d;specific-constant-dependent"/>
    <rdfs:subPropertyOf rdf:resource="&d;immediate-relation-i"/>
    <rdfs:domain rdf:resource="&d;particular"/>
    <rdfs:range rdf:resource="&d;particular"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;strong-connection">
    <rdfs:comment rdf:datatype="&xsd;string">By strong connection here we mean a connection between  two entities that share a boundary.</rdfs:comment>
    <owl:inverseOf rdf:resource="&d;strong-connection"/>
    <rdfs:subPropertyOf rdf:resource="&d;mediated-relation"/>
    <rdfs:domain rdf:resource="&d;particular"/>
    <rdfs:range rdf:resource="&d;particular"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;t-inherent-in">
    <rdfs:comment rdf:datatype="&xsd;string">The immediate relation holding for qualities and entities at time t.</rdfs:comment>
    <owl:inverseOf rdf:resource="&d;has-t-quality"/>
    <rdfs:subPropertyOf rdf:resource="&d;inherent-in"/>
    <rdfs:domain rdf:resource="&d;quality"/>
    <rdfs:range rdf:resource="&d;particular"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;temporary-atomic-part">
    <rdfs:comment rdf:datatype="&xsd;string">Having an atom as part at a time t.</rdfs:comment>
    <owl:inverseOf rdf:resource="&d;temporary-atomic-part-of"/>
    <rdfs:subPropertyOf rdf:resource="&d;temporary-proper-part"/>
    <rdfs:domain rdf:resource="&d;endurant"/>
    <rdfs:range rdf:resource="&d;endurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;temporary-atomic-part-of">
    <owl:inverseOf rdf:resource="&d;temporary-atomic-part"/>
    <rdfs:subPropertyOf rdf:resource="&d;temporary-proper-part-of"/>
    <rdfs:domain rdf:resource="&d;endurant"/>
    <rdfs:range rdf:resource="&d;endurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;temporary-part">
    <rdfs:comment rdf:datatype="&xsd;string">Being part at time t. It holds for endurants only. This is important to model parts that can change or be lost over time without affecting the identity of the whole. In FOL, this is expressed as a ternary relation, but in DLs we only can reason with binary relations, then only the necessary axiom of compresence is represented here.</rdfs:comment>
    <owl:inverseOf rdf:resource="&d;temporary-part-of"/>
    <rdfs:subPropertyOf rdf:resource="&d;part"/>
    <rdfs:subPropertyOf rdf:resource="&d;partly-compresent"/>
    <rdfs:domain rdf:resource="&d;endurant"/>
    <rdfs:range rdf:resource="&d;endurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;temporary-part-of">
    <owl:inverseOf rdf:resource="&d;temporary-part"/>
    <rdfs:subPropertyOf rdf:resource="&d;part-of"/>
    <rdfs:subPropertyOf rdf:resource="&d;partly-compresent"/>
    <rdfs:domain rdf:resource="&d;endurant"/>
    <rdfs:range rdf:resource="&d;endurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;temporary-participant">
    <rdfs:comment rdf:datatype="&xsd;string">Only some parts of the perdurant p have a participant e.In fact, participation can be constant (in all parts of the perdurant, e.g. in 'the car is running'), or temporary (in only some parts, e.g. in 'I'm electing the president').Implicitly, this relation has a temporal indexing.If needed, in OWL one can derive such indexing by expliciting what parts of p have e as _constant_ participant.An appropriate OWL axiom is created to bind this relation to a proper part of it, which has the temporary-participant as a constant one.</rdfs:comment>
    <owl:inverseOf rdf:resource="&d;temporary-participant-in"/>
    <rdfs:subPropertyOf rdf:resource="&d;participant"/>
    <rdfs:domain rdf:resource="&d;perdurant"/>
    <rdfs:range rdf:resource="&d;endurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;temporary-participant-in">
    <rdfs:comment rdf:datatype="&xsd;string">x participates in some of y's parts.</rdfs:comment>
    <owl:inverseOf rdf:resource="&d;temporary-participant"/>
    <rdfs:subPropertyOf rdf:resource="&d;participant-in"/>
    <rdfs:domain rdf:resource="&d;endurant"/>
    <rdfs:range rdf:resource="&d;perdurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;temporary-proper-part">
    <rdfs:comment rdf:datatype="&xsd;string">Being proper part at time t. It holds for endurants only. This is important to model proper parts that can change or be lost over time without affecting the identity of the whole.</rdfs:comment>
    <owl:inverseOf rdf:resource="&d;temporary-proper-part-of"/>
    <rdfs:subPropertyOf rdf:resource="&d;proper-part"/>
    <rdfs:subPropertyOf rdf:resource="&d;temporary-part"/>
    <rdfs:domain rdf:resource="&d;endurant"/>
    <rdfs:range rdf:resource="&d;endurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;temporary-proper-part-of">
    <owl:inverseOf rdf:resource="&d;temporary-proper-part"/>
    <rdfs:subPropertyOf rdf:resource="&d;proper-part-of"/>
    <rdfs:subPropertyOf rdf:resource="&d;temporary-part-of"/>
    <rdfs:domain rdf:resource="&d;endurant"/>
    <rdfs:range rdf:resource="&d;endurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;time-of-q-presence-of">
    <owl:inverseOf rdf:resource="&d;q-present-at"/>
    <rdfs:subPropertyOf rdf:resource="&d;mediated-relation-i"/>
    <rdfs:domain rdf:resource="&d;time-interval"/>
    <rdfs:range rdf:resource="&d;physical-quality"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;total-constant-participant">
    <rdfs:comment rdf:datatype="&xsd;string">The perdurant p has a participant e that constantly participates in p with all its parts, e.g. in 'I played the concert' (where the concert is a solo concert).</rdfs:comment>
    <owl:inverseOf rdf:resource="&d;total-constant-participant-in"/>
    <rdfs:subPropertyOf rdf:resource="&d;constant-participant"/>
    <rdfs:domain rdf:resource="&d;perdurant"/>
    <rdfs:range rdf:resource="&d;endurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;total-constant-participant-in">
    <owl:inverseOf rdf:resource="&d;total-constant-participant"/>
    <rdfs:subPropertyOf rdf:resource="&d;constant-participant-in"/>
    <rdfs:domain rdf:resource="&d;endurant"/>
    <rdfs:range rdf:resource="&d;perdurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;total-temporary-participant">
    <rdfs:comment rdf:datatype="&xsd;string">The perdurant p has a participant e that temporarily participates in p with all its parts, e.g. in 'I played the concert' (where I actually played just an ouverture).See also 'temporary-participant'.</rdfs:comment>
    <owl:inverseOf rdf:resource="&d;total-temporary-participant-in"/>
    <rdfs:subPropertyOf rdf:resource="&d;temporary-participant"/>
    <rdfs:domain rdf:resource="&d;perdurant"/>
    <rdfs:range rdf:resource="&d;endurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;total-temporary-participant-in">
    <owl:inverseOf rdf:resource="&d;total-temporary-participant"/>
    <rdfs:subPropertyOf rdf:resource="&d;temporary-participant-in"/>
    <rdfs:domain rdf:resource="&d;endurant"/>
    <rdfs:range rdf:resource="&d;perdurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&d;weak-connection">
    <rdfs:comment rdf:datatype="&xsd;string">The basic connection, not requiring a  common boundary.</rdfs:comment>
    <owl:inverseOf rdf:resource="&d;weak-connection"/>
    <rdfs:subPropertyOf rdf:resource="&d;immediate-relation"/>
    <rdfs:domain rdf:resource="&d;particular"/>
    <rdfs:range rdf:resource="&d;particular"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;about">
    <rdfs:comment rdf:datatype="&xsd;string">The relation between information objects and entities they are about. The difference with 'expresses' is that the last requires a situation to be about something. E.g. Dante's Comedy is about facts like Dante's travel to the hereafter. The Comedy expresses a script as well as various related meanings, while the facts talked about are not 'expressed'.Given that descriptions are expressed by at least one IO, and that interpretations of IOs requires conceiving a description, and the (plausible) claim that being about something can only be done in context, i.e. within a situation, we can propose that the conceived description is satisfied by the situation (the context) of the entity the IO is about.On this basis, about would result to be a mediated relation. This is still a proposal, then we keep about here as a primitive for some time.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;aboutness-of"/>
    <rdfs:subPropertyOf rdf:resource="&b;references"/>
    <rdfs:domain rdf:resource="&b;information-object"/>
    <rdfs:range rdf:resource="&d;particular"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;aboutness-of">
    <owl:inverseOf rdf:resource="&b;about"/>
    <rdfs:subPropertyOf rdf:resource="&b;referenced-by"/>
    <rdfs:domain rdf:resource="&d;particular"/>
    <rdfs:range rdf:resource="&b;information-object"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;acted-by">
    <owl:inverseOf rdf:resource="&b;acts-for"/>
    <rdfs:subPropertyOf rdf:resource="&d;mediated-relation-i"/>
    <rdfs:domain rdf:resource="&b;figure"/>
    <rdfs:range rdf:resource="&b;agent"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;acts-for">
    <rdfs:comment rdf:datatype="&xsd;string">Figures are not dependent on roles defined or used in the same descriptions they are defined or used, but they can act because they depute some powers to some of those roles. In other words, a figure selected by some agentive role can play that role because there are other roles in the descriptions that define or use the figure. Those roles select endurants that result to act for the figure.For example, an employee acts for an organization that deputes the role (e.g. turner) that classifies the employee. Simply put, a guy working as a turner at FIAT acts for (or on behalf of) FIAT.In complex figures, like organizations or societies, a total agency is possible when an endurant plays a delegate, or representative role of the figure.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;acted-by"/>
    <rdfs:subPropertyOf rdf:resource="&d;mediated-relation"/>
    <rdfs:domain rdf:resource="&b;agent"/>
    <rdfs:range rdf:resource="&b;figure"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;admits">
    <rdfs:comment rdf:datatype="&xsd;string">The composition of d-uses and valued-by relations: a description d-uses a parameter that is valued by a region.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;admitted-by"/>
    <rdfs:subPropertyOf rdf:resource="&d;mediated-relation"/>
    <rdfs:domain rdf:resource="&b;description"/>
    <rdfs:range rdf:resource="&d;region"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;admitted-by">
    <owl:inverseOf rdf:resource="&b;admits"/>
    <rdfs:subPropertyOf rdf:resource="&d;mediated-relation-i"/>
    <rdfs:domain rdf:resource="&d;region"/>
    <rdfs:range rdf:resource="&b;description"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;adopted-by">
    <rdfs:comment rdf:datatype="&xsd;string">An important relation between agents and descriptions is adoption, requiring previous creation by a rational agent, and internal representation by the same agent. It can involve an actual desire to perform the possibly expected actions.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;adopts"/>
    <rdfs:subPropertyOf rdf:resource="&b;internally-represented-in"/>
    <rdfs:domain rdf:resource="&b;description"/>
    <rdfs:range rdf:resource="&b;rational-agent"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;adopts">
    <rdfs:comment rdf:datatype="&xsd;string">An important relation between agents and descriptions is adoption, requiring previous creation by a rational agent, and internal representation by the same agent. It can involve an actual desire to perform the possibly expected actions.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;adopted-by"/>
    <rdfs:subPropertyOf rdf:resource="&b;internally-represents"/>
    <rdfs:domain rdf:resource="&b;rational-agent"/>
    <rdfs:range rdf:resource="&b;description"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;attitude-target-of">
    <owl:inverseOf rdf:resource="&b;attitude-towards"/>
    <rdfs:subPropertyOf rdf:resource="&b;modal-target-of"/>
    <rdfs:domain rdf:resource="&b;course"/>
    <rdfs:range>
        <owl:Class>
            <owl:unionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&b;agent-driven-role"/>
                <owl:Class rdf:about="&b;agentive-figure"/>
            </owl:unionOf>
        </owl:Class>
    </rdfs:range>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;attitude-towards">
    <rdfs:comment rdf:datatype="&xsd;string">It is the immediate relation between roles or figures, and tasks. It is the descriptive counterpart of the 'participant-in' relation for agentive roles or figures.In other words, it is used to state attitudes, attention or even subjection that an object can have wrt an action or process. Formally, a modality target is a task that sequences a perdurant that has a participant that plays a role bound to that modality target with a certain modality.For example, a person is usually obliged to drive in a way that prevents hurting other persons. Or a person can have the right to express her ideas.Another, more complex example: a BDI application to a certain ordered set of tasks including  initial conditions (beliefs), final conditions (desires), and ways to reach goals (intentions). In other words, to move from beliefs to goals is a way of bounding one or more agent(s) to a sequence of actions.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;attitude-target-of"/>
    <rdfs:subPropertyOf rdf:resource="&b;modal-target"/>
    <rdfs:domain>
        <owl:Class>
            <owl:unionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&b;agent-driven-role"/>
                <owl:Class rdf:about="&b;agentive-figure"/>
            </owl:unionOf>
        </owl:Class>
    </rdfs:domain>
    <rdfs:range rdf:resource="&b;course"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;c-sat">
    <rdfs:comment rdf:datatype="&xsd;string">C-SAT - like R-SAT - concerns entities that exist in a situation entirely prior to the description. Moreover, it assumes redundant satisfaction. But, differently from P-SAT and R-SAT, no qualified satisfaction is assumed. In fact, C-SAT implies no dependency of a situation on its description. C-SAT typically applies to different views of existing situations, as for regulative descriptions (disclaimer: the situation can be already created by complying to the regulation, e.g executing it as a plan, but in this case there actually exists a plan that has the regulation as part), narratives, symbolic interpretations, etc.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;c-sat-by"/>
    <rdfs:subPropertyOf rdf:resource="&b;satisfies"/>
    <rdfs:domain rdf:resource="&b;situation"/>
    <rdfs:range rdf:resource="&b;description"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;c-sat-by">
    <owl:inverseOf rdf:resource="&b;c-sat"/>
    <rdfs:subPropertyOf rdf:resource="&b;satisfied-by"/>
    <rdfs:domain rdf:resource="&b;description"/>
    <rdfs:range rdf:resource="&b;situation"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;characterized-by">
    <owl:inverseOf rdf:resource="&b;characterizes"/>
    <rdfs:subPropertyOf rdf:resource="&b;intensionally-referenced-by"/>
    <rdfs:domain rdf:resource="&b;collection"/>
    <rdfs:range rdf:resource="&b;role"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;characterizes">
    <rdfs:comment rdf:datatype="&xsd;string">A role r characterizes a collection c when proper subsets of the members of c play different roles r,...,rn that are all used by a same description or deputed by a same figure.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;characterized-by"/>
    <rdfs:subPropertyOf rdf:resource="&b;intensionally-references"/>
    <rdfs:domain rdf:resource="&b;role"/>
    <rdfs:range rdf:resource="&b;collection"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;classified-by">
    <rdfs:comment rdf:datatype="&xsd;string">A.K.A. 'selected-by'.The referencing relation between concepts defined by descriptions and constituents of situations. It can be understood as a reification of a 'satisfiability' relation holding between elements of  theories and elements of models.It has a time index, but this should not be intended as a partial compresence, since the time only refers to a part of the classified particular life or extension.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;classifies"/>
    <rdfs:subPropertyOf rdf:resource="&b;intensionally-referenced-by"/>
    <rdfs:domain rdf:resource="&d;particular"/>
    <rdfs:range rdf:resource="&b;concept"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;classifies">
    <rdfs:comment rdf:datatype="&xsd;string">A.K.A. 'selects'.The referencing relation between concepts defined by  descriptions, and constituents of situations. It can be understood as a  reification of a 'satisfiability' relation holding between elements of theories and elements of models.It has a time index, but this should not be intended as a partial compresence, since the time only refers to a part of the classified particular life or extension.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;classified-by"/>
    <rdfs:subPropertyOf rdf:resource="&b;intensionally-references"/>
    <rdfs:domain rdf:resource="&b;concept"/>
    <rdfs:range rdf:resource="&d;particular"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;co-participates-with">
    <rdfs:comment rdf:datatype="&xsd;string">A relation holding between two endurants participating in a same perdurant. This typically subsumes many common sense, verbally encoded, relations, such as "making", "moving", "transforming", etc.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;co-participates-with"/>
    <rdfs:subPropertyOf rdf:resource="&d;mediated-relation"/>
    <rdfs:domain rdf:resource="&d;endurant"/>
    <rdfs:range rdf:resource="&d;endurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;component">
    <rdfs:comment rdf:datatype="&xsd;string">'Component' is a proper part with a role (or function) in a system or a context. Roles can be different for the same entity, and the evaluation of them changes according to the kind of entity. For instance, components of endurants can 'play functional roles' in a whole, while components of perdurants are the  essential 'episodes' in their whole.As a functional part relation, component is not transitive, because functions depend on intentions and/or designs, and something intentionally essential for a direct whole, can be non-essential for another, indirect whole.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;component-of"/>
    <rdfs:subPropertyOf rdf:resource="&d;proper-part"/>
    <rdfs:domain rdf:resource="&d;particular"/>
    <rdfs:range rdf:resource="&d;particular"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;component-of">
    <owl:inverseOf rdf:resource="&b;component"/>
    <rdfs:subPropertyOf rdf:resource="&d;proper-part-of"/>
    <rdfs:domain rdf:resource="&d;particular"/>
    <rdfs:range rdf:resource="&d;particular"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;covered-by">
    <owl:inverseOf rdf:resource="&b;covers"/>
    <rdfs:subPropertyOf rdf:resource="&b;intensionally-referenced-by"/>
    <rdfs:domain rdf:resource="&b;collection"/>
    <rdfs:range rdf:resource="&b;role"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;covers">
    <rdfs:comment rdf:datatype="&xsd;string">The role shared by all members of a collection has a covering relation towards the collection.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;covered-by"/>
    <rdfs:subPropertyOf rdf:resource="&b;intensionally-references"/>
    <rdfs:domain rdf:resource="&b;role"/>
    <rdfs:range rdf:resource="&b;collection"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;created-by">
    <rdfs:comment rdf:datatype="&xsd;string">An important relation between agents and descriptions is creation, implying that a given description is *specifically* dependent on a rational agent.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;creates"/>
    <rdfs:subPropertyOf rdf:resource="&b;internally-represented-in"/>
    <rdfs:domain rdf:resource="&b;description"/>
    <rdfs:range rdf:resource="&b;rational-agent"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;creates">
    <rdfs:comment rdf:datatype="&xsd;string">An important relation between agents and descriptions is creation,  implying that a given description is *specifically* dependent on a rational agent.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;created-by"/>
    <rdfs:subPropertyOf rdf:resource="&b;internally-represents"/>
    <rdfs:domain rdf:resource="&b;rational-agent"/>
    <rdfs:range rdf:resource="&b;description"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;d-used-by">
    <owl:inverseOf rdf:resource="&b;d-uses"/>
    <rdfs:subPropertyOf rdf:resource="&b;component-of"/>
    <rdfs:domain>
        <owl:Class>
            <owl:unionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&b;concept"/>
                <owl:Class rdf:about="&b;figure"/>
            </owl:unionOf>
        </owl:Class>
    </rdfs:domain>
    <rdfs:range rdf:resource="&b;description"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;d-uses">
    <rdfs:comment rdf:datatype="&xsd;string">Descriptions can d-use (descriptively use) concepts or figures, provided that used ones are defined by some description.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;d-used-by"/>
    <rdfs:subPropertyOf rdf:resource="&b;component"/>
    <rdfs:domain rdf:resource="&b;description"/>
    <rdfs:range>
        <owl:Class>
            <owl:unionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&b;concept"/>
                <owl:Class rdf:about="&b;figure"/>
            </owl:unionOf>
        </owl:Class>
    </rdfs:range>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;defined-by">
    <owl:inverseOf rdf:resource="&b;defines"/>
    <rdfs:subPropertyOf rdf:resource="&b;d-used-by"/>
    <rdfs:domain>
        <owl:Class>
            <owl:unionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&b;concept"/>
                <owl:Class rdf:about="&b;figure"/>
            </owl:unionOf>
        </owl:Class>
    </rdfs:domain>
    <rdfs:range rdf:resource="&b;description"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;defines">
    <rdfs:comment rdf:datatype="&xsd;string">Descriptions define either concepts or (social) figures. Once defined, they can be d-used by other descriptions.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;defined-by"/>
    <rdfs:subPropertyOf rdf:resource="&b;d-uses"/>
    <rdfs:domain rdf:resource="&b;description"/>
    <rdfs:range>
        <owl:Class>
            <owl:unionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&b;concept"/>
                <owl:Class rdf:about="&b;figure"/>
            </owl:unionOf>
        </owl:Class>
    </rdfs:range>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;deputed-by">
    <owl:inverseOf rdf:resource="&b;deputes"/>
    <rdfs:subPropertyOf rdf:resource="&d;immediate-relation-i"/>
    <rdfs:domain rdf:resource="&b;role"/>
    <rdfs:range rdf:resource="&b;figure"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;deputes">
    <rdfs:comment rdf:datatype="&xsd;string">Figures can depute roles that are played by endurants that are supposed to 'act for' the figure.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;deputed-by"/>
    <rdfs:subPropertyOf rdf:resource="&d;immediate-relation"/>
    <rdfs:domain rdf:resource="&b;figure"/>
    <rdfs:range rdf:resource="&b;role"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;direct-predecessor">
    <rdfs:comment rdf:datatype="&xsd;string">Anti-transitive predecessor.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;direct-successor"/>
    <rdfs:subPropertyOf rdf:resource="&b;predecessor"/>
    <rdfs:domain rdf:resource="&d;particular"/>
    <rdfs:range rdf:resource="&d;particular"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;direct-successor">
    <rdfs:comment rdf:datatype="&xsd;string">Anti-transitive succession.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;direct-predecessor"/>
    <rdfs:subPropertyOf rdf:resource="&b;successor"/>
    <rdfs:domain rdf:resource="&d;particular"/>
    <rdfs:range rdf:resource="&d;particular"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;empowered-for">
    <owl:inverseOf rdf:resource="&b;empowered-to"/>
    <rdfs:subPropertyOf rdf:resource="&b;attitude-target-of"/>
    <rdfs:domain rdf:resource="&b;task"/>
    <rdfs:range>
        <owl:Class>
            <owl:unionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&b;agent-driven-role"/>
                <owl:Class rdf:about="&b;agentive-figure"/>
            </owl:unionOf>
        </owl:Class>
    </rdfs:range>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;empowered-to">
    <rdfs:comment rdf:datatype="&xsd;string">A relation between a role and a power allowed towards some function/task.This is dispositional, and implies that a participation classified by this relation is an 'empowered participation'.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;empowered-for"/>
    <rdfs:subPropertyOf rdf:resource="&b;attitude-towards"/>
    <rdfs:domain>
        <owl:Class>
            <owl:unionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&b;agent-driven-role"/>
                <owl:Class rdf:about="&b;agentive-figure"/>
            </owl:unionOf>
        </owl:Class>
    </rdfs:domain>
    <rdfs:range rdf:resource="&b;task"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;expanded-by">
    <owl:inverseOf rdf:resource="&b;expands"/>
    <rdfs:subPropertyOf rdf:resource="&d;proper-part-of"/>
    <rdfs:domain rdf:resource="&b;description"/>
    <rdfs:range rdf:resource="&b;description"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;expands">
    <rdfs:comment rdf:datatype="&xsd;string">A partial order relation that holds between descriptions. It represents the proper part relation between a description and another description featuring the same properties of the former, with at least an additional one.Descriptions can be expanded either by adding other descriptions as parts, or by refining concepts or figures that are d-used by them.Specializing the concepts or figures that are d-used by them is on the contrary a case of description specialization.For descriptions, an intention to expand must be present (unless purely formal theories are considered, but even in this case a criterion of relevance is usually active).</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;expanded-by"/>
    <rdfs:subPropertyOf rdf:resource="&d;proper-part"/>
    <rdfs:domain rdf:resource="&b;description"/>
    <rdfs:range rdf:resource="&b;description"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;expected-by">
    <owl:inverseOf rdf:resource="&b;expects"/>
    <rdfs:subPropertyOf rdf:resource="&d;mediated-relation-i"/>
    <rdfs:domain rdf:resource="&d;perdurant"/>
    <rdfs:range rdf:resource="&b;description"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;expected-setting">
    <owl:inverseOf rdf:resource="&b;expected-setting-for"/>
    <rdfs:subPropertyOf rdf:resource="&d;mediated-relation-i"/>
    <rdfs:domain rdf:resource="&b;concept"/>
    <rdfs:range rdf:resource="&b;situation"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;expected-setting-for">
    <rdfs:comment rdf:datatype="&xsd;string">A double composition is needed here for linking situations and descriptions components, since many possible constituents could be available in the situation. The first one constrains the classifies relation through description components, the second one constrains it through situation constituents.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;expected-setting"/>
    <rdfs:subPropertyOf rdf:resource="&d;mediated-relation"/>
    <rdfs:domain rdf:resource="&b;situation"/>
    <rdfs:range rdf:resource="&b;concept"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;expects">
    <rdfs:comment rdf:datatype="&xsd;string">The composition of d-uses and sequences relations: a description d-uses a course that sequences a perdurant.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;expected-by"/>
    <rdfs:subPropertyOf rdf:resource="&d;mediated-relation"/>
    <rdfs:domain rdf:resource="&b;description"/>
    <rdfs:range rdf:resource="&d;perdurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;exploited-by">
    <owl:inverseOf rdf:resource="&b;exploits"/>
    <rdfs:subPropertyOf rdf:resource="&b;involved-in"/>
    <rdfs:domain rdf:resource="&d;endurant"/>
    <rdfs:range rdf:resource="&b;method"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;exploits">
    <rdfs:comment rdf:datatype="&xsd;string">A method can exploit an involved endurant when it plays a device-like role.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;exploited-by"/>
    <rdfs:subPropertyOf rdf:resource="&b;involves"/>
    <rdfs:domain rdf:resource="&b;method"/>
    <rdfs:range rdf:resource="&d;endurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;expressed-by">
    <owl:inverseOf rdf:resource="&b;expresses"/>
    <rdfs:subPropertyOf rdf:resource="&b;referenced-by"/>
    <rdfs:domain rdf:resource="&b;description"/>
    <rdfs:range rdf:resource="&b;information-object"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;expresses">
    <rdfs:comment rdf:datatype="&xsd;string">A relation between information objects that are used as representations (signs) and the content (meaning, conceptualization) they represent. In this ontology content is reified as a 'description'.Information objects are 'systemic' objects created by the system of rules of a semiotic code. For the representation between the physical implementation of information objects (physical representations) and information objects, the 'realized-by' relation  is used.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;expressed-by"/>
    <rdfs:subPropertyOf rdf:resource="&b;references"/>
    <rdfs:domain rdf:resource="&b;information-object"/>
    <rdfs:range rdf:resource="&b;description"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;extensionally-equivalent">
    <rdfs:comment rdf:datatype="&xsd;string">Two or more collections can be extensionally equivalent and still not be the same collection. Each collection needs a unifying description which provides its intensional identity criterion.</rdfs:comment>
    <rdf:type rdf:resource="&owl;TransitiveProperty"/>
    <owl:inverseOf rdf:resource="&b;extensionally-equivalent"/>
    <rdfs:subPropertyOf rdf:resource="&d;immediate-relation"/>
    <rdfs:domain rdf:resource="&b;collection"/>
    <rdfs:range rdf:resource="&b;collection"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;functionally-unified-by">
    <owl:inverseOf rdf:resource="&b;functionally-unifies"/>
    <rdfs:subPropertyOf rdf:resource="&b;referenced-by"/>
    <rdfs:domain rdf:resource="&d;physical-object"/>
    <rdfs:range rdf:resource="&b;description"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;functionally-unifies">
    <rdfs:comment rdf:datatype="&xsd;string">A description can provide its unity criterion to a physical object. In this case we say that the description *functionally unifies* the physical object. This relation is equivalent to a composition of a description that unifies a collection whose members are (usually connected) proper parts of a physical object.Ideally, this notion should be used to provide a definition to physical objects, but this application would destroy the distinction between a 'perceived' object (an endurant whose unity depends on the perception competence of an agent), and a 'functional' object, since each perceived object would be such because it is functionally unified by a description conceived by the perceiving agent. In DOLCE we still apply to the distinction between perception and function.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;functionally-unified-by"/>
    <rdfs:subPropertyOf rdf:resource="&b;references"/>
    <rdfs:domain rdf:resource="&b;description"/>
    <rdfs:range rdf:resource="&d;physical-object"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;has-in-scope">
    <rdfs:comment rdf:datatype="&xsd;string">When there is an 'epistemological layering', i.e. a description d involves another description d' (one of the roles in d classifies d'), a situation that satisfies d', will be in the scope of d as well.For example, a judgment procedure will have a legal case in its scope, but being a legal case depends on satisfying some legal description not identical to that procedure.Another example: a plan assessment is a technique to evaluate a plan execute, and the assessment 'has in scope' the plan execution.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;in-scope-of"/>
    <rdfs:subPropertyOf rdf:resource="&b;references"/>
    <rdfs:domain rdf:resource="&b;description"/>
    <rdfs:range rdf:resource="&b;situation"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;has-method">
    <rdfs:comment rdf:datatype="&xsd;string">An activity expected by a method.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;method-of"/>
    <rdfs:subPropertyOf rdf:resource="&b;expected-by"/>
    <rdfs:domain rdf:resource="&b;activity"/>
    <rdfs:range rdf:resource="&b;method"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;hypostasis">
    <rdfs:comment rdf:datatype="&xsd;string">A particular has a figure as (one of) its hypostases, e.g. a personification like the holy grail or a goddess.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;hypostasis-of"/>
    <rdfs:subPropertyOf rdf:resource="&d;immediate-relation-i"/>
    <rdfs:subPropertyOf rdf:resource="&b;referenced-by"/>
    <rdfs:domain rdf:resource="&d;particular"/>
    <rdfs:range rdf:resource="&b;figure"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;hypostasis-of">
    <rdfs:comment rdf:datatype="&xsd;string">A figure is an hypostasis of a particular, e.g. a personification like the holy grail or a goddess, or an organization, which is the hypostatis of a (postulated) collective).</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;hypostasis"/>
    <rdfs:subPropertyOf rdf:resource="&b;references"/>
    <rdfs:domain rdf:resource="&b;figure"/>
    <rdfs:range rdf:resource="&d;particular"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;in-scope-of">
    <owl:inverseOf rdf:resource="&b;has-in-scope"/>
    <rdfs:subPropertyOf rdf:resource="&b;referenced-by"/>
    <rdfs:domain rdf:resource="&b;situation"/>
    <rdfs:range rdf:resource="&b;description"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;instantiated-by">
    <owl:inverseOf rdf:resource="&b;instantiates"/>
    <rdfs:subPropertyOf rdf:resource="&b;specialized-by"/>
    <rdfs:domain>
        <owl:Class>
            <owl:unionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&b;concept"/>
                <owl:Class rdf:about="&b;description"/>
                <owl:Class rdf:about="&b;collection"/>
            </owl:unionOf>
        </owl:Class>
    </rdfs:domain>
    <rdfs:range>
        <owl:Class>
            <owl:unionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&b;concept"/>
                <owl:Class rdf:about="&b;description"/>
                <owl:Class rdf:about="&b;collection"/>
            </owl:unionOf>
        </owl:Class>
    </rdfs:range>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;instantiates">
    <rdfs:comment rdf:datatype="&xsd;string">The maximal specialization achievable according to some criterion. Only applicable to social objects that logically reify set-related entities (relations, classes, sets).</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;instantiated-by"/>
    <rdfs:subPropertyOf rdf:resource="&b;specializes"/>
    <rdfs:domain>
        <owl:Class>
            <owl:unionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&b;concept"/>
                <owl:Class rdf:about="&b;description"/>
                <owl:Class rdf:about="&b;collection"/>
            </owl:unionOf>
        </owl:Class>
    </rdfs:domain>
    <rdfs:range>
        <owl:Class>
            <owl:unionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&b;concept"/>
                <owl:Class rdf:about="&b;description"/>
                <owl:Class rdf:about="&b;collection"/>
            </owl:unionOf>
        </owl:Class>
    </rdfs:range>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;intensionally-referenced-by">
    <owl:inverseOf rdf:resource="&b;intensionally-references"/>
    <rdfs:subPropertyOf rdf:resource="&b;referenced-by"/>
    <rdfs:domain rdf:resource="&d;particular"/>
    <rdfs:range rdf:resource="&d;non-physical-object"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;intensionally-references">
    <owl:inverseOf rdf:resource="&b;intensionally-referenced-by"/>
    <rdfs:subPropertyOf rdf:resource="&b;references"/>
    <rdfs:domain rdf:resource="&d;non-physical-object"/>
    <rdfs:range rdf:resource="&d;particular"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;internally-represented-in">
    <rdfs:comment rdf:datatype="&xsd;string">The relation between descriptions and agents. Agents have inner (a.k.a. 'mental') states and are endowed with, or produce, representations or conceptualizations, both corresponding here to 'descriptions'. The relation has a time index, but this should not be intended as a partial compresence, since time only refers to the part of the agent's life in which it represents the description (a.k.a. 'conceives', now rejected because of its strong human-rationality connotation). Provisionally, internally-represents is introduced here as an immediate (primitive) relation, but other options are under study. The first involves mediating internal representation through an ontology of mental states and events, while the second is semiotic: since descriptions are expressed by at least one information object, representing internally requires at least one creation/interpretation of an information object, therefore internally-represents would be a 'mediated' relation.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;internally-represents"/>
    <rdfs:subPropertyOf rdf:resource="&d;immediate-relation-i"/>
    <rdfs:domain rdf:resource="&b;description"/>
    <rdfs:range rdf:resource="&b;agent"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;internally-represents">
    <rdfs:comment rdf:datatype="&xsd;string">The relation between agents and descriptions. Agents have inner (a.k.a. 'mental') states and are endowed with, or produce, representations or conceptualizations, both corresponding here to 'descriptions'. The relation has a time index, but this should not be intended as a partial compresence, since time only refers to the part of the agent's life in which it represents the description (a.k.a. 'conceives', now rejected because of  its strong human-rationality connotation). Provisionally, internally-represents is introduced here as an immediate (primitive) relation, but other options are under study. The first involves mediating internal representation through an ontology of mental states and events, while the second is semiotic: since descriptions are expressed by at least one information object, representing internally requires at least one creation/interpretation of an information object, therefore internally-represents would be a 'mediated' relation.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;internally-represented-in"/>
    <rdfs:subPropertyOf rdf:resource="&d;immediate-relation"/>
    <rdfs:domain rdf:resource="&b;agent"/>
    <rdfs:range rdf:resource="&b;description"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;interpreted-by">
    <owl:inverseOf rdf:resource="&b;interprets"/>
    <rdfs:subPropertyOf rdf:resource="&d;immediate-relation-i"/>
    <rdfs:domain rdf:resource="&b;information-object"/>
    <rdfs:range rdf:resource="&b;agent"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;interprets">
    <rdfs:comment rdf:datatype="&xsd;string">The relation between agents and information objects. In order to interpret something, an agent should conceive a description that results to be 'expressed by' that information object.Interprets implies that an expressed description is conceived by the agent (i.e., when an agent interprets an IO, it conceives of a description expressed by the IO; of course two agents can conceive of different descriptions, then resulting in different interpretations).</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;interpreted-by"/>
    <rdfs:subPropertyOf rdf:resource="&d;immediate-relation"/>
    <rdfs:domain rdf:resource="&b;agent"/>
    <rdfs:range rdf:resource="&b;information-object"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;involved-in">
    <owl:inverseOf rdf:resource="&b;involves"/>
    <rdfs:subPropertyOf rdf:resource="&d;mediated-relation-i"/>
    <rdfs:domain rdf:resource="&d;endurant"/>
    <rdfs:range rdf:resource="&b;description"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;involves">
    <rdfs:comment rdf:datatype="&xsd;string">The composition of d-uses and played-by relations: a description d-uses a role that is played by an endurant.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;involved-in"/>
    <rdfs:subPropertyOf rdf:resource="&d;mediated-relation"/>
    <rdfs:domain rdf:resource="&b;description"/>
    <rdfs:range rdf:resource="&d;endurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;made-by">
    <owl:inverseOf rdf:resource="&b;makes"/>
    <rdfs:subPropertyOf rdf:resource="&b;co-participates-with"/>
    <rdfs:domain rdf:resource="&d;endurant"/>
    <rdfs:range rdf:resource="&d;endurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;makes">
    <rdfs:comment rdf:datatype="&xsd;string">A particular case of an endurant participating in a perdurant that meets (is connected to the beginning of) the life of another endurant.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;made-by"/>
    <rdfs:subPropertyOf rdf:resource="&b;co-participates-with"/>
    <rdfs:domain rdf:resource="&d;endurant"/>
    <rdfs:range rdf:resource="&d;endurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;member">
    <rdfs:comment rdf:datatype="&xsd;string">Being a (generic, temporary) constituent in a countable collection, for example: member of a society, bacterium in a colony, etc.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;member-of"/>
    <rdfs:subPropertyOf rdf:resource="&d;generic-constituent"/>
    <rdfs:domain rdf:resource="&b;collection"/>
    <rdfs:range rdf:resource="&d;endurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;member-of">
    <owl:inverseOf rdf:resource="&b;member"/>
    <rdfs:subPropertyOf rdf:resource="&d;generic-constituent-of"/>
    <rdfs:domain rdf:resource="&d;endurant"/>
    <rdfs:range rdf:resource="&b;collection"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;metaphorically-played-by">
    <owl:inverseOf rdf:resource="&b;metaphorically-plays"/>
    <rdfs:subPropertyOf rdf:resource="&b;played-by"/>
    <rdfs:domain rdf:resource="&b;role"/>
    <rdfs:range rdf:resource="&d;endurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;metaphorically-plays">
    <rdfs:comment rdf:datatype="&xsd;string">An endurant of type e1 metaphorically plays a role (defined in a description d2), when that role comes from a metaphorical mapping between the description d1 that grants a unity criterion to endurants of type e1, and another description d2 that grants a unity criterion to endurants of type e2.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;metaphorically-played-by"/>
    <rdfs:subPropertyOf rdf:resource="&b;plays"/>
    <rdfs:domain rdf:resource="&d;endurant"/>
    <rdfs:range rdf:resource="&b;role"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;method-of">
    <owl:inverseOf rdf:resource="&b;has-method"/>
    <rdfs:subPropertyOf rdf:resource="&b;expects"/>
    <rdfs:domain rdf:resource="&b;method"/>
    <rdfs:range rdf:resource="&b;activity"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;modal-target">
    <rdfs:comment rdf:datatype="&xsd;string">The relation between roles and courses. Modal target subrelations can be seen as 'reifications' of the operators of modal logics.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;modal-target-of"/>
    <rdfs:subPropertyOf rdf:resource="&d;immediate-relation"/>
    <rdfs:domain>
        <owl:Class>
            <owl:unionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&b;non-agentive-figure"/>
                <owl:Class rdf:about="&b;agentive-figure"/>
                <owl:Class rdf:about="&b;role"/>
            </owl:unionOf>
        </owl:Class>
    </rdfs:domain>
    <rdfs:range rdf:resource="&b;course"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;modal-target-of">
    <owl:inverseOf rdf:resource="&b;modal-target"/>
    <rdfs:subPropertyOf rdf:resource="&d;immediate-relation-i"/>
    <rdfs:domain rdf:resource="&b;course"/>
    <rdfs:range>
        <owl:Class>
            <owl:unionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&b;non-agentive-figure"/>
                <owl:Class rdf:about="&b;agentive-figure"/>
                <owl:Class rdf:about="&b;role"/>
            </owl:unionOf>
        </owl:Class>
    </rdfs:range>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;obligation-for">
    <owl:inverseOf rdf:resource="&b;obliged-to"/>
    <rdfs:subPropertyOf rdf:resource="&b;attitude-target-of"/>
    <rdfs:domain rdf:resource="&b;task"/>
    <rdfs:range>
        <owl:Class>
            <owl:unionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&b;agent-driven-role"/>
                <owl:Class rdf:about="&b;agentive-figure"/>
            </owl:unionOf>
        </owl:Class>
    </rdfs:range>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;obliged-to">
    <rdfs:comment rdf:datatype="&xsd;string">A relation between a role and a duty binding towards some function/task.This is dispositional, and implies that a participation classified by this relation is a 'due participation'.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;obligation-for"/>
    <rdfs:subPropertyOf rdf:resource="&b;attitude-towards"/>
    <rdfs:domain>
        <owl:Class>
            <owl:unionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&b;agent-driven-role"/>
                <owl:Class rdf:about="&b;agentive-figure"/>
            </owl:unionOf>
        </owl:Class>
    </rdfs:domain>
    <rdfs:range rdf:resource="&b;task"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;optionally-used-by">
    <rdfs:comment rdf:datatype="&xsd;string">A task (as any other concept) can be optional within some plan (or any description). In this case, it can be ignored in plan execution without affecting the satisfaction of the plan.Within plans, an task said to be optional should be placed in a way that preserves the topology (the connectedness) of the maximal task, except for sequential tasks, where it can be skipped without affecting the control structure. In fact, an optional task must either be component of a bag or sequential task, or have the concurrent task or the any-order task as a direct predecessor.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;optionally-uses"/>
    <rdfs:subPropertyOf rdf:resource="&b;d-used-by"/>
    <rdfs:domain rdf:resource="&b;concept"/>
    <rdfs:range rdf:resource="&b;description"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;optionally-uses">
    <owl:inverseOf rdf:resource="&b;optionally-used-by"/>
    <rdfs:subPropertyOf rdf:resource="&b;d-uses"/>
    <rdfs:domain rdf:resource="&b;description"/>
    <rdfs:range rdf:resource="&b;concept"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;ordered-by">
    <rdfs:comment rdf:datatype="&xsd;string">a.k.a. 'expressed according to'. The relation between information objects and the languages, codes, grammars, etc. that they are ordered by. E.g. Dante's Comedy is ordered by Middle Age Italian language (in this case, a complex of encoding systems).In principle, any description can be used as an encoding system, but in practice, only some combinatorial systems are used for encoding (see module on 'information objects').</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;orders"/>
    <rdfs:subPropertyOf rdf:resource="&d;mediated-relation"/>
    <rdfs:domain rdf:resource="&b;information-object"/>
    <rdfs:range rdf:resource="&b;description"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;orders">
    <owl:inverseOf rdf:resource="&b;ordered-by"/>
    <rdfs:subPropertyOf rdf:resource="&d;mediated-relation-i"/>
    <rdfs:domain rdf:resource="&b;description"/>
    <rdfs:range rdf:resource="&b;information-object"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;p-sat">
    <rdfs:comment rdf:datatype="&xsd;string">P-SAT assumes two satisfaction semantics: redundant satisfaction and qualified satisfaction. In order to allow for a correct implementation of the qualified satisfaction, P-SAT requires that the description exists prior to at least some of the entities in the setting of the satisfying situation. Ontologically, it results that P-SAT also implies a specific dependency of the situation on its description. P-SAT typically applies to plans, projects, designs, methods, techniques, game rules, instructions, punishment rules, constitutive descriptions, sanctions, and strategies.A sample P-SAT qualified satisfaction axiom for plans is given in OWL.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;p-sat-by"/>
    <rdfs:subPropertyOf rdf:resource="&b;satisfies"/>
    <rdfs:domain rdf:resource="&b;situation"/>
    <rdfs:range rdf:resource="&b;description"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;p-sat-by">
    <owl:inverseOf rdf:resource="&b;p-sat"/>
    <rdfs:subPropertyOf rdf:resource="&b;satisfied-by"/>
    <rdfs:domain rdf:resource="&b;description"/>
    <rdfs:range rdf:resource="&b;situation"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;parametrized-by">
    <rdfs:comment rdf:datatype="&xsd;string">The mediated relation between an entity and a parameter through the region at which the entity is localized and that is the value for the parameter.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;parametrizes"/>
    <rdfs:subPropertyOf rdf:resource="&d;mediated-relation-i"/>
    <rdfs:domain rdf:resource="&d;particular"/>
    <rdfs:range rdf:resource="&b;parameter"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;parametrizes">
    <owl:inverseOf rdf:resource="&b;parametrized-by"/>
    <rdfs:subPropertyOf rdf:resource="&d;mediated-relation"/>
    <rdfs:domain rdf:resource="&b;parameter"/>
    <rdfs:range rdf:resource="&d;particular"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;played-by">
    <rdfs:comment rdf:datatype="&xsd;string">This is the immediate relation between roles and endurants. A role classifies the position (function, use, relevance, ...) of an endurant within a context (description). Roles can be ordered, interdependent, at different layers. etc.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;plays"/>
    <rdfs:subPropertyOf rdf:resource="&b;classifies"/>
    <rdfs:domain rdf:resource="&b;role"/>
    <rdfs:range rdf:resource="&d;endurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;plays">
    <rdfs:comment rdf:datatype="&xsd;string">This is the immediate relation between roles and endurants. A role classifies the position (function, use, relevance, ...) of an endurant within a context (description). Roles can be ordered, interdependent, at different layers. etc.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;played-by"/>
    <rdfs:subPropertyOf rdf:resource="&b;classified-by"/>
    <rdfs:domain rdf:resource="&d;endurant"/>
    <rdfs:range rdf:resource="&b;role"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;predecessor">
    <rdfs:comment rdf:datatype="&xsd;string">To be understood as 'entity x  has predecessor y'.This is the transitive version, but it results to be a complex property in OWL-DL, and transitivity should be overruled.</rdfs:comment>
    <rdf:type rdf:resource="&owl;TransitiveProperty"/>
    <owl:inverseOf rdf:resource="&b;successor"/>
    <rdfs:subPropertyOf rdf:resource="&d;immediate-relation-i"/>
    <rdfs:domain rdf:resource="&d;particular"/>
    <rdfs:range rdf:resource="&d;particular"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;r-sat">
    <rdfs:comment rdf:datatype="&xsd;string">R-SAT assumes redundant satisfaction and qualified satisfaction, but it works out that semantics with entities in the situation that entirely exist prior to the description.This seems paradoxical, since a description hardly motivates what happens if it is not present to any agent involved in things happening. For this reason, we postulate a so-called specific retroactive dependency (SRD), meaning that the creator of the description is willing to attribute the status of a scientific law to that description, despite it could not be present before the situation. R-SAT typically applies to explanations that are considered as well-founded in science (physical, social, or cognitive), reverse engineering, criminal investigation, etc. Consider that the actual validity of the explanation is not addressed by the description, but by external evaluation descriptions.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;r-sat-by"/>
    <rdfs:subPropertyOf rdf:resource="&b;satisfies"/>
    <rdfs:domain rdf:resource="&b;situation"/>
    <rdfs:range rdf:resource="&b;description"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;r-sat-by">
    <owl:inverseOf rdf:resource="&b;r-sat"/>
    <rdfs:subPropertyOf rdf:resource="&b;satisfied-by"/>
    <rdfs:domain rdf:resource="&b;description"/>
    <rdfs:range rdf:resource="&b;situation"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;realized-by">
    <rdfs:comment rdf:datatype="&xsd;string">a.k.a. support.A (usually physical) representation (p. endurant, p. perdurant, p. quality, p. region, or p. situation) realizes a non-physical object according to a system of rules.The main use of this relation is between information objects and the entities through which information objects are used and interpreted. E.g. a paper copy of the 1861 edition of Dante's Comedy, with Dore's illustrations, realizes the Comedy (as an information object).There is a sense in which any entity that realizes an IO also realizes an IO about itself.For example, a painting realizing information about a woman also realizes information about its own information. Of course, the converse of the previous axiom does not hold in general.For example, the information about a woman can be realized by entities different from that woman (as when referring to an absent woman). In other words, an entity (in a semiotic perspective) always realizes two information objects: one about itself, and another about something else.In the non-representation cases, the information objects are identical (an entity only realizes information about itself).Therefore entities, once they have a relevance in a society, can have semiotic properties. Even physical artifacts that are not built primarily for communicative purposes  e.g. a chair  can be considered as realizing some IO that expresses a design description (cf. system-design), and is about a context (situation) of use, fruition, or just affordance that satisfies the design.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;realizes"/>
    <rdfs:subPropertyOf rdf:resource="&b;intensionally-references"/>
    <rdfs:domain rdf:resource="&d;non-physical-object"/>
    <rdfs:range rdf:resource="&b;physical-realization"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;realizes">
    <owl:inverseOf rdf:resource="&b;realized-by"/>
    <rdfs:subPropertyOf rdf:resource="&b;intensionally-referenced-by"/>
    <rdfs:domain rdf:resource="&b;physical-realization"/>
    <rdfs:range rdf:resource="&d;non-physical-object"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;referenced-by">
    <rdfs:comment rdf:datatype="&xsd;string">A relation holding between non-physical objects and entities whatsoever (thus including non-physical objects themselves). An intuition for the references relation could be that a non-physical object adds 'information'  to an entity. In fact, non-physical objects depend on a communication setting. In most cases, this is the characteristic relation that provides  a unity criterion to objects, events, etc. For example, cars are objects and not mere aggregates because there is a project, a design, a social value, a functional structure, a personal emotional structure, etc. attached to them. This attachment can be represented by means of 'non-physical objects' that 'reference' cars. The most obvious application is for situations, which do not exist without a description, although they still are extensional entities: a situation without a part is no more the same situation, but a situation is not a mere aggregate, since it has references to a description as its unity criterion. Adding information to an entity can also be thought as an intentional solution to a holistic stance. Defenders of this view -within different frameworks- are Kant, Brentano, Husserl, Gestalt psychologists, Merleau-Ponty ... References is distinguished according to the kinds of non-physical objects and referenced ground entities: referencing between descriptions and situations is called 'SATISFIED-BY', while referencing between description components and situation components is called 'CLASSIFIES'. 'SETTING-FOR' is a referencing relation between a situation and the entities in its setting (it was formerly a constitution relation, but since situation appear to be social objects from the DOLCE viewpoint, the constitution solution is no more applicable). 'EXPRESSES' is bound to information objects and the meaning (description of a representation or conceptualization) in which they are involved. 'REALIZED-BY' is bound to information objects and physical representations that are used to communicate them, etc. 'ABOUT' is bound to information objects and entities whatsoever (aboutness of intentionality).</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;references"/>
    <rdfs:subPropertyOf rdf:resource="&d;immediate-relation-i"/>
    <rdfs:domain rdf:resource="&d;particular"/>
    <rdfs:range rdf:resource="&d;non-physical-object"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;references">
    <rdfs:comment rdf:datatype="&xsd;string">A relation holding between non-physical objects and entities whatsoever (thus including non-physical objects themselves). An intuition for the references relation could be that a non-physical object adds  'information' to an entity. In fact, non-physical objects depend on a communication setting. In most cases, this is the characteristic relation that provides a unity criterion to objects, events, etc.  For example, cars are objects and not mere aggregates because there is a  project, a design, a social value, a functional structure, a  personal emotional structure, etc. attached to them. This attachment can be represented by means of 'non-physical objects' that 'reference' cars. The most obvious application is for situations, which do not exist without a description, although they still are extensional entities: a situation without a part is no more the same situation, but a situation is not a mere aggregate, since it has references to a description  as its unity criterion. Adding information to an entity can also be thought as an intentional solution to a holistic stance. Defenders of this view -within different frameworks- are  Kant, Brentano, Husserl, Gestalt psychologists, Merleau-Ponty ... References is distinguished according to the kinds of non-physical objects and referenced  ground entities: referencing between descriptions and situations is called 'SATISFIED-BY', while referencing between description components and situation components is called 'CLASSIFIES'. 'SETTING-FOR' is a referencing relation between situation and the entities in its setting (it was formerly a constitution relation, but since situation appear to be social objects from the DOLCE viewpoint, the constitution solution is no more applicable). 'EXPRESSES' is bound to information objects and the meaning (description of a representation or conceptualization) in which they are involved. 'REALIZED-BY' is bound to information objects and physical representations that are used to communicate them, etc. 'ABOUT' is bound to information objects and entities whatsoever (aboutness of intentionality).</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;referenced-by"/>
    <rdfs:subPropertyOf rdf:resource="&d;immediate-relation"/>
    <rdfs:domain rdf:resource="&d;non-physical-object"/>
    <rdfs:range rdf:resource="&d;particular"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;refined-by">
    <owl:inverseOf rdf:resource="&b;refines"/>
    <rdfs:subPropertyOf rdf:resource="&d;proper-part-of"/>
    <rdfs:domain rdf:resource="&b;social-object"/>
    <rdfs:range rdf:resource="&b;social-object"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;refines">
    <rdfs:comment rdf:datatype="&xsd;string">Concepts and figures can be refined by adding components, e.g. an elementary task can become complex, a complex task can increase its complexity, maximal tasks can be composed, etc.A description gets expanded if one of the concepts or figures it uses are refined.Refinement applies also to collections, situations, and information objects.Descriptions are refined by adding component descriptions.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;refined-by"/>
    <rdfs:subPropertyOf rdf:resource="&d;proper-part"/>
    <rdfs:domain rdf:resource="&b;social-object"/>
    <rdfs:range rdf:resource="&b;social-object"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;regulated-by">
    <owl:inverseOf rdf:resource="&b;regulates"/>
    <rdfs:subPropertyOf rdf:resource="&b;satisfies"/>
    <rdfs:domain rdf:resource="&b;situation"/>
    <rdfs:range rdf:resource="&b;regulation"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;regulates">
    <rdfs:comment rdf:datatype="&xsd;string">A regulation states reified conditions on how a situation should look like. Regulations are mostly taken as descriptions for the social world.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;regulated-by"/>
    <rdfs:subPropertyOf rdf:resource="&b;satisfied-by"/>
    <rdfs:domain rdf:resource="&b;regulation"/>
    <rdfs:range rdf:resource="&b;situation"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;required-by">
    <owl:inverseOf rdf:resource="&b;requires"/>
    <rdfs:subPropertyOf rdf:resource="&d;immediate-relation-i"/>
    <rdfs:domain rdf:resource="&b;social-object"/>
    <rdfs:range rdf:resource="&b;social-object"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;requires">
    <owl:inverseOf rdf:resource="&b;required-by"/>
    <rdfs:subPropertyOf rdf:resource="&d;immediate-relation"/>
    <rdfs:domain rdf:resource="&b;social-object"/>
    <rdfs:range rdf:resource="&b;social-object"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;requisite">
    <rdfs:comment rdf:datatype="&xsd;string">Requisites are constraints over the attributes of entities. Within DnS, a requisite-for relation holds between parameters (that bound regions to certain value ranges), and either roles, figures or courses. When a situation satisfies a description with parameters, endurants and perdurants in the situation must have attributes that range within the boundaries stated by parameters (in DOLCE terms, entities must have qualities that are mapped to certain value ranges of regions).</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;requisite-for"/>
    <rdfs:subPropertyOf rdf:resource="&d;immediate-relation-i"/>
    <rdfs:domain>
        <owl:Class>
            <owl:unionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&b;information-object"/>
                <owl:Class rdf:about="&b;role"/>
                <owl:Class rdf:about="&b;figure"/>
                <owl:Class rdf:about="&b;course"/>
            </owl:unionOf>
        </owl:Class>
    </rdfs:domain>
    <rdfs:range rdf:resource="&b;parameter"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;requisite-for">
    <rdfs:comment rdf:datatype="&xsd;string">Requisites are constraints over the attributes of entities. Within DnS, a requisite-for relation holds between parameters (that bound regions to certain value ranges), and either roles, figures or courses. When a situation satisfies a description with parameters, endurants and perdurants in the situation must have attributes that range within the boundaries stated by parameters (in DOLCE terms, entities must have qualities that are mapped to certain value ranges of regions).</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;requisite"/>
    <rdfs:subPropertyOf rdf:resource="&d;immediate-relation"/>
    <rdfs:domain rdf:resource="&b;parameter"/>
    <rdfs:range>
        <owl:Class>
            <owl:unionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&b;information-object"/>
                <owl:Class rdf:about="&b;role"/>
                <owl:Class rdf:about="&b;figure"/>
                <owl:Class rdf:about="&b;course"/>
            </owl:unionOf>
        </owl:Class>
    </rdfs:range>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;right-task-for">
    <owl:inverseOf rdf:resource="&b;right-to"/>
    <rdfs:subPropertyOf rdf:resource="&b;attitude-target-of"/>
    <rdfs:domain rdf:resource="&b;task"/>
    <rdfs:range>
        <owl:Class>
            <owl:unionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&b;agent-driven-role"/>
                <owl:Class rdf:about="&b;agentive-figure"/>
            </owl:unionOf>
        </owl:Class>
    </rdfs:range>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;right-to">
    <rdfs:comment rdf:datatype="&xsd;string">A relation between a role and a right allowance towards some function/task.This is dispositional, and implies that a participation classified by this relation is a 'righteous participation'.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;right-task-for"/>
    <rdfs:subPropertyOf rdf:resource="&b;attitude-towards"/>
    <rdfs:domain>
        <owl:Class>
            <owl:unionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&b;agent-driven-role"/>
                <owl:Class rdf:about="&b;agentive-figure"/>
            </owl:unionOf>
        </owl:Class>
    </rdfs:domain>
    <rdfs:range rdf:resource="&b;task"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;satisfied-by">
    <rdfs:comment rdf:datatype="&xsd;string">See also comment on 'satisfies' for a different explanation.This is the     primitive relation between descriptions and situations. It can be     understood as a reification of the 'satisfiability' relation of formal     semantics that holds between theories and models. A theory is reified as a description, thus acquiring a life-cycle: a theory     can be changed, versioned, discussed, issued, etc. 'Theory' can be a 'potential' theory in the sense that most conceptualizations     that could be formalized, could also be reified, e.g. plans, norms,     stories, projects, diagnoses, methods, etc. No position is taken on the     extensionality of descriptions. For example, if a theory is required to be     reified in fine detail, if it changes an axiom, it could be considered no     more the same theory. On the other hand, if theories are reified without such a strong assumption,     some axioms can be changed just like non-essential parts of physical     objects, with the theory preserving its identity.In case a theory is considered extensional, it might be considered a member of     a class of 'theory changing history'. The 'refines' relation provides this     possibility.A model is reified as a situation, thus a *class* of models that can satisfy a     theory is reified as a situation type (class). Situations can depend on     descriptions, but not vice-versa (constructivist stance). Components of     descriptions 'classify' entities of situations.There are at least three     satisfaction subrelations, and a lot of conditions can be stated for     allowing an automatic matching of satisfaction. See the FOL version of DLP     for details.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;satisfies"/>
    <rdfs:subPropertyOf rdf:resource="&b;intensionally-references"/>
    <rdfs:domain rdf:resource="&b;description"/>
    <rdfs:range rdf:resource="&b;situation"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;satisfies">
    <rdfs:comment rdf:datatype="&xsd;string">See 'satisfied-by'.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;satisfied-by"/>
    <rdfs:subPropertyOf rdf:resource="&b;intensionally-referenced-by"/>
    <rdfs:domain rdf:resource="&b;situation"/>
    <rdfs:range rdf:resource="&b;description"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;sequenced-by">
    <owl:inverseOf rdf:resource="&b;sequences"/>
    <rdfs:subPropertyOf rdf:resource="&b;classified-by"/>
    <rdfs:domain rdf:resource="&d;perdurant"/>
    <rdfs:range rdf:resource="&b;course"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;sequences">
    <rdfs:comment rdf:datatype="&xsd;string">This is the immediate relation between courses and perdurants. A course can be either atomic, being a simple 'perdurant role', or it can be complex, thus creating an abstract ordering over a temporal or causal sequence of processes or actions. The ontology of plans develops in detail intentional complex courses.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;sequenced-by"/>
    <rdfs:subPropertyOf rdf:resource="&b;classifies"/>
    <rdfs:domain rdf:resource="&b;course"/>
    <rdfs:range rdf:resource="&d;perdurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;setting">
    <owl:inverseOf rdf:resource="&b;setting-for"/>
    <rdfs:subPropertyOf rdf:resource="&b;referenced-by"/>
    <rdfs:domain rdf:resource="&d;particular"/>
    <rdfs:range rdf:resource="&b;situation"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;setting-for">
    <rdfs:comment rdf:datatype="&xsd;string">The relation between a situation and the entities that are referenced by it. (At least some of, or all) such entities must be classified by concepts defined by the description that the situation is supposed to satisfy.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;setting"/>
    <rdfs:subPropertyOf rdf:resource="&b;references"/>
    <rdfs:domain rdf:resource="&b;situation"/>
    <rdfs:range rdf:resource="&d;particular"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;specialized-by">
    <rdfs:comment rdf:datatype="&xsd;string">Specialization as reification of a partial-order relation between type- or set-reified social objects, i.e. descriptions, concepts, and collections.For example, concepts that are apparently classified by other concepts; e.g. a manager that plays the role of buyer, where the role manager actually specializes the role buyer. Descriptions can be specialized by other descriptions that specialize their concepts. For descriptions, an intention to specialize must be present (unless purely formal theories are considered, but even in this case a criterion of relevance is usually active). Specialization does not imply expansion (proper part) for descriptions. If there exists a concept that is defined by the specialized description, which is not d-used in the specializing one, the second only specializes a part of the first. If there exists a concept that is defined by the specializing description, which is not d-used by the specialized one, the first both specializes and expands the second.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;specializes"/>
    <rdfs:subPropertyOf rdf:resource="&d;immediate-relation-i"/>
    <rdfs:domain>
        <owl:Class>
            <owl:unionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&b;concept"/>
                <owl:Class rdf:about="&b;description"/>
                <owl:Class rdf:about="&b;collection"/>
            </owl:unionOf>
        </owl:Class>
    </rdfs:domain>
    <rdfs:range>
        <owl:Class>
            <owl:unionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&b;concept"/>
                <owl:Class rdf:about="&b;description"/>
                <owl:Class rdf:about="&b;collection"/>
            </owl:unionOf>
        </owl:Class>
    </rdfs:range>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;specializes">
    <rdfs:comment rdf:datatype="&xsd;string">Specialization as reification of a partial-order relation between social objects. For example, concepts that are apparently classified by other concepts; e.g. a manager that plays the role of buyer, where the role manager actually specializes the role buyer. Descriptions can be specialized by other descriptions that specialize their concepts or figures. For descriptions, an intention to specialize must be present (unless purely formal theories are considered, but even in this case a criterion of relevance is usually active). Specialization does not imply expansion (proper part) for descriptions. If there exists a concept that is defined by the specialized description, which is not d-used in the specializing one, the second only specializes a part of the first. If there exists a concept that is defined by the specializing description, which is not d-used by the specialized one, the first both specializes and expands the second.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;specialized-by"/>
    <rdfs:subPropertyOf rdf:resource="&d;immediate-relation"/>
    <rdfs:domain>
        <owl:Class>
            <owl:unionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&b;concept"/>
                <owl:Class rdf:about="&b;description"/>
                <owl:Class rdf:about="&b;collection"/>
            </owl:unionOf>
        </owl:Class>
    </rdfs:domain>
    <rdfs:range>
        <owl:Class>
            <owl:unionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&b;concept"/>
                <owl:Class rdf:about="&b;description"/>
                <owl:Class rdf:about="&b;collection"/>
            </owl:unionOf>
        </owl:Class>
    </rdfs:range>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;successor">
    <rdfs:comment rdf:datatype="&xsd;string">To be understood as 'entity x  has successor y'. Succession does not exclude connection, but it excludes overlapping. It can be direct or indirect, and assumes a choice (temporal, spatial, abstract, etc.) Cf. the cognitive 'path' schema. This is the transitive version.</rdfs:comment>
    <rdf:type rdf:resource="&owl;TransitiveProperty"/>
    <owl:inverseOf rdf:resource="&b;predecessor"/>
    <rdfs:subPropertyOf rdf:resource="&d;immediate-relation"/>
    <rdfs:domain rdf:resource="&d;particular"/>
    <rdfs:range rdf:resource="&d;particular"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;temporary-component">
    <rdfs:comment rdf:datatype="&xsd;string">Being component at time t. It holds for endurants only. This is important to model components that can change or be lost over time without affecting the identity of the whole.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;temporary-component-of"/>
    <rdfs:subPropertyOf rdf:resource="&d;temporary-proper-part"/>
    <rdfs:subPropertyOf rdf:resource="&b;component"/>
    <rdfs:domain rdf:resource="&d;endurant"/>
    <rdfs:range rdf:resource="&d;endurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;temporary-component-of">
    <owl:inverseOf rdf:resource="&b;temporary-component"/>
    <rdfs:subPropertyOf rdf:resource="&d;temporary-proper-part-of"/>
    <rdfs:subPropertyOf rdf:resource="&b;component-of"/>
    <rdfs:domain rdf:resource="&d;endurant"/>
    <rdfs:range rdf:resource="&d;endurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;unified-by">
    <owl:inverseOf rdf:resource="&b;unifies"/>
    <rdfs:subPropertyOf rdf:resource="&b;referenced-by"/>
    <rdfs:domain rdf:resource="&b;collection"/>
    <rdfs:range rdf:resource="&b;description"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;unifies">
    <rdfs:comment rdf:datatype="&xsd;string">Based on characterizing roles, collections specifically depend on some description.We can therefore build a new relation of unification between collections and the descriptions on which they depend. Unification is axiomatized by means of sufficient conditions, and is not temporalized, since changing the description (differently from changing some members) creates a new collection.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;unified-by"/>
    <rdfs:subPropertyOf rdf:resource="&b;references"/>
    <rdfs:domain rdf:resource="&b;description"/>
    <rdfs:range rdf:resource="&b;collection"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;used-by">
    <owl:inverseOf rdf:resource="&b;uses"/>
    <rdfs:subPropertyOf rdf:resource="&b;co-participates-with"/>
    <rdfs:domain rdf:resource="&d;endurant"/>
    <rdfs:range rdf:resource="&d;endurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;uses">
    <rdfs:comment rdf:datatype="&xsd;string">The use relations between endurants: an endurant e1 uses e2 within a perdurant in which both are participating. A rule then states that if e1 uses e2, e2 is used *in* a perdurant.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;used-by"/>
    <rdfs:subPropertyOf rdf:resource="&b;co-participates-with"/>
    <rdfs:domain rdf:resource="&d;endurant"/>
    <rdfs:range rdf:resource="&d;endurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;value-for">
    <rdfs:comment rdf:datatype="&xsd;string">The "selected by" relations holding between regions and parameters. At least one region is supposed to be a value for a parameter.</rdfs:comment>
    <owl:inverseOf rdf:resource="&b;valued-by"/>
    <rdfs:subPropertyOf rdf:resource="&b;classified-by"/>
    <rdfs:domain rdf:resource="&d;region"/>
    <rdfs:range rdf:resource="&b;parameter"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&b;valued-by">
    <owl:inverseOf rdf:resource="&b;value-for"/>
    <rdfs:subPropertyOf rdf:resource="&b;classifies"/>
    <rdfs:domain rdf:resource="&b;parameter"/>
    <rdfs:range rdf:resource="&d;region"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&c;causally-follows">
    <owl:inverseOf rdf:resource="&c;causally-precedes"/>
    <rdfs:subPropertyOf rdf:resource="&f;follows"/>
    <rdfs:domain rdf:resource="&d;perdurant"/>
    <rdfs:range rdf:resource="&b;activity"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&c;causally-precedes">
    <owl:inverseOf rdf:resource="&c;causally-follows"/>
    <rdfs:subPropertyOf rdf:resource="&f;precedes"/>
    <rdfs:domain rdf:resource="&b;activity"/>
    <rdfs:range rdf:resource="&d;perdurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&c;functional-participant">
    <rdfs:comment rdf:datatype="&xsd;string">This relation constrains participation within the scope of a description: a perdurant is participated by an object according to a description and its components.</rdfs:comment>
    <owl:inverseOf rdf:resource="&c;functional-participant-in"/>
    <rdfs:subPropertyOf rdf:resource="&d;participant"/>
    <rdfs:domain rdf:resource="&d;perdurant"/>
    <rdfs:range rdf:resource="&d;endurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&c;functional-participant-in">
    <owl:inverseOf rdf:resource="&c;functional-participant"/>
    <rdfs:subPropertyOf rdf:resource="&d;participant-in"/>
    <rdfs:domain rdf:resource="&d;endurant"/>
    <rdfs:range rdf:resource="&d;perdurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&c;generic-target">
    <rdfs:comment rdf:datatype="&xsd;string">A functional participation relation holding between activities and targeted endurants.It catches the everyday language notion of being the destination of an action. Unfortunately, such a notion can't be formalized in general, because it is sensible to the particular plan that drives the action. Possibly, once a rich taxonomy of actions and related personal and social plans is developed, a better axiomatization can be provided.</rdfs:comment>
    <owl:inverseOf rdf:resource="&c;generic-target-of"/>
    <rdfs:subPropertyOf rdf:resource="&c;functional-participant"/>
    <rdfs:domain rdf:resource="&b;activity"/>
    <rdfs:range rdf:resource="&d;endurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&c;generic-target-of">
    <owl:inverseOf rdf:resource="&c;generic-target"/>
    <rdfs:subPropertyOf rdf:resource="&c;functional-participant-in"/>
    <rdfs:domain rdf:resource="&d;endurant"/>
    <rdfs:range rdf:resource="&b;activity"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&c;has-state">
    <owl:inverseOf rdf:resource="&c;state-of"/>
    <rdfs:subPropertyOf rdf:resource="&c;substrate-of"/>
    <rdfs:domain rdf:resource="&d;endurant"/>
    <rdfs:range rdf:resource="&d;state"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&c;instrument">
    <rdfs:comment rdf:datatype="&xsd;string">A functional usage participation relation holding between activities and physical objects.It catches the everyday language notion of being the tool, support or devisce of an action. Unfortunately, such a notion can't be formalized in general, because it is sensible to the particular plan that drives the action. Possibly, once a rich taxonomy of actions and related personal and social plans is developed, a better axiomatization can be provided.</rdfs:comment>
    <owl:inverseOf rdf:resource="&c;instrument-of"/>
    <rdfs:subPropertyOf rdf:resource="&c;use-of"/>
    <rdfs:domain rdf:resource="&b;activity"/>
    <rdfs:range rdf:resource="&d;physical-object"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&c;instrument-of">
    <owl:inverseOf rdf:resource="&c;instrument"/>
    <rdfs:subPropertyOf rdf:resource="&c;used-in"/>
    <rdfs:domain rdf:resource="&d;physical-object"/>
    <rdfs:range rdf:resource="&b;activity"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&c;patient">
    <rdfs:comment rdf:datatype="&xsd;string">A functional participation relation assuming a relatively static role played by the endurant (e.g. not conceiving a plan, being subjected to some manipulation without involvement, etc.).Unfortunately, such a notion can't be formalized in general, because it is sensible to the particular plan that drives the action. Possibly, once a rich taxonomy of actions and related personal and social plans is developed, a better axiomatization can be provided.</rdfs:comment>
    <owl:inverseOf rdf:resource="&c;patient-of"/>
    <rdfs:subPropertyOf rdf:resource="&c;functional-participant"/>
    <rdfs:domain rdf:resource="&d;perdurant"/>
    <rdfs:range rdf:resource="&d;endurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&c;patient-of">
    <owl:inverseOf rdf:resource="&c;patient"/>
    <rdfs:subPropertyOf rdf:resource="&c;functional-participant-in"/>
    <rdfs:domain rdf:resource="&d;endurant"/>
    <rdfs:range rdf:resource="&d;perdurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&c;performed-by">
    <owl:inverseOf rdf:resource="&c;performs"/>
    <rdfs:subPropertyOf rdf:resource="&c;functional-participant"/>
    <rdfs:domain rdf:resource="&b;action"/>
    <rdfs:range rdf:resource="&b;agent"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&c;performs">
    <rdfs:comment rdf:datatype="&xsd;string">A functional participation relation holding between agents and actions. It catches the everyday language notion of being the initiator of an action, or having a leading or primary role. Unfortunately, such a notion can't be formalized in general, because it is sensible to the particular plan that drives the action. Possibly, once a rich taxonomy of actions and related personal and social plans is developed, a better axiomatization can be provided.</rdfs:comment>
    <owl:inverseOf rdf:resource="&c;performed-by"/>
    <rdfs:subPropertyOf rdf:resource="&c;functional-participant-in"/>
    <rdfs:domain rdf:resource="&b;agent"/>
    <rdfs:range rdf:resource="&b;action"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&c;prescribed-by">
    <owl:inverseOf rdf:resource="&c;prescribes"/>
    <rdfs:subPropertyOf rdf:resource="&c;performed-by"/>
    <rdfs:domain rdf:resource="&b;action"/>
    <rdfs:range rdf:resource="&b;agent"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&c;prescribes">
    <rdfs:comment rdf:datatype="&xsd;string">The power of enforcing a plan of action to other agents.</rdfs:comment>
    <owl:inverseOf rdf:resource="&c;prescribed-by"/>
    <rdfs:subPropertyOf rdf:resource="&c;performs"/>
    <rdfs:domain rdf:resource="&b;agent"/>
    <rdfs:range rdf:resource="&b;action"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&c;product">
    <rdfs:comment rdf:datatype="&xsd;string">A functional participation relation that assumes a meet relation between an activity and the life of an endurant.Unfortunately, such a notion can't be formalized in general, because it is sensible to the particular project that drives the action. Possibly, once a rich taxonomy of actions and related personal and social plans is developed, a better axiomatization can be provided.</rdfs:comment>
    <owl:inverseOf rdf:resource="&c;product-of"/>
    <rdfs:subPropertyOf rdf:resource="&c;functional-participant"/>
    <rdfs:domain rdf:resource="&b;activity"/>
    <rdfs:range rdf:resource="&d;endurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&c;product-of">
    <owl:inverseOf rdf:resource="&c;product"/>
    <rdfs:subPropertyOf rdf:resource="&c;functional-participant-in"/>
    <rdfs:domain rdf:resource="&d;endurant"/>
    <rdfs:range rdf:resource="&b;activity"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&c;resource">
    <rdfs:comment rdf:datatype="&xsd;string">An amount of matter can be a resource in some activity, if it has some role bound to the course that sequences the activity in a same description (typically a plan).</rdfs:comment>
    <owl:inverseOf rdf:resource="&c;resource-for"/>
    <rdfs:subPropertyOf rdf:resource="&c;use-of"/>
    <rdfs:domain rdf:resource="&b;activity"/>
    <rdfs:range rdf:resource="&d;amount-of-matter"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&c;resource-for">
    <owl:inverseOf rdf:resource="&c;resource"/>
    <rdfs:subPropertyOf rdf:resource="&c;used-in"/>
    <rdfs:domain rdf:resource="&d;amount-of-matter"/>
    <rdfs:range rdf:resource="&b;activity"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&c;result">
    <owl:inverseOf rdf:resource="&c;result-of"/>
    <rdfs:subPropertyOf rdf:resource="&c;causally-precedes"/>
    <rdfs:domain rdf:resource="&b;activity"/>
    <rdfs:range rdf:resource="&d;perdurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&c;result-of">
    <rdfs:comment rdf:datatype="&xsd;string">A perdurant p1 results from another one p2 if they are sequenced within a same course, if a same endurant participates in both perdurants, and if p1 follows p2.</rdfs:comment>
    <owl:inverseOf rdf:resource="&c;result"/>
    <rdfs:subPropertyOf rdf:resource="&c;causally-follows"/>
    <rdfs:domain rdf:resource="&d;perdurant"/>
    <rdfs:range rdf:resource="&b;activity"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&c;state-of">
    <owl:inverseOf rdf:resource="&c;has-state"/>
    <rdfs:subPropertyOf rdf:resource="&c;substrate"/>
    <rdfs:domain rdf:resource="&d;state"/>
    <rdfs:range rdf:resource="&d;endurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&c;substrate">
    <rdfs:comment rdf:datatype="&xsd;string">A functional participation relation assuming a total constant participation, beyond certain roles and courses defined by a description.</rdfs:comment>
    <owl:inverseOf rdf:resource="&c;substrate-of"/>
    <rdfs:subPropertyOf rdf:resource="&d;total-constant-participant"/>
    <rdfs:subPropertyOf rdf:resource="&c;functional-participant"/>
    <rdfs:domain rdf:resource="&d;perdurant"/>
    <rdfs:range rdf:resource="&d;endurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&c;substrate-of">
    <rdfs:comment rdf:datatype="&xsd;string">A functional participation relation assuming a total constant participation, beyond certain roles and courses defined by a description.</rdfs:comment>
    <owl:inverseOf rdf:resource="&c;substrate"/>
    <rdfs:subPropertyOf rdf:resource="&d;total-constant-participant-in"/>
    <rdfs:subPropertyOf rdf:resource="&c;functional-participant-in"/>
    <rdfs:domain rdf:resource="&d;endurant"/>
    <rdfs:range rdf:resource="&d;perdurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&c;target">
    <rdfs:comment rdf:datatype="&xsd;string">Targeting at an endurant, which in principle can avoid bearing modifications.</rdfs:comment>
    <owl:inverseOf rdf:resource="&c;target-of"/>
    <rdfs:subPropertyOf rdf:resource="&c;patient"/>
    <rdfs:domain rdf:resource="&d;perdurant"/>
    <rdfs:range rdf:resource="&d;endurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&c;target-of">
    <owl:inverseOf rdf:resource="&c;target"/>
    <rdfs:subPropertyOf rdf:resource="&c;patient-of"/>
    <rdfs:domain rdf:resource="&d;endurant"/>
    <rdfs:range rdf:resource="&d;perdurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&c;theme">
    <rdfs:comment rdf:datatype="&xsd;string">A perdurant can have some information object as patient participant, e.g. in a communication activity.</rdfs:comment>
    <owl:inverseOf rdf:resource="&c;theme-of"/>
    <rdfs:subPropertyOf rdf:resource="&c;patient"/>
    <rdfs:domain rdf:resource="&d;perdurant"/>
    <rdfs:range rdf:resource="&b;information-object"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&c;theme-of">
    <owl:inverseOf rdf:resource="&c;theme"/>
    <rdfs:subPropertyOf rdf:resource="&c;patient-of"/>
    <rdfs:domain rdf:resource="&b;information-object"/>
    <rdfs:range rdf:resource="&d;perdurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&c;use-of">
    <rdfs:comment rdf:datatype="&xsd;string">A functional participation between an action and an endurant that supports the goals of a performer.It catches the everyday language notion of being exploited during an action by someone/something that initiates or leads  it.Unfortunately, such a notion can't be formalized in general, because it is sensible to the particular plan that drives the action. Possibly, once a rich taxonomy of actions and related personal and social plans is developed, a better axiomatization can be provided.</rdfs:comment>
    <owl:inverseOf rdf:resource="&c;used-in"/>
    <rdfs:subPropertyOf rdf:resource="&c;functional-participant"/>
    <rdfs:domain rdf:resource="&b;action"/>
    <rdfs:range rdf:resource="&d;endurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&c;used-in">
    <owl:inverseOf rdf:resource="&c;use-of"/>
    <rdfs:subPropertyOf rdf:resource="&c;functional-participant-in"/>
    <rdfs:domain rdf:resource="&d;endurant"/>
    <rdfs:range rdf:resource="&b;action"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&e;bdi">
    <rdfs:comment rdf:datatype="&xsd;string">A generic attitude relation that holds between agent-driven roles or agentive figures and tasks. This is used here as a shortcut for saying that someone participates to some action with a plan in mind, and desiring it. An analytic account of this relation requires an explicit plan, and that the course be a goal inside that plan.The acronym 'bdi' in the name is for 'belief, desire, intention', a well known model of deliberation used in many agent architectures.The intuition goes to the deliberative agent as something that, provided it has the belief _p_, the desire to have _q_, and the intention to do _r_ in order to get _q_, then it is ready to deliberate an action.Here it is as a placeholder, wating for a more comprehensive ontological theory that takes into account not only BDI, but also the details of interacting, cooperative, competitive agents in the context of complex social and legal modalities of action.This is a simple summary of how BDI is usually understood and implemented in information systems:- According to Wooldridge and Jennings, strong agents can possess mental attitudes.- According to the BDI paradigm, the current state of entities and environment as perceived by the agent (preconditions) are the agent's beliefs.- Desires are some future states that an agent would like to be in. Desires are sometimes called goals.- Intentions are some commitment of an agent to achieve a goal by progressing along a particular future path that leads to the goal. Such path is sometimes called a plan. - One advantage with using intentions is that the effort associated with creating them needs not be repeated every time they are required. Intentions can be pre-computed and cached. Each intention can be tagged with a trigger describing some situation in which this intention should be accessed and applied.- In a typical BDI paradigm, deliberation is done through the selection of a goal, the selection of a plan that will be used to form an intention, the selection of an intention, and the execution of the selected intention. All these decisions are based on the beliefs the agent has about the current state of the environment. The process of selecting the plan is known as means-end reasoning.</rdfs:comment>
    <owl:inverseOf rdf:resource="&e;bdi-target-of"/>
    <rdfs:subPropertyOf rdf:resource="&b;attitude-towards"/>
    <rdfs:domain>
        <owl:Class>
            <owl:unionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&b;agent-driven-role"/>
                <owl:Class rdf:about="&b;agentive-figure"/>
            </owl:unionOf>
        </owl:Class>
    </rdfs:domain>
    <rdfs:range rdf:resource="&b;task"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&e;bdi-target-of">
    <owl:inverseOf rdf:resource="&e;bdi"/>
    <rdfs:subPropertyOf rdf:resource="&b;attitude-target-of"/>
    <rdfs:domain rdf:resource="&b;task"/>
    <rdfs:range>
        <owl:Class>
            <owl:unionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&b;agent-driven-role"/>
                <owl:Class rdf:about="&b;agentive-figure"/>
            </owl:unionOf>
        </owl:Class>
    </rdfs:range>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&e;desire-target-of">
    <owl:inverseOf rdf:resource="&e;desire-towards"/>
    <rdfs:subPropertyOf rdf:resource="&b;attitude-target-of"/>
    <rdfs:domain rdf:resource="&b;course"/>
    <rdfs:range>
        <owl:Class>
            <owl:unionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&b;agent-driven-role"/>
                <owl:Class rdf:about="&b;agentive-figure"/>
            </owl:unionOf>
        </owl:Class>
    </rdfs:range>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&e;desire-towards">
    <rdfs:comment rdf:datatype="&xsd;string">A modal relation expressing that an agent conceives a description by 'desiring' a certain course of events.</rdfs:comment>
    <owl:inverseOf rdf:resource="&e;desire-target-of"/>
    <rdfs:subPropertyOf rdf:resource="&b;attitude-towards"/>
    <rdfs:domain>
        <owl:Class>
            <owl:unionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&b;agent-driven-role"/>
                <owl:Class rdf:about="&b;agentive-figure"/>
            </owl:unionOf>
        </owl:Class>
    </rdfs:domain>
    <rdfs:range rdf:resource="&b;course"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&e;subject-target-of">
    <owl:inverseOf rdf:resource="&e;subjected-to"/>
    <rdfs:subPropertyOf rdf:resource="&b;attitude-target-of"/>
    <rdfs:domain rdf:resource="&b;task"/>
    <rdfs:range>
        <owl:Class>
            <owl:unionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&b;agent-driven-role"/>
                <owl:Class rdf:about="&b;agentive-figure"/>
            </owl:unionOf>
        </owl:Class>
    </rdfs:range>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&e;subjected-to">
    <rdfs:comment rdf:datatype="&xsd;string">A modality characterized by a low commitment, and bearing modifications to the player of the role, or the figure.</rdfs:comment>
    <owl:inverseOf rdf:resource="&e;subject-target-of"/>
    <rdfs:subPropertyOf rdf:resource="&b;attitude-towards"/>
    <rdfs:domain>
        <owl:Class>
            <owl:unionOf rdf:parseType="Collection">
                <owl:Class rdf:about="&b;agent-driven-role"/>
                <owl:Class rdf:about="&b;agentive-figure"/>
            </owl:unionOf>
        </owl:Class>
    </rdfs:domain>
    <rdfs:range rdf:resource="&b;task"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&f;concluded-by">
    <owl:inverseOf rdf:resource="&f;concludes"/>
    <rdfs:subPropertyOf rdf:resource="&f;temporally-includes"/>
    <rdfs:domain rdf:resource="&d;perdurant"/>
    <rdfs:range rdf:resource="&d;perdurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&f;concludes">
    <rdfs:comment rdf:datatype="&xsd;string">A last part of a perdurant (any part that includes the 'final' boundary, but not the 'initial' one.</rdfs:comment>
    <owl:inverseOf rdf:resource="&f;concluded-by"/>
    <rdfs:subPropertyOf rdf:resource="&f;temporally-included-in"/>
    <rdfs:domain rdf:resource="&d;perdurant"/>
    <rdfs:range rdf:resource="&d;perdurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&f;e-temporal-location">
    <rdfs:comment rdf:datatype="&xsd;string">Analytical indirect location holding between endurants and temporal regions.</rdfs:comment>
    <owl:inverseOf rdf:resource="&f;e-temporal-location-of"/>
    <rdfs:subPropertyOf rdf:resource="&d;exact-location"/>
    <rdfs:domain rdf:resource="&d;endurant"/>
    <rdfs:range rdf:resource="&d;temporal-region"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&f;e-temporal-location-of">
    <owl:inverseOf rdf:resource="&f;e-temporal-location"/>
    <rdfs:subPropertyOf rdf:resource="&d;exact-location-of"/>
    <rdfs:domain rdf:resource="&d;temporal-region"/>
    <rdfs:range rdf:resource="&d;endurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&f;follows">
    <rdf:type rdf:resource="&owl;TransitiveProperty"/>
    <owl:inverseOf rdf:resource="&f;precedes"/>
    <rdfs:subPropertyOf rdf:resource="&f;temporal-relation-i"/>
    <rdfs:domain rdf:resource="&d;perdurant"/>
    <rdfs:range rdf:resource="&d;perdurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&f;meets">
    <rdfs:comment rdf:datatype="&xsd;string">Temporal connection between perdurants: p1 ending part is connected to p2 beginning part.</rdfs:comment>
    <owl:inverseOf rdf:resource="&f;met-by"/>
    <rdfs:subPropertyOf rdf:resource="&f;temporally-connected"/>
    <rdfs:domain rdf:resource="&d;perdurant"/>
    <rdfs:range rdf:resource="&d;perdurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&f;met-by">
    <owl:inverseOf rdf:resource="&f;meets"/>
    <rdfs:subPropertyOf rdf:resource="&f;temporally-connected"/>
    <rdfs:domain rdf:resource="&d;perdurant"/>
    <rdfs:range rdf:resource="&d;perdurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&f;precedes">
    <rdfs:comment rdf:datatype="&xsd;string">Temporal precedence between two perdurants. No further dependence is implied (e.g. mereological, causal).</rdfs:comment>
    <rdf:type rdf:resource="&owl;TransitiveProperty"/>
    <owl:inverseOf rdf:resource="&f;follows"/>
    <rdfs:subPropertyOf rdf:resource="&f;temporal-relation"/>
    <rdfs:domain rdf:resource="&d;perdurant"/>
    <rdfs:range rdf:resource="&d;perdurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&f;present-at">
    <rdfs:comment rdf:datatype="&xsd;string">Presence is axiomatized as being temporally  located in a part of one's life.</rdfs:comment>
    <owl:inverseOf rdf:resource="&f;time-of-presence-of"/>
    <rdfs:subPropertyOf rdf:resource="&f;e-temporal-location"/>
    <rdfs:domain rdf:resource="&d;endurant"/>
    <rdfs:range rdf:resource="&d;time-interval"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&f;started-by">
    <owl:inverseOf rdf:resource="&f;starts"/>
    <rdfs:subPropertyOf rdf:resource="&f;temporally-includes"/>
    <rdfs:domain rdf:resource="&d;perdurant"/>
    <rdfs:range rdf:resource="&d;perdurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&f;starts">
    <rdfs:comment rdf:datatype="&xsd;string">A beginning part of a perdurant (any part that includes the 'initial' boundary, but not the 'final' one.</rdfs:comment>
    <owl:inverseOf rdf:resource="&f;started-by"/>
    <rdfs:subPropertyOf rdf:resource="&f;temporally-included-in"/>
    <rdfs:domain rdf:resource="&d;perdurant"/>
    <rdfs:range rdf:resource="&d;perdurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&f;temporal-location">
    <owl:inverseOf rdf:resource="&f;temporal-location-of"/>
    <rdfs:subPropertyOf rdf:resource="&d;exact-location"/>
    <rdfs:domain rdf:resource="&d;perdurant"/>
    <rdfs:range rdf:resource="&d;temporal-region"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&f;temporal-location-of">
    <owl:inverseOf rdf:resource="&f;temporal-location"/>
    <rdfs:subPropertyOf rdf:resource="&d;exact-location-of"/>
    <rdfs:domain rdf:resource="&d;temporal-region"/>
    <rdfs:range rdf:resource="&d;perdurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&f;temporal-relation">
    <rdfs:comment rdf:datatype="&xsd;string">Any mediated relation that composes temporal locations of perdurants with mereotopological relations between those locations.Mereotopological relations are those specified in the J. Allen's theory of time intervals.</rdfs:comment>
    <owl:inverseOf rdf:resource="&f;temporal-relation-i"/>
    <rdfs:subPropertyOf rdf:resource="&d;mediated-relation"/>
    <rdfs:domain rdf:resource="&d;perdurant"/>
    <rdfs:range rdf:resource="&d;perdurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&f;temporal-relation-i">
    <owl:inverseOf rdf:resource="&f;temporal-relation"/>
    <rdfs:subPropertyOf rdf:resource="&d;mediated-relation-i"/>
    <rdfs:domain rdf:resource="&d;perdurant"/>
    <rdfs:range rdf:resource="&d;perdurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&f;temporally-coincides">
    <rdfs:comment rdf:datatype="&xsd;string">AKA 'co-occurs'. Temporal coincidence between perdurants.</rdfs:comment>
    <owl:inverseOf rdf:resource="&f;temporally-coincides"/>
    <rdfs:subPropertyOf rdf:resource="&f;temporal-relation"/>
    <rdfs:domain rdf:resource="&d;perdurant"/>
    <rdfs:range rdf:resource="&d;perdurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&f;temporally-connected">
    <rdfs:comment rdf:datatype="&xsd;string">Having a common atomic temporal location.</rdfs:comment>
    <owl:inverseOf rdf:resource="&f;temporally-connected"/>
    <rdfs:subPropertyOf rdf:resource="&f;temporal-relation"/>
    <rdfs:domain rdf:resource="&d;perdurant"/>
    <rdfs:range rdf:resource="&d;perdurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&f;temporally-included-in">
    <rdf:type rdf:resource="&owl;TransitiveProperty"/>
    <owl:inverseOf rdf:resource="&f;temporally-includes"/>
    <rdfs:subPropertyOf rdf:resource="&f;temporal-relation-i"/>
    <rdfs:domain rdf:resource="&d;perdurant"/>
    <rdfs:range rdf:resource="&d;perdurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&f;temporally-includes">
    <rdfs:comment rdf:datatype="&xsd;string">All temporal locations of perdurant x are also temporal locations of perdurant y.</rdfs:comment>
    <rdf:type rdf:resource="&owl;TransitiveProperty"/>
    <owl:inverseOf rdf:resource="&f;temporally-included-in"/>
    <rdfs:subPropertyOf rdf:resource="&f;temporal-relation"/>
    <rdfs:domain rdf:resource="&d;perdurant"/>
    <rdfs:range rdf:resource="&d;perdurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&f;temporally-overlaps">
    <rdfs:comment rdf:datatype="&xsd;string">Temporal overlap: having a (partly) common temporal location.</rdfs:comment>
    <owl:inverseOf rdf:resource="&f;temporally-overlaps"/>
    <rdfs:subPropertyOf rdf:resource="&f;temporal-relation"/>
    <rdfs:domain rdf:resource="&d;perdurant"/>
    <rdfs:range rdf:resource="&d;perdurant"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&f;time-of-presence-of">
    <owl:inverseOf rdf:resource="&f;present-at"/>
    <rdfs:subPropertyOf rdf:resource="&f;e-temporal-location-of"/>
    <rdfs:domain rdf:resource="&d;time-interval"/>
    <rdfs:range rdf:resource="&d;endurant"/>
</owl:ObjectProperty>


<owl:Datatype rdf:about="&xsd;decimal"/>

<owl:Datatype rdf:about="&xsd;string"/>

</rdf:RDF>
