Foreword
TROEPS
is an object based knowledge representation system. It thus allows to model
particular domains under the form of objects. This means that the individual
entities of the domain are seen as discrete entities with fields denoting their
characteristics and their relationship with other such entities. These objects
are also grouped into families of objects called concepts or classes which, in
turn, can be related to each others by specialisation or attributive
relationship. Each construct of the system has a precise semantics which allows
to check the models for internal consistency.
TROEPS
knowledge bases can be explored in order to find the objects and their
relationships. To that extent, turning a knowledge base into a Web knowledge
server, either for browsing, editing or exploiting the model, has been made
easy. Moreover, lexicons and annotations enable to document the model
straightforwardly.
However,
the interpretation and exploitation of the model is left to external programs
(generally through the
TROEPS
API). The system provides basic tools for easing the use of models such as
sophisticated field value computation, instance classification and conceptual
clustering.
About
TROEPS
TROEPS
can be considered as the successor of
SHIRKA.
It thus shares with
SHIRKA
the notions of objects, classes, taxonomy, hypertext links and classification
facilities. It also adds the possibility of having several taxonomies over the
same set of objects, extendibility through abstract data types and constraint
satisfaction.
TROEPS
is a result of the
Sherpa
project headed by François Rechenmann from 1988 to 1999. The system
stems from the work of the whole Sherpa team and the previous research on
SHIRKA
and continuous efforts made in order to enhance it. Meanwhile, the overall
design of
TROEPS
has been the early initiative of Olga Mariño, the development of
TROEPS
has been carried out at various level of involvement by Christophe Alemany,
Cécile Capponi, Isabelle Crampé, Pierre Fontanille, Pierre
Girard, Jérôme Gensel, Claire Lecourtier, Florence Lemaire,
Olivier Schmeltzer, Loïc Tricand De La Goutte, Nina Tayar and Petko
Valtchev under the supervision of Jérôme Euzenat.
The
actual implemented system is not faithful to the design of Olga Mariño's
papers. Some notions (like annotations, lexicon, categorisation) have been
added to the system, others (like the semantics of taxonomies) have been
changed but the main advantage of the current design is that it works and is
implemented. Nevertheless, the implemented system is not the final one. The
implementation has been carried out in such a modular way that it will be
possible to replace a straightforward implementation by another one
(concerning, for example, the memory storage or the basic classification
mechanisms) or to add new modules (for instance, clustering facilities or a
complete revision mechanism).
The
extensions of the system such as the knowledge server are built on top of an
API (Application Programming Interface). That API which represents the core of
the system is implemented and described in the present manual.
Beware:
although other documents, anterior or posterior, can help to understand
particular aspects of the system,
this
reference manual is the only trustworthy documentation of
TROEPS
1.3 made available from december 1999
.
Organisation
and notation
As
said above,
TROEPS
is made of a restricted set of basic notions. These notions are described in
this manual in a constant frame consisting of:
- an
explanation of the notion,
- the
description of the graphic interaction involved in the manipulation of the
notion (through Web pages),
- the
complete specification of the API about that notion.
- the
presentation of API manipulation through an example.
Among
the particular notations used in this manual, functions of the API are
presented in the following format:
- (primitive-name
argument1...
argumentn) primitive-type
in [library-name]
-> returned-type,
argument1
argument
1-typeerror-types...,
argumentn
argumentn-typeerror-types
- Description
of the primitive behaviour.
Type
expressions are expressed in a kind of Backus-Naur form. The error names can be
found in Appendix
7.
Sometimes, the mention "
NIY"
and a "--" sign after the closing parenthesis signals that the primitive is not
available in the current version. There are very few non available primitives.
Interface
are displayed through particular figures called Screendumps. They provide a
picture of the
HTTP
browser screen together with the indications of the next screens when clicking
on an active element (link or button). Some screens (mainly dialogues) are
omitted since they do not carry a lot of information and other ones are reduced
through white stripes across them.
Screendump
<number>: <Description of the screen function>. <Additional
information>
The
examples are given in their
TALK
form (i.e. not in a C form, however, the use of
TALK
constructions is limited to the well-known list operations:
cons,
car,
cdr,
list
and
eq).
They constitute the creation of a knowledge base extending an already existing
base (
real-estate
available in the examples, which, by opposition, is the subject of the examples
given in the text). So, each example session can be played only after having
played the former sessions. A primitive is presented in both the section
corresponding to its API description and/or in the section corresponding to its
arguments. Finally, the format of
TALK
examples is made of a form to evaluate (preceded by a question mark) and the
results of the evaluation (preceded by an equal sign). The result is printed by
the
TROEPS
printer which displays a simple readable form for
TROEPS
entities. For instance,
? (tr-find-concept "house")
= (tr-concept "house")
corresponds
to the evaluation of
(tr-find-concept
"house")
which returns the "house" concept printed as
(tr-concept
"house")
.
This is useful since the result can be cut and pasted in order to provide a
reference to the object.
Hereafter,
the "designer" will not be considered as different from the "user": a designer
has,
a
priori
,
no additional facilities to use a knowledge base. So, "user" will be the
general term used, and "designer" will be reserved for discussions on strict
design problems, if any.
Plan
The
manual is made of three main chapters. The first one,
Data
model
,
describes the static model used in
TROEPS
in order to represent knowledge in term of objects. The second one,
Computing
field values
,
is dedicated to the dynamic aspect of inferring field values. The third one,
Classification
principles
,
concerns a very important aspect of
TROEPS:
the possibility to find the most suited class for an object with regard to the
overall knowledge base. A fourth chapter concerns the setting of a
Knowledge
server
taking advantage of the World wide web.
A
set of appendices is added to these four main chapters. They concern:
- how
to get and install
TROEPS;
- the
textual format (how to describe knowledge bases in files);
- an
example of knowledge base (
TROEPS
itself);
- the
TROEPS
document type description
- how
to add data types into
TROEPS;
- how
to launch and catch errors;
- the
list of error messages;
- the
list of reserved annotation labels;
- a
glossary;
- the
index of functions.
The
novice reader is invited to read the manual through the three main sections; it
is possible to reproduce the examples from the first to the last. The installer
and/or newcomer should consult the Appendix
1
for a quick start. The programmer will access directly the manual from the
function index at the end of the manual or by browsing the on-line manual
through a
WWW
client (see Appendix
1).
Montbonnot,
le 20 décembre 1999