A New Approach in Object-Based Knowledge Representation: the AROM System 1, 2
Michel Page , Jérôme Gensel1, 2, Cécile Capponi4, Christophe Bruley1, Philippe Genoud1, 3, Danielle Ziébelin1, 3, Daniel Bardou1, 2, Véronique Dupierris1 1
Action Romans, INRIA Rhône-Alpes, ZIRST, 655, av. de l’Europe, Montbonnot 38334 Saint Ismier Cedex - France 2 Université Pierre Mendès-France, BP 47, 38040 Grenoble Cedex 9, France 3 Université Joseph Fourier, Grenoble, BP 53, 38041 Grenoble Cedex 9, France 4 Labo. d’Informatique de Marseille, Univ. de Provence, 163 av. de Luminy, 13288 Marseille Cedex 9, France
[email protected]
Abstract. This paper presents AROM, a new object-based knowledge representation system. AROM is original in two ways. Firstly, in addition to classes, knowledge representation in AROM uses associations for describing links between classes instances. Secondly, AROM integrates an algebraic modeling language (AML) for describing operational knowledge (equations, constraints and queries) in a declarative way. AROM comes as a platform for knowledge representation and manipulation. It includes an interactive modeling environment, a Java API, an AML interpreter for processing queries and solving sets of equations, and a tool for consulting and editing knowledge bases on the Web.
1
Introduction
Most object knowledge representation systems fall into two categories: description logics (DL) and object-based knowledge representation systems (OBKRS). DL systems like KL-ONE [1] represent concepts using formal syntax and semantics; emphasize is put on complexity study of both subsumption and concept classification, which is the main inference mechanism of these systems. OBKRS (KRL [2], KEE [3], for instance) are declarative systems for describing, organizing and processing large amounts of knowledge; they offer various inference mechanisms such as classification, procedural attachment, default values, filters, etc. In this paper, we present AROM (Associating Relations and Objects for Modeling), a new OBKRS which departs from existing systems in two ways. Firstly, in addition to classes which are usually found in existing OBKRS, AROM uses associations similar to those found in UML [4] for organizing links between objects having common structure and semantics. Secondly, in addition to classical inference mecha-
nisms found in other OKBRS, AROM integrates an algebraic modeling language (AML) for expressing operational knowledge in a declarative manner. This language allows one to write constraints, queries, numerical and symbolic equations between the various elements composing a knowledge base (KB). AROM comes as a platform with a Java API, an interactive graphical environment for designing and manipulating KBs, an AML interpreter for processing queries and solving sets of equations, and tools for consulting and editing KBs on the Web. The paper is organized as follows. Knowledge representation in AROM is presented in section 2 along with an example. The AROM platform is detailed in section 3. Related work and conclusion are presented is section 4.
2 Knowledge Representation in AROM Many data and knowledge engineering methods involve two notions for modeling a domain: entity and relation. In object-oriented models like UML, three kinds of relation are considered: specialization/generalization, association and aggregation (a particular case of the latter being composition). An association denotes a group of similar links between instances of two or more, distinct or not, classes. Most OBKRS handle specialization, and sometimes aggregation (and/or composition). Associations usually have no specific representation; they are implemented either by link-attributes or by reification of associations as classes. A link-attribute is a slot typed by a class and its value references one (or several) instance(s) of this class. Several OBKRS like SMECI [5], implement binary associations with two inverse link-attributes, and integrate mechanisms for maintaining their consistency. This technique has two problems. It works fine only for binary associations [6], and it does not easily take into account attributes of associations (i.e. properties attached to links; for instance, the wedding date of two married persons). Using reification, associations are considered as classes whose attributes correspond either to links between objects or to specific properties. This enables associations with an arity greater than two to be described. However, since no distinction is made between classes and associations, operations or mechanisms specific to either of them cannot be defined. Neither link-attributes nor reification is thus satisfactory for representing associations. Furthermore, using both techniques within a KB can only lead to inconsistencies and lack of extensibility. This has led us to promote associations as first-class entities for knowledge representation, on equal ground with classes.
2.1 Knowledge Representation in AROM using Classes and Associations Classes and objects. A class in AROM describes a set of objects sharing common properties and constraints. Classes are descriptive: they provide a set of necessary yet not sufficient conditions for membership. Each class is characterized by a set of properties called variables and by a set of constraints.
A variable denotes a property whose type is not a class of the KB. In AROM, no variable can reference object(s), but associations are used for this purpose. AROM includes an extensible set of basic types for mono- and multi-valued variables. Each variable is characterized by a set of facets, which can be divided in the three categories: domain restriction facets, inference facets, and documentation facets. Constraints are necessary conditions expressed in the AML for an object to belong to the class. They bind together variables of – or reachable from – the class. The generalization/specialization relation is a partial order organizing classes in a hierarchy supported by a simple inheritance mechanism. Specialization of a class involves the following operations: addition or refinement of a facet, addition of a new variable, addition of a constraint. Unless redefined, a class inherits all the variables (including facets) as well as all the constraints of its super-class. An AROM object represents a distinguishable entity of the modeled domain. Each object is attached to exactly one class at any moment. The term “attached”, used with the same acceptation as in the TROEPS system [7], enlightens the dynamic aspect of class membership: an object may move from a class to another whenever additional information about it becomes available. Object identity is ensured by the use of unique identifiers, provided either by the user, or by the system. Associations and tuples. In AROM, associations are similar to those found in UML: an association represents a set of similar links between n (n ≥ 2) classes, being distinct or not. A link contains objects of the classes (one for each class) connected by the association. An association thus defines a subset of the Cartesian product of the classes it connects. An association is described by means of roles, variables and constraints. A role r corresponds to the connection between an association and one of the classes it connects, called the corresponding class of the role and noted as C(r). Each n-ary association has thus n roles and the value of each role ri (1 ≤ i ≤ n) is an instance of C(ri). Each role has a multiplicity, whose meaning is the same as in UML. A variable of an association denotes a property associated with a link and has the same set of facets as the one available for a class variable. We call tuple of an n-ary association having m variables vi (1 ≤ i ≤ m), the (n+m)-uple made up of the n objects of the link and of the m values of the variables of the association. A tuple can then be seen as an "instance" of an association. Its identity relies on the identities of the instances of its link. This ensures that two tuples can not share the same link. As for classes, constraints involving variables or roles belonging to or reachable from an association can be written in the AML, and must be satisfied by every tuple of the association. Associations are organized in specialization hierarchies. As for classes, association inheritance is simple and relies on set-based inclusion. Specializing an association A involves the following operations: specializing the corresponding class of a role of A, restricting or adding a facet to a variable or to a role of A, adding a constraint to a variable or to a role of A, adding a constraint to A, and adding a variable to A. Note that specialization of an association can not involve the addition of a role.
2.2 Algebraic Modeling of Operational Knowledge First introduced in Operations Research, algebraic modeling languages (AMLs) make it possible to write systems of equations and/or of constraints, in a formalism close to mathematical notations. They support the use of indexed variables and expressions, quantifiers and iterated operators like ∑ (sum) and ∏ (product), in order to build expressions such as ∀i ∈ I , xi = ∑ j∈J x j . AMLs have been used for linear and non-linear [8], for discrete-time simulation [9], and recently for constraint programming [10]. In AROM, the AML is used for writing both equations, constraints, and queries. AML expressions are built from the following elements: constants, indices and indexed expressions, operators and functions, iterated operators, quantified expressions, variables belonging to classes and associations, and expressions that allow to access to the tuples of an association. In AROM, an AML interpreter solves systems of (nonsimultaneous) equations and processes queries. A constraint satisfaction mechanism is currently under development.
2.3 Example Fig. 1 and 2 present an excerpt of an AROM KB involving three hierarchies of classes: Teaching, Training, Course, and two hierarchies of associations: Manages and Teaches. Association ManagesPostGraduate specializes association Manages by refining the type of its roles and by adding a new variable. knowledge-base: Teaching class: Teacher variables: variable: socSecNumber type: string variable: service type: float definition: service = sum(t in this!Teaches: t.hourlyVolume * t.course.coeff) … association: Teaches roles: role: teacher type: Teacher multiplicity: min:0 max:1 role: course type: Course multiplicity: min:0 max:* role: training type: Teaching multiplicity: min:0 max: *
variables: variable: HourlyVolume type: integer association: Manages roles: role: manager type: Permanent multiplicity: min:1 max:1 role: training type: Teaching multiplicity: min:0 max:1 association: ManagesPostGraduate super-association: Manages roles: role: manager type: Prof role: training type: PostGraduateTraining variables: variable: bonus type: float
Fig. 1. Excerpt of an AROM KB. The AML definition (definition: facet) of service in class Teacher allows the computation of this variable as the sum, for each tuple t in this!Teaches – the set of tuples of Teaches in which this (the current Teacher) appears as teacher – of the product of the hourly volume of t and of the coefficient of the course associated with this tuple.
3 The AROM platform
Fig. 2. Screenshot of the interactive modeling environment of AROM, using the example KB. Graphical notations are similar to those of UML except for associations, which are represented by gray rectangles with rounded corners.
Written in Java 1.2, AROM is available1 as a platform for knowledge representation and exploitation. It comprises an interactive modeling environment (see Fig. 2), which allows one to create, consult, and modify an AROM KB; a Java API, for developing applications based on AROM, an interpreter for processing queries and solving sets of (non-simultaneous) equations written in AML, and tools for consulting and editing knowledge bases through a Web browser.
1 http://www.inrialpes.fr/romans/arom. In this site are also presented some formal aspects of
knowledge representation in AROM, in particular its denotational semantics.
4 Discussion and conclusion In this paper, AROM, a new knowledge representation system has been presented. The first originality of this system is to propose two complementary entities for representing knowledge: classes and associations. The second originality is the presence of an algebraic modeling language allowing one to write equations, constraints and queries in a declarative manner. AROM shares some similarities about the representation of associations in Description Logics (DL) using roles. However, roles as defined in DL systems are generally binary, described within concepts, and are not organized by subsumption. Only few of DL systems deal with role hierarchies [11], and few of others studied n-ary roles (DLR [12]). AROM is currently used for developing KBs in several domains. In medicine, AROM is used for neuromuscular diseases diagnosis. In biology, it is used for the modeling of several domains in human genomic. A KB for modeling metabolic pathways containing several hundred thousands of instances and tuples is currently developed. In signal processing, AROM is also used for the supervision of program libraries dedicated to spectral analysis.
References 1.
Brachman, R.J., Schmolze, J.G.: An Overview of the KL-ONE Knowledge Representation System. Communications of the ACM, 31 (1988) 382–401 2. Bobrow, D., Winograd, T.: An Overview of KRL, Knowledge Representation Language. Cognitive Science, 1 (1977) 3–46 3. Filman, R.E.: Reasoning with worlds and truth maintenance in a knowledge-based programming environment, Cognitive Science, 9 (1985) 171–216 4. Rumbaugh, J., Jacobson, I., Booch, G.: The Unified Modeling Language Reference Manual. Addison-Wesley (1999) 5. SMECI: Ref. manual. ILOG S.A., 2 av. Galliéni, 94253 Gentilly Cédex, France (1991) 6. Tanzer, C.: Remarks on object-oriented modeling of associations. Journal of ObjectOriented Programming, 7 (1995) 43–46. 7. Euzenat, J.: On a purely taxonomic and descriptive meaning for classes, 13th IJCAI Workshop on Object-Based Representation Systems, Chambéry, France (1993) 81–92 8. Fourer, R., Gay, D., Kernighan, B.: A Modeling Language for Mathematical Programming. Management Science, 36 (1990) 519–554 9. Page, M., Gensel, J., Boudis, M.: AMIA: An environment for knowledge-based discretetime simulation. 2nd IMACS Int. Conf. on Computational Engineering in Systems Applications, Hammamet,Tunisia (1998) 56–61 10. van Hentenryck, P.: The OPL Optimization Programming Language. MIT Press (1999) 11. Horrocks, I., Sattler, U.: A Description Logic with Transitive and Inverse Roles and Role Hierarchies. International Workshop on Description Logics, Trento, Italy (1998) 12. Calvanese, D., de Giacomo, G., Lenzerini, M.: Conjunctive Query Containment in Description Logics with n-ary Relations. Int. Workshop on Description Logics, Paris (1997) 5–9
