Parallel propagation in the description-logic system FLEX

Parallel Processing for Artificial Intelligence 3 J. Geller, H. Kitano and C.B. Suttner (Editors) 1997 Elsevier Science B.V.

181

Parallel Propagation in the Description-Logic System FLEX* Frank W. Bergmann a and J. Joachim Quantz b aTechnische Universit~it Berlin, Projekt K I T - V M l l , FR 5-12, Franklinstr. 28/29, D-10587 Berlin, Germany, e-mail: [email protected] bTechnische Universit~it Berlin, Projekt K I T - V M l l , FR 5-12, Franklinstr. 28/29, D-10587 Berlin, Germany, e-mail: [email protected] In this paper we describe a parallel implementation of object-level propagation in the Description-Logic (DL) system FLEX. We begin by analyzing the parallel potential of the main DL inference algorithms normalization, subsumption checking, classification, and object-level propagation. Instead of relying on a parallelism inherent in logic programming languages, we propose to exploit the application-specific potentials of DLs and to use a more data-oriented parallelization strategy that is also applicable to imperative programming languages. Propagation turns out to be the most promising inference component for such a parallelization. We present two alternative PROLOG implementations of paralle!ized propagation on a loosely coupled MIMD (Multiple Instruction, Multiple Data) system, one based on a .farm strategy, the other based on distributed objects. Evaluation based on benchmarks containing artificial examples shows that the farm strategy yields only poor results. The implementation based on distributed objects, on the other hand, achieves a considerable speed-up, in particular for large-size applications. We finally discuss the impact of these results for real applications. 1. I N T R O D U C T I O N In the last 15 years Description Logics (DL) have become one of the major paradigms in Knowledge Representation. Combining ideas from Semantic Networks and Frames with the formal rigor of First Order Logic, research in DL has focussed on theoretical foundations [1] as well as on system development [2] and application in real-world scenarios

[3-5]. Whereas in the beginning it was hoped that DL provide representation formalisms which allowed efficient computation, at least three trends in recent years caused efficiency problems for DL systems and applications: 9 a trend towards expressive dialects; *This work was funded by the German Federal Ministry of Education, Science, Research and Technology (BMBF) in the framework of the Verbmobil Project under Grant 01 IV 101 Q 8. The responsibility for the contents of this study lies with the authors.

182 9 a trend towards complete inference algorithms; 9 a trend towards large-scale applications. With the current state of technology it seems not possible to build a DL system for largescale applications which offers an expressive dialect with complete inference algorithms. The standard strategy to cope with this dilemma is to restrict either expressivity, or completeness, or application size. In this paper we investigate an alternative approach, namely a parallelization of Description Logics. Due to physical limitations in performance gains in conventional processor architectures, parallelization has become more and more important in recent years. This comprises parallel structures inside processors as well as outside by scaling several processors to parallel systems. Several fields of high-performance computing already adopted to this new world of paradigms, such as image processing [6], finite element simulation [7], and fluid dynamics [8]. We expect that in the future parallelism will become a standard technique in the construction of complex AI applications. A standard approach to parallelization in the context of logic programming concentrates on the development of parallel languages that exploit the parallelism inherent in the underlying logic formalism ([9,10] and many more). In this paper we will follow a rather different approach which analyzes a particular application, namely Description Logics. The parallelization we propose uses explicit parallelism based on the notion of processes and messages that is programming language independent. In the next section we give a brief introduction into Description Logics. Section 3 then pi'esents the main inference components of the DL system FLEX and investigates their parallel potential. In Section 4 we describe two different strategies of parallelizing objectlevel propagation in DL systems. The corresponding implementations are evaluated in detail in Section 5 based ' On benchmarks containing artificial examples. Section 6 finally discusses the impact of these results on real applications. 2. D E S C R I P T I O N

LOGICS

In this section we give a brief introduction into Description Logics. Our main goal is to provide a rough overview over DL-based knowledge representation and DL systems. In the next section we will then take a closer look at inferences in the DL system FLEX and their respective parallel potential. 2.1. T h e R e p r e s e n t a t i o n L a n g u a g e In DL one typically distinguishes between terms and objects as basic language entities from which three kinds of formulae can be formed: definitions, descriptions, and rules (see the sample model on page 3 below). A definition has the form 'tn:= t' and expresses the fact that the name tn is used as an abbreviation for the term t. A list of such definitions is often called terminology (hence also the name Terminological Logics). If only necessary but no sufficient conditions of terms are specified a definition has the form 'tn:< t', meaning that 'tn' is more specific than 't'. Terms introduced via ' : - ' are called defined terms, those introduced via ':<' are primitive terms.

183 All DL dialects provide two types of terms, namely concepts (una .ry predicates) and roles (binary predicates), but they differ with respectto the term-forming operators they contain. Common concept-forming operators are: conjunction (cl and c2), disjunction (cl or c2), and negation (not(c)), as well as quantified restrictions such as value restrictions (all(r,c)), which stipulate that all fillers for a role r must be of type c, or number restrictions (atleast(n,r,c), atmost(n,r,c)), stipulating that there are at least or at most n role-fillers of type c for r. Role-forming operators are, besides conjunction, disjunction, and negation, role composition (rl comp r2), transitive closure (trans(r)), inverse roles (inv(r)) and domain or range restrictions (domain(c), range(r,c)). In a description, an object is described as being an instance of a concept (o :: c), or as being related to another object by a role (ol :: r:o2). Rules have the form ' c 1 - > c2' and stipulate that each instance of the concept cl is also an instance of the concept c2. In general, the representation language is defined by giving a formal syntax and semantics. Note that DL are subsets of First-Order Logic (with Equality), which can be shown easily by specifying translation functions from DL formulae into FOL formulae [11,12]. Just as in FOL there is thus an entailment relation between (sets of) DL formulae, i.e. a DL model can be regarded as a set of formulae F which entails other DL formulae (F ~ 7)- Depending on the term-forming operators used in a DL dialect this entailment relation can be decidable or undecidable and the inference algorithms implemented in a DL system can be complete or incomplete with respect to the entailment relation. 2.2. A S a m p l e M o d e l In order to get a better understanding of DL-based knowledge representation let us take a look at the modeling scenario assumed for applications. An application in DL is basically a domain model, i.e. a list of definitions, rules, and descriptions. Note that from a system perspective a model or knowledge base is thus a list of tells, from a theoretical perspective it is a set of DL-formulae F. Consider the highly simplified domain model below, whose net representation is shown in Figure 1. One role and five concepts are defined, out of which four are primitive (only necessa .ry, but no sufficient conditions are given). Furthermore, the model contains one rule and four object descriptions. product chemical product biological product company produces chemical company some(produces,chemical product) toxipharm biograin chemoplant toxiplant

