DOLCE+DnS Ultralite (DUL) is a simplification and an improvement of some parts of DOLCE Lite-Plus" (an OWL-compatible version of "DOLCE-Full, a foundational ontology). and the ""Descriptions and Situations" ontology. This file also includes Dolce-Zero (D0; a few classes generalizing those of DUL). This file also includes a few top-level classes from the multi-source ontology (MSO) of WebKB-2 for two reasons: i) allow the integration of DUL into the MSO, and ii) structure DUL (group some classes) to ease its understanding. These additional few top-level classes are prefixed by "pm#".
This file shows a translation of DUL in the FL notation. The DUL 3.32 version of April 14th, 2019, in OWL format, was taken as source. The following prefixes are used: "dul#", "d0#", "pm#" and "owl".
To see and browse relations
from a category, copy-paste its identifier into the following text field
(or click here for more options).
A few hyperlinks are also provided below.
Table of Contents
0. Things: Situations (Processes/States) or Entities
1. Situations or types/descriptions of them
1.1. Situations
1.2. Situation types/descriptions
2. Entities: Things that are not Situations
2.1. Entities that are mental or located in space
2.2. Dimensions/Attributes or types/descriptions of them
2.3. Description Instruments/Results/Containers
2.4. Other kinds of Entities that are not Relations
2.5. Entities playing a role
3. Relations
3.1. Relations from/to dul#Entity or dul#Concept, unless in sections below
3.2. Relations from/to "Situations or types/descriptions of them"
3.3. Other Relations from/to Agents
3.4. Other Relations from/to Characteristics
3.5. Other Relations from/to Information Entities
dul#Entity (^Anything: real, possible, or imaginary, which some modeller wants to
talk about for some purpose.^)
\. {( dul#Event/*= pm#situation*/ pm#entity )}
pm#Situation_or_Situation-type-or-description
pm#Collection_or_Collection-type-or-description
d0#CognitiveEntity d0#System d0#Topic
dul#Event_or_PhysicalObject ; //implicitly from DUL; only used once
//= owl#Thing (pm);
d0#CognitiveEntity
(^Attitudes, cognitive abilities, ideologies, psychological phenomena,
mind, etc. E.g. discernment, homophobia, precognition, etc.^) ;
d0#System (^Physical, social, political systems.
viticulture, non-linear system, democracy, water system, etc.
E.g. viticulture, non-linear system, democracy, water system, etc.^) ;
d0#Topic (^Any area, discipline, subject of knowledge.
E.g. algebra, avionics, ballet, theology, engineering, etc.^) ;
dul#Event_or_PhysicalObject
\. {( dul#Event dul#PhysicalObject )} dul#InformationRealization ;
pm#Situation_or_Situation-type-or-description
\. {( dul#Event/*= pm#situation*/ pm#Situation_type-or-description
)} //see next sub-sections
pm#Situation_or_Situation-representation
d0#Activity (pm) d0#Eventuality (pm);
pm#Situation_or_Situation-representation //implicit in relation signatures
\. {( dul#Event/*= pm#situation*/
dul#Situation/*= pm#Situation_representation*/
)};
d0#Activity
(^Any action or task planned or executed by an agent intentionally causing
and participating in it. E.g. swimming, shopping, knowledge sharing, etc.^)
\. {( dul#Action dul#Task )};
d0#Eventuality
(^Any event, situation, activity, event type, etc.
Used to abstract from formal criteria that distinguish between
event occurrences, their types, and
constructed objects (situations, tropes, qua-entities) that provide
a setting for multiple entities^)
\. {( dul#Situation d0#Event )};
d0#Event
(^Any natural event, independently of its possible causes.
E.g. avalanche, earthquake, brainwave, bonfire, etc.^)
\. {( dul#EventType dul#Event )};
dul#Event //= pm#situation
(^Any physical, social, or mental process, event, or state. ^)
/*More theoretically, events can be classified in different ways,
possibly based on
"aspect" (e.g. stative, continuous, accomplishement, achievement, etc.),
on "agentivity" (e.g. intentional, natural, etc.), or on
"typical participants" (e.g. human, physical, abstract, food, etc.).
Here no special direction is taken, and the following explains why:
events are related to observable situations, and they can have
different views at a same time.
If a position has to be suggested here anyway, the participant-based
classification of events seems the most stable and appropriate for
many modelling problems.
(1) Alternative aspectual views
Consider a same event "rock erosion in the Sinni valley": it
can be conceptualized as an accomplishment (what has brought a
certain state to occur), as an achievement (the state resulting
from a previous accomplishment), as a punctual event (if we
collapse the time interval of the erosion into a time point), or
as a transition (something that has changed from a state to a
different one).
In the erosion case, we could therefore have good motivations to
shift from one aspect to another: a) causation focus,
b) effectual focus, c) historical condensation,
d) transition (causality).
The different views refer to the same event, but are still
different: how to live with this seeming paradox?
A typical solution e.g. in linguistics (cf. Levin's aspectual
classes) and in DOLCE Full (cf. WonderWeb D18 axiomatization) is
to classify events based on aspectual differences.
But this solution would create different identities for
a same event, where the difference is only based on the
modeller's attitude.
An alternative solution is applied here, and exploits the
notion of (observable) Situation; a Situation is a view,
consistent with a Description, which can be observed of a
set of entities. It can also be seen as a "relational context"
created by an observer on the basis of a "frame". Therefore, a
Situation allows to create a context where each particular view
can have a proper identity, while the Event preserves its own
identity.
For example, ErosionAsAccomplishment is a Situation where
rock erosion is observed as a process leading to a certain
achievement: the conditions (roles, parameters) that suggest
such view are stated in a Description, which acts as a
"theory of accomplishments". Similarly, ErosionAsTransition is
a Situation where rock erosion is observed as an event that
has changed a state to another: the conditions for such
interpretation are stated in a different Description, which
acts as a "theory of state transitions".
Consider that in no case the actual event is changed or enriched
in parts by the aspectual view.
(2) Alternative intentionality views
Similarly to aspectual views, several intentionality views can be
provided for a same Event. For example, one can investigate if
an avalanche has been caused by immediate natural forces, or if
there is any hint of an intentional effort to activate those
natural forces.
Also in this case, the Event as such has not different identities,
while the causal analysis generates situations with different
identities, according to what Description is taken for
interpreting the Event.
On the other hand, if the possible actions of an Agent causing
the starting of an avalanche are taken as parts of the Event,
then this makes its identity change, because we are adding a
part to it.
Therefore, if intentionality is a criterion to classify events
or not, this depends on if an ontology designer wants to
consider causality as a relevant dimension for events" identity.
(3) Alternative participant views
A slightly different case is when we consider the basic
participants to an Event. In this case, the identity of the
Event is affected by the participating objects, because it
depends on them.
For example, if snow, mountain slopes, wind, waves, etc. are
considered as an avalanche basic participants, or if we also
want to add water, human agents, etc., that makes the
identity of an avalanche change.
Anyway, this approach to event classification is based on the
designer's choices, and more accurately mirrors lexical or
commonsense classifications (see. e.g. WordNet "supersenses"
for verb synsets).
Ultimately, this discussion has no end, because realists will
keep defending the idea that events in reality are not
changed by the way we describe them, while constructivists
will keep defending the idea that, whatever "true reality"
is about, it cannot be modelled without the theoretical burden
of how we observe and describe it.
Both positions are in principle valid, but, if taken too
radically, they focus on issues that are only partly relevant
to the aim of computational ontologies, which only attempt to
assist domain experts in representing what they want to
conceptualize a certain portion of reality according to
their own ideas.
For this reason, in this ontology both events and situations are
allowed, together with descriptions, in order to encode the
modelling needs, independently from the position (if any)
chosen by the designer. */
\. dul#Action dul#Process , //!dul#Object !dul#Quality !Abstract(symm),
dul#hasParticipant: 1..* dul#Object , dul#hasTimeInterval: 1..* dul#TimeInterval ,
dul#hasConstituent=> dul#Event , dul#hasPart=> dul#Event ;
dul#Action
(^An Event with at least one Agent that isParticipantIn it, and that
executes a Task that typically isDefinedIn a Plan, Workflow, Project, etc.^)
dul#hasParticipant: 1..* dul#Agent ,
dul#executesTask: 1..* dul#Task ;//owl#Thing
dul#Process
(^This is a placeholder for events that are considered in their evolution,
or anyway not strictly dependent on agents, tasks, and plans.
See Event class for some thoughts on classifying events.
See also "Transition".^) ;
pm#Situation_type-or-description // /^ pm#Type_or_information_or_description_or_situation
// hence /^ dul#SocialObject
\. dul#EventType/*= pm#Situation_category*/
{ dul#Situation/*= pm#Situation_representation*/ pm#Situation_description };
//pm: why not all excl ?
dul#EventType //= pm#Situation_category, /^ dul#Concept , ! dul#Parameter dul#Role ,
(^A Concept that classifies an Event.
An event type describes how an Event should be interpreted,
executed, expected, seen, etc., according to the Description that
the EventType isDefinedIn (or used in).^)
\. dul#Task ,
dul#classifies=> dul#Event ;
dul#Task
(^An EventType that classifies an Action to be executed.
For example, reaching a destination is a task that can be
executed by performing certain actions, e.g. driving a car,
buying a train ticket, etc.
The actions to execute a task can also be organized according
to a Plan that is not the same as the one that defines the
task (if any).
For example, reaching a destination could be defined by a plan
to get on holidays, while the plan to execute the task can
consist of putting some travels into a sequence.^)
dul#hasPart=> dul#Task , dul#isExecutedIn=> dul#Action ,
dul#isTaskDefinedIn=> dul#Description , dul#isTaskOf=> dul#Role ;
dul#Situation //= pm#Situation_representation, /^ dul#SocialObject ,
//! dul#SocialAgent
//! dul#Concept(symm) dul#Description(symm) dul#InformationObject(symm)
(^A view, consistent with ("satisfying") a Description, on a set of entities.
It can also be seen as a "relational context" created by an observer
on the basis of a "frame" (i.e. a Description).
For example, a PlanExecution is a context including some actions
executed by agents according to certain parameters and expected
tasks to be achieved from a Plan; a DiagnosedSituation is a context
of observed entities that is interpreted on the basis of a
Diagnosis, etc.
Situation is also able to represent reified n-ary relations, where
isSettingFor is the top-level relation for all binary projections of
the n-ary relation. If used in a transformation pattern for n-ary
relations, the designer should take care of creating only one
subclass of Situation for each n-ary relation, otherwise the
"identification constraint" (Calvanese et al., IJCAI 2001) could
be violated.^)
\. dul#Classification dul#PlanExecution dul#WorkflowExecution dul#Transition ,
dul#satisfies: 1..* dul#Description ;
dul#Classification
(^A special kind of Situation that allows to include time indexing for
the classifies relation in situations. For example, if a
Situation s "my old cradle is used in these days as a flower pot"
isSettingFor the entity "my old cradle" and the TimeIntervals
"8June2007" and "10June2007", and we know that s satisfies a
functional Description for aesthetic objects, which defines the
Concepts "flower pot" and "flower", then we also need to know what
concept classifies "my old cradle" at what time.
In order to solve this issue, we need to create a sub-situation s'
for the classification time: "my old cradle is a flower pot in
8June2007". Such sub-situation s' isPartOf s.^)
dul#isSettingFor: 1..* dul#Concept , dul#isSettingFor: 1..* dul#TimeInterval ;
dul#PlanExecution
(^Plan executions are situations that proactively satisfy a plan.
Subplan executions are proper parts of the whole plan execution.^)
dul#satisfies=> 1..* dul#Plan ; //pm: ":="
dul#WorkflowExecution dul#satisfies=> 1..* dul#Workflow ; //pm: ":="
dul#Transition
(^A transition is a Situation that creates a context for three
TimeInterval(s), two additional different Situation(s), one Event,
one Process, and at least one Object: the Event is observed as the
cause for the transition, one Situation is the state before the
transition, the second Situation is the state after the transition,
the Process is the invariance under some different transitions
(including the one represented here), in which at least one Object
is situated. Finally, the time intervals position the situations
and the transitional event in time.
This class of situations partly encodes the ontology underlying
typical engineering algebras for processes, e.g. Petri Nets.
A full representation of the transition ontology is outside the
expressivity of OWL, because we would need qualified cardinality
restrictions, coreference, property equivalence, and property
composition.^)
dul#isSettingFor: 1..* dul#Process , //pm:@@@ 1..* dul#Situation ,
dul#includesEvent: 2 dul#Event , dul#includesObject: 1..* dul#Object ,
dul#includesTime: 3 dul#TimeInterval ;
pm#Situation_description // /^ dul#Description,
\. dul#Method dul#Plan dul#Design dul#Diagnosis dul#Goal ; //pm: excl?
dul#Method
(^A method is a Description that defines or uses concepts in order to
guide carrying out actions aimed at a solution with respect to a problem.
It is different from a Plan, because plans could be carried out in order
to follow a method, but a method can be followed by executing
alternative plans.^) ;
dul#Plan
(^A Description having an explicit Goal, to be achieved by executing the plan^)
\. dul#Project dul#Workflow ,
dul#hasComponent: 1..* dul#Goal ;
dul#Project
(^A Plan that defines Role(s), Task(s), and a specific structure for tasks
to be executed in relation to goals to be achieved, in order to achieve
the main goal of the project. In other words, a project is a plan with
a subgoal structure and multiple roles and tasks.^)
dul#definesRole: 1..* dul#Role , dul#definesTask: 1..* dul#Task ;
dul#Workflow
(^A Plan that defines Role(s), Task(s), and a specific structure for
tasks to be executed, usually supporting the work of an Organization^)
dul#definesRole: 1..* dul#Role , dul#definesTask: 1..* dul#Task ;
dul#Design
(^A Description of the Situation, in terms of structure and function,
held by an Entity for some reason.
A design is usually accompanied by the rationales behind the
construction of the designed Entity (i.e. of the reasons why a design
is claimed to be as such). For example, the actual design (a Situation)
of a car or of a law is based on both the specification (a Description)
of the structure, and the rationales used to construct cars or laws.
While designs typically describe entities to be constructed, they can
also be used to describe "refunctionalized" entities, or to hypothesize
unknown functions. For example, a cradle can be refunctionalized as
a flowerpot based on a certain home design.^) ;
dul#Diagnosis
(^A Description of the Situation of a system, usually applied in order to
control a normal behaviour, or to explain a notable behavior (e.g. a
functional breakdown).^) ;
dul#Goal
(^The Description of a Situation that is desired by an Agent, and usually
associated to a Plan that describes how to actually achieve it^) ;
pm#entity
\. {( pm#Entity_that_is_mental_or_located_in_space //Section 2.1
pm#Entity_that_is_not_mental_nor_located_in_space )}
d0#Characteristic /*Section 2.2*/ d0#Location ;
d0#Location
(^A location, in a very generic sense e.g. geo-political entities, or
physical object that are inherently located.
E.g. Oslo, Australia, Inner Mongolia, resort area, intergalactic space,
tundra, tunnel, etc.^)
\. {( pm#Place_or_PhysicalPlace dul#SpaceRegion )};
//was c{} but the exclusion links are inferrable
pm#Entity_that_is_not_mental_nor_located_in_space
\. { dul#Abstract dul#Quality };
dul#Abstract //! dul#Event dul#Object dul#Quality
//pm: e.g. dul#Region (Section 2.2) and hence dul#SpaceRegion
(^Any Entity that cannot be located in space-time.
E.g. mathematical entities: formal semantics elements, regions within
dimensional spaces, etc.^)
\. dul#Region dul#FormalEntity ;
dul#FormalEntity
(^Entities that are formally defined and are considered independent
from the social context in which they are used. They cannot be
localized in space or time. Also called "Platonic entities".
Mathematical and logical entities are included in this class: sets,
categories, tuples, constants, variables, etc.
Abstract formal entities are distinguished from information objects,
which are supposed to be part of a social context, and are localized
in space and time, therefore being (social) objects. For example,
the class "Quark" is an abstract formal entity from the purely
set-theoretical perspective, but it is an InformationObject from
the viewpoint of ontology design, when e.g. implemented in a
logical language like OWL.
Abstract formal entities are also distinguished from Concept(s),
Collection(s), and Description(s), which are part of a social context,
therefore being SocialObject(s) as well. For example, the class
"Quark" is an abstract FormalEntity from the purely set-theoretical
perspective, but it is a Concept within history of science and
cultural dynamics.
These distinctions allow to represent two different notions of
"semantics".
The first one is abstract and formal ("formal semantics"), and
formallyInterprets symbols that are about entities whatsoever;
for example, the term "Quark" isAbout the Collection of all quarks,
and that Collection isFormalGroundingFor the abstract class
"Quark" (in the extensional sense).
The second notion is social, localized in space-time ("social
semantics"), and can be used to interpret entities in the
intensional sense. For example, the Collection of all quarks
isCoveredBy the Concept "Quark", which is also expressed by
the term "Quark".^)
\. dul#Set ;
pm#Entity_that_is_mental_or_located_in_space
\. pm#Place_or_PhysicalPlace dul#Object ;
pm#Place_or_PhysicalPlace
\. {( dul#PhysicalPlace dul#Place )}; //since physical ! social
dul#Object //!dul#Quality !dul#Abstract(symm) !dul#Event(symm)
(^Any physical, social, or mental object, or a substance.
Following DOLCE Full, objects are always participating in some event
(at least their own life), and are spatially located.^)
\. {dul#SocialObject dul#PhysicalObject } pm#Object_playing_a_role ,
dul#hasLocation: 1..* dul#Entity , dul#isParticipantIn: 1..* dul#Event ,
dul#hasConstituent=> dul#Object , dul#hasPart=> dul#Object,
dul#isClassifiedBy=> dul#Role ;
dul#SocialObject // /^ dul#Object ,
(^Any Object that exists only within some communication Event,
in which at least one PhysicalObject participates in.
In other words, all objects that have been or are created in the
process of social communication: for the sake of communication
(InformationObject), for incorporating new individuals (SocialAgent,
Place), for contextualizing existing entities (Situation),
for collecting existing entities (Collection), or for describing
existing entities (Description, Concept).
Being dependent on communication, all social objects need to be
expressed by some information object (information object are
self-expressing).^)
\. dul#Place dul#Collection //pm: missing !s
{ dul#SocialAgent pm#Type_or_information_or_description_or_situation }
pm#Situation_type-or-description ,
dul#isExpressedBy: 1..* dul#InformationObject ,
dul#hasPart=> dul#SocialObject ;
dul#Place
(^A location, in a very generic sense: a political geographic
entity (Roma, Lesotho), a non-material location determined by
the presence of other entities ("the area close to Roma"),
pivot events or signs ("the area where the helicopter fell"),
complements of other entities ("the area under the table"), etc.
In this generic sense, a Place is an "approximate" location.
For an "absolute" location, see the class SpaceRegion^)
dul#isLocationOf: 1..* dul#Entity ;
dul#PhysicalObject //! dul#SocialObject
(^Any Object that has a proper space region.
The prototypical physical object has also an associated mass,
but the nature of its mass can greatly vary based on the
epistemological status of the object (scientifically measured,
subjectively possible, imaginary).^)
\. dul#PhysicalBody dul#PhysicalArtifact dul#PhysicalAgent ,
dul#hasPart=> dul#PhysicalObject ;
dul#PhysicalBody
(^Physical bodies are PhysicalObject(s) for which we tend to
neutralize any possible artifactual character. They can have
several granularity levels: geological, chemical, physical,
biological, etc.^)
\. dul#PhysicalPlace dul#Substance dul#BiologicalObject
dul#ChemicalObject ; //pm: candidate for incompleteness
dul#PhysicalPlace
(^A physical object that is inherently located;
for example, a water area.^) ;
//pm: so a PhysicalPlace has a dul#Place ; strange/heavy
dul#Substance
(^Any PhysicalBody that has not necessarily specified (designed)
boundaries, e.g. a pile of trash, some sand, etc.
In this sense, an artistic object made of trash or a dose of
medicine in the form of a pill would be a FunctionalSubstance
and a DesignedArtifact, since its boundaries are specified
by a Design; aleatoric objects that are outcomes of an
artistic process might be still considered
DesignedArtifact(s), and Substance(s).^)
\. dul#FunctionalSubstance ;
dul#FunctionalSubstance
\. dul#DesignedSubstance ; //also /^ dul#DesignedArtifact
dul#BiologicalObject
\. dul#Organism ;
dul#Organism // /^ dul#PhysicalAgent dul#BiologicalObject
(^A physical objects with biological characteristics,
typically that organisms can self-reproduce.^);
dul#PhysicalArtifact
(^Any PhysicalObject that isDescribedBy a Plan.
This axiomatization is weak, but allows to talk of artifacts in
a very general sense, i.e. including recycled objects, objects
with an intentional functional change, natural objects that are
given a certain function, even though they are not modified or
structurally designed, etc. PhysicalArtifact(s) are not
considered disjoint from PhysicalBody(s), in order to allow a
dual classification when needed. E.g., FunctionalSubstance(s)
are included here as well.
Immaterial (non-physical) artifacts (e.g. texts, ideas, cultural
movements, corporations, communities, etc. can be modelled as
social objects (see SocialObject), which are all "artifactual"
in the weak sense assumed here.^)
\. dul#DesignedArtifact ,
dul#isDescribedBy: 1..* dul#Plan ;
dul#DesignedArtifact
(^A PhysicalArtifact that is also described by a Design.
This excludes simple recycling or refunctionalization of
natural objects. Most common sense "artifacts" can be
included in this class: cars, lamps, houses, chips, etc.^)
\. dul#DesignedSubstance , //also /^ dul#FunctionalSubstance
dul#isDescribedBy: 1..* dul#Design ;
d0#Characteristic
(^An aspect or quality of a thing.
E.g. radial symmetry, poker face, alkalinity, attractiveness, darkness, etc.^)
\. /*c*/{ dul#Quality dul#Region } dul#Parameter ; //pm: missing exclusion links
//{( pm#spatial_characteristic (pm) pm#non-spatial_characteristic (pm) )};
dul#Quality // /^ d0#characteristic, /^ dul#Region(symm)
(^Any aspect of an Entity (but not a part of it), which cannot exist without
that Entity. For example, the way the surface of a specific PhysicalObject
looks like, or the specific light of a place at a certain time, are
examples of Quality, while the encoding of a Quality into e.g. a
PhysicalAttribute should be modeled as a Region.
From the design viewpoint, the Quality-Region distinction is useful only
when individual aspects of an Entity are considered in a domain of discourse.
For example, in an automotive context, it would be irrelevant to consider the
aspects of car windows for a specific car, unless the factory wants to
check a specific window against design parameters (anomaly detection).
On the other hand, in an antiques context, the individual aspects for a
specific piece of furniture are a major focus of attention, and may
constitute the actual added value, because the design parameters for
old furniture are often not fixed, and may not be viewed as "anomalies".^)
dul#hasRegion: 1..* dul#Region , dul#hasConstituent=> dul#Quality ,
dul#hasPart=> dul#Quality ;
dul#Region // /^ dul#Abstract (hence ! dul#Event dul#Object dul#quality)
(^Any region in a dimensional space (a dimensional space is a
maximal Region), which can be used as a value for a quality of an Entity.
For example, TimeInterval, SpaceRegion, PhysicalAttribute, Amount,
SocialAttribute are all subclasses of Region.
Regions are not data values in the ordinary knowledge representation sense;
in order to get patterns for modelling data, see the properties:
representsDataValue and hasDataValue^)
\. {dul#Amount dul#TimeInterval dul#SpaceRegion dul#PhysicalAttribute }
dul#SpatioTemporalRegion dul#SocialObjectAttribute ,
dul#hasConstituent=> dul#Region ,
dul#hasPart=> dul#Region , dul#overlaps=> dul#Region , dul#precedes=> dul#Region ;
dul#Amount //! dul#PhysicalAttribute dul#SpaceRegion dul#TimeInterval
(^A quantity, independently from how it is measured, computed, etc.^) ;
dul#TimeInterval // /^ dul#Region
//! dul#SpaceRegion(symm) dul#PhysicalAttribute(symm) dul#Amount(symm)
(^Any Region in a dimensional space that aims at representing time.^)
\. xmls#dateTime (pm); //pm: added
dul#SpaceRegion //! dul#TimeInterval dul#PhysicalAttribute(symm) dul#Amount(symm)
(^Any Region in a dimensional space that is used to localize an Entity ;
i.e., it is not used to represent some characteristic (e.g. it excludes
time intervals, colors, size values, judgment values, etc.).
Unlike a Place, a space region has a specific dimensional space.^) ;
dul#PhysicalAttribute // ! dul#TimeInterval dul#SpaceRegion dul#Amount(symm)
(^Physical value of a physical object, e.g. density, color, etc.^)
dul#isRegionFor=> dul#PhysicalObject ;
dul#SpatioTemporalRegion // /^ dul#Region,
dul#hasConstituent: 1..* dul#SpaceRegion , //pm:?? implies !/^ ????
dul#hasConstituent: 1..* dul#TimeInterval ;
dul#SocialObjectAttribute // /^ dul#Region,
(^Any Region in a dimensional space that is used to represent some
characteristic of a SocialObject, e.g. judgment values, social scalars,
statistical attributes over a collection of entities, etc.^)
dul#isRegionFor=> dul#SocialObject ;
dul#Parameter //= pm#RegionType, /^ dul#Concept,
//! dul#Role dul#EventType(symm) +? dul#Region dul#Quality
(^A Concept that classifies a Region; the difference between a Region and a
Parameter is that regions represent sets of observable values, e.g.
the height of a given building, while parameters represent constraints
or selections on observable values, e.g. "VeryHigh".
Therefore, parameters can also be used to constrain regions,
e.g. VeryHigh on a subset of values of the Region Height applied to
buildings, or to add an external selection criterion, such as
measurement units, to regions, e.g. Meter on a subset of values from
the Region Length applied to the Region Length applied to roads.^)
\. dul#UnitOfMeasure ,
dul#classifies=> dul#Region , dul#hasPart=> dul#Parameter ;
dul#UnitOfMeasure
(^Units of measure are conceptualized here as parameters on regions,
which can be valued as datatype values.^)
dul#parametrizes: 1..* dul#Region ;
pm#Type_or_information_or_description_or_situation // /^ dul#SocialObject
// /^ pm#Description_instrument-or-result-or-container, ! dul#SocialAgent
\. pm#Situation_type-or-description //Section 1.2
{ dul#Concept dul#Description dul#InformationObject dul#Situation }
dul#InformationEntity; //pm: orig: /^ dul#Entity
// bugFix2: use dul#InformationEntity above
//Extract from the revision notes of DU:
// In 3.20, revised the comment for Quality, added InformationEntity as the
// superclass for InformationObject and InformationRealization (represented
// as the union of those classes).
//So dul#InformationEntity has been added as direct subtype of dul#Entity and
// without its exclusion links. I think that the supertypes and exclusion links of
// dul#InformationObjec should have been used.
dul#Concept // /^ dul#SocialObject
// ! dul#Description dul#InformationObject dul#SocialAgent dul#Situation
(^A Concept is a SocialObject, and isDefinedIn some Description;
once defined, a Concept can be used in other Description(s).
If a Concept isDefinedIn exactly one Description, see the LocalConcept class.
The classifies relation relates Concept(s) to Entity(s) at some TimeInterval^)
\. dul#LocalConcept
{ dul#Role dul#Parameter dul#EventType/*= pm#Situation_category*/ } ,
dul#isDefinedIn: 1..* dul#Description , dul#hasPart=> dul#Concept ;
dul#LocalConcept
(^A Concept that isDefinedIn exactly 1 Description. For example, the
Concept "coffee" in a "preparesCoffee" relation can be defined in
that relation, and for all other Description(s) that use it, the
isConceptUsedIn property should be applied. Notice therefore that
not necessarily all Concept(s) isDefinedIn exactly 1 Description.^);
dul#Role // /^ du#Concept, ! dul#Parameter(symm) dul#EventType(symm)
(^A Concept that classifies an Object^)
dul#classifies=> dul#Object , dul#hasPart=> dul#Role ;
dul#InformationEntity // /^ dul#Entity //bug fix: /^ dul#SocialObject
(^A piece of information, be it concretely realized or not.^)
\. dul#InformationObject dul#InformationRealization ;
dul#InformationObject // /^ dul#InformationEntity dul#SocialObject
// !dul#Situation dul#SocialAgent dul#Concept(symm) dul#Description(symm)
(^A piece of information, such as a musical composition, a text, a word,
a picture, independently from how it is concretely realized.^) ;
dul#InformationRealization // /^ dul#InformationEntity dul#Event_or_PhysicalObject ,
(^A concrete realization of an InformationObject, e.g. the written
document containing the text of a law.^)
dul#realizes: 1..* dul#InformationObject ;
dul#Description // /^ dul#SocialObject,
//! dul#InformationObject dul#Situation dul#SocialAgent dul#Concept(symm) ;
(^A Description is a SocialObject that represents a conceptualization.
It can be thought also as a "descriptive context" that uses or defines
concepts in order to create a view on a "relational context" (cf. Situation)
out of a set of data or observations.
For example, a Plan is a Description of some actions to be executed by agents
in a certain way, with certain parameters; a Diagnosis is a Description
that provides an interpretation for a set of observed entities, etc.^)
\. pm#Situation_description
dul#Contract dul#Theory dul#Narrative dul#Norm dul#Right dul#Relation
pm#ontology ;
dul#Contract
(^(The content of) an agreement between at least two agents that play
a Party Role, about some contract object (a Task to be executed).^) ;
dul#Theory
(^A Theory is a Description that represents a set of assumptions for
describing something, usually general. Scientific, philosophical,
and commonsense theories can be included here.
This class can also be used to act as "naturalized reifications" of
logical theories (of course, they will be necessarily incomplete in
this case, because second-order entities are represented as
first-order ones).^)
dul#hasComponent: 1..* dul#Relation ;
dul#Norm (^A social norm.^) ;
dul#Right
(^A legal position by which an Agent is entitled to obtain something
from another Agent , under specified circumstances, through an
enforcement explicited either in a Law, Contract , etc.^)
dul#definesRole: 2 dul#Role , dul#definesTask: 1..* dul#Task ;
dul#Relation
(^Relations are descriptions that can be considered as the counterpart
of formal relations (that are included in the FormalEntity class).
For example, "givingGrantToInstitution(x,y,z)" with 3 argument types:
Provider(x),Grant(y),Recipient(z), can have a Relation counterpart:
"GivingGrantToInstitution", which defines three Concept instances:
Provider,Grant,Recipient.
Since social objects are not formal entities, Relation includes here
any "relation-like" entity in common sense, including social
relations.^)
\. dul#Pattern dul#SocialRelation ;
dul#Pattern
(^Any invariance detected from a dataset, or from observation;
also, any invariance proposed based on top-down considerations.
E.g. patterns detected and abstracted by an organism, by
pattern recognition algorithms, by machine learning techniques, etc.
An occurrence of a pattern is an "observable" or detected Situation^);
dul#SocialRelation (^Any social relationship^) ;
pm#ontology
\. { pm#DOLCE\+DnS_Ultralite pm#Dolce-Zero };
pm#DOLCE\+DnS_Ultralite
(^A simplification of some parts of the DOLCE Lite-Plus library
(cf. http://www.ontologydesignpatterns.org/ont/dul/DLP397.owl).
Main aspects in which DOLCE+DnS Ultralite departs from DOLCE Lite-Plus
are the following:
- The names of classes and relations have been made more intuitive
- The DnS-related part is closer to the newer "constructive DnS"
ontology (http://www.ontologydesignpatterns.org/ont/dul/cDnS.owl).
- Temporal and spatial relations are simplified
- Qualities and regions are more relaxed than in DOLCE-Full: they can
be used as attributes of any entity; an axiom states that each
quality has a region
- Axiomatization makes use of simpler constructs than DOLCE Lite-Plus
- The architecture of the ontology is pattern-based, which means that
DOLCE+DnS Ultralite is also available in modules, called
"content ontology design patterns", which can be applied
independently in the design of domain ontologies
(cf. http://www.ontologydesignpatterns.org). If many modules are
needed in a same ontology project, it is anyway useful to use this
integrated version.
The final result is a lightweight, easy-to-apply foundational ontology
for modeling either physical or social contexts.^)
pm#url: http://www.ontologydesignpatterns.org/ont/dul/DUL.owl ;
pm#Dolce-Zero
(^A supplementary ontology used as a generalization of
DOLCE+DnS Ultralite (DUL dul), in order to deal with the systematic
polysemy of many lexical items, whose senses create problems when
used as OWL classes. For example, it's customary to find lexical
items that carry both a sense of physical or abstract location, of
event or event type, etc.^)
pm#url: http://www.ontologydesignpatterns.org/ont/d0.owl ; //06-May-2013
pm#Collection_or_Collection-type-or-description
\. dul#Set dul#Collection ;
// dul#Set /^ dul#FormalEntity ;
dul#Collection // /^ dul#SocialObject,
(^Any container for entities that share one or more common properties.
E.g. "stone objects", "the nurses", "the Louvre Aegyptian collection",
all the elections for the Italian President of the Republic.
A collection is not a logical class: a collection is a first-order entity,
while a class is second-order.^)
\. dul#TypeCollection dul#Configuration dul#Collective ,
dul#hasPart=> dul#Collection ;
dul#TypeCollection
(^A Collection whose members are the maximal set of individuals that
share the same (named) type, e.g. "the gem stones", "the Italians".
This class is very useful to apply a variety of the so-called
"ClassesAsValues" design pattern, when it is used to talk about the
extensional aspect of a class. An alternative variety of the pattern
applies to the intensional aspect of a class, and the class Concept
should be used instead.^) ;
dul#Configuration
(^A collection whose members are "unified", i.e. organized according to
a certain schema that can be represented by a Description.
Typically, a configuration is the collection that emerges out of a
composed entity: an industrial artifact, a plan, a discourse, etc.
E.g. a physical book has a configuration provided by the part-whole
schema that holds together its cover, pages, ink. That schema, based
on the individual relations between the book and its parts, can be
represented in a reified way by means of a (structural) description,
which is said to "unify" the book configuration.^) ;
dul#Collective
(^A Collection whose members are agents, e.g. "the nurses",
"the Italian rockabilly fans".
Collectives, facon de parler, can act as agents, although they are not
assumed here to be agents (they are even disjoint from the class
SocialAgent). This is represented by admitting collectives in the
range of the relations having Agent in their domain or range.^)
dul#hasMember=> dul#Agent ;
pm#Object_playing_a_role
\. dul#Agent ;
dul#Agent //
(^Any agentive Object, either physical (e.g. a whale, a robot, an oak),
or social (e.g. a corporation, an institution, a community).
Additional comment: a computational agent can be considered as a
PhysicalAgent that realizes a certain class of algorithms (that can
be considered as instances of InformationObject) that allow to obtain
some behaviors that are considered typical of agents in general.
For an ontology of computational objects based on DOLCE see e.g.
http://km.aifb.kit.edu/sites/cos/cso.owl and
http://www.ontologydesignpatterns.org/ont/dul/KCO.owl ^)
\. dul#Person {( dul#PhysicalAgent dul#SocialAgent )} ;
dul#Person
(^Persons in commonsense intuition, which does not apparently
distinguish between either natural or social persons.^)
\. {( dul#NaturalPerson dul#SocialPerson )};
dul#NaturalPerson // /^ dul#Person dul#PhysicalAgent
(^A person in the physical commonsense intuition:
"have you seen that person walking down the street?"^) ;
dul#SocialPerson // /^ dul#Person dul#SocialAgent ,
(^A SocialAgent that needs the existence of a specific
NaturalPerson in order to act (but the lifetime of the
NaturalPerson has only to overlap that of the SocialPerson).^)
//Formerl Person: changed to avoid confusion with commonsense intuition
dul#actsThrough: 1 dul#Agent ;
dul#PhysicalAgent // /^ dul#Agent dul#PhysicalObject
(^A PhysicalObject that is capable of self-representing
(conceptualizing) a Description in order to plan an Action.
A PhysicalAgent is a substrate for (actsFor) a Social Agent^)
\. dul#NaturalPerson dul#Organism ;
dul#SocialAgent // /^ dul#Agent dul#SocialObject ,
(^Any individual whose existence is granted simply by its social
communicability and capability of action (through some PhysicalAgent).^)
\. dul#SocialPerson dul#Organization dul#Personification dul#CollectiveAgent ,
dul#actsThrough: 1..* dul#PhysicalAgent dul#CollectiveAgent ;
dul#Organization
(^An internally structured, conventionally created SocialAgent,
needing a specific Role and Agent that plays it, in order to act.^);
dul#Personification
(^A social entity with agentive features, but whose status is the
result of a cultural transformation from e.g. a PhysicalObject,
an Event, an Abstract, another SocialObject, etc.
For example: the holy grail, deus ex machina, gods, magic wands, etc.^);
dul#CollectiveAgent
(^A SocialAgent that is actedBy agents that are (and act as) members
of a Collective. A collective agent can have roles that are also
roles of those agents.
For example, in sociology, a "group action" is the situation in
which a number of people (that result to be members of a collective)
in a given area behave in a coordinated way in order to achieve a
(often common) goal. The Agent in such a Situation is not single,
but a CollectiveAgent (a Group). This can be generalized to the
notion of social movement, which assumes a large Community or
even the entire Society as agents.
The difference between a CollectiveAgent and an Organization is
that a Description that introduces a CollectiveAgent is also one
that unifies the corresponding Collective. In practice, this
difference makes collective agents "less stable" than organizations,
because they have a dedicated, publicly recognizable Description
that is conceived to introduce them.^)
\. dul#Community dul#Group ,
dul#actsThrough: 1..* dul#Agent , dul#isIntroducedBy: 1..* dul#Description ;
dul#Group
(^A CollectiveAgent whose acting agents conceptualize a same
SocialRelation.^)
dul#isDescribedBy: 1..* dul#Plan ;
dul#associatedWith (?,?) // /^ pm#binary_relation ,
(^A catch-all object property, useful for alignment and querying purposes.^)
- dul#associatedWith , |^ owl#SymmetricProperty owl#TransitiveProperty ,
\. owl#datatype_property ;
dul#precedes (dul#Entity, dul#Entity)
(^A relation between entities, expressing a "sequence" schema.
E.g. "year 1999 precedes 2000", "deciding what coffee to use" precedes
"preparing coffee", "World War II follows World War I",
"in the Milan to Rome autoroute, Bologna precedes Florence", etc.
It can then be used between tasks, processes, time intervals, spatially
locate objects, situations, etc.
Subproperties can be defined in order to distinguish the different uses.^)
/^ dul#associatedWith , |^ owl#TransitiveProperty ;
dul#follows (dul#Entity, dul#Entity)
(^See the inverse relation type: dul#precedes^)
/^ dul#associatedWith , |^ owl#TransitiveProperty ;
dul#directlyPrecedes (dul#Entity, dul#Entity)
(^The intransitive precedes relation. For example, Monday directly
precedes Tuesday. Directness of precedence depends on the designer
conceptualization.^)
/^ dul#precedes ;
dul#directlyFollows (dul#Entity, dul#Entity)
(^See the inverse relation type: dul#directlyPrecedes^)
/^ dul#follows ;
dul#hasLocation (dul#Entity, dul#Entity)
(^A generic, relative spatial location, holding between any entities.
E.g. "the cat is on the mat", "Omar is in Samarcanda",
"the wound is close to the femural artery".
For "absolute" locations, see SpaceRegion^)
/^ dul#associatedWith , - dul#isLocationOf ;
dul#isLocationOf (dul#Entity, dul#Entity)
(^See the inverse relation type: dul#hasLocation^)
/^ dul#associatedWith ;
dul#farFrom (dul#Entity, dul#Entity)
(^Generic distance relation between any Entity(s).
E.g. Rome is far from Beijing, astronomy is far from necromancy.^)
/^ dul#associatedWith , - dul#farFrom , |^ owl#SymmetricProperty ;
dul#nearTo (dul#Entity, dul#Entity)
(^Generic distance relation between any Entity(s).
E.g. Rome is near to Florence, astronomy is near to physics.^)
/^ dul#associatedWith , - dul#nearTo , |^ owl#SymmetricProperty ;
dul#overlaps (dul#Entity, dul#Entity)
(^A schematic relation between any entities, e.g.
"the chest region overlaps with the abdomen region",
"my spoken words overlap with hers",
"the time of my leave overlaps with the time of your arrival",
"fibromyalgia overlaps with other conditions".
Subproperties and restrictions can be used to specialize overlaps for
objects, events, time intervals, etc.^)
/^ dul#associatedWith , - dul#overlaps , |^ owl#SymmetricProperty ;
dul#hasCommonBoundary (dul#Entity, dul#Entity)
(^A relation to encode either formal or informal characterizations of
"boundaries" common to two different entities: an Event that ends when
another begins, two abstract regions that have a common topological
boundary, two objects that are said to be "in contact" from a
commonsense perspective, etc.^)
/^ dul#associatedWith , - dul#hasCommonBoundary , |^ owl#SymmetricProperty ;
dul#hasPart (dul#Entity, dul#Entity)
(^A schematic relation between any entities, e.g. "the human body has a
brain as part", "20th century contains year 1923",
"World War II includes the Pearl Harbour event".
Subproperties and restrictions can be used to specialize hasPart for
objects, events, etc.^)
/^ dul#associatedWith , - dul#isPartOf , |^ owl#TransitiveProperty ;
dul#isPartOf (dul#Entity, dul#Entity)
(^A relation between any entities, e.g."brain is a part of the human body".^)
/^ dul#associatedWith , |^ owl#TransitiveProperty ;
dul#hasComponent (dul#Entity, dul#Entity)
(^The hasPart relation without transitivity, holding between an
Object (the system) and another (the component), and assuming a
Design that structures the Object.^)
/^ dul#hasPart , - dul#isComponentOf ;
dul#isComponentOf (dul#Entity, dul#Entity)
(^See the inverse relation type: dul#hasComponent^)
/^ dul#isPartOf ;
dul#hasConstituent (dul#Entity, dul#Entity)
(^"Constituency" depends on some layering of the world described by
the ontology. For example, scientific granularities (e.g.
body-organ-tissue-cell) or ontological "strata" (e.g.
social-mental-biological-physical) are typical layerings.
Intuitively, a constituent is a part belonging to a lower layer.
Since layering is actually a partition of the world described by
the ontology, constituents are not properly classified as parts,
although this kinship can be intuitive for common sense.
A desirable advantage of this distinction is that we are able to talk
e.g. of physical constituents of non-physical objects (e.g. systems),
while this is not possible in terms of parts.
Example of are the persons constituting a social system, the molecules
constituting a person, the atoms constituting a river, etc.
In all these examples, we notice a typical discontinuity between the
constituted and the constituent object: e.g. a social system is
conceptualized at a different layer from the persons that constitute
it, a person is conceptualized at a different layer from the molecules
that constitute them, and a river is conceptualized at a different
layer from the atoms that constitute it.^)
/^ dul#associatedWith , - dul#isConstituentOf ;
dul#isConstituentOf (dul#Entity, dul#Entity)
(^See the inverse relation type: dul#hasConstituent^)
/^ dul#associatedWith ;
dul#sameSettingAs (dul#Entity, dul#Entity)
(^A relation between two entities participating in a same Situation;
e.g., "Our company provides an antivenom service" (the situation is the
service, the two entities are the company and the antivenom).^)
/^ dul#associatedWith , - dul#sameSettingAs , |^ owl#SymmetricProperty ;
dul#hasMember (dul#Collection, dul#Entity)
(^A relation between collections and entities, e.g.
"my collection of saxophones includes an old Adolphe Sax original alto"
(i.e. my collection has member an Adolphe Sax alto).^)
/^ dul#associatedWith , - dul#isMemberOf ;
dul#isMemberOf (dul#Entity, dul#Collection)
(^A relation between collections and entities, e.g.
"the Night Watch by Rembrandt is in the Rijksmuseum collection";
"David is member of the Pen Club", "Igor is one the subjects chosen
for the experiment".^)
/^ dul#associatedWith ;
dul#unifies (dul#Description, dul#Collection)
(^A Collection has a unification criterion, provided by a Description;
for example, a community of practice can be unified by a shared theory
or interest, e.g. the community that makes research on mirror neurons
shares some core knowledge about mirror neurons, which can be represented
as a Description MirrorNeuronTheory that unifies the community.
There can be several unifying descriptions.^)
/^ dul#associatedWith ;
dul#isUnifiedBy (dul#Collection, dul#Description)
(^See the inverse relation type: dul#unifies.^)
/^ dul#associatedWith , - dul#unifies ;
dul#describes (dul#Description, dul#Entity)
(^The relation between a Description and an Entity : a Description gives
a unity to a Collection of parts (the components), or constituents, by
assigning a Role to each of them in the context of a whole Object (the system).
A same Entity can be given different descriptions, for example, an old
cradle can be given a unifying Description based on the original aesthetic
design, the functionality it was built for, or a new aesthetic functionality
in which it can be used as a flower pot.^)
/^ dul#associatedWith , - dul#isDescribedBy ;
dul#isDescribedBy (dul#Entity, dul#Description)
(^See the inverse relation type: dul#describes.^)
/^ dul#associatedWith ;
dul#isRelatedToDescription (dul#Description, dul#Description)
(^Any relation between descriptions.^)
/^ dul#associatedWith , - dul#isRelatedToDescription , |^ owl#SymmetricProperty ;
dul#expands (dul#Description, dul#Description)
(^A partial order relation that holds between descriptions.
It represents the proper part relation between a description and
another description featuring the same properties as the former,
with at least one additional one.
Descriptions can be expanded either by adding other descriptions as
parts, or by refining concepts that are used by them.
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).^)
/^ dul#isRelatedToDescription , - dul#isExpandedIn ;
dul#isExpandedIn (dul#Description, dul#Description)
(^See the inverse relation type: dul#expands^)
/^ dul#isRelatedToDescription ;
dul#specializes (dul#SocialObject, dul#SocialObject)
(^A partial order relation that holds between social objects.
It mainly represents the subsumption relation between e.g. a
Concept or Description and another Concept (resp. Description) that
is broader in extensional interpretation, but narrower in intensional
interpretation. For example, the role PhDStudent specializes the role Student.
Another possible use is between a Collection that isCoveredBy a Concept A,
and another Collection that isCoveredBy a Concept B that in turn
specializes A. For example, the 70,000 series Selmer Mark VI saxophone
Collection specializes the Selmer Mark VI saxophone Collection.^)
/^ dul#associatedWith , |^ owl#TransitiveProperty ;
dul#isSpecializedBy (dul#SocialObject, dul#SocialObject)
(^A partial order relation that holds between social objects.
It represents the subsumption relation between e.g. a Concept and
another Concept that is broader in extensional interpretation, but
narrower in intensional interpretation.
E.g. PhDStudent Role specializes Student Role^)
/^ dul#associatedWith , - dul#specializes , |^ owl#TransitiveProperty ;
dul#characterizes (dul#Concept, dul#Collection)
(^A relation between concepts and collections, where a Concept is said to
characterize a Collection; it corresponds to a link between the (reified)
intensional and extensional interpretations of a _proper subset of_ a
(reified) class. This is different from covers, because it refers to
an interpretation the entire reified class.
E.g. the collection of vintage saxophones is characterized by the
Concept "manufactured by hand", while it gets covered by the Concept
"Saxophone" with the Parameter "Vintage".^)
/^ dul#associatedWith , - dul#isCharacterizedBy ;
dul#isCharacterizedBy (dul#Collection, dul#Concept)
/^ dul#associatedWith ;
dul#covers (dul#Concept, dul#Collection)
(^A relation between concepts and collections, where a Concept is said to cover
a Collection; it corresponds to a link between the (reified) intensional and
extensional interpretations of a (reified) class.
E.g. the collection of vintage saxophones is covered by the Concept "Saxophone"
with the Parameter "Vintage".^)
/^ dul#associatedWith , - dul#isCoveredBy ;
dul#isCoveredBy (dul#Collection, dul#Concept)
(^See the inverse relation type: dul#covers^)
/^ dul#associatedWith ;
dul#classifies (dul#Concept, dul#Entity)
(^A relation between a Concept and an Entity,
e.g. the Role "student" classifies a Person "John".^)
/^ dul#associatedWith , - dul#isClassifiedBy ;
dul#isClassifiedBy (dul#Entity, dul#Concept)
(^A relation between a Concept and an Entity, e.g.
"John is considered a typical rude man"; "your last concert constitutes
the achievement of a lifetime"; "20-year-old means she's mature enough".^)
/^ dul#associatedWith ;
dul#hasRole (dul#Object, dul#Role)
(^A relation between an object and a role, e.g. the person "John" has
role "student".^)
/^ dul#isClassifiedBy , - dul#isRoleOf ;
dul#isRoleOf (dul#Role, dul#Object)
(^A relation between an object and a role, e.g. "student" is the
role of "John".^)
/^ dul#classifies ;
dul#isRelatedToConcept (dul#Concept, dul#Concept) //+ \. dul#isTaskOf
(^Any relation between concepts, e.g. superordinated, conceptual parthood,
having a parameter, having a task, superordination, etc.^)
/^ dul#associatedWith , - dul#isRelatedToConcept , |^ owl#SymmetricProperty ;
dul#hasParameter (dul#Concept, dul#Parameter)
(^A Concept can have a Parameter that constrains the attributes that a
classified Entity can have in a certain Situation,
e.g. a 4WheelDriver Role definedIn the ItalianTrafficLaw has a
MinimumAge parameter on the Amount 16.^)
/^ dul#isRelatedToConcept , - dul#isParameterFor ;
dul#isParameterFor (dul#Parameter, dul#Concept)
(^See the inverse relation type: dul#hasParameter^)
/^ dul#isRelatedToConcept ;
dul#usesConcept (dul#Description, dul#Concept)
(^A generic relation holding between a Description and a Concept.
In order to be used, a Concept must be previously definedIn another
Description. This last condition cannot be encoded for object
properties in OWL.^)
/^ dul#associatedWith ;
dul#isConceptUsedIn (dul#Concept, dul#Description)
(^A more generic relation holding between a Description and a Concept.
In order to be used, a Concept must be previously definedIn another
Description^)
/^ dul#associatedWith , - dul#usesConcept ;
dul#defines (dul#Description, dul#Concept)
(^A relation between a Description and a Concept, e.g. a Workflow for
a governmental Organization defines the Role "officer", or
"the Italian Traffic Law defines the role Vehicle".^)
/^ dul#usesConcept , - dul#isDefinedIn ;
dul#isDefinedIn (dul#Concept, dul#Description)
(^See the inverse relation type: dul#defines^)
/^ dul#isConceptUsedIn ;
dul#definesRole (dul#Description, dul#Role)
(^A relation between a description and a role,
e.g. the recipe for a cake defines the role "ingredient".^)
/^ dul#defines , - dul#isRoleDefinedIn ;
dul#isRoleDefinedIn (dul#Role, dul#Description)
(^A relation between a description and a role,
e.g. the role "Ingredient" is defined in the recipe for a cake.^)
/^ dul#isDefinedIn ;
dul#definesTask (dul#Description, dul#Task)
(^A relation between a description and a task,
e.g. the recipe for a cake defines the task "boil".^)
/^ dul#defines , - dul#isTaskDefinedIn ;
dul#isTaskDefinedIn (dul#Task, dul#Description)
(^A relation between a description and a task,
e.g. the task "boil" is defined in a recipe for a cake.^)
/^ dul#isDefinedIn ;
dul#isSubordinatedTo (dul#Concept, dul#Concept)
(^Direct succession applied to concepts.
E.g. the role "Officer" is subordinated to "Director".^)
/^ dul#directlyFollows dul#isRelatedToConcept , - dul#isSuperordinatedTo ;
dul#isSuperordinatedTo (dul#Concept, dul#Concept)
(^Direct precedence applied to concepts.
E.g. the role "Executive" is superordinated to "DepartmentManager".^)
/^ dul#directlyPrecedes dul#isRelatedToConcept ;
dul#isPreconditionOf ( pm#Situation_or_Situation-representation ,
pm#Situation_or_Situation-representation )
(^Direct precedence applied to situations.
E.g., "claiming to find nuclear weapons in a foreign country is a
precondition to declare war against it".^)
/^ dul#directlyPrecedes ;
dul#hasPrecondition (pm#Situation_or_Situation-representation ,
pm#Situation_or_Situation-representation )
(^Direct precedence applied to situations.
E.g., "A precondition to declare war against a foreign country is
claiming to find nuclear weapons in it".^)
/^ dul#directlyFollows , - dul#isPreconditionOf ;
dul#isPostconditionOf ( pm#Situation_or_Situation-representation ,
pm#Situation_or_Situation-representation )
(^Direct succession applied to situations.
E.g., "Taking some rest is a postcondition of my search for a hotel".^)
/^ dul#directlyFollows ;
dul#hasPostcondition (pm#Situation_or_Situation-representation ,
pm#Situation_or_Situation-representation )
(^Direct succession applied to situations.
E.g., "A postcondition of our Plan is to have things settled".^)
/^ dul#directlyPrecedes , - dul#isPostconditionOf ;
dul#executesTask (dul#Action, dul#Task)
(^A relation between an action and a task, e.g. "putting some water in
a pot and putting the pot on a fire until the water starts bubbling"
executes the task "boiling".^)
/^ dul#isClassifiedBy , - dul#isExecutedIn ;
dul#isExecutedIn (dul#Task, dul#Action)
(^See the inverse relation type: dul#executesTask^)
/^ dul#classifies ;
dul#coparticipatesWith (dul#Object, dul#Object)
(^A relation between two objects participating in a same Event;
e.g., "Vitas and Jimmy are playing tennis".^)
/^ dul#associatedWith , - dul#coparticipatesWith , |^ owl#SymmetricProperty ;
dul#hasParticipant (dul#Event, dul#Object)
(^A relation between an object and a process, e.g.
"John took part in the discussion", "a large mass of snow fell during
the avalanche", or "a cook, some sugar, flour, etc. are all present in
the cooking of a cake".^)
/^ dul#associatedWith , - dul#isParticipantIn ;
dul#isParticipantIn (dul#Object, dul#Event)
(^See the inverse relation type: dul#hasParticipant^)
/^ dul#associatedWith ;
dul#involvesAgent (dul#Event, dul#Agent)
(^Agent participation.^)
/^ dul#hasParticipant , - dul#isAgentInvolvedIn ;
dul#isAgentInvolvedIn (dul#Agent, dul#Event)
(^Agent participation.^)
/^ dul#isParticipantIn ;
dul#isSettingFor (dul#Situation, dul#Entity)
(^A relation between situations and entities,
e.g. "this morning I have prepared my coffee with a new fantastic Arabica",
i.e.: the preparation of my coffee this morning is the setting for (an
amount of) a new fantastic Arabica.^)
/^ dul#associatedWith ;
dul#hasSetting (dul#Entity, dul#Situation)
(^A relation between entities and situations, e.g.
"this morning I have prepared my coffee with a new fantastic Arabica",
i.e.: (an amount of) a new fantastic Arabica hasSetting the
preparation of my coffee this morning.^)
/^ dul#associatedWith , - dul#isSettingFor;
dul#includesObject (dul#Situation, dul#Object)
(^A relation between situations and objects, e.g.
"this morning I have prepared my coffee and had my fingers burnt"
(i.e.: the preparation of my coffee this morning included me).^)
/^ dul#isSettingFor , - dul#isObjectIncludedIn ;
dul#isObjectIncludedIn (dul#Object, dul#Situation)
/^ dul#hasSetting ;
dul#includesAgent (dul#Situation, dul#Agent)
(^A relation between situations and persons, e.g.
"this morning I have prepared my coffee and had my fingers burnt"
(i.e.: the preparation of my coffee this morning included me).^)
/^ dul#includesObject , - dul#isAgentIncludedIn ;
dul#isAgentIncludedIn (dul#Agent, dul#Situation)
/^ dul#isObjectIncludedIn ;
dul#includesTime (dul#Situation, dul#TimeInterval)
(^A relation between situations and time intervals, e.g.
"this morning I have prepared my coffee and had my fingers burnt"
(i.e.: preparing my coffee was held this morning).
A data value attached to the time interval typically complements
this modelling pattern.^)
/^ dul#isSettingFor , - dul#isTimeIncludedIn ;
dul#isTimeIncludedIn (dul#TimeInterval, dul#Situation)
/^ dul#hasSetting ;
dul#includesEvent (dul#Situation, dul#Event)
(^A relation between situations and events, e.g.
"this morning I have prepared my coffee and had my fingers burnt"
(i.e.: the preparation of my coffee this morning included a burning
of my fingers).^)
/^ dul#isSettingFor , - dul#isEventIncludedIn ;
dul#isEventIncludedIn (dul#Event, dul#Situation)
/^ dul#hasSetting ;
dul#includesAction (dul#Situation, dul#Action)
(^A relation between situations and actions, e.g.
"this morning I have prepared my coffee and had my fingers burnt"
(i.e.: the preparation of my coffee this morning included a
burning of my fingers).^)
/^ dul#includesEvent , - dul#isActionIncludedIn ;
dul#isActionIncludedIn (dul#Action, dul#Situation)
/^ dul#isEventIncludedIn ;
dul#isTaskOf (dul#Task, dul#Role)
(^A relation between roles and tasks, e.g. "students have the duty of
giving exams" (i.e. the Role "student" hasTask the Task "giving exams").^)
/^ dul#isRelatedToConcept ;
dul#hasTask (dul#Role, dul#Task)
(^A relation between roles and tasks, e.g. "students have the duty of
giving exams" (i.e. the Role "student" hasTask the Task "giving exams").^)
/^ dul#isRelatedToConcept , - dul#isTaskOf ;
dul#satisfies (dul#Situation, dul#Description)
(^A relation between a Situation and a Description,
e.g. the execution of a Plan satisfies that plan.^)
/^ dul#associatedWith ;
dul#isSatisfiedBy (dul#Description, dul#Situation)
(^A relation between a Situation and a Description,
e.g. the execution of a Plan satisfies that plan.^)
/^ dul#associatedWith , - dul#satisfies ;
dul#actsFor (dul#Agent, dul#SocialAgent)
(^The relation holding between any Agent, and a SocialAgent.
In principle, a SocialAgent requires at least one PhysicalAgent
in order to act, but this dependency can be "delegated";
e.g. a university can be acted for by a department, which in turn
is acted for by physical agents.^)
/^ dul#associatedWith , - dul#actsThrough ;
dul#actsThrough (dul#SocialAgent, dul#Agent)
(^The relation holding between a PhysicalAgent and a SocialAgent.
In principle, a SocialAgent requires at least one PhysicalAgent
in order to act, but this dependency can be "delegated",
e.g. a university can be acted for by a department, which is
acted for by physical agents. AKA isActedBy^)
/^ dul#associatedWith ;
dul#conceptualizes (dul#Agent, dul#SocialObject)
(^A relation stating that an Agent is internally representing a
SocialObject: situations, descriptions, concepts, etc.
E.g., "John believes in the conspiracy theory";
"Niels Bohr created the solar-system metaphor for the atomic theory";
"Jacques assumes all swans are white";
"the task force members share the attack plan".
Conceptualizations can be distinguished into different forms,
primarily based on the type of SocialObject that is conceptualized.
Descriptions and concepts can be "assumed", situations can be "believed"
or "known", plans can be "adopted", etc. (see ontology:
http://www.ontologydesignpatterns.org/ont/dul/Conceptualization.owl.^)
/^ dul#associatedWith , - dul#isConceptualizedBy;
dul#isConceptualizedBy (dul#SocialObject, dul#Agent)
(^A relation stating that an Agent is internally representing a Description.
E.g., "John believes in the conspiracy theory";
"Niels Bohr created a solar-system metaphor for his atomic theory";
"Jacques assumes all swans are white";
"the task force shares the attack plan".^)
/^ dul#associatedWith ;
dul#isIntroducedBy (dul#SocialAgent, dul#Description)
(^A relation between a Description and a SocialAgent, e.g. a
Constitutional Charter introduces the SocialAgent "PresidentOfRepublic".^)
/^ dul#associatedWith ;
dul#introduces (dul#Description, dul#SocialAgent)
(^A relation between a Description and a SocialAgent, e.g. a
Constitutional Charter introduces the SocialAgent "PresidentOfRepublic".^)
/^ dul#associatedWith , - dul#isIntroducedBy ;
dul#hasConstraint (dul#Entity, dul#Parameter)
(^A relation between parameters and entities. It allows to assert generic
constraints (encoded as parameters), e.g.
MinimumAgeForDriving isConstraintFor John (where John is a legal subject
under the TrafficLaw).
The intended semantics (not expressible in OWL) is that a
Parameter isParameterFor a Concept that classifies an Entity;
moreover, it entails that a Parameter parametrizes a Region that
isRegionFor that Entity.^)
/^ dul#isClassifiedBy , - dul#isConstraintFor ;
dul#isConstraintFor (dul#Parameter, dul#Entity)
(^A relation between parameters and entities. It allows to assert
generic constraints (encoded as parameters), e.g.
MinimumAgeForDriving isConstraintFor John (where John is a legal subject
under the TrafficLaw).
The intended semantics (not expressible in OWL) is that a
Parameter isConstraintFor and Entity if the Parameter isParameterFor
a Concept that classifies that Entity;
moreover, it entails that a Parameter parametrizes a Region that
isRegionFor that Entity.
The use in OWL is therefore a shortcut to annotate what Parameter
constrains what Entity^)
/^ dul#classifies ;
dul#hasQuality (dul#Entity, dul#Quality)
(^A relation between entities and qualities, e.g. "Dmitri's skin is yellowish".^)
/^ dul#associatedWith , - dul#isQualityOf;
dul#isQualityOf (dul#Quality, dul#Entity)
(^A relation between entities and qualities, e.g. "Dmitri's skin is yellowish".^)
/^ dul#associatedWith ;
dul#hasRegion (dul#Entity, dul#Region)
(^A relation between entities and regions, e.g.
"the number of wheels of that truck is 12",
"the time of the experiment is August 9th, 2004",
"the whale has been localized at 34 degrees E, 20 degrees S".^)
/^ dul#associatedWith , - dul#isRegionFor ;
dul#isRegionFor (dul#Region, dul#Entity)
(^A relation between entities and regions, e.g. "the color of my car is red".^)
/^ dul#associatedWith ;
dul#hasTimeInterval (dul#Event, dul#TimeInterval)
(^The generic relation between events and time intervals.^)
/^ dul#hasRegion , - dul#isTimeIntervalOf ;
dul#isTimeIntervalOf (dul#TimeInterval, dul#Event)
(^The generic relation between time intervals and events.^)
/^ dul#isRegionFor ;
dul#isObservableAt (dul#Entity, dul#TimeInterval)
(^A relation to represent a (past, present or future) TimeInterval at which
an Entity is observable.
In order to encode a specific time, a data value should be related to the
TimeInterval.
An alternative way of representing time is the datatype property:
hasIntervalDate^)
/^ dul#hasRegion , - dul#isTimeOfObservationOf ;
dul#isTimeOfObservationOf (dul#TimeInterval, dul#Entity)
(^A relation to represent a (past, present or future) TimeInterval at which
an Entity is observable.
In order to encode a specific time, a data value should be related to the
TimeInterval.
An alternative way of representing time is the datatype property:
hasIntervalDate^)
/^ dul#isRegionFor ;
dul#isParametrizedBy (dul#Region, dul#Parameter)
(^The relation between a Parameter, e.g. "MajorAge", and a Region,
e.g. "less than 17 year".^)
/^ dul#isClassifiedBy , - dul#parametrizes ;
dul#parametrizes (dul#Parameter, dul#Region)
(^The relation between a Parameter, e.g. "MajorAgeLimit",
and a Region, e.g. "18_year".
For a more data-oriented relation, see hasDataValue^)
/^ dul#classifies ;
dul#hasDataValue (dul#Entity, ?) // Data property
(^A datatype property that encodes values from a datatype for an Entity.
There are several ways to encode values in DOLCE (Ultralite):
1) Directly assert an xsd:_ value to an Entity by using hasDataValue
2) Assert a Region for an Entity by using hasRegion, and then assert an
xsd:_ value to that Region, by using hasRegionDataValue
3) Assert a Quality for an Entity by using hasQuality, then assert a Region
for that Quality, and assert an xsd:_ value to that Region, by using
hasRegionDataValue
4) When the value is required, but not directly observed, assert a Parameter
for an xsd:_ value by using hasParameterDataValue, and then associate the
Parameter to an Entity by using isConstraintFor
5) When the value is required, but not directly observed, you can also assert
a Parameter for a Region by using parametrizes, and then assert an
"xsd:_" value to that Region, by using hasRegionDataValue
The five approaches obey different requirements.
For example, a simple value can be easily asserted by using pattern (1), but
if one needs to assert an interval between two values, a Region should be
introduced to materialize that interval, as pattern (2) suggests.
Furthermore, if one needs to distinguish the individual Quality of a value,
e.g. the particular nature of the density of a substance, pattern (3) can
be used.
Patterns (4) and (5) should be used instead when a constraint or a selection
is modeled, independently from the actual observation of values in the
real world.^)
/^ owl#datatype_property ; //pm: dul#associatedWith
dul#hasEventDate (dul#Event, xmls#dateTime)
(^A datatype property that encodes values from xsd:dateTime for an Event;
a same Event can have more than one xsd:dateTime value: begin date,
end date, date at which the interval holds, etc.^)
/^ dul#hasDataValue ;
dul#hasParameterDataValue (dul#Parameter,?)
(^Parametrizes values from a datatype. For example, a
Parameter MinimumAgeForDriving hasParameterDataValue 18 on
datatype xsd:int, in the Italian traffic code. In this example,
MinimumAgeForDriving isDefinedIn the Norm ItalianTrafficCodeAgeDriving.
More complex parametrization requires workarounds.
E.g. AgeRangeForDrugUsage could parametrize data value:
14 to 50 on the datatype: xsd:int. Since complex datatypes are not
allowed in OWL1.0, a solution to this can only work by creating two
"sub-parameters": MinimumAgeForDrugUsage (that hasParameterDataValue 14)
and MaximumAgeForDrugUsage (that hasParameterDataValue 50), which are
components of (cf. hasComponent) the main Parameter AgeRangeForDrugUsage.
Ordering on subparameters can be created by using or specializing the
object property "precedes".^)
/^ dul#hasDataValue ;
dul#hasRegionDataValue (dul#Region,?)
(^A datatype property that encodes values for a Region,
e.g. a float for the Region Height.^)
/^ dul#hasDataValue ;
dul#hasIntervalDate (dul#TimeInterval, xmls#dateTime)
(^A datatype property that encodes values from xsd:dateTime for a
TimeInterval; a same TimeInterval can have more than one
xsd:dateTime value: begin date, end date, date at which the
interval holds, etc.^)
/^ dul#hasRegionDataValue ;
dul#expresses (dul#InformationObject, dul#SocialObject)
(^A relation between an InformationObject and a "meaning", generalized here as
a "SocialObject". For example: "A Beehive is a structure in which bees are
kept, typically in the form of a dome or box." (Oxford dictionary)";
"the term Beehive expresses the concept Beehive in my apiculture ontology".
The intuition for "meaning" is intended to be very broad. A separate, large
comment is included for those who want to investigate more on what kind of
meaning can be represented in what form. ^)
/*
This is a large comment field for those who want to investigate the different
uses of the "expresses" relation for modeling different approaches to
meaning characterization and modeling.
For example, in all these cases, some aspect of meaning is involved:
- Beehive means "a structure in which bees are kept, typically in the form of
a dome or box." (Oxford dictionary)
- "Beehive" is a synonym in noun synset 09218159 "beehive|hive" (WordNet)
- "the term Beehive can be interpreted as the fact of "being a beehive",
i.e. a relation that holds for concepts such as Bee, Honey, Hosting, etc."
- "the text of Italian apiculture regulation expresses a rule by which
beehives should be kept at least one kilometer away from inhabited areas"
- "the term Beehive expresses the concept Beehive"
- "Beehive" for apiculturists does not express the same meaning as for, say,
fishermen"
- "Your meaning of "Beautiful" does not seem to fit mine"
- "Beehive" is formally interpreted as the set of all beehives"
- "from the term "Beehive", we can build a vector space of statistically
significant cooccurring terms in the documents that contain it"
- the lexeme "Belly" expresses the role "Body_Part" in the frame
"ObservableBodyParts" (FrameNet)
As the examples suggest, the "meaning of meaning" is dependent
on the background approach/theory that one assumes. One can
hardly make a summary of the too many approaches and theories
of meaning, therefore this relation is maybe the most
controversial and difficult to explain; normally, in such cases
it would be better to give up formalizing. However, the
usefulness of having a "semantic abstraction" in modeling
information objects is so high (e.g. for the semantic web,
interoperability, reengineering, etc.), that we accept this
challenging task, although without taking any particular
position in the debate. We provide here some examples, which
we want to generalize upon when using the "expresses" relation
to model semantic aspects of social reality.
In the most common approach, lexicographers that write
dictionaries, glossaries, etc. assume that the meaning of a
term is a paraphrase (or "gloss", or "definition"). Another
approach is provided by concept schemes like thesauri and
lexicons, which assume that the meaning of a term is a
"concept", encoded as a "lemma", "synset", or
"descriptor". Still another approach is that of psychologists
and cognitive scientists, which often assume that the meaning
of an information object is a concept encoded in the mind or
cognitive system of an agent. A radically different approach
is taken by social scientists and semioticians, who usually
assume that meanings of an information object are spread across
the communication practices in which members of a community use
that object. Another approach that tackles the distributed
nature of meaning is assumed by geometrical models of
semantics, which assume that the meaning of an
InformationObject (e.g. a word) results from the set of
informational contexts (e.g. within texts) in which that object
is used similarly. The logical approach to meaning is still
different, since it assumes that the meaning of e.g. a term is
equivalent to the set of individuals that the term can be
applied to; for example, the meaning of "Ali" is e.g. an
individual person called Ali, the meaning of "Airplane" is
e.g. the set of airplanes, etc. Finally, an approach taken by
structuralist linguistics and frame semantics is that a meaning
is the relational context in which an information object can be
applied; for example, a meaning of "Airplane" is situated
e.g. in the context ("frame") of passenger airline flights.
These different approaches are not necessarily conflicting, and
they mostly talk about different aspects of so-called
"semantics". They can be summarized and modelled within
DOLCE-Ultralite as follows (notice that such list is far from
exhaustive):
(1) Informal meaning (as for linguistic or commonsense semantics:
a distinction is assumed between (informal) meaning and reference;
see isAbout for an alternative pattern on reference)
- Paraphrase meaning (as for lexicographic semantics). Here it
is modelled as the expresses relation between instances of
InformationObject and different instances of InformationObject
that act as "paraphrases"
- Conceptual meaning (as for "concept scheme" semantics). Here it
is modelled as the expresses relation between instances of
InformationObject and instances of Concept
- Relational meaning (as for frame semantics). Here it is modelled
as the expresses relation between instances of InformationObject
and instances of Description
- Cognitive meaning (as for "psychological" semantics). Here it is
modelled as the expresses relation between any instance of
InformationObject and any different instance of InformationObject
that isRealizedBy a mental, cognitive or neural state (depending
on which theory of mind is assumed). Such states can be considered
here as instances of Process (occurring in the mind, cognitive
system, or neural system of an agent)
- Cultural meaning (as for "social science" semantics). Here it is
modelled as the expresses relation between instances of
InformationObject and instances of SocialObject (institutions,
cultural paradigms, norms, social practices, etc.)
- Distributional meaning (as for geometrical models of meaning).
Here it is modelled as the expresses relation between any
instance of InformationObject and any different instance of
InformationObject that isFormallyRepresentedIn some (geometrical)
Region (e.g. a vector space)
(2) Formal meaning (as for logic and formal semantics: no distinction is
assumed between informal meaning and reference,
therefore between "expresses" and "isAbout",
which can be used interchangeably)
- Object-level formal meaning (as in the traditional
first-order logic semantics). Here it is modelled as the
expresses relation between an instance of InformationObject and
an instance of Collection that isGroundingFor (in most cases) a
Set; isGroundingFor is defined in the ontology at
http://www.ontologydesignpatterns.org/ont/dul/IOLite.owl
- Modal formal meaning (as in possible-world semantics). Here
it is modelled as the expresses relation between an instance of
InformationObject and an instance of Collection that
isGroundingFor a Set, and which isPartOf some different
instance of Collection that isGroundingFor a PossibleWorld
This is only a first step to provide a framework, in which one
can model different aspects of meaning. A more developed
ontology should approach the problem of integrating the
different uses of "expresses", so that different theories,
resources, methods can interoperate. */
/^ dul#associatedWith ,
- dul#isExpressedBy ;
dul#isExpressedBy (dul#SocialObject, dul#InformationObject)
(^See the inverse relation type: dul#expresses.^)
/^ dul#associatedWith ;
dul#expressesConcept (dul#InformationObject, dul#Concept)
(^A relation between an InformationObject and a Concept,
e.g. the term "dog" expresses the Concept "dog".
For expressing a relational meaning, see the more general object
property: expresses^)
/^ dul#expresses , - dul#isConceptExpressedBy ;
dul#isConceptExpressedBy (dul#Concept, dul#InformationObject)
(^See the inverse relation type: dul#expressesConcept^)
/^ dul#isExpressedBy ;
dul#concretelyExpresses (dul#InformationRealization, dul#SocialObject)
(^A relation between an InformationRealization and a Description,
e.g. "the printout of the Italian Constitution concretelyExpresses
the Italian Constitution". It should be supplied also with a rule
stating that the InformationRealization realizes an InformationObject
that expresses the Description^)
/^ dul#associatedWith , - dul#isConcretelyExpressedBy ;
dul#isConcretelyExpressedBy (dul#SocialObject, dul#InformationRealization)
(^See the inverse relation type: dul#concretelyExpresses^)
/^ dul#associatedWith ;
dul#isAbout (dul#InformationObject, dul#Entity)
(^A relation between information objects and any Entity (including
information objects). It can be used to talk about e.g. entities are
references of proper nouns: the proper noun "Leonardo da Vinci" isAbout
the Person Leonardo da Vinci; as well as to talk about sets of entities
that can be described by a common noun: the common noun "person" isAbout
the set of all persons in a domain of discourse, which can be represented
in DOLCE-Ultralite as an individual of the class: Collection.
The isAbout relation is reflexive (not expressible in OWL1.0), because
information objects are also about themselves.^)
/^ dul#associatedWith , - dul#isReferenceOf ;
dul#isReferenceOf (dul#Entity, dul#InformationObject)
(^See the inverse relation type: dul#isAbout.^)
/^ dul#associatedWith ,
\. pm#url ;
dul#realizes (dul#InformationRealization, dul#InformationObject)
(^A relation between an information realization and an information object,
e.g. the paper copy of the Italian Constitution realizes the text of the
Constitution.^)
/^ dul#associatedWith ;
dul#isRealizedBy (dul#InformationObject, dul#InformationRealization)
(^See the inverse relation type: dul#realizes.^)
/^ dul#associatedWith , - dul#realizes ;
dul#realizesInformationAbout (dul#InformationRealization, dul#Entity)
(^The relation between entities and information realizations,
e.g. between Italy and a paper copy of the text of the Italian Constitution.^)
/^ dul#associatedWith ;
dul#isReferenceOfInformationRealizedBy (dul#Entity, dul#InformationRealization)
(^See the inverse relation type: dul#realizesInformationAbout.^)
/^ dul#associatedWith , - dul#realizesInformationAbout ;
CN _('*','>'); //">" would be converted to an ID; see fs.lex