8/13/2019 Kamp-BN-97

1/10

Knowledge-based Inference Methods for Modeling Technical SystemsGerd Kam p and Bernd NeumannUniversity of Hamburg Vogt-KO~ln-Str.30,0-22527 amburgEmail:{ kamp neumann}Oinfonnatik.uni-hamburg.de

AbstractDescription Logics with concrete domains present an ap -proach to realize a general engineering workbench. Theyprovide a representation language that enables us to de-scribe in a uni orm way devices assemblies and compo-nents along with their structure constraints on attributesand physical laws as well as models of their correct andfado behavio : Furthermore sound and complete algo-rithms can be given fo r a set of basic inferenc es. Thesebasic inferences render it possible to simulate the behav-ior of the devices and provide the basic building blocks f o rconsistency-based diagnosis. In addition they enable us todevise procedures fo r finding errors omissions and incon-sistencies in model libraries.1. Introduction

During the design and engineering phase of a new tech-nical device it is necessary to develop solutions for severaltasks, such as configuration from components and assem-blies, determination of parameter values, simulation of be-havior, intelligent selection from parts catalogs and diagno-sis of prototypes. Traditionally these problems are tackledwith a number of specific tools. These tools most often bestand-alone systems and are not designed to communicatewith each other. In other words, every tool realizes its ownlanguage to describe the device, thereby preventing resultsobtained by one tool to be employed in other tools.In this paper we present an approach for an integrated en-gineering workbench based on description logics extendedwith concrete domains. The knowledge representation lan-guage that is supplied by this approach enables us to de-scribe important model features in a uniform language, e.g.:component types, component structures, physical laws andmodels of correct and faulty behavior. A number of basicinference services can be defined, and sound and completealgorithms for these inferences can be given for the descrip-tion language used. First results show that by making useof these basic inference services it is not only possible tosimulate the behavior and support the diagnosis of the sys-tem, but also to detect errors, inconsistencies and lacunae inmodel libraries.The remainder of this paper is organized as follows: First

we give a brief introduction to description logics and thefollowing enhancements needed in technical domains: con-crete domains, model generation and calculation of admissi-ble parameter ranges. We then focus on how different engi-neering tasks can be tacklled with this approach. In Section2 we show how the basic concepts needed to describe gear-wheel mechanisms can be represented within the descrip-tion language. Section 3 shows how simulation behaviorcan be accomplished via model generation and calculationof admissible parameter values. Section 4 presents an ap-proach to diagnosis based on object classification. Section5 shows how the inference service of concept classificationis useful for building and maintaining large model libraries.A summary and an outlook conclude the paper.1.1. Description Logiics

Description logics (DL) have a long tradition in organiz-ing information with a powerful object-oriented representa-tion scheme and clearly defined semantics. Description log-ics systems mainly consist of two parts: a TerminologicalBox (TBox) and an Asserlional Box (ABox) :1.1.1. TBox At the core of description logics lies thenotion of concept terms. Starting with primitive concept androle terms, new concept terms can be constructed from oth-ers by a set of concept forming operators. There are mainlythe following categories of such operators [ 6 ] :

1. Boolean operators and C D ...), (or C D ...), (not C ,allowing for the combination of concepts without a ref-erence to their internal structure.2 . Role forming operators that allow new roles to be de-fined, e.g. composition of roles (compose r s ) .3 . Operators on role Jillers that operate on the internalstructure of the concept terms, e.g. provide quantifica-tion over role fillers some C).

Terminological axioms of the form (define-concept CNC) associate a concept naime CN with a concept term C andare used to define the relevant concepts of an application.We cannot elaborate on the basics of description logics and refer thereader to [ 1 for a more detailed introduction.

1060-3425197 10.00 997 EEE 297

http://uni-hamburg.de/http://uni-hamburg.de/http://uni-hamburg.de/

8/13/2019 Kamp-BN-97

2/10

Terminological axioms are roughly comparable to the classdefinitions of an object-oriented representation language2.Finally a TBox T is a finite set of terminological axioms.1.1.2. ABox Concrete objects are realized as instancesof concepts. New instances o can be introduced into theABox via define-distinct-individual o), and assertions con-cerning the membership of an instance o to a concept C, orabout existing reIations r between two objects o and p canbe made through state instance o C))resp. state relatedo p r . The set of assertions finally constitutes the ABox A.1.2. Basic Inference Services

What sets description logics apart from other knowledgerepresentation approaches, is that one is able to formallydefine a model-theoretic semantics by means of an interpre-tation function I. This formal semantics allows a formal def-inition of a number of powerful inferences. In our contextthe following inference services are of particular interest:Classification Classification is the most prominent TBoxinference service. Classification calculates the con-cept subsumption hierarchy, i.e. the subconcept-superconcept relations between pairs of concepts.Technically a concept C subsumes another concept D