:< :< :< :< :< := => :: :: :: ::

anything product product & not(chemical product) some(produces,product) domain(company) company & all(produces,chemical product) high risk company chemical product biological product chemical company atmost(1,produces) & produces:toxipharm

As mentioned above such a model can be regarded as a set of formulae and the service provided by DL systems basically is to answer queries concerning the formulae entailed

184

1..in

company

O

produces

high risk

~

~

9 fr

chemical ~ ( product j , . r _ . . ~ ~

biological product

chemical company

chemoplant

toxiplant

toxipharm

biogmin

produces

Figure 1. The net representation of the sample domain on page 3. Concepts are drawn as ellipses and are arranged in a subsumption hierarchy. Objects are listed below the most specific concepts they instantiate. Roles are drawn as labeled horizontal arrows (annotated with number and value restrictions) relating concepts or instances. The dashed arrow relates the left-hand side of a rule with its right-hand side ('conc_l' is the concept 'some(produces,chemical product)'). The flashed arrow between 'chemical product' and 'biological product' indicates disjointness.

185 by such a model. The following list contains examples for the types of queries that can be answered by a DL system: 9

tl ?< t2 Is a term tl more specific than a term t2, i.e., is tl subsumed by t27 In the sample model, the concept 'chemical company' is subsumed by 'high risk company', i.e., eve .ry chemical company is a high risk company. 2

9 t l and t2 ?< nothing Are two terms tl and t2 incompatible or disjoint? In the sample model, the concepts 'chemical product' and 'biological product' are disjoint, i.e., no object can be both a chemical and a biological product. .o?:c Is an object o an instance of concept c (object classification)? In the sample model, 'toxiplant' is recognized as a 'chemical company'. 9 o17:r:o2

Are two objects ol,o2 related by a role r, i.e., is 02 a role-filler for r at o1? In the sample model, 'toxipharm' is a role-filler for the role 'produces' at 'toxiplant'. 9 Which objects are instances of a concept c (retrieval)? In the sample model, 'chemoplant' and 'toxiplant' are retrieved as instances of the concept 'high risk company'. 9 o::cfails

Is a description inconsistent with the model (consistency check)? The description 'chemoplant :: produces:biograin' is inconsistent, with respect to the sample model, i.e., 'biograin' cannot be produced by 'chemoplant'. 3 This very general scenario can be refined by considering generic application tasks such as information retrieval, diagnosis, or configuration. 2.3. S y s t e m I m p l e m e n t a t i o n s From the beginning on, research in DL was praxis-oriented in the sense that the development of DL systems and their use in applications was one of the primary interests. In the first half of the 1980's several systems were developed that might be called in retrospection first-generation DL systems. These systems include KL-ONE, NIKL, KANDOR, KL-TWO, KRYPTON, MESON, and SB-ONE. In the second half of the 1980's three systems were developed which are still in use, namely BACK, CLASSIC, and LOOM. The LOOM system [13] is being developed at USC/ISI and focuses on the integration of a variety of programming paradigms aiming at a general purpose knowledge representation system. CLASSIC [2] is an ongoing 2'chemical company' is defined as a 'company' all whose products are chemical products; each 'company' produces some 'product'; thus 'chemical company' is subsumed by 'some(produces,chemical product)' and due to the rule by 'high risk company'. 3Object tells leading to inconsistencies are rejected by DL systems.

186 AT&T development. Favoring limited expressiveness for the central component, it is attempted to keep the system compact and simple so that it potentially fits into a larger, more expressive system. The final goal is the development of a deductive, object-oriented database manager. BACK [14] is intended to serve as the kernel representation system of AIMS (Advanced Information Management System), in which tools for semantic modeling, defining schemata, manipulating data, and que .rying, will be replaced by a single high-level description interface. To avoid a "tool-box-like" approach, all interaction with the information reposito .ry occurs through a uniform knowledge representation system, namely BACK, which thus acts as a mediating layer between the domain-oriented description level and the persistency level. The cited systems share the notion of DL knowledge representation as being the appropriate basis for expressive and efficient information systems [15]. In contrast to the systems of the first generation, these second generation DL systems are full-fledged systems developed in long-term projects and used in various applications. The systems of the second generation take an explicit stance to the problem that determination of subsumption is at least NP-hard or even undecidable for sufficiently expressive languages: CLASSIC offers a ve.ry restricted DL and almost complete inference algorithms, whereas LOOM provides a ve~. expressive language but is incomplete in many respects. Recently, the KRIS system has been developed, which uses tableaux-based algorithms and provides complete algorithms for a ve.ry expressive DL [16]. KRIS might thus be the first representative of a third generation of DL systems, though there are not yet enough experiences with realistic applications to judge the adequacy of this new approach. 4 In the following section we describe the FLEX System, which can be seen as an extension of the BACK system. FLEX is developed at the Technische Universit~it Berlin within the project KIT-VM11, which is part of the German Machine-Translation project VERBMOBIL. 3. T H E F L E X S Y S T E M Having sketched some of the general characteristics of DL we will now turn our attention towards a specific DL system, namely the FLEX system [18]. Compared to its predecessor, the BACK System, FLEX offers some additional expressivity such as disjunction and negation, term-valued features, situated descriptions, and weighted defaults. In the context of this paper another characteristic of FLEX is more important, however, namely the one giving rise to its name, i.e. flexible inference strategies. 3.1. D L I n f e r e n c e s Given the specification of DL in the previous Section, the inference algorithms have to answer queries of the form o tl

?: ?<

c t2

with respect to a knowledge base containing formulae of the form 4The missing constructiveness of the refutation-oriented tableaux algorithms (see next section) leads to problems with respect to object recognition and retrieval (see [17]).

187 tn tn

:---:(

El

=~

0

::

t t C2 C

Two things are important to note: 1. The FLEX system already performs inferences when reading in a model. There are two major inference components, namely the classifier and the recognizer. The classifier checks subsumption between the terms defined in the terminology and thus computes the subsumption hierarchy. The recognizer determines for each object which concepts it instantiates and thus computes the instantiation index. 2. For answering both kinds of queries, the same method can be used, namely subsumption checking. Thus when answering a query 'o ?: c', the system checks whether the normal form derived for 'o' is subsumed by 'c'. Though the recognizer thus uses the classifier to perform its task, there is an important difference between the two components. Whereas the classifier performs only "local" operations, the recognizer has to perform "global" operations. This distinction can be illustrated by briefly sketching the algorithmic structure of both components. Given a list of definitions, the classifier takes each definition and compares it with all previously processed definitions, thereby constructing a directed acyclic graph called the subsumption hierarchy. Thus the concept classifier is a function 'Concept x DAG --+ DAG', where the initial DAG contains the nodes 'anything' and 'nothing'. Locality here means that classifying a concept has no impact on previous classification results, i.e. classifying concept Ca has no impact on the subsumption relation between cl and c2. Recognition, on the other hand, has global effects. Basically, the recognizer processes a list of descriptions and computes for each object which concepts it instantiates, i.e. it is a function 'Description x Index x DAG--+ Index'. Nonlocality here means that recognition triggered by a description 'ol :: c' can lead to changes in the instantiation index for some other object 02, as exemplified by Ol Ol

:: ::

r:o2 all(r,c)

Here processing the second description includes the derivation of '02 :: c' Note that another distinction between classification and recognition is thus that there is exactly one definition for each term in the terminology, whereas objects can be described incrementally, i.e. we can have several descriptions for an object in a situation. In the following we will briefly describe the algorithmic structure of normalization, subsumption checking, and object-level propagation. Before doing so, however, we will first present the proof-theoretical basis of these algorithms.

3.2. Tableaux-Based Algorithms vs. Normalize-Compare Algorithms The first classifiers for DL were specified as structural subsumption algorithms [11]. The basic idea underlying structural subsumption is to transform terms into canonical normal forms, which are then structurally compared. Structural subsumption algorithms

188 are therefore also referred to as normalize-compare algorithms. Note that there is a general tradeoff between normalization and comparison: the more inferences are drawn in normalization, the less inferences have to be drawn in comparison, and vice versa. There is one severe drawback of normalize-compare algorithms--though it is in general straightforward to prove the correctness of such algorithms there is no method for proving their completeness. In fact, most normalize-compare algorithms are incomplete which is usually demonstrated by giving examples for subsumption relations which are not detected by the algorithm [19]. At the end of the 1980's tableaux methods, as known from FOL (cf. [20, p. 180fl]), were applied to DL (e.g. [1,21]). The resulting subsumption algorithms had the advantage of providing an excellent basis for theoretical investigations. Not only was their correctness and completeness easy to prove, they also allowed a systematic study of the decidability and the tractability of different DL dialects. The main disadvantage of tableaux-based subsumption algorithms is that they are not constructive but rather employ refutation techniques. Thus in order to prove the subsumption 'cl :< c2' it is proven that the term 'cl and not(c2)' is inconsistent, i.e. that 'o :: Cl and not(c2)' is not satisfiable. Though this is straightforward for computing subsumption, this approach leads to efficiency problems in the context of retrieval. In order to retrieve the instances of a concept 'c', we would in principle have to check for each object 'o' whether F U {o :: not(c)} is satisfiable, where F is the knowledge base. 5 In most existing systems, on the other hand, inference rules are more seen as production rules, which are used to pre-compute part of the consequences of the initial information. This corresponds more closely to Natural Deduction or Sequent Calculi, two deduction systems also developed in the context of FOL. A third alternative, combining advantages of the normalize-compare approach and tableaux-based methods has therefore been proposed in [12]. The basic idea is to use Sequent Calculi (SC) instead of tableaux-based methods for the characterization of the deduction rules. Like tableaux methods, Sequent Calculi provide a sound logical framework, but whereas tableaux-based methods are refutation based, i.e. suitable for theorem checking, sequent calculi are constructive, i.e. suitable for theorem proving. By rewriting SC proofs of FOL translations of DL formulae we obtain sequent-style DL inference rules like rl :< r2, cl :< c2 ~ cl and c2:< nothing, h : < r2, p > 0 ~

all(r2,cl) :< all(rl,c2) all(r2,c2) and atleast(p,rl,cl) :< nothing

The first rule captures the monotonicity properties of the all operator [23, 24]. If 'has_daughter' is subsumed by 'has_child' and 'computer_scientist' is subsumed by 'scientist', then 'all(has_child,computer_scientist)' is more specific than 'all (has_daughter,scientist)'. The second rule means that a qualified minimum restriction combined with a value restriction which is disjoint from the concept used in the minimum restriction is incoherent. If 'european' and 'american' are disjoint concepts and 'workshop_participant' 5See [22] for tableaux-based algorithms for object-level reasoning and [17] for a discussion of efficiency problems.

189 subsumes 'workshop_speaker', then the concept 'all(workshop_participant,american) and some(workshop_speaker,european)' is incoherent, i.e. is subsumed by 'nothing'. Note that this format is sufficient for a theoretical characterization of a deduction system, i.e. given a set of inference schemata E we can define a least fixed point r by taking the logical closure of a set of formulae F under E. We can then say that F k-z "7 iff e r ~ Though we can study formal properties like soundness or completeness, i.e. the relation between F k-z -y and F ~ % on the basis of this characterization, we need an additional control strategy for turning the deduction system into an algorithm. The main reason for this is that r is not finite. The sequent-style approach thus falls into two separate phases: 1. Derivation of a complete axiomatization by systematically rewriting FOL proofs. 2. Specification of a control strategy to turn the complete axiomatization into an algorithm. In the second phase we have to turn the sequent-style inference rules into normalization rules and subsumption rules. As it turns out, some inference rules can be straightforwardly encoded as both normalization and subsumption rules, while others can only be represented as normalization or subsumption rules, respectively. The idea of a flexible inference strategy then means that each inference rule can be used during normalization, during subsumption or switched off completely. Note that this "customization" of the inference engine of FLEX should be performed by the system developers according to the inference requirements arising in a particular application. 3.3. N o r m a l i z a t i o n For each object, concept, and role, the FLEX system computes a normal form. The basic building blocks of normal forms are so-called atoms, which correspond to the termbuilding operators of the DL, e.g. 'all(R,C)', 'fills(R,O)'. Note that the R's and C's occurring in the atoms are themselves normal forms of roles and concepts. One way of formally defining atoms and normal forms is thus by means of a parallel inductive definition, as done in [12]. For languages not containing negation or disjunction, a normal form is simply a set of atoms. Since the FLEX system supports both disjunction and negation, however, we use the format of disjunctive normal forms proposed in [26]. In the context of this paper, however, it is sufficient to consider the simpler case in which normal forms are represented as sets of atoms. When reading in a concept or a role the parser already performs certain kinds of normalization, such as eliminating negation. Thus given a concept definition 'cn:= c' or an object description 'o :: c', the system transforms the term 'c' into a normal form. This normal form is then further processed by applying normalization rules. The basic idea of normalization is to make information implicitly contained in a normal form explicit, i.e. NORMALIZE: NF -~ NF 6See [25] for a formal definition.

190 The general format of a normalization rule is: 7 0/1,

.

.

.

,

Ot n

~

O~

The application of such a normalization rule is triggered when a normal form contains the atoms a l , . . . , an, in which case a is added to the normal form. The parallel potential of normalization consists in the possibility to apply all normalization rules in parallel. However, the results of applying normalization rules then have to be synchronized in a second step. 3.4. S u b s u m p t i o n C h e c k i n g The task of subsumption checking is to decide whether a normal form subsumes another normal form, i.e. SUBSUMES: NF x NF -~ BOOL As has been mentioned above, there is a general trade-off between normalization and subsumption checking. The more inferences are performed during normalization, the less inferences have to be drawn during subsumption checking. In principle it is possible to produce normal forms which guarantee that subsumption checking only has to test subsumption between individual atoms. Such vivid normal forms have been presented for a simple fragment of DL in [12, Sect. 5]. The disadvantage of such vivid normal forms is that they require the application of many normalization rules, making information explicit which might never be needed. Performing inferences during subsumption checking on the other hand guarantees that inferences are only drawn when actually needed. 8 Basically, subsumption checking between normal forms is ultimately reduced to subsumption checks between atoms, but includes also special subsumption rules for disjunctive parts, non-disjunctive parts, etc. This reduction of subsumption offers the possibility to perform subsumption tests between the atoms in the normal forms in parallel. It should be noted, however, that these atomic subsumption tests are rather fine-grained and unevenly distributed tasks. 3.5. Classification As already sketched above, the primary task of the classifier is to compute a subsumption hierarchy for the terms defined in the terminology. Thus given the normal form of a term, the classifier has to find its direct subsumers and its direct subsumees in the hierarchy. This can obviously achieved by comparing the normal form with all normal forms contained in the hierarchy, i.e. by checking the respective subsumption relations. The number of subsumption checks can be reduced, however, by taking into account the information already contained in the hierarchy. Thus if 'tl' subsumes 't2' and the subsumption test between the normal form and 't2' fails, there is no need to test subsumption between the normal form and 'tl'. Such optimization techniques are employed in all DL systems and are discussed in some detail in [16]. TThis is a further simplification since there are more complicated normalization rules involving disjunctions of atoms. Sin general, a mixed strategy is needed, which ensures both efficient performance and detection of inconsistency already during normalization.

191 The FLEX system uses different forms of classification which are based on a single algorithm, however. When processing an object description, for example, the object's normal form is first classified only with respect to a subset of the subsumption hierarchy, namely the left-hand sides of rules. Moreover, this classification step only computes direct subsumers of the object's normal form, since there is no need to determine the subsumees of objects. The parallel potential of classification obviously is given by the possibility to perform the comparisons of a normal form with all the normal forms contained in the hierarchy in parallel. However the more efficient algorithms utilize the fact that subsumption tests within a classification task are not independent from each other. Consequently, algorithms using this fact pose an order on the subsumption tests and thus loose the property of being straightforwardly parallelizable. 3.6. O b j e c t - L e v e l R e a s o n i n g

As already indicated above, object-level reasoning is inherently non-local and it is therefore useful to distinguish between a local phase and a non-local phase in object-level reasoning. In the local phase we determine for an object the most specific concept it instantiates. This can be done by using the standard normalize and compare predicates. Thus we normalize the description of an object thereby obtaining a normal form and compare it with the normal forms of the concepts in the hierarchy. In addition to this standard classification we also have to apply rules when processing objects. This is achieved by applying all rules whose left-hand sides subsume the object's normal form. After this application the normal form is again normalized and classified until no new rules are applicable [27]. In the non-local phase we have to propagate information to other objects. There are five basic rules for propagation, whose effects we will illustrate below with examples:

01 ::.all(r,c), 01 :: r:02 -~

o2 :: c

01 :: all(r,oneof([ol,...,on])), 02 :: c,...,on :: c --~ 01 :: all(r,c) 01 :: r:02, o2 :: c -~

01 :: (r and range(c)):02

01 :: h:02, o2 :: r2:03 -~ o2 :: (rlcomp r2):03 01 :: r:02 - -

o2:: inv(r):01

(1) (2) (3) (4) (5)

Rule (1) is usually called forward propagation since the value restriction is propagated to each individual filler of a role. Rule (2) is called backward propagation or abstraction over closed role-filler sets--if all fillers of a role are known the most specific value restriction for that role can be abstracted. The other three rules are related to role-forming operators. Rule (3) says that a filler for a role 'r' which is an instance of a concept 'c' is automatically a filler for the role 'r and range(c)'. Rules (4) and (5) capture the semantics of role composition and inversion, respectively. The following examples illustrate the effects of these propagation rules:

192

~(5) (3) (2)

(4) (1)

has_child has_parent has_daughter has_grandchild father happy_father john john mary mary john mary john mary mary john ma.ry

:< := := := := := :: :: :: :: :: :: :: :: :: :: ::

domain(human) and range(human) inv(has,child) has_child and range(female) has_child comp has_child male and some(has_child) father and all(has_daughter,married) male and has_child:ma.ry and exactly(1,has_child) father has_parent:john female has_daughter:mary married happy_father has_daughter:kim has_child:kim has_grandchild:kim female

Note that this sequent-style characterization of object-level reasoning is sufficient for a theoretical characterization of a deduction system (see Section 3.2). The actual propagation algorithm of the FLEX system consists of these rules together with data structures and predicates which trigger the appropriate rules. Basically, whenever an object is processed, we collect propagations of the form 'O :: c' resulting from the five propagation rules. First, it should be noted that object-level propagation is a rather coarse-grained task, since adding information to an object involves normalization and classification (and hence subsumption checking). Furthermore, processing propagations in parallel does not require any additional synchronization of propagation results. Processing a propagation can trigger additional propagations, but these can be processed by the same parallel mechanism. Finally, object-level propagation poses the main performance problem in most DL applications. In Section 6 we sketch some mechanisms to reduce the complexity of objectlevel reasoning in the sequential FLEX system and compare their effects to the speed-up obtained by our parallel implementation. 3.7. P a r a l l e l P o t e n t i a l of Inference A l g o r i t h m s in F L E X To summarize this section on the FLEX system we briefly recapitulate the results concerning the parallelization potential of the different inference algorithms. Figure 2 shows which inference components are used by which other inference components. First, we note that normalization, subsumption checking and classification share the following negative properties with respect to parallelization: 1. they are rather fine-grained tasks; 2. the distribution of the task length is rather widespread; 3. they involve a synchronization step that is not required in the parallelization of object-level propagation.

193 Object-Level Propagation

Classification

~

USeS

Normalization

Subsumption Checking

Figure 2. Dependencies between the DL Inference components.

Object-level propagation, on the other hand, has the following positive characteristics with respect to parallelization: 1. propagation involves coarse-grained tasks; 2. many applications involve a high number of propagations; 3. propagations are independent from each other, monotonic, and invariant with respect to the order of execution; 4. synchronization is only required before an object query ist stated (to make sure that all propagations have terminated); 5. the propagation algorithm tion/communication ratio.

can

be

implemented

with

a

high

computa-

We therefore concentrate on the parallelization of object-level propagation in the following. 4. P A R A L L E L I Z A T I O N S T R A T E G I E S In the remainder of this paper we investigate two parallel implementations of objectlevel propagation. The following properties of propagation should be kept in mind: 1. the length of propagation tasks is not known a priori; 2. the number of propagation tasks is not known a priori; 3. the "direction" of propagation flow is not known a priori. We will briefly illustrate these properties by analyzing the propagation data flow.

194

initial propagation

Figure 3. A group of objects interchanging propagations.

Hems

I000I

/

~

i00

Pending Propagations

/

N

k Iz

I0 Propagation o

2

4

6

8

1o

12

14

16

18

I

l

Figure 4. Exponential increase of propagations.

20

Steps

195

lime

Figure 5. Timing of the farm communication scheme.

4.1. F L E X D a t a F l o w We begin by noting several relevant properties of object-level propagation. As already indicated above propagation of information from one object to another can cause additional propagation to other objects. This kind of 'ping-pong' interaction terminates only when a 'fixed point' is reached and no new information is produced. Since propagation in Description Logics is monotonic, we can execute propagations in an arbitra .ry order, always ending up with the same result. We will refer to this property as confluence. For illustration consider the artificial example in Figure 3. The initial propagation affects object '02' and processing this object yields propagations to objects 'o1', '06', and 'o8', etc. The propagation at '02' thus creates a "chain reaction", i.e. the number of pending propagations increases exponentially. After some time the new information is integrated into the network and the pending propagations decrease until the fixed point is reached. For a parallel processing of propagations we thus obtain the work distribution qualitatively sketched in Figure 4. In the initial phase there are only few propagations and hence idle processors, in the middle phase there are more pending propagations than processors, and in the final phase there are again only few propagations and hence idle processors. Thus the propagation steps in the middle part will take longer to process since they cannot be completely distributed to the limited number of processors available. Given the analysis of the FLEX data flow, we consider two parallel paradigms as potential candidates for an implementation: The farm paradigm and the distributed objects paradigm. In the remainder of this section we briefly present these two alternatives. Theoretical considerations and numerical calculations towards efficiency and scalability can be found in the detailed analysis in [28].

196

tim

Figure 6. Communication events and workload distribution during the first two propagation stages.

4.2. Farm Parallelism The .farm communication structure shown in Figure 5 is widely used in industrial applications such as image processing [6] and finite element simulation [7]. It is theoretically well known and there exists a variety of strategies to distribute workload evenly across a network. A farm consists of several parallel processes with a fixed structure: one process is called 'master' and is responsible to distribute tasks to a group of 'worker' processes which perform their tasks in parallel and return control and results back to the master. Farm structures are frequently used to parallelize applications that can be split into subtasks with a priori known duration. Examples are image processing or finite element systems. From a theoretical point of view, there are two potential sources of inefficiency in this architecture: 1. uneven distribution of workload and 2. a communication bottleneck created by the centralized position of the master.

4.3. C o m m u n i c a t i n g Objects Parallelism In the communicating-objectsparadigm the central management institution (master) of the farm parallelism is replaced by (local) knowledge of all objects about the 'addresses' of

197

,s+r.o,,..~..~ . ~ . .

_

:

-_

. . - - _ - _ - - - . -

-

-.

gN, g,,l : :,

Topology Processors Workers

2xl 3 1

3xl 4 2

2x2 5 3

", -:%

3x2 7 5

3x3 10 8

4x3 13 11

4x4 17 15

Figure 7. Hardware configuration and working nodes.

their neighbors. Objects communicate directly with each other, in contrast to the centered communication scheme of the farm. This helps to avoid communication bottlenecks in a network. The general difference between a farm and a network of communicating objects is the different perspective of parallelism: Within a farm, tasks are distributed; within the distributed objects scheme, objects are distributed. This approach appears to be similar to the agent-based paradigm developed by distributed AI research [29]. In contrast to this approach, objects within FLEX have to be considered elements of a distribution strategy rather then independently interacting entities. With respect to the definition given in [30] we have to subsume our efforts here under the field of 'distributed problem solving'. For an effective balancing of workload, certain assumptions about tasks and the computational environment have to be made. In our case, all processors can be assumed to behave identical and the statistical distribution of the task length is assumed to be narrow. Uneven distributions of workload can finally be treatedby special load balancing algorithms (see below).

5. E X P E R I M E N T A L

RESULTS

In this section we describe the hardware and the software used for implementing and evaluating our parallel implementations of FLEX. We also present benchmark results for artificial examples. In the next section we discuss the connection between these benchmark evaluations and real applications.

198 cl c2 c3

:< :< :<

all(r,c2) all(r,c3) all(r,cl)

ol o2 03 04 05 06 07 08 ol

:: :: :: :: :: :: :: :: ::

r:o3 r:o4 r:o7 r:ol r:o2 r:ol r:o3 r:o7 cl

and and and and and and and and

r:o2 r:o7 r:o2 r:o8 r:o7 r:o7 r:o8 r:o4

and and and and and and and and

r:o8 r:o2 r:ol r:o6 r:o8 r:o5 r:o4 r:o6

Figure 8. A sample benchmark with 8 objects, 3 concepts and fan-out 3.

5.1. H a r d w a r e and Software We chose the 'Parsytec Multicluster II' machine as base for the parallel implementation of FLEX. It consists of 16 processing nodes that each contain an INMOS T800 Transputer with 4 MByte of RAM. Each Transputer consists of a RISC processing kernel, a memo .ry interface and 4 DMA driven serial interfaces, called 'links'. Each link has a transfer rate of approximately 1.2 MByte/s and all 4 links can run independently together with the RISK kernel, hardly: affecting processing performance (communication delays could be neglected). This hardware platform is especially suitable to serve as a testbed for parallel implementations due to its simple architecture and the availability of comfortable development environments. However, it does not provide state of the art computational performance and suffers substantially from memo .ry restrictions. Figure 7 shows the topologies used for the tests in this section and the number of available worker nodes. The overhead of 2 processors is due to memo .ry limitations. Processor I could not be used because its 1 MByte RAM is not sufficient to hold the FLEX code. Processor 2 is used to hold the 'shell' process that synchronizes the generation of new objects. Normally this process can be located somewhere in the network and would not consume any computing performance, but in this case it had to be separated due to memo .ry restrictions. The language used to implement Distributed FLEX is a Prolog dialect called Brain Aid Prolog (BAP)[31]. It represents a standard Prolog with parallel libra .ry extensions, implementing a scheme similar to CSP [32]. Parallelism and synchronization is expressed explicitly using the notion of processes and messages. A process in BAP is a single and independent Prolog instance with a private database. A message is any Prolog term that is exchanged between two processes. Messages are sent and received using the 'send_msg(Dest, Msg)' and 'rec_msg(Sender, Msg)' predicates. Message sender and destination are identified by their process id' (PID). Messages are routed transparently through the network. The order of messages is maintained when several messages are sent from the same sender to the same destination. When a message reaches its destination process, it is stored in a special database, called 'mailbox'. Each process owns its private

199

el 0_3_2 c20_3_2

(seq) (58) (177)

1 78 253

2

3

5

63 185

55 159

56 160

8 58 162

Figure 9. Execution times (seconds) for the farm parallelization.

mailbox in which the messages are stored FIFO. Although the development of parallel FLEX was greatly simplified by the way BAP expresses parallelism, it is possible to apply the same parallel techniques to future FLEX implementation in programming languages such as LISP or C. 5.2. B e n c h m a r k s

To evaluate our parallel implementations we developed a benchmark generator that is capable of generating randomly connected networks of objects. The basic structure of these benchmarks is shown in Figure 8, which contains a benchmark consisting of 8 objects, 3 concepts, and a fan-out of 3. Thus, the final object tell 'ol :: cl' triggers propagation to three objects, namely 'o2', '03', and 'o8'. Each of these propagations again triggers 3 more propagations, etc. It should be obvious that the average fan-out, i.e. the number of additional propagations triggered by each propagation is a measure to describe the "avalanche" effect and is the major factor for the system's performance. 9 Figure 9 shows the execution times for the farm benchmarks. The first row contains the benchmark names that are composed by three numbers that indicate the number of objects, concepts and fan-out respectively (for example 'c20_5_3' means that the benchmark consists of 20 objects, 5 concepts and a fan-out of 3). The following rows give the execution times with respect to the number of processors. The '(seq)' fields gives the reference time of the (original) sequential version of FLEX. The parallelization of FLEX using the farm paradigm showed very poor results. This can be explained by the rather high costs to distribute the system state out to the workers and to integrate the computation results back into the system state. Both activities have to be done sequentially, thus slowing down the parallel execution. Although there is some potential for optimizing the FARM implementation, we stopped the development and focused on the distributed-object version of FLEX. The parallelization of FLEX using the distributed objects paradigm turned out to be a lot more promising. Figure 10 shows the absolute execution times of the considered benchmarks. The names of the benchmarks are composed as in Figure 9. Note that the execution times in Figure 10 are measured with an accuracy of • seconds. The sequential execution times (entries in the '1' row) for several benchmarks are not available due to the memory limitations. This means that it is not possible to calculate the relative speed-up in such a line (future tests on Transputer machines with 9[28] analyzes quantitatively the influence of the avalanche exponent on the applicability of parallel execution.

200

c10_3_2 c10_3_3 c10_3_4 c20_3_2 c20_3_3 c20_3_4 c20_5_3 c20_5_4 c40_3_2 c40_3_3 c40_3A c80_3_2 c80_3_3 c80_3_4

1.0 1.0 1.0 1.0

1 59 43 327 179

1.9 1.5 2.0 1.8

30 28 159 97 145 240 527 344 314

1.8 1.5 2.3 3.0

3 32 28 141 59 129 173 355 453 176 258 569 1032

3.3 2.4 3.1 3.1

5 18 18 105 58 58 164 173 411 137 231 467 665

3.3 2.7 3.8 4.0

8 18 16 87 45 56 70 155 185 105 141 264 225 443

947

2.8 2.5 4.4 4.8

11 21 17 74 37 66 74 141 126 111 111 319 200 336 662

3.3 2.9 4.4 4.5

15 18 15 73 40 51 68 160 189 72 87 230 181 266 583

Figure 10. Benchmark Execution Times.

more memo .ry will fill these gaps). This is the reason why we omited the speed-up figures in all but the first 4 benchmarks. The table shows high speed-ups (efficiencies > 80~163for all benchmarks, if the number of objects exceeds the number of processors by a certain factor (between 5 and 10). This result can be interpreted by the perspective of Section 3, where we saw that network efficiently is dependent on the number of pending propagations in the network. If this number is too low, few processing nodes are busy, resulting in a bad network efficiency. Within [28] the quantitative analysis shows that the propagation-processor ratio is more relevant to system performance than the overhead caused by message passing. 1~ It also indicates how these problems can be overcome, allowing for even larger networks. A major problem for all distributed systems is the balance of load inside the network. Within distributed FLEX each object represents a potential load. Unfortunately, the presence of objects is only a statistical measure for load, while the actual distribution depends on runtime conditions. The illustration in Figure 11 depicts execution of a benchmark with an uneven load distribution. The Transputers 2 and 4 slow down the overall performance. It is easy to see that the network is quite busy during the first half of the execution time (ca. 75~163 efficiency). At the second half, all object servers have terminated, except two (ca. 25% efficiency). This leads to a reduction of the overall efficiency to ca. 50~163 and explains the variation of the results in Figure 10. The necessa~, optimization of the uneven distribution of processor load over the network can be achieved by temporarily 'relocating' objects to other processors. Such a mechanism would be capable of reducing overhead time created by loads remaining on a '~ is valid for Transputer systems with 2..256 processors, 2D matrix topology and shortest path routing algorithm.

201

Load (%)

Time l )

o, ~

~

c:) eq

