=Paper=
{{Paper
|id=Vol-71/paper-14
|storemode=property
|title=Engineering a complex ontology with time
|pdfUrl=https://ceur-ws.org/Vol-71/Santos.pdf
|volume=Vol-71
}}
==Engineering a complex ontology with time==
https://ceur-ws.org/Vol-71/Santos.pdf
Engineering a complex ontology with time
Jorge Santos Steffen Staab
GECAD - Knowledge Engineering and Universität Karlsruhe (TH)
Decision Support Research Group Institut AIFB
Instituto Superior de Engenharia do Porto D-76128 Karlsruhe - Germany
Departamento de Engenharia Informática
4200-072 Porto - Portugal
Abstract In this paper, we present our ontology engineering method-
ology, F ONTE (Factorizing ONTology Engineering complex-
Because it is difficult to engineer a complex on- ity), that pursues a ‘divide-and-conquer’ strategy for engi-
tology with time, we here consider a method that neering complex ontologies with time. F ONTE divides a tar-
allows for factorizing the complexity of the en- geted ontology that is complex and that includes time into
gineering process, F ONTE (Factorizing ONTology two building blocks, viz. a temporal theory and a time-less
Engineering complexity). F ONTE divides the engi- domain ontology. Each one of the two subontologies can be
neering task into building a time-less domain on- built independently allowing for a factorization of complex-
tology and a temporal theory independently from ity. The targeted ontology is then build by assembling the
each other. F ONTE provides an operator that as- time-less domain ontology and the temporal theory by the op-
sembles the two independently developed ontolo- erator .
gies into the targeted ontology. We investigate the Thereby, the assembling operator is very different from
quality of the proposed operator by applying it existing operators for merging or aligning ontologies [Noy
to a practical case study, viz. the engineering of an and Musen, 2000; Rahm and Bernstein, 2001 ]. Merging on-
ontology about researchers including temporal in- tologies is a process that intends to join different ontologies
teractions. about overlapping domains into a new one and most of its
problems and techniques are related to the identification of
1 Introduction similar concepts through structure analysis (e.g. graph anal-
ysis, path length, common nodes or/and edges and lexical
In recent years, we have seen a surge of ontologies and on- analysis). For instance, car from ontology 1, O1.car , and
tology technology with many ontologies now being avail- auto from ontology 2 O2.auto may be defined to be identi-
able on the Web. At the same time one could observe cal in the merging process because of results of the struc-
that most ontologies (e.g., consider the DAML ontology li- ture analysis. To formalize the merging and aligning process,
brary at http://www.daml.org/ontologies/) engi- Wiederhold proposed a general algebra for composing large
neered exhibit only rather simple structures, viz. taxonomies applications through merging ontologies of related domains
and frame-like links between concepts. [Wiederhold, 1994 ] and actually, the operations proposed (In-
This observation might indicate that such — comparatively tersection, Union and Difference) are about the similarities
— simple structures are sufficient for the large majority of and differences of two ontologies.
ontology-based systems. According to our own experiences In contrast, the result of needs rather to be seen in anal-
about ontologies for knowledge portals [?] and power sys- ogy to the Cartesian product of two entities. For instance, car
tems [Santos et al., 2001 ], however, one frequently needs in- from ontology 1, O1.car , with its frame O1.licensedInState is
tricate concept descriptions and interactions — in particular assembled by with ontology 2 and its O2.timeInterval in a
ones about time and space. way such that every car in the result ontology has a lifetime
Because of intense (and fruitfully ongoing) research, many as well as multiple O1.licensedInState-frames with different,
practical theories about time are now well understood. While mutually exclusive life spans.
the same can be said about the engineering of concept hi-
is operationalized by an iterative, interactive process.
erarchies and concept frames, the issue of how to engineer
It starts off with a human assembly — in the sense just ex-
complex ontologies with intricate interactions based on time
plained — between an ontology O1 , the time-less domain
has not been researched very deeply, yet, rendering the engi-
ontology, and an ontology O2 , the temporal theory. It is then
neering of a new complex domain ontology with time a labor
propelled by a set of rules and a set of constraints. The set
intensive, one-off experience with little methodology.
of rules drives a semi-automatic process proposing combina-
0
Jorge Santos was supported by a Marie-Curie Fellowship for a tions. The set of constraints narrows down the set of plausible
research visit to University of Karlsruhe. Most of the work presented proposals to valid ones.
here, has been developed during this research stay. We have applied the methodology F ONTE with its opera-
tor to a case study, where O1 is a time-less ontology about TimeRoot x y isa(x,y)
pred
a semantic web research community and O2 is a temporal x y pred(x,y)
ontology. We have investigated how many assembling steps TemporalEntity
were proposed and evaluated their adequacy. The study re-
sults suggest that indeed F ONTE provided a way to factorize Instant
the complexity of building large applications leading to more begin end
reliable and cheaper final products. Period atTime
The rest of the paper is organized as follows. In Sections 2
duringAt
and 3, we sketch the temporal ontology and the time-less do-
Eventuality
main ontology we have used for our case study, respectively.
In Section 4 we describe the semi-automatic process of as- Process
sembling two ontologies by , with some emphasis on the
starts finishes duringAt
tool support developed to drive the process. Then we give an
evaluation of our sample case in Section 5. Event
2 Temporal Ontology TimedThing
roleOf
The temporal ontology used for our case study (see Figure 1 Role
for the depiction of an excerpt) embodies many concepts like roleOf
Instant or Period routinely found in ‘standard’ ontologies TimedConcept
like Time-DAML [Hobbs, 2002 ] or SUMO [Niles and Pease,
2001]. As argued by [Vila and Schwalb, 1996 ] a temporal TimedRelation
representation requires the characterization of time itself and
temporal incidence, which are represented in our temporal Figure 1: Excerpt of temporal ontology used in case study
ontology by TemporalEntity and Eventuality , respectively. and after are strict linear, namely irreflexive, asymmetric,
We defined a further notion TimedThing that bridges be- transitive and linear. The thirteen binary relations proposed
tween temporal concepts and the domain concepts that will in the Allen’s interval algebra [Allen, 1983 ] can be defined in
be used during the assemble process. In particular, we have a straightforward way based on the previous three relations
included the notion of Role as a core concept. While there [Freksa, 1992 ].
are concepts that give identity to their instances (i.e. they While begin and end are relations from TemporalEntity to
are semantically rigid), e.g. while the identity of a particu- Instant , for convenience it is stated that start and end of an
lar person depends on being an instance of Person , the iden- Instant is itself. Also, there are no null duration periods and
tity of the same person does not change when it ends being a each period is unique.
student and starts being a professor . Thus, the notion of Role
is important when connecting a temporal theory, e.g. Allen’s Processes and Events. There are two subclasses of
interval calculus, with a concrete domain, e.g. an ontology Eventuality : Process and Event , in order to be possible to
about researchers (cf., e.g., [Lehmann, 1996; Sowa, 1996; express continuous and instantaneous eventualities, respec-
Guarino and Welty, 2000; Steimann, 2000 ]).1 tively. Event have a relation atTime to Instant while Process
Some of the choices for the temporal ontology that we have a relation duringAt to Period . The relations starts
made were driven by modelling objectives particular to the and finishes allows to state what can start or finish one pro-
knowledge portal application that we had in mind when per- cess, that relations can be useful when modelling a reasoning
forming the case study. For instance, our objective was to mechanism like Event Calculus [Kowalski and Sergot, 1986 ].
have a 3-dimensional model of the world with time as an ex- Roles. A role can have roles but can not be role of itself
tra variable. For future applications an ontology engineer may (R1) and that roleOf relation it is transitive (R2). Guarino
prefer a 4-dimensional view, leading to a somewhat different distinguishes roles from natural types based on the lack of
temporal ontology and, thus, to an overall different target on- semantic rigidity of the first, hence, it is possible to derive that
tology in the end (cf. [Hayes et al., 2002 ]). The scope of this a role is timely bounded to the concept from which inherits
paper is to show a factorization of complexity into two sub- identity (R3).
ontologies and a re-assembly into a target ontology in a way
that is independent of such underlying concerns.
8 : ? roleOf ( )
x x; x : (R1)
Temporal Entities In the temporal ontology we used for
the case study there are two subclasses of TemporalEntity : 8 : roleOf (
x; y; z ) x; z
Instant and Period . The relations before, after and equality roleOf ( ) ^ roleOf (
x; y ) y; z : (R2)
can hold between Instants , respectively represented by the 8 1 2 : containedBy( 1 2)
symbols: , , =, allowing to define an algebra based on
o; x; y; p ; p p ;p
(isa( Role ) _ isa( TimedConcept )) ^
y; y;
points [Vilain and Kautz, 1986 ]. It is assumed that the before
isa( Role ) ^ roleOf (
x; ) ^ x; y
1) ^
1
The reader may note that we could not directly use a ‘standard’ hasRoleDuringAt( o; x; p
temporal ontology like Time-DAML or SUMO as they do not in-
clude the notion of role . hasRoleDuringAt(o; y; p2): (R3)
2
3 Case Study Example: The SWRC Ontology Rules for
Ontology 2
Assemble
The assemble process may be used either for development Initial Load Parameters
Setup Ontology 1
of ontologies with time from the scratch as well as for re-
engineering existing ones in order to include time. For
Analyze Add Create
our case study we have used the SWRC (Semantic Web Structure Tasks
Research Community) ontology (http://ontobroker.
Task
semanticweb.org/ontos/swrc.html) that served List
as a seed ontology for the knowledge portal of OntoWeb. USER: Read
Create or Tasks Target
SWRC comprises 55 concepts, 151 relations and 25 ax- accept Ontology
ioms. The results presented in the section 5 are based on re- Allow Undo
engineering the complete SWRC. Here we present an excerpt Accept Create
that is also used in order to elucidate the assembling process proposed new
task task Task
with . History
The SWRC ontology contains different types of axioms, Update
Validate
namely, transitive, inverse, symmetric and general, being that, Update
any axiom that does not fall in the first three types is called
’general’. Execute Task
isa(Student ; Person ) studiesAt(Student ; University ) USER:
Process Flow
isa(Employee ; Person ) member(Person ; Project ) Iterate Data Flow
isa(Male ; Person ) isAbout(Project ; Topic )
isa(Graduate ; Student ) Conclude
8p; t : isAbout(p; t) $ dealsWithIn(t; p) (I1.1)
Process
Figure 3: Assembly main process
8pers; top : worksOn(pers; top) (A1.1) subsequent iterations, the usefulness of results provided by
9 instOf (pers; Person ) ^
proj : (A1.2) the structure analysis improves.
instOf (proj; Project ) ^ (A1.3) In every iteration the engineer decides whether to accept an
instOf (top; Topic ) ^ (A1.4) automatically proposed task instance from the Task List.
isAbout(proj; top) ^ (A1.5) Alternatively, the user may take the initiative and assemble
member(pers; proj ) (A1.6) a new task instance from scratch. Then a set of logical tests
(Validate) are performed in order to detect the existence
Figure 2: Excerpt of SWRC ontology of any knowledge anomalies (e.g. circularity or redundancy
[Preece and Shinghal, 1994 ]). In contrast, the acceptance of a
4 The Assembly Process proposed task instance does not require further checks as the
checks are tested for validity before the user sees them.
The assembly process comprises two main building blocks. By the Execute Task step the corresponding changes
First, the specification of temporal aspects for a time-less do- are made to the target ontology. Thereafter, the
main ontology remains dependent on the conceptualization of user decides either to pursue another iteration or to
the ontology engineer. Therefore, it is very important that the go to Conclude Process and accept the current
engineer may interactively influence the process. Second, in Target Ontology as the final version.
order to facilitate and accelerate the assembly of time-less do-
main concepts with temporal notions, the interactive process 4.1 Data Structures
is supported by heuristics asking and pointing the engineer.
The assembling process runs as depicted in Figure 3: It In the remainder of Section 4, we first present the principal
starts by an Initial Setup. Some basic operations are data structures we use for defining the heuristics, before we
performed, namely loading the ontologies to be assembled, elaborate on its application in three subsections for assem-
loading a set of rules to drive the process and initializing some bling concepts, frame-like relations and axioms, respectively
process parameters. The rules and parameters are defined (Sections 4.2 to 4.4).
separately from the tool in order to allow for adaptations to Task. We have already informally used the notion of task
the particular needs of different temporal ontologies. How- in order to refer to an action template (i.e. a generic task)
ever the rules and parameters do not change when a new do- that may be instantiated and executed in order to modify a
main ontology is to be assembled. The Target Ontology current target ontology. A task is defined by its procedure
initially corresponds to the union of the time-less domain on- and a task question. The task code uses a set of keywords
tology, O1 , and the temporal theory, O2 . with the commonly expected semantics of structured pro-
In the Analyze Structure step a set of tests are per- gramming (e.g. if, then, else) and some special key-
formed that restrict the set of possible task instances to plau- words, do and propose, the semantics of which we provide
sible ones, which are then proposed by insertion into the subsequently.
Task List. As more information becomes available in Task instance. A task instance is fully identified by its head
3
(i.e. by its task name and some instantiated arguments). A assembly of axioms. Thus, proposals for modifications with
task instance is either either proposed by the application of concepts are typically made first — and elaborated in this
the assembly rules in the Analyze Structure step or by subsection.
instantiation of a generic task of the ontology engineer (both For the running example here, we assume that
ways operationalizing ). For instance, consider the task in- a user defines and executes a task instance of
stance assemble-concepts that subclasses a concept C 1,
create-role-of(Student,Person), viz. person , from a C 2, viz. TimedConcept :
which defines the concept Student to become a role of
Person . procedure assemble-concepts(C1,C2)
if (C2=’TimedConcept’ or C2=’Role’)
Task question. Before the execution of a task, the system do(create-relation(isa(C1,C2)))
asks a task question in natural language to the engineer in assemble-related-concepts(C1)
order to determine if the proposal should really be accepted assemble-related-relations(C1)
or not and in order to ask for additional constraints that the assemble-related-axioms(C1)
user might want to add. The task question is defined by a end-if
List of words and parameters used to compose a sentence in end-procedure
natural language. The corresponding procedure assemble-concepts
For instance, the following task question exists for the pre- creates a new isa relation between the Person and
vious example TimedConcept and then proposes further assembling tasks
create-role-of(#arg1,#arg2): for related concepts, relations and axioms. Tracing the
[’Define’,#arg1,’as role of’,#arg2,’?’] changes that may be proposed to related concepts in
It implies that the question ”Define Student as role of Per- assemble-related-concepts, we find that it pro-
son?” would be posed before executing the example task in- poses the definition of Employee , Student and Male as pos-
stance. sible roles of Person . 2
In order to manage various task instances, the assembling procedure assemble-related-concepts(C)
algorithm uses the following data structures: foreach S do
Task List. This is a list of tuples (TaskIn- %check if S is a sub-concept of C
stance,ListOfTriggers,Weight) storing proposed task if(isa(S,C))
instances together with the triggers that raised their proposal W=calculate-weight(S,C)
and their weight according to which they are ranked on the %T is the trigger for this proposal
T=(concept,C)
task list. Thereby, TaskInstance has been defined before;
propose(create-role-of(S,C),T,W)
ListOfTriggers denotes the list of items that have triggered
the proposal. A trigger is a pair fTriggerType,TriggerIdg
end-if
end-do
where TriggerType has one of the values concept, relation or end-procedure
axiom and the TriggerId is the item identifier. For instance,
the pair fconcept, Persong is a valid trigger. The list is use- Later, if definition of Student as role becomes accepted,
ful for queries about what proposals by a specific item or a recursively Graduate will be proposed to become a role of
certain TriggerType ; Student utilizing create-role-of:
Weight. Since competing task instances may be proposed, procedure create-role-of(S,C)
Weight is used to reflect the strength of the proposal on the %delete isa(S,C) if true; if not, no effect
TaskList. do(delete-relation(isa(S,C)))
do(create-relation(roleOf(S,C)))
Task History is the list of all tasks that were previously per- assert(temporal-role-constraint(S,C))
formed. This list is useful to allow the undo operation and to do(assemble-concepts(S,’Role’))
provide statistics about the assembly process. end-procedure
do(TaskInstance). The function do executes a task instance
and creates a corresponding entry on the History List. with temporal-role-constraint(S ,C ) defined by
propose(TaskInstance,Trigger,Weight). The function 8o; p1; p2 : containedBy (p1; p2)
propose creates a proposal and asserts the corresponding instOf DuringAt(o; S; p1) ^
tuple in the Task List. instOf DuringAt(o; C; p2): (C1.1)
4.2 Assembly of Concepts Assuming that Male were not accepted as role of Person in
As mentioned before system proposals are generated based the further course of assembly, the result depicted in Figure 4
on rules and constraints. Typically, in the initial phase only would be obtained.
few interactions between the initially time-less domain on- The reader may note that this result crucially depends on
tology and the temporal theory are known and, hence, few our temporal theory, but that rules could be easily modified to
proposals are generated. Furthermore, the assembling of accommodate other theories (e.g., ones without roles).
concepts with temporal attributes needs to fulfill fewer con-
2
straints than the assembly of relations and far less than the The character ‘%’ indicates a line remark.
4
TimedThing
fied. In our running example, this affects the instances of
TimedConcept Person (A1.2) and Project (A1.3). Furthermore, it also up-
isa(Person ; TimedConcept ) Person dates the preconditions of the axiom involving relations that
isa(Male ; Person ) need to be temporally modified. In the running example, this
Male
isa(Student ; Role ) roleOf
roleOf
affects, e.g., member (A1.6). Finally, the user is asked to
isa(Employee ; Role ) Role define one (or several) constraint(s) that relates all the timed
isa(Graduate ; Role ) Employee variables (intervals or instants) for the pre- or the postcondi-
roleOf (Student ; Person ) Student
tions of the axiom.
roleOf (Employee ; Person ) roleOf
procedure assemble-axiom(A)
Graduate
roleOf (Graduate ; Student ) %for each concept present in the axiom
%LC is a list of all new constraints
Figure 4: Result of assembly of concepts with time foreach C partOf(A)
if isa(C,’Eventuality’) or
4.3 Assembly of Relations isa(C,’TimedThing’)
From the assembly of concepts there follow proposals for the then add-concept-constraint(C,A)
modification of relations. For instance, when we assume that LC=concat(LC,C)
Person and Project were previously modified to become sub- end-if
concepts of TimedConcept and Process respectively, it be- end-do
comes plausible that also the relation that links them, viz. %for each relation present in the axiom
%LR is a list of modified constraints
member(Person ; Project ), should incur changes. foreach R partOf(A)
The changes occur in analogy to the tasks defined for the if isa(R,’TimedRelation’)
assembly of concepts. In addition however, there arise fur- then modify-relation-constraint(R,A)
ther possibilities in order to constrain the life-time of the LR=concat(LR,R)
actual relationship by the life-time of the participating con- end-if
cept instances. Thus, member(Person ; Project ) is replaced end-do
by member(Person ; Project ; Period ) and — maybe — further %select a temporal constraint over
contraints on the time period as added by the engineer. % all the timed variables
if (LC not empty) or (LR not empty)
4.4 Assembly of Axioms then select-temporal-constraint(A,LC,LR)
end-if
The temporal constraints on concepts, relations and their in- end-procedure
stances also requires the corresponding consistent modifica-
tions of axioms. With axioms we here refer to general propo- Then the updated axiom includes previously existing pre-
sitions in first-order horn logics with function symbols. conditions (A1.2 to A1.5) and further ones about Person
For instance, let us consider the axiom defined in Fig- (A2.1), Project (A2.2) and member (A2.3) — as well as
ure 2 by lines A1.1 through A1.6 and let us name it a temporal constraint (e.g.intersection) over them (A2.4).
axiomWorksOn . axiomWorksOn defines that a Person who Hence the structure of the modified axiom looks like:
works in a Project that is dealing with a Topic , worksOn this 8p; top; t :worksOn(p; top; t)
topic. (A1.2)...(A1.5)
In order to assemble time into the axiom representation we 9t1; t2; t3 : duringAt(p; t1) ^ (A2.1)
must consider the constraints available for the instances of duringAt(prj; t1) ^ (A2.2)
participating concepts and, furthermore, the ontology engi- member(p; prj; t3) ^ (A2.3)
neer must define which one of these constraints is used in tempRelation([t1; t2; t3]; t) (A2.4)
which way. For instance, for the relation worksOn it may
be adequate to say that the Person worksOn the Topic as
long as he is a member of the Project and as long as the
5 User Interaction
Project isAbout the Topic , i.e. intersecting the lifetimes of F ONTE uses an approach that relies on iterative interaction
relations in lines A1.5 and A1.6. For an analogous structure with the user. All the assemble operations as well as interac-
where knowsAbout (pers,top) appears in the head instead of tions with the Task List and the History List can be performed
worksOn (pers,top), however, the conclusion might be that a using both the graphical drag-and-drop tool or a command
Person knowsAbout a Topic ever after he has encountered it line interface (please refer to appendix A).
in a Project until he dies, i.e. restraining the knowsAbout - In order to evaluate the effectiveness of F ONTE, we have
relation only to the earliest time-point of the encounter and numerically evaluated the assembly tasks proposed and exe-
the life-time of the Person . cuted for the ontologies presented in Sections 2 and 3. An
Since, the only difference between the two example struc- ontology engineer interactively assembled the two ontologies
tures lies in the naming of the relations and the intentions as- and by our process log we could evaluate the success of our
sociated with their names, it is necessary to involve the user approach by listing the numbers from Table 1:
for defining additional temporal constraints. The reader may note that the engineer initiated only very
The task assemble-axiom asserts an additional tempo- few tasks (10). From this initial structure a large number of
ral precondition for each concept that is temporally quanti- tasks were proposed and accepted by the user (135). Of these
5
User-initiated tasks 10 needed in order to factorize engineering complexity out lead-
Tasks proposed on Task List 135 ing to more consistent and cheaper target ontologies.
Proposed tasks accepted 78
Proposed tasks postponed for later inspection 10
Proposed tasks rejected 47 Acknowledgments
Table 1: Figures summarizing the log file This work was partially supported by a Marie-Curie Fellow-
58% were accepted (78), 7.4% (10) were postponed for later ship and by FCT (Portuguese Science and Technology Foun-
inspection and the rest was ignored. I.e. only 34.8% were dation) with programs ONTOMAPPER (POSI-41818) and
considered inadequate indicating a high success rate for our SANSKI (POCTI-41830). We are also in indebted to our col-
interactive approach. leagues in LS3, particulary to Gerd Stumme and Julien Tane
and Nuno Silva in ISEP.
This does not only seem to be true for simple structures
(where it might have been expected), but also for modifi-
cations of horn-logic axioms. Originally SWRC contained References
25 axioms. 20 of them were updated automatically the rest [Allen, 1983] J. Allen. Maintaining knowledge about temporal in-
needed some more careful inspection. tervals. Communication ACM, 26(11):832–843, 1983.
[Clark et al., 2000] P. Clark, J. Thompson, and B. Porter. Knowl-
6 Related Work edge patterns. In KR2000, pages 591–600, 2000.
In the past a variety of approaches were proposed for reduc- [Freksa, 1992] C. Freksa. Temporal reasoning based on semi-
ing the complexity of engineering a rule-based system, e.g. intervals. Artificial Intelligence, 54(1):199–227, 1992.
by task analysis [Schreiber et al., 1999 ], or an ontology-based [Guarino and Welty, 2000] N. Guarino and C. Welty. A formal on-
system, e.g. by developing with patterns [Clark et al., 2000; tology of properties. In Knowledge Acquisition, Modeling and
Staab et al., 2001; Hou et al., 2002 ] or developing subontolo- Management, pages 97–112, 2000.
gies and merging them [Noy and Musen, 2000; Rahm and [Hayes et al., 2002] P. Hayes, F. Lehmann, and C. Welty.
Bernstein, 2001 ]. As different as these methods are, they Endurantism and perdurantism: An ongoing debate.
may be characterized by subdividing the task of building a http://ontology.teknowledge.com:8080/rsigma/dialog-3d-
large ontology by engineering, re-using and then connecting 4d.html, 2002.
smaller parts of the overall ontology. [Hobbs, 2002] J. Hobbs. Towards an ontology for time for the se-
Though F ONTE shares its goal with these methodologies mantic web. In Proc. Workshop on Annotation Standards for
is its rather different in its operationalization. F ONTE does Temporal Information in Natural Language,LREC2002, Las Pal-
not aim at a partitioning and re-union (by merge or align with mas, Spain, May 2002.
recognition of similarities) of the problem space, but rather [Hou et al., 2002] Chih-Sheng Johnson Hou, N. F. Noy, and M. A.
by a factorization into primordial concepts and a subsequent Musen. A template-based approach toward acquisition of logical
combination that is more akin to a Cartesian product than sentences. In Procs.Intelligent Information Processing 2002 -
a union of ontologies. Despite these difference, one may World Computer Congress, Montreal, Canada, 2002.
note that F ONTE implements an iterative and interactive ap- [Kowalski and Sergot, 1986] R. Kowalski and M. Sergot. A logic-
proach which was previously successfully adopted in sophis- based calculus of events. New Generation Computing, 4:67–95,
ticated tools for merging ontologies [Noy and Musen, 2000; 1986.
Mitra and Wiederhold, 2001; McGuinness et al., 2000 ]. Also, [Lehmann, 1996] F. Lehmann. Big posets of participants and the-
F ONTE does not substitute these other methodologies, rather matic roles. In G. Ellis & G. Mann In P.W. Eklund, editor, Con-
we envision that one wants to separate the target ontology to ceptual Structures: Knowledge Representation as Interlingua,
be built into different (possibly overlapping) domains as well pages 50–74. Springer-Verlag, 1996.
as into time-less and temporal subontologies. The two ways
[McGuinness et al., 2000] D.L. McGuinness, R. Fikes, J. Rice, and
of carving up the engineering task need different, comple-
S. Wilder. An environment for merging and testing large ontolo-
mentary methodologies. gies. In Procs.KR2000, 2000.
[Mitra and Wiederhold, 2001] P. Mitra and G. Wiederhold. An al-
7 Conclusions and Future Work gebra for semantic interoperability of information sources. In
We have proposed a method, named F ONTE, for engineering Proc.2nd.IEEE Symp. on BioInformatics and Bioengineering,
BIBE 2001, pages 174–182, Bethesda, MD, 2001.
complex ontologies with time by assembling them from time-
less domain ontologies and a temporal theory. F ONTE pro- [Niles and Pease, 2001] I. Niles and A. Pease. Toward a standard
vides an operator that operationalizes the assembly in an upper ontology. In Procs of the 2nd International Conference on
interactive way. combines two independently developed Formal Ontology in Information Systems (FOIS-2001), 2001.
ontologies into a target ontology. [Noy and Musen, 2000] N. Noy and M. Musen. Prompt: Algo-
Though, so far, we have only studied the assembly of time rithm and tool for automated ontology merging and alignment.
into a given ontology, we conjecture that F ONTE may also In Procs.AAAI-2000, 2000.
be applied to integrate other important concepts like space, [Preece and Shinghal, 1994] A. Preece and R. Shinghal. Founda-
trust, or user access rights — concepts that pervade a given tion and application of knowledge base verification. International
ontology in intricate ways such that a method like F ONTE is Journal of Intelligent Systems, 9(8):683–702, 1994.
6
[Rahm and Bernstein, 2001] Erhard Rahm and Philip A. Bernstein. Command Description
A survey of approaches to automatic schema matching. VLDB shownextprop Show detailed information about
Journal, 10(4):334–350, 2001. next task on Task List, including a
question in natural language
[Santos et al., 2001] J. Santos, C. Ramos, Z. Vale, and A. Mar- showprop(N) Show detailed information about
ques. Verification & validation of power systems control centres task N on Task List, including a
kbs. In Procs.IASTED Artificial Intelligence and Applications question in natural language
(AIA2001), pages 324–329, Marbella, Spain, September 2001. sortproplist(F) Sorts tasks in Task List by field F
[Schreiber et al., 1999] G. Schreiber, Akkermans H., Anjewierden (e.g.Weight or Trigger )
A., R. Hoog, N. Shadbolt, W. Van de Velde, and B. Wielinga. showproplist Shows content of Task List
Knowledge engineering and management. The CommonKADS showhistlist Shows content of History List
Methodology. MIT Press, 1999.
[Sowa, 1996] J. Sowa. Processes and participants. In G. Ellis & Table 3: Historic and Task Lists Handling
G. Mann (Eds.) In P.W. Eklund, editor, Conceptual Structures: The table 4 describes commands used for handling files
Knowledge Representation as Interlingua, pages 1–22. Springer- used in the assemble process, namely, ontology files and
Verlag, 1996.
batch files.
[Staab et al., 2001] S. Staab, M. Erdmann, and A. Maedche. Engi-
neering ontologies using semantic patterns. In Procs. IJCAI-01 Command Description
Workshop on E-Business & the Intelligent Web, 2001. loaddomont(F) Loads contents of file F containing
[Steimann, 2000] F. Steimann. On the representation of roles in a domain ontology
object-oriented and conceptual modelling. Data & Knowledge loadgenont(F) Loads contents of file F containing
Engineering, 35(1):83–106, 2000. a general ontology (e.g. time ontol-
ogy)
[Vila and Schwalb, 1996] L. Vila and E. Schwalb. A theory of loadscript(F) Loads a batch file File with a as-
time and temporal incidence based on instants and periods. semble tasks
Proc.International Workshop on Temporal Representation and savescript(F) Saves into a batch file F the
Reasoning, pages 21–28, 1996. list of user driven assemble tasks
[Vilain and Kautz, 1986] M. Vilain and H. Kautz. Constraint prop- recorded in History List
agation algorithms for temporal reasoning. In Proc. of AAAI-86, savetargont(F) Saves target ontology obtained
pages 377–382, Philadelphia, PA, 1986. through the assemble process into
file F
[Wiederhold, 1994] G. Wiederhold. An algebra for ontology com-
position. In Proc.Workshop on Formal Methods, pages 56–61,
Monterey, 1994. Table 4: File Handling
A User’s Choices Finally, table 5 describes some auxiliary commands.
A command line interface was developed for the tool that im- Command Description
plements the F ONTE method. Table 2 describes commands cmd(C) Performs command C, allowing to evoke
used on the execution of assemble tasks both are available any assemble task not available through
through the acceptance of automatic produced proposals or command line
by user driven operations. help Shows help texts about available com-
mands
Command Description exit Finishes program execution
link(C1,C2) Assembles concept C1 from do-
main ontology with concept C2 Table 5: Auxiliary Commands
from general ontology
link(R,C1,C2) Defines the relation R between
concepts C1 and C2 as a temporal
relation
acptnextprop Accepts the next proposal in the
Task List for execution
acptpropnum(N) Accepts proposal N from Task List
for execution
acptprops(L) Accepts a list of proposals L from
Task List for execution
undo Undo last performed assemble task
Table 2: Assemble Tasks
Table 3 describes commands used for handling Task List
and History List. Provided facilities are showing and sorting
list contents.
7