if each model for C is also a model for D (i.e. I C)I @ ).

Object Classification Object Classification is an ABox in-ference service that, given an object o of the ABox,determines the set of most specific concepts in the con-cept hierarchy {C D . } to which this object is a mem-ber.Retrieval The retrieval problem is dual to the Object Clas-sification problem. Here the set of ABox objects (in-stances) {o p ...} are retumed that are members of agiven concept C.

All these inference services can be reduced to the consis-tency problem of an ABox. An ABox is consistent if it hasa model, i.e. the set of interpretations I(A) is not empty (seee.g. [ 2 ]for detail's). Further it can be shown that there existsound and complete algorithms for certain description lan-guages, especially for the language ALCF which we havechosen for our system (for a description of LCF see [6]).1.3. Concrete Domains

The previous section more or less gave the generalframework for a standard description logics system. Butin order to use description logics in technical domains more'The class hierarchy of object oriented systems could be translated intoconjunctive concept terms with the slot definitions resulting in appropriaterole definitions.

expressive representation languages are needed. In addi-tion to the abstract domain of definable concepts presentedabove several concrete dom ains, such as numbers, stringsand symbols must be added to the language and the infer-ence services of the description logic3. These are needed inorder to describe parameter values and constraints betweendifferent parameters.

For example, n order to represent, simulate and diagnosethe simple bike drive train in Fig.1 at least the followingknowledge must be representable within such a system:The different types of components , e.g. wheels, gear-,wheels, chains, along with their attributes like force F,radius r and torqueM?The structure of assemblies, e.g the kinematic structureof the mechanisms using kinematic pairs.Physical laws like M =F r and constraints imposed onthe attributes like F>=0 and DOThe normal and faulty behaviors (often called mod-els in consistency-based diagnosis) of components andassemblies, e.g. the propagation of torques from onewheel to another M1=M2) with a correct or faultychain drive.

Therefore, in order to describe physical laws and modelsof behavior we need at least a concrete domain for whichone is able to reason with linear systems of inequalities be-tween multivariate polynomials. But current terminologicalsystems such as LOOM,CLASSIC,KRISand TAXONeal-ize only a concrete domain [9]where it is possible to expresscomparisons of parameters with constant values.

Bottom bracket

Figure 1 A simple bike drive trainA scheme for the integration of admissible concrete do-mains was developed by Baader and Hanschke [2, 61. An3This requirement arises in other domains, too. But in technical do-mains it is vital.41n this paper we model these attributes using scalar numeric valuesresulting in quantitative models of behavior. Altematively a qualitativemodel using symbolic values as it is used in qualitative physics is possible.

298

8/13/2019 Kamp-BN-97

3/10

admissible concrete domain is mainly a base data type to-gether with a set of so-called concrete predicates (n-ary rela-tions over the base data type). In order to be admissible sucha structure has to fulfill a number of constraints. The mostimportant of these constraints requires that the satisfiabilityof a finite conjunction of concrete predicates must be decid-able. Baader and Hanschke then show that if a concrete do-main is admissible the resulting concept languageALCF D)is still decidable. Hence, there exist sound and complete al-gorithms for the above inference services in ALCF D). Toour knowledge, TAXONs the only description logic systemthat uses this approach to realize concrete domains. But asalready mentioned, so far the concrete domains are too in-expressive.Fortunately it can be shown [9] that systems of inequali-ties are an admissible concrete domain. Therefore it is pos-sible to build a description logic system that is able to repre-sent and handle the above mentioned component types, thelaws of physics and the models of behavior. Thus we de-veloped CTL, a system where admissible concrete domainsare realized through a well-defined interface to external al-gorithms [9]. In particular, we are currently able to handlesystems of arbitrary linear polynomials with the help of anCLP(R)-system.In order to express concrete predicates we extended thedescription language with the following constructs: define-constraint PN x7 . xN) expr) defines a new concrete pred-icate (normally an (in)equality) between a number of vari-ables. Further constrain R7 .._ N P is an additional con-cept term operator for associating a number of parametersR7 . RN with the variables of a defined concrete predicateP. Alternatively, it is possible to write constrain R7 ... RN

x7 . xN) expr)) if one does not want to introduce a predi-cate name but rather use anonymous concrete predicates.1.4. Model Generation

Description logic systems with sound and complete in-ference algorithms are based on a tableaux calculus. Thismeans that in order to determine if an B o x s consistent,the consistency test explicitly generates a consistent model.That model obeys and enforces the constraints imposed onthe ABox objects by the TBox concepts. Not only are therestrictions enforced on the ABox instances introduced bythe user, but additional instances may be generated by oper-ators on role fillers, especially the operatorsome.The latterfact comes in handy, e.g. if one wants to check if there areany instances that were automatically generated and not in-troduced by the user. It is also the base for configurationsystems and useful during the construction phase of a de-vice model in simulation and diagnosis.Description logic systems normally display only the re-sult of the consistency test and the constructed model ismore or less thrown away. But at least in technical domains