3

Procuaor

Figure 11. Runtime behavior of distributed FLEX within a 3x3 Network.

few processors. We are currently implementing this optimization. 6. A P P L I C A T I O N S C E N A R I O S In the previous section we have presented evaluation results for benchmarks based on artificial examples. These results have shown a considerable speed-up for the parallelization based on distributed objects. In this section we discuss the impact of these results for real applications. First, it should be noted that the "optimal speed-up" is achieved for examples involving both 1. many propagation steps; 2. many pending propagations. If there are only few pending propagations, there are no tasks to distribute; if there are only few propagation steps, the phase in which many processors are used is rather short (cf. Figure 4). Obviously, such examples pose severe performance problems for sequential propagation algorithms and several strategies are possible to avoid these problems, such as 1. restricting the expressivity of the representation language; 2. using incomplete inference algorithms;

202 3. simplifying the structure of the model. As can be seen from the examples in Section 3 one source of propagations are roleforming operators such as composition, inversion, or range. Banning such operators from the representation language or using them carefully in the model is thus one way to avoid performance problems due to propagation. Let us illustrate this strategy by briefly sketching the use of the sequential FLEX system in the VERBMOBIL project. VERBMOBIL is a project concerned with face-to-face dialogue interpreting [33] and focuses in its current phase on the translation of appointment scheduling dialogues from German and Japanese to English. The FLEX system is used in the component for semantic evaluation which takes the semantic representation of German utterances and performs contextual disambiguation in order to provide additional information needed by the transfer component. A central task of semantic evaluation is to determine the dialogue act performed by an utterance, e.g. suggest_date, reject_date, request_comment [34]. This is achieved by using the approach of preferential disambiguation [4,35] where preference rules are encoded as weighted defaults [36] in FLEX. Semantic evaluation in the current VERBMOBIL system thus contains three steps: 1. translating the semantic representation into FLEX object tells; 2. processing these objects tells; 3. applying the weighted defaults to determine the preferred interpretation. The basic idea of representing utterances in FLEX is to introduce objects for the linguistic signs used in the utterance. Thus a simple sentence like Ich schlage Freitag vor. (I propose Friday.) would be represented as ol 02 oa

