Markus Stumptner

Consistency-based diagnosis of configuration knowledge bases

Configuration problems are a thriving application area for declarative knowledge representation that currently experiences a constant increase in size and complexity of knowledge bases. Automated support of the debugging of such knowledge bases is a necessary prerequisite for effective development of configurators. We show that this task can be achieved by consistency-based diagnosis techniques. Based on the formal definition of consistency-based configuration we develop a framework suitable for diagnosing configuration knowledge bases. During the test phase of configurators, valid and invalid examples are used to test the correctness of the system. In case such examples lead to unintended results, debugging of the knowledge base is initiated. Starting from a clear definition of diagnosis in the configuration domain we develop an algorithm based on conflicts. Our framework is general enough for its adaptation to diagnosing customer requirements to identify unachievable conditions during configuration sessions.

Generative constraint-based configuration of large technical systems

This paper describes the technical principles and representation behind the constraint-based, automated configurator COCOS. Traditionally, representation methods for technical configuration have focused either on reasoning about structure of systems or quantity of components, which is not satisfactory in many target areas that need both. Starting from general requirements on configuration systems, we have developed an extension of the standard CSP model. The constraint-based approach allows a simple system architecture, and a declarative description of the different types of configuration knowledge. Knowledge bases are described in terms of a component-centered knowledge base written in an object-oriented representation language with semantics directly based on the underlying constraint model. The approach combines a simple, declarative representation with the ability to configure large-scale systems and is in use for actual production applications.

Configuration knowledge representations for Semantic Web applications

Todays economy exhibits a growing trend toward highly specialized solution providers cooperatively offering configurable products and services to their customers. This paradigm shift requires the extension of current standalone configuration technology with capabilities of knowledge sharing and distributed problem solving. In this context a standardized configuration knowledge representation language with formal semantics is needed in order to support knowledge interchange between different configuration environments. Languages such as Ontology Inference Layer (OIL) and DARPA Agent Markup Language (DAML+OIL) are based on such formal semantics (description logic) and are very popular for knowledge representation in the Semantic Web. In this paper we analyze the applicability of those languages with respect to configuration knowledge representation and discuss additional demands on expressivity. For joint configuration problem solving it is necessary to agree on a common problem definition. Therefore, we give a description logic based definition of a configuration problem and show its equivalence with existing consistency-based definitions, thus joining the two major streams in knowledge-based configuration (description logics and predicate logic/constraint based configuration).

Evaluating Models for Model-Based Debugging

Developing model-based automatic debugging strategies has been an active research area for several years, with the aim of locating defects in a program by utilising fully automated generation of a model of the program from its source code. We provide an overview of current techniques in model-based debugging and assess strengths and weaknesses of the individual approaches. An empirical comparison is presented that investigates the relative accuracy of different models on a set of test programs and fault assumptions, showing that our abstract interpretation based model provides high accuracy at significantly less computational effort than slightly more accurate techniques. We compare a range of model-based debugging techniques with other state-of-the-art automated debugging approaches and outline possible future developments in automatic debugging using model-based reasoning as the central unifying component in a comprehensive framework.

Model-Based Debugging -- State of the Art And Future Challenges

A considerable body of work on model-based software debugging (MBSD) has been published in the past decade. We summarise the underlying ideas and present the different approaches as abstractions of the concrete semantics of the programming language. We compare the model-based framework with other well-known Automated Debugging approaches and present open issues, challenges and potential future directions of MBSD.

Model-Based Debugging or How to Diagnose Programs Automatically

We describe the extension of the well-known model-based diagnosis approach to the location of errors in imperative programs (exhibited on a subset of the Java language). The source program is automatically converted to a logical representation (called model). Given this model and a particular test case or set of test cases, a program-independent search algorithm determines a the minimal sets of statements whose incorrectness can explain incorrect outcomes when the program is executed on the test cases, and which can then be indicated to the developer by the system. We analyze example cases and discuss empirical results from a Java debugger implementation incorporating our approach. The use of AI techniques is more flexible than traditional debugging techniques such as algorithmic debugging and program slicing.

Analysis of business process integration in Web service context

The integration of Web services is a recent outgrowth of the Business Process integration field that will require powerful meta-schema matching mechanisms supported by higher level abstractions, such as UML meta-models. Currently, there are many XML-based workflow process specification languages (e.g. XPDL, BPEL) which can be used to define business processes in the Web services and Grid Computing world. However, with limited capability to describe the relationships (schemas or ontologies) between process objects, the dominant use of XML as a meta-data markup language makes the semantics of the processes ambiguous. OWL-S (Ontology Web Language for Services) exploits the semantic description power of OWL to build an ontology language for services. It therefore becomes a candidate for an inter lingua. In this paper, we propose an integration framework for business processes, which is applied to Web services defined in OWL-S.

Behavior based integration of composite business processes

Integration of autonomous object-oriented systems requires the integration of object structure and object behavior. Past research in the integration of autonomous object-oriented systems has so far mainly addressed integration of object structure. During our research we have identified business process correspondences and have given proper integration operators. So far these integration operators are suited for creating generalized models but not for creating or dealing with the composition of business processes. In this paper we propose integration operators which are able to create, deal, and finalize composition between them. For modeling purposes we use the Unified Modeling Language (UML), especially activity diagrams.

Model-Based Reconfiguration

Knowledge-based configuration is both a successful application domain for AI techniques and and an active research area. An open issue in many practical domains is that of reconfiguration, typically exhibited by legacy systems that are to be extended, upgraded or simply altered. Standard configuration techniques are not necessarily suited to this task. We discuss the use of a diagnosis approach to reconfiguration. We present the differing application and representation requirements, develop a representation that is suitable for expressing the information about the required and configurable functionalities from the diagnosis point of view, present an example and discuss our experiences.

A Generative Constraint Formalism for Configuration Problems

Traditionally, constraint satisfaction systems have been considered an especially well-suited representation to configuration problems. However, a conventional constraint system with a predefined set of variables does not capture the flexibility inherent in composing systems out of a multitude of components of varying types. We propose an extended constraint satisfaction scheme that allows the incremental extension of a constraint network in accordance with the component-oriented view of configuration. Components can be individually represented and connected, while resource constraints express non-local requirements on the interaction of components. Constraints may be generative in that they lead to introduction of new variables, and are generic in that they may be defined to hold for all components of a given type.