we are not only interested in the existence of a solution, wewant to see the solution, e:.g. the set of instances and therelations between them. Therefore, the calculated model isthe main object of interest, not the result of the consistencytest. Thus we extended CTL with a method that enables usto access the model which is generated during the consis-tency test.1.5. Calculating Admissible Parameter Ranges

If a description logic is enhanced with concrete domains,it must provide a means to check the consistency of the con-crete domain. As we have: seen this is mainly the task ofchecking whether a finite conjunction of predicates is sat-isfiable. In our case this means checking if a system of in-equalities between polynornials has a solution. But in anal-ogy to model generation we are not only interested in theexistence of a solution, but in how this solution looks like.Both tasks can be accom plished by using quantifier elim-

ination techniques from computer algebra (in the field ofCLP(R) this technique is called variable elimination or pro-jection). Quantifier elimination [171 is a method that trans-forms an arbitrary first-order formula of the theory of theelementary algebra over the reals (more or less real arith-metic) into an equivalent formula without (or with fewer)quantifiers. Since the solvability of a system of inequalitiescan be expressed as an existential sentence of elementaryalgebra (for details see [9])1,checking for the existence of asolution of such a system is simply done by eliminating allquantifiers from that sentence.Besides checking the validity of a sentence, quantifierelimination can also be used for the calculation of admis-sible parameter ranges. This is realized by eliminating allparameters but the one whose restrictions should be calcu-lated. Quantifier elimination transforms he sentence into anequivalent one containing only one quantified variable. Theresulting sentence describes the restrictions on the range ofthe respective parameters admissible values. Since this pro-cedure is independent of the actual parameter, it can be usedto determine the admissible ranges of all parameters con-tained in the model that is ,generated during the consistencytest.Over the years quantifier elimination techniques havebeen vastly improved. On one side more efficient generalalgorithms than Tarskis have been devised (e.g. Cylindri-cal Algebraic Decomposition (CAD) [3]) and further im-proved (e.g. PCAD [7]). But these are still too inefficient tobe actually useful and no implementation is publicly avail-able. On the other side specialized algorithms for subsetsof the theory of elementary algebra have been found andimplemented. Most important, more or less all CLP(R)-systems implement some kind of the Fourier-Motzkin al-gorithm that realizes quantifier elimination for linear SYS-tems of inequalities (see e.g. [111). Since quite a number of

299

8/13/2019 Kamp-BN-97

4/10

CLP(R)-systems are freely available and are sufficient forour representation needs, we have chosen a CLP(R)-systemas the decision procedure over systems of linear inequali-ties. CLP(R)-systems can also be used for nonlinear sys-tems, but in this case complete inferences can not be guar-anteed. Since the only non-linear expression in the aboveexamplesis the law of torque, this restriction does not reallyimpose a problem on our example. At the moment we areimplementing an interface to a quantifier elimination proce-dure of a computer algebra system. This elimination proce-dure allowsus to'handle arbitrary quadratic sentences of thetheory of the elementary algebra over the reals. With thissystem we can guarantee sound and complete inferences forour example'.In the following we will use a simple example itom me-chanics to illustrate how description logics based on CTLcan be used for the representation, the simulation and thediagnosis of simple linear systems.2. Representation

The first task is to describe the different kinds of knowl-edge to be captured by the provided description language.First, we must be able to describe the different componenttypes of a mechanism as well as the kinematic structure. Inkinematics this is normally done with links and kinematicpairs [16,8]. In the following we show how these conceptscan be described in the description languageof CTL,whichis based on the proposed KRSSstandard[151for descriptionlogic languages.2.1. Links

In order to describe the different component types of thedrive train of Fig. 1, it is sufficient to define rotational linksand tension links as specializations of general links. Theterminology in F ig2 defines links as something that carriesa force link.force). Rotational links rotational-link) are linksthat in addition have attributes for a radius rot.radius) and atorque rotto rque) . link.force and rot.torque are not negative,rot.radius is strictly positive, and the torque is the productof radius and applied force. Finally we define a number ofadditional links such aswheel, chain etc. without detailingthem further.2 2 Kinematic Pairs

In order to describe the behavioral structure of a mecha-nism, kinematic pairs are used. A kinematic-pair describesthe connection between two links pair.link1 and pair.link2.Depending on the relative motion of the links and the typeof connection different types of pairs can be identified. The

sWe already used t h i s system to calculate the parameter restrictions inthe following examples