:: :: ::

per_pron and per:l and num:sg freitag vorschlagen and argl:ol and arg2:o2 and tense:pres

In order to achieve acceptable performance we minimized the number of object tells and the number of propagations. This is possible by using a flat representation instead of a structured one. Furthermore, we used a feature of the flexible inference strateKy implemented in the FLEX system. This feature allows the user to specify for each role which propagation rules are to be applied. The user can thus control the amount of propagation in the model and in particular can avoid propagations which do not add any significant information. This approach thus yields the performance advantages of incomplete algorithms while offering at the same time a control of the incompleteness to the user. In the current implementation of the semantic-evaluation component we thus achieve an average processing time of 5 seconds per utterance on a Sparc 10. In the prototype of the VERBMOBIL system, which will be released in October '96, we will use a C-t-+

203 Processors 1 2 3 4

Seconds 33 22 23 17

Figure 12. Processing time for a real-world example from NLP.

reimplementation of the FLEX system and thereby hope to reach processing times of 1 second per utterance. It should be obvious, however, that the constraints posed on the modeling and on finetuning the propagation control by hand is far from satisfying. Achieving the performance gains by parallel algorithms instead would be much more adequate for the user. Since the memory restrictions of the transputer hardware did not allow to test our parallel implementation with our real application, we reimplemented parallel FLEX on a cluster of SUN workstations connected by Ethernet. First evaluation results show that communication between processors is 20 times faster on transputers than on SUNs, whereas computation is 50 times faster on SUNs than on transputers. The computation/communication ratio is thus 1000 times better on transputers than on SUNs. Figure 12 shows the first evaluation result for processing an utterance of the VERBMOBIL scenario. Note that all propagation rules are active at all roles in this example, hence the 33 seconds execution time on a single processor. As can be seen, the speed-up is not as good as for our benchmarks which is due to the comparatively low number of pending propagations and propagation steps, as well as to the communication overhead in the SUN cluster. Nevertheless, this result shows that pursuing the parallelization of propagation is a promising alternative to the current strategies of dealing with performance problems, i.e. incomplete algorithms, simplified modeling structures, or restricted expressiveness. 7. C O N C L U S I O N The results of the parallel implementation of FLEX are in general very satisfying. We achieved high speed-ups with benchmarks that are structurally similar to a real-world applications in natural language processing (> 80% for benchmarks that fit the size of the network). The efficiency of execution rises mainly with the propagation/processor ratio and thus with the application size. This is an important result because especially large applications are to be considered candidates for a parallel implementation. Theoretical considerations [28] show that there are only few technical limits to the scalability of the distributed objects implementation. We have to state that the Transputer system under consideration here is not applicable to real world problems due to its poor overall performance and its memo .ry restrictions. Ideal candidates for such implementations are parallel computers with large (local)

204 memory resources and high communication bandwidth. Alternatively, shared-memo .ry multiprocessor workstations fulfill all requirements for an efficient parallelization. First evaluation results obtained on a cluster of workstations for an example taken from the VERBMOBIL application confirm the benchmark results, even though the speed-up is not quite as high. We assume that the communication structure of FLEX is similar to many other applications in Artificial Intelligence. In particular, applications involving complex, forwardchaining inferencing are potential candidates for a parallelization based on the distributedobjects approach presented in this paper. REFERENCES

1. F.M. Donini, M. Lenzerini, D. Nardi, W. Nutt, "The Complexity of Concept Languages", KR'91,151-162. 2. R. Brachman, D.L. McGuiness, P.F. Patel-Schneider, L. Alperin Resnick, A. Borgida, "Living with CLASSIC: When and How to Use a KLONE-like Language", in J. Sowa (Ed.), Principles of Semantic Networks: Explorations in the Representation of Knowledge, San Mateo: Morgan Kaufmann, 1991, 401-456. 3. J.R. Wright, E.S. Weixelbaum, G.T. Vesonder, K.E. Brown, S.R. Palmer, J.I. Berman, H.H. Moore, "A Knowledge-Based Configurator that Supports Sales, Engineering, and Manufacturing at AT&T Network Systems", Proceedings of the Fifth Innovative Applications of Artificial Intelligence Conference, 1993, 183-193. 4. J.J. Quantz, B. Schmitz, "Knowledge-Based Disambiguation for Machine Translation", Minds and Machines 4, 39-57, 1994. 5. The KIT-MIHMA Project, Technische Universitiit Berlin, Projektgruppe KIT, http: //www. cs.t u- berlin, de/..-kit / mihma, ht ml. 6. H. Burkhard, A. Bienick, R. Klaus, M. NSlle, G. Schreiber, H. Schulz-Mirbach, "The Parallel Image Processing System PIPS" in R. Flieger, R. Grebe (eds), Parallelrechner Grundlagen und Anwendung IOS Press, Amsterdam, Netherlands, 1994, 288-293. 7. R. Diekmann, D. Meyer, B. Monien, "Parallele Partitionierung unstrukturierter Finite Elemente Netze auf Transputernetzwerken" in R. Flieger, R. Grebe (eds), Parallelrechner Grundlagen und Anwendung IOS Press, Amsterdam, Netherlands, 1994, 317-326. 8. Strietzel, "Large Eddy Simulation turbulenter StrSmungen auf MIMD-Systemen" in R. Flieger, R. Grebe (eds), Parallelrechner Grundlagen und Anwendung, IOS Press, Amsterdam, Netherlands, 1994, 357-366. 9. K. Clark, S, Grego.ry, "PARLOG: Parallel Programming in Logic" in E. Shapiro (ed), Concurrent Prolog The MIT Press, Cambridge, Massachusetts, 1987, 8 4 - 139. 10. E. Pontelli, G. Gupta, "Design and Implementation of Parallel Logic Programming Systems", Proceedings of ILPS'9~ Post Conference Workshop 1994. 11. J. Schmolze, D. Israel, "KL-ONE: Semantics and Classification", in BBN Annual Report, Rep.No. 5421, 1983, 27-39. 12. V. Royer, J.J. Quantz, "Deriving Inference Rules for Terminological Logics", in D. Pearce, G. Wagner (eds), Logics in AI, Proceedings of JELIA-92, Berlin: Springer, 1992, 84-105.