(def i ne- pri mt i ve- att ri bute ink.force Top)( def i ne- pr i mt i ve- concept ink( and Top ( some 1i nk. f orce ( mni mum0 ) ) ) )(def i ne- pri mt i ve- att ri bute ot.radius Top)(def i ne- pri mt i ve- att ri bute ot.torque Top)( def i ne- const rai nt 0 (?x) > ?x 0( def i ne- const rai nt =O (?x) >= ?x 0( def i ne- const rai nt * p z ? x ? y ? z )( def i ne- pr i mt i ve- concept otational-link( = * ?X ? y ) ? z( and l i nk( const rai n rot. radi us e o( const rai n rot . t orque -=O( const rai n rot . radi us 1i nk. f orce rot . t orque

x*y=z))( def i ne- pr i mt i ve- concept ension-link l i nk)( def i ne- pr i mt i ve- concept rank rotati onal - l i nk)( def i ne- pr i mt i ve- concept heel rotati onal - l i nk)( def i ne- pr i mt i ve- conceptgearwheel( def i ne- pr i mt i ve- concept pindle rotati onal - l i nk)( def i ne- pr i mt i ve- concept hain tensi on- l i nk)

rotati onal - l i nk)

Figure 2: Links

terminology shown in Fig.3 is restricted to the descrip-tion of pairs of two rotational-links rot-pair) and pairs of arotational-link and a tension-link rot-tension-pair). Note thatit is possible to describe rot-tension-pair via an or construct,something which is not possible within object-oriented rep-resentation systems.(def i ne- pri mt i ve- att ri bute air-link1 t op)(def i ne- pri mt i ve- att ri bute air.link.2 t op)( def i ne- pr i mt i ve- concept inematic-pair

(and (al l pai r. l i nk1 l i nk)(al l pai r. l i nk2 l i nk) )( def i ne- concept rot-pair(and ki nemat i c- pai r(al l pai r. l i nk1 rotati onal - l i nk)(al l pai r. l i nk2 rotati onal - l i nk) I( def i ne- conceptrot-tension-gaix( and ki nemat i c- pai r( or (and (al l pai r. l i nk1 rotati onal - l i nk)

(and (al l pai r. l i nk2 r otati onal - l i nk)(al l pai r. l i nk2 tensi on- l i nk))(al l pai r. l i nk1 tensi on-l i nk)) )) )

Figure3: Kmematicpairs

2.3. Models ofBehaviorIn addition to the component types and the structure ofthe device, descriptions of the correct and of different faultybehaviors are needed for the consistency-baseddiagnosis aswell as the simulation of the device. The terminology in

300

8/13/2019 Kamp-BN-97

5/10

Fig.4 describes the correct behavior of rotational-pairs androt-tension-pairs. The torque is propagated in ok-rot-pair,the force is propagated in ok-rot-tension-pair.( def i ne- constr ai nt =y ( ?x ? y ( = ?x ?y) )( def i ne- concept ok-rot-pair( and rot- pai r( const rai n ( compose pai r . l i nk1 rot . t or que)

( compose pai r . l i nk2 rot . t orque)x=y) )( def i ne- concept ok-rot-tension-pair( and rot - t ensi on- pai r( const r ai n ( compose pai r . l i nk1 1i nk. f orce)( compose pai r . l i nk2 1i nk. f orce)

x=y) )

Figure 4: The correct behavior of the kinematic-pairsThe terminology in Fig.5 shows some exemplary faultybehaviors of a rotational pair. A pair is slipping slipping-

rot-pair) if both torques are strictly positive and different.A pair is broken broken-rot-pair) if one torque is strictlypositive, the other zero.( def i ne- concept slipping-rot-pair( and r ot - pai r( const rai n ( compose pai r . l i nk1 rot. t orque)

( const rai n ( compose pai r . l i nk2 rot. t orque)or ( const rai n ( compose pai r . l i nk1 rot . t orque)( compose pai r . l i nk2 r ot. t orque)

( const rai n ( compose pai r . l i nk2 rot . t orque)( compose pai r . l i nk1 rot. t orque)

-0 1*O )

-Y)

m y( def i ne- constr ai nt =O ( ?XI ( Number ) (= ?x 0( def i ne- conceptbroken-rot-pair( and rot - pai r

(or(and( const r ai n ( compose pai r . l i nk2 rot. t or que)( const r ai n ( compose pai r . l i nk1 rot . t orque)-0 1x=O))( and( const r ai n ( compose pai r . l i nk1 rot . t orque)

( const rai n ( compose pai r . l i nk2 rot . t orque)-0 )x=o ) 1 ) 1

Figure 5: Faulty behaviors of a rotational pair (I)A second developer might distinguish between strongand weak slipping pairs strong-slipping-rot-pairresp. weak-

slipping-rot-pair) as it is depicted in Fig.6. Note that in ourlanguage it is possible to describe the weak slipping pair asthe negation of a strong one. This allows for a simple de-scription of a weak slipping pair, and reduces the sources

of possible faults. It further eases the modification of theknowledge base, e.g. a change of the limiting value betweenstrong and weak slipping pairs is local to one definition andnot spread across two defiinitions.( def i ne- constr ai nt

8/13/2019 Kamp-BN-97

6/10

of the consistency test. All constraints are automatically en-tered into this constraint net and its satisfiability is automat-ically checked. If one additionally gives the values of someparameters (e.g. via (state (related linkl 10 1ink.force)) hesevalues are also automatically entered into the constraint net.Furthermore, every assertion about parameters constrainsthe range of admissible values of at least this parameter, butmost often also a number of additional parameters (e.g. viathe law of torque).Using this approach, it is unnecessary to define a fixed setof input parameters for the simulation. The consistency testand hence the model generation and calculation of parame-ter ranges works whichever set of assertions is given. Sincethe consistency test can be initiated after every ABox asser-tion, i.e. after every (state . , this approach renders it pos-sible to interactively and incrementally determine the modeland the parameter ranges. Moreover it is possible to freelyintermix assertions about parameter values (e.g. (state (re-lated linkl 10 1ink.force))) and behavior models (e.g. (state(instance pairl ok-rot-pair)), giving the developer a maxi-mum amount of freedom. We illustrate this procedure usingthe bike drive train from Figure 1as an example.3.1. Describing the device

Before a device can be simulated, its structure must bedescribed. To do so, firstly the instances are created andappropriate primitive concepts are assigned to the freshlycreated instances:define-distin ct-individual crankarm-1)define-distin ct-individual chainring-1)define-distinct-individualdefine-distin ct-individual chain-1)define-distin ct-individual sprocket-1)define-distinct -individual rear-axle-1)define-distin ct-individual rear-wheel-1)state

bottom-bracket-spindle-1)

and instance crankarm-1 crank)instance chainring-1 gearw heel)instance bottom-bracket -spindle-1instance chain-1 chain)instance sprocket-1 gear wheel)instance rear-axle-1 s pindle)instance rear-wheel-1rotational-link)))

define-distinct-individual airl)define-distinct-individual air6)state

spindle)

...and instance pairl kinematic-pair)...

instance pair6 kinematic-pair)))Secondly, the links are related to the respective kinematicpairs and the kinematic chain is set up:

state

andrelatedrelatedrelated

relatedrelatedrelated

pairl crankarm-1 pair.link1)pairl bottom-bracket-spindle-1pair. ink2)pair2 bottom-bracket-spindle-1pair. linkl)pair5 rear-axle-1 pair.link2)pair6 rear-axle-1 pair.link1)pair6 rear-wheel-1 pair.link2)))

This concludes the description of the structure of thedrive train. Since neither parameter values nor behaviormodels are given at this point, the generated model onlyreflects the constraints imposed on the parameter vaIues bythe concept definitionsof their respective concepts (see Fig-ure 8).

Figure 8: Simulation: Describing a device

3.2. Simulation with parameter valuesThe simplest form of simulation uses exact parametervalues for some parameters in order to determine the admis-sible parameter ranges for the other parameters containedin the calculated model. If there are no disjunctions, orinequalities are contained in the models of behavior, theranges for the dependent parameters are restricted to a sin-gle exact value. Simulation proceeds as follows:1 Determine of some parameter values in order to startthe simulation.

In our example we set the radii of the crankarmcrankarm-1 , the chain ring chainring-1 the sprocketsprocket-1 and the rear wheel rear-wheel-I ,as well asthe value of the force applied to the crank arm:

state andrelated crankarm-1 .175 rot.radius)related chainring-1 .1 rot.radius)related sprocket-1 . 05 rot.radius)related rear-wheel-1 0 . 6 8 5 8 rot.radius)))

302

8/13/2019 Kamp-BN-97

7/10

2. Determine of the behavior models for the components.In our example all kinematic pairs (pairl . pair6) ex-pose their normal behavior:stateand instance pairl ok-rot-pair)instan ce pair2 ok-rot-pair)

inst ance pair3 ok-rot-tension-pair)inst ance pair4 ok-rot-tension-pair)instance pair5 ok-rot-pair)instance pair6 ok-rot-pair )))

These assertions add new constraints to the constraintnet (see Figure 9) but executing the consistency testdoes not reveal any new information since giving onlysome radii does not trigger the restriction of any pa-rameter within the constraint net.

Figure 9: Simulation with parameter values: Initial pa-rameters and behaviors

3. Determine some additional parameter values.With additional parameter values enough informationis available to trigger propagation through the con-straint net. In our example we choose to assert a valuefor the force that is applied to the crankarm by stating6:state related crankarm-1 200 1ink.force))

Now the values for nearly all missing parameter valuescan be calculated (see Figure 10). W.r.t. the bottom-bracket-spindle-1and the rear-axle-1 the value 0 couldbe excluded from the admissible ranges of the respec-tive forces (since the force applied to the crankarm isstrictly positive). It is not surprising that no furtherrestriction is possible, given the fact that no radius isgiven for these links. Nevertheless the propagation ofthe respective torques to their adjoining links is pos-sible because the law of torque is applicable to intactrotation pairs.00N is a reasonable value for an average cyclist.

Figure 10: Simulation with parameter values: FinalModel3.3. Simulationwith complex parameterrestrictions

We now consider simulation using complex parameterrestrictions instead of simple parameter values. The quan-tifier elimination method allows us to use arbitrary con-crete predicates as parameter restrictions, i.e. linear (resp.quadratic) sentences over the elementary algebra of the re-als.This kind of simulation is especially interesting for per-forming What-If analysis during the design phase of a tech-nical device. But it allows us also to describe more com-plex devices. The following example combines both as-pects. Consider a drive itrain that consists not only of asingle chainring and a single sprocket but which has twochainrings and a freewheel block with sprockets in 3 differ-ent sizes. This can be described using our drive train set-upfrom above and the following parameter restrictions:state andrelated crankarm-1 .i75 rot.radius)

related rear-wheel-1 0 . 6 8 5 8 rot.radius)instanc e chainring-1cons train rot.rad.ius((?x) or (= ?x 0. 1)( = ? x 0.125)))))instanc e sprocket-1

constra in rot.radiius? x ) or ( = ?x 0.05) = ?x 0.0625)

( = ?x 0.075)))))))Additionally we restrict the force applied to the crankarmto a range typical for a moderately trained cyclist:

state instanc e crankarm-iconstra in link. force((?x) and >= ?x 200)

8/13/2019 Kamp-BN-97

8/10

Furs : 1ZO.llb57.4141

Figure 11: Simulation with complex parameter restric-tions

(or ( = * 429 f rw) 70000) = * 3429 frw) 87500)( = * 3429 f rw) 109375) = * 2286 f rw) 109375)( = * 1143 f rw) 35000) ( = * 1143 frw 43750)( = * 381 f r w) 17500) = * 381 f rw) 21875)( and ( > * 1143 f rw) 43750)

( < * 381 f rw) 21875))( and ( > ( *. 3429 rw) 109375)( < * 2286 f r w) 109375) )(and ( > * 3429 f r w) 70000)( < * 1143 f rw) 35000))( and ( > * 1143 f rw) 35000)( < * 381 f r w 17500))( and > * 3429 f rw 87500)( < * 1143 f r w) 43750)) )

One can instantly recognize two facts from this formula.First, there are only 5 intervals instead of the expected 2 . 3=6 . An inspection of the given radii reveals that 0.05.0.125= 0.625-0.1,and hence there are only 5 different gears. Thesecond observation is that only 8 interval endpoints are re-turned, indicating that there are two occurrences of intervalsthat actually meet.

s already mentioned in Section 1.2. all inferences of adescription logic, such as concept- or object classification,instantiation and retrieval can be reduced to the consistencytest. Object classification computes the set of concepts towhich the object belongs for sure, whereas weak object clas-sification calculates the set of concepts to which it is stillpossible to classify this object. These two inferences, to-gether with a set of behavior models - models of normaland faulty behavior - can be used to realize some kind ofconsistency-based7diagnosis.The first step is similar to the simulation approach pre-sented in the previous section: Describing the device to bediagnosed. But rather than asserting concrete models of be-havior together with a small set of input parameters (like insimulation), one starts by asserting very general models of

behavior and incrementally adds values of observed param-eters. After each assertion of new parameter values objectclassification is called. This inference service not only com-putes the set of most special models of behavior, but the em-bedded consistency est also calculates - s we have seen inthe previous section- he restrictions for the various param-eters. Weak object classification computes the set of behav-ior models to which it is still possible to classify the object.In our case this are the models of behavior that are still pos-sible but can only be confirmed if new information is (e.g.new parameter values) available. Therefore weak classifi-cation, together with computed parameter restrictions giveshints which parameter values should be determined in thenext step. Also note that weak object classification is notidentical to the set of subconcepts of the concepts returnedby the strong object classification. Some of these may beexcluded due to the fact that they are not consistent with thecalculated parameter restrictions.Hence strong and weak object classification compute anupper and a lower boundary within the concept graph, de-noting the possible models of behavior. Each new asser-tion of a parameter value moves these boundaries until theuser has gathered enough information for a decision or bothboundaries meet and the diagnosis is firm. We will illustratethis procedure by using a rotational-pair as an example:First we describe the structure of the device (similar tosimulation):(def i ne- di st i nct- i ndi vi dual ot- pai rl )( def i ne- di sti nct- i ndi vi dual i nkl . 1)( def i ne- di sti nct- i ndi vi dual i nkl . 2)( stat e (and ( i nst ance rot - pai r1 ki nemat i c- pai r )(i nstance l i nkl . 2 rotati onal - l i nk)(i nstance l i nkl . 1 rotati onal - l i nk)

(r el ated rot- pai r1 l i nkl . 1(r el ated rot- pai r1 l i nkl . 2pai r. l i nk1)pai r. l i nk2)) )Next, we assert general model of behavior:

( state ( i nstance r ot - pai r1 ki nemat i c-pai r ) )Finally, we assert the observed parameter values and callthe object classification inference. Since different sets of pa-rameter values should lead to different diagnosis, we illus-trate the effect of this step by using three different parametersets.

1. Giving two identical torques as parameter values leadsto the classification as an ok-rot-pair, as it should beexpected:( state (and (r el at ed l i nkl . 1 10

( rel at ed l i nkl . 2 10rot . t orque)rot . orque) )7akind of model-based diagnosis.

3 4

8/13/2019 Kamp-BN-97

9/10

2. The diagnostic process becomes clearer if one uses an-other set of parameter values, as shown below. Thefirst assertion, together with the law of torque and theconstraint that a radius is strictly positive enforces thatthe torque of linkl.l is strictly positive. Therefore thesecond assertion, giving a zero value for the torque oflinkl.2 suffices to classify rot-pair1 as a broken-rot-pair.Note that only 2 of the 6 parameters are needed for cor-rect classification.state rela ted linkl.2 0 rot.torque))state related linkl.1 8 1ink.force))

3.

5.

The last example illustrates how the rot-pair1 can beclassified as a weak-slipping-rot-pair. This is possibledue to the calculation of the torque of linkl.2 via thelaw of torque and the calculation of the ratio of thetwo torques. This example also illustrates the role ofweak object classification. After the second assertionbroken-rot-pair can be excluded from the list of possi-ble behavior models since- sing the same argumenta-tion as above- he torque of linkl.2 is strictly positive.Hence both torques of rot-pairl are strictly positive andit is impossible that it is a broken-rot-pair.state rela ted linkl.1 20 rot.torque))state rela ted linkl.2 8 1ink.force))state related linkl.2 3 rot.radius))

Model LibrariesIn this section we will briefly describe how concept clas-sification can be used for the organization and maintenance

of model libraries. The following observations are impor-tant w.r.t this aspect:1. All concept definitions are different from bottom.Therefore all definitions are satisfiable. That guaran-tees that no model of behavior is mistakenly defined ina way such that exists no parameter combination thatmay lead to .this behavior (e.g. through a parameter re-striction like (and (constrain force x>O) (constrain force

xox>o

compose pair.link2 ro t.torqu e)X U Y 1

the system would detect that both definitions are equiv-alent.3. The strong and weak slipping pairs in Fig.6 are mod-eled as specializations of rot-pair, but not of slipping-rot-pair. Situations like this may occur easily if dif-ferent people develop models of behavior simultane-ously, or when model libraries are complex. The clas-sification service detects the missing subsumption re-lation between slipping-rot-pair and strong-slipping-rot-pair. In other situations it may be the case that a com-puted subsumption relation is not missing but fortu-

itous in a sense that it is caused by some error or lax-ness in the description of the models of behavior.Errors like the ones describe above are very likely to occurin large and complex model libraries. Therefore the detec-tion of these errors is crucial for the development of suchlibraries. Since all inferences are sound and complete8 inCTL,we can guarantee that all missing and fortuitous sub-sumption relations in the model library are detected.6 Summary and Outlook

Description Logics with concrete domains present an ap-proach to realize a general engineering workbench. Theyprovide a representation language that enables us to de-scribe in a uniform way the devices, their assemblies andcomponents along with their structure, constraints on theirattributes and physical laws as well as models of their cor-rect and faulty behavior. Furthermore sound and completealgorithms can be given for a set of basic inferences.These basic inferences render it possible to simulatethe behavior of the devices and provide the basic buildingblocks for consistency-based diagnosis. In addition they en-able us to devise procedurles for finding errors, omissionsand inconsistencies in model libraries.The approaches that are most similar to ours are systemsthat were developed within the Knowledge Sharing Effort,e.g. S H A D E 13, 14, 121 and the systems derived from itlike PACT [4] and P A R MA N [lo]. In contrast to our morebasic research oriented approach, these projects investigateto which extent it is possible to define a common knowledgerepresentation or a set of existing systems. The exchangeofinformation is accomplished through a translation approach

define-concept another-slipping-rot-pair t least for linear systems of inequalities in our current implementation

305

8/13/2019 Kamp-BN-97

10/10

between a common interlingua and the representation lan-guage of the target system. In practice that proved to bcdifficult, since different systems employ a different seman-tics for the same terms.The results presented in this paper are first steps to-wards an integrated knowledge-based engineering work-bench. Actual work focuses on realizing quantifier elimi-nation over quadratic sentences of the elementary algebraby implementing an interface to an computer algebra sys-tem [ 8,5]. Further work concentrates on concrete domainsover other base types, e.g. using CLP FD) systems for de-scribing qualitative models. This would allow us to directlycompare our approach to methods developed in qualitativephysics.Parallel to these more theoretical questions we are in-vestigating how the basic mechanisms can be further en-hanced in ordcr to obtain systems that can actually be usedby engineers. Finally we explore the possibility to integrateother modules of our envisioned workbench like eonfigu-ration and intclligent retrieval from parts catalogs into theframework presented in this paper.References[I] E Baader, H. Burckert, B. Hollunder, A. Laux, and W. Nutt.Terminologische Logiken. KI (3):23-33, 1992.[Z] F. Baader and P. Hanschke. A Scheme for Integrating Con-crete Domains into Concept Languages. Research ReportRR-91-10, DFKI, Kaiserslautem, Germany, April 1991.[3] G. E. Collins. Quantifier Elimination for Real Closed Fieldsby Cylindrical Algebraic Decomposition. In Proc. of theSecond GI Conference on Automata Theory and Formal

Languages number 33 in LNCS, pages 512-532. Springer,1975.[4] M.R. Cutkosky, R.S. Engelmore, R.E. Fikes, M.R. Gene-sereth, T.R. Gruber, W.S. Mark, J.M. Tenenbaum, and J.C.Weber. PACT: An Experimentin Integrating Concurrent En-gineering Systems. IEEE Computer, (1):28-37, 1993.

[5] Andreas Dolzmann and Thomas Sturm. REDLOG- Com-puter Algebra Meets Computer Logic. Technical ReportMIP-9603, Universitat Passau, Passau, Germany, February1996.[6] P. Hanschke. A Declarative Integration of Terminological,Constraint-Bused, Datu-driven, and Goal-directed Reuson-ing. Dissertation, Universitat Kaiserslautem, 1993.[7] H. Hong. RISC-CLP(Rea1): Constraint Logic Programming

over the real numbers. In Constraint Logic Programming:Selected Research. MIT Press, Cambridge, MA, 1993.[ 8 ] ISO. IS 0 I0303 Part 105: Integrated Application Ressource:Kinematics. ISO, 1994.[9] Gerd Kamp and Holger Wache. CTL - a description logicwith expressive concrete domains. Technical report, LKI,

1996.

[ IO ] Daniel Kuokka and Brian Livezey. A Collaborative Paramet-ric Design Agent. In B. Hayes-Roth and R. Korf, editors,Proc. of the Twelfth National C onference onArtificial Intel-ligence AAAI-94) , volume 1, pages 387-393, Seattle, WA,1994. AAAI Press.[ 1 I] Jean-Louis Lassez. Parametric queries, linear constraints andvariable elimination. In A. Miola, editor, Design and im -plemenlation of Sym bolic C omputation Systems, volume 429of LNCS, pages 164-173, Capri, Italy, April 1990. SpringerVerlag.[I21 J.G. McGuire, Daniel R. Kuokka, J.C. Weber, J M Tenen-baum, T. Gruber, and G. Olsen. SHADE: Technology forKnowledge-Based Collaborative Engineering. ConcurrenlEngineering: Research Applica tions, 1(3), 1993.1131 J.G. McGuire, R.N. Pelavin, J.C. Weber, J.M. Tenenbaum,T. Gruber, and G . Olsen. SHADE: A Medium for SharingDesign Knowledge among Engineering Tools. Annual re-port, 1992.[14] J.G. McGuire, R.N. Pelavin, J.C. Weber, J.M. Tenenbaum,T. Gruber, and G. Olsen. SHADE: Knowledge-Based Tech-

nology for the Re-Engineering Problem. Annual report,1993.[15] P. E Patel-Schneider and B. Swartout. Description LogicSpecification from the KRSSEffort. November 1993.[161 E Reuleaux. The Kinematics of machinery - outlines of atheory of machines. Macmillan Co, New York, NY, 1876.[171 A. Tarski. A Decision Method for Elementary Algebra andGeometry. In Collected Works of A. Tarski, volume 3, pages300-364.[181 Volker Weispfenning. Applying Quantifier Elimination toProbIems in Simulation and Optimization. Technical ReportMIP-9607, Universitat Passau, Passau, Germany, April 1996.

306