205 13. R. MacGregor, "Using a Description Classifier to Enhance Deductive Inference", in Proceedings SeventhIEEE Conference on AI Applications, Miami, Florida, 1991; 141147. 14. T. Hoppe, C. Kindermann, J.J. Quantz, A. Schmiedel, M. Fischer, BACK 1/5 Tutorial ~ Manual, KIT Report 100, Technische Universit~it Berlin, 1993. 15. P.F. Patel-Schneider, An Approach to Practical Object-Based Knowledge Representation, Technical Report 68, Schlumberger Palo Alto Research, 1987. 16. F. Baader, B. Hollunder, B. Nebel, H.J. Profitlich, E. Franconi, "An Empirical Analysis of Optimization Techniques for Terminological Representation Systems", KR-92, 270-281. 17. C. Kindermann, Verwaltung assertorischer Inferenzen in terminologischen Wissensbanksystemen, PhD Thesis, Technische Universit~it Berlin, 1995. 18. J.J. Quantz, G. Dunker, F. Bergmann, I. Kellner, The FLEX System, KIT Report 124, Technische Universit~it Berlin, 1995. 19. B. Nebel, Reasoning and Revision in Hybrid Representation Systems, Berlin: Springer, 1990. 20. G. Sundholm, "Systems of Deduction", in D. Gabbay, F. Guenthner (eds), Handbook of Philosophical Logic, Vol. I: Elements of Classical Logic, Dordrecht: Reidel, 1983, 133-188. 21. F.M. Donini, M. Lenzerini, D. Nardi, W. Nutt, "Tractable Concept Languages", IJCAI-91, 458-463. 22. A. Schaerf, Query Answering in Concept-Based Knowledge Representation Systems: Algorithms, Complexity, and Semantic Issues, Dissertation Thesis, Dipartimento di Informatica e Sistemistica, Universit~ di Roma "La Sapienza", 1994. 23. D. Westersts "Quantifiers in Formal and Natural Languages", in D. Gabbay, F. Guenthner (eds), Handbook of Philosophical Logic, Vol. IV: Topics in the Philosophy of Language, Dordrecht: Reidel, 1989, 1-131. 24. J.J. Quantz, "How to Fit Generalized Quantifiers into Terminological Logics", ECAL 9P, 543-547. 25. V. Royer, J.J. Quantz, "On Intuitionistic Query Answering in Description Bases", in A. Bundy (Ed.), CADE-94, Berlin: Springer, 1994, 326-340. 26. B. Kasper, "A Unification Method for Disjunctive Feature Descriptions", A CL-87, 235-242. 27. B. Owsnicki-Klewe, "Configuration as a Consistency Maintenance Task", in W. Hoeppner (Ed.), Proceedings of GWAI'88, Berlin: Springer, 1988, 77-87. 28. F.W. Bergmann, Parallelizing FLEX, KIT Report in preparation, TU Berlin. 29. A.C. Dossier, "Intelligence Artificielle Distribuee", Bulletin de I'AFIA, 6, 1991. 30. A. Bond, L. Gasser, "Readings in Distributed Artificial Intelligence", Morgan Kaufmann, Los Angeles, CA, 1988. 31. F.W. Bergmann, M. Ostermann, G. von Walter, "Brain Aid Prolog Language Reference" Brain Aid Systems, 1993. 32. C. A. R. Hoare, "Communicating Sequential Processes" Prentice Hall, Englewood Cliffs, N.J., USA, 1985. 33. M. Kay, J.M. Gawron, P. Norvig, Verbmobil: A Translation System/or Face-to-Face Dialog, CSLI Lecture Notes 33 August 1991.

206 34. B. Schmitz, J.J. Quantz, "Dialogue Acts in Automatic Dialogue Interpreting", TMI95, 33-47. 35. J.J. Quantz, "Interpretation as Exception Minimization", IJCAI-93, 1310-1315. 36. J.J. Quantz, S. Suska, "Weighted Defaults in Description Logics--Formal Properties and Proof Theo .ry", in B. Nebel, L. Dreschler-Fischer (eds), KI-94: Advances in Artificial Intelligence, Berlin: Springer, 1994, 178-189.

207

Frank Bergmann Frank Bergmann is a researcher in the Department of Computer Science at the Berlin University of Technology. He received a Diploma in electronic engineering from the RWTH Aachen in 1995. He developed several parallel Prolog systems at Parsytec GmbH, Aachen and Brain Aid Systems GbR. He is now a researcher in the project KIT-VM11 which is part of the German Machine Translation project VERBMOBIL. His current research interests include Robust Natural Language Processing and Parallel Logic Programming.

J. Joachim Quantz J. Joachim Quantz is a researcher in the Department of Computer Science at the Berlin University of Technology. He received a Diploma in computer science in 1988, a Master's degree in linguistics and philosophy in 1992, and a Ph.D. in computer science in 1995. From 1988 to 1993 he worked as a researcher in an ESPRIT project on Advanced Information Management Systems. Since 1993 he is leader of the project KIT-VM11 which is part of the German Machine Translation project VERBMOBIL. His current research interests include Robust Natural Language Processing, Natural Language Semantics, Machine Translation, Nonmonotonic Reasoning and Description Logics.