Automated extraction of knowledge for model-based diagnostics

The concept of accessing computer aided design (CAD) design databases and extracting a process model automatically is investigated as a possible source for the generation of knowledge bases for model-based reasoning systems. The resulting system, referred to as automated knowledge generation (AKG), uses an object-oriented programming structure and constraint techniques as well as internal database of component descriptions to generate a frame-based structure that describes the model. The procedure has been designed to be general enough to be easily coupled to CAD systems that feature a database capable of providing label and connectivity data from the drawn system. The AKG system is capable of defining knowledge bases in formats required by various model-based reasoning tools

Logic programming in the context of multiparadigm programming: the Oz experience

Oz is a multiparadigm language that supports logic programming as one of its major paradigms. A multiparadigm language is designed to support different programming paradigms (logic, functional, constraint, object-oriented, sequential, concurrent, etc.) with equal ease. This article has two goals: to give a tutorial of logic programming in Oz and to show how logic programming fits naturally into the wider context of multiparadigm programming. Our experience shows that there are two classes of problems, which we call algorithmic and search problems, for which logic programming can help formulate practical solutions. Algorithmic problems have known efficient algorithms. Search problems do not have known efficient algorithms but can be solved with search. The Oz support for logic programming targets these two problem classes specifically, using the concepts needed for each. This is in contrast to the Prolog approach, which targets both classes with one set of concepts, which results in less than optimal support for each class. To explain the essential difference between algorithmic and search programs, we define the Oz execution model. This model subsumes both concurrent logic programming (committed-choice-style) and search-based logic programming (Prolog-style). Instead of Horn clause syntax, Oz has a simple, fully compositional, higher-order syntax that accommodates the abilities of the language. We conclude with lessons learned from this work, a brief history of Oz, and many entry points into the Oz literature.Comment: 48 pages, to appear in the journal "Theory and Practice of Logic Programming

G+: A Constraint-Based System for Geometric Modeling

Most commercial CAD systems do not offer sufficient support for the design activity. The reason is that they cannot understand the functional requirements of the design product. The user is responsible for maintaining the functional requirements in different design phases. By incorporating constraint programming concepts, these CAD systems would evolve into systems which would maintain the functional requirements in the design process, and perform analysis and simulation of geometric models. The CAD systems incorporated with constraint programming concepts would reduce design time, avoid human fatigue and error, and also maintain consistency of the geometric constraints imposed on the model. The G+ system addresses these issues by introducing a constraint-based system for geometric modeling by object-oriented methods. The G+ is designed such that available specialized algorithms can be utilized to enable handling of non-linear problems by both iterative and non-iterative schemes

A modular modeling approach to simulate interactively multibody systems with Baumgarte/Uzawa formulation

International audienceIn this paper, a modular modeling approach of multibody systems adapted to interactive simulation is presented. This work is based on the study of the stability of two Differential Algebraic Equations solvers. The first one is based on the acceleration-based augmented Lagrangian formulation and the second one on the Baumgarte formulation. We show that these two solvers give the same results and have to satisfy the same criteria to stabilize the algebraic constraint acceleration error. For a modular modeling approach, we propose to use the Baumgarte formulation and an iterative Uzawa algorithm to solve external constraint forces. This work is also the first step to validate the concept of two types of numerical components for Object-Oriented Programming

Structural Constraint-Based Modeling and Reasoning with Basic Configuration Cells

Configuration tasks are an important application area in engineering design. The proposed solving techniques use either a constraintbased framework or a logic-based approach. We propose a methodology to obtains desired configuration using basic configuration cells(BCC). They are built by means of the predefined components and connections of the given configuration problem. In practical applications of configuration tasks the BCCs and configuration goals are represented according to object-oriented programming paradigm. They are mapped into a numeric constraint satisfaction problem. The transformation of a basic configuration cell into a new one generates a sequence of numeric constraint satisfaction problems. We propose an algorithm that solves this sequence of problems in order to obtain a configuration solution according to the desired requirements or that detects inconsistencies in the requirements. The integration of objectoriented and constraint programming paradigms allows us to achieve a synergy that produces results that could not be obtained if each one were working individually

Automatic Feedback for UML Modeling Exercises as an Extension of INLOOP

In recent years, e-learning systems have become an important part of normal and university education. One reason for this is the growth in student numbers. INLOOP is an assessment system for object-oriented programming and is used in a beginner software engineering course of the TU Dresden. Unfortunately, for the course, there is no assessment system for object-oriented modeling. This thesis extends the INLOOP concept with functionality to assess object-oriented modeling. For that, it introduces INLOOM as a constraint-based model assessment system that works well with the architecture and workflow of INLOOP. It is based on a two-stage system that generates constraint-based test sets out of expert solution models and uses these to generate feedback and a score for a student's solution model. The system was designed by first surveying the literature on model assessment systems and then creating a design that is easy to include into INLOOP. To assess the new INLOOM system, a proof-of-concept realization for analysis UML class models is introduced. For evaluation, this realization is used to assess student solutions for tasks of multiple exams. The results of the assessment system are then compared with the assessments of human instructors. It could be shown that the INLOOM system works as well as other comparable systems. In conclusion, the INLOOM system can be used alongside INLOOP to improve the student feedback in the beginner software engineering course

Relational extensions to feature logic: applications to constraint based grammars

This thesis investigates the logical and computational foundations of unification-based or more appropriately constraint based grammars. The thesis explores extensions to feature logics (which provide the basic knowledge representation services to constraint based grammars) with multi-valued or relational features. These extensions are useful for knowledge representation tasks that cannot be expressed within current feature logics.The approach bridges the gap between concept languages (such as KL-ONE), which are the mainstay of knowledge representation languages in AI, and feature logics. Va¬ rious constraints on relational attributes are considered such as existential membership, universal membership, set descriptions, transitive relations and linear precedence con¬ straints.The specific contributions of this thesis can be summarised as follows: 1. Development of an integrated feature/concept logic 2. Development of a constraint logic for so called partial set descriptions 3. Development of a constraint logic for expressing linear precedence constraints 4. The design of a constraint language CL-ONE that incorporates the central ideas provided by the above study 5. A study of the application of CL-ONE for constraint based grammarsThe thesis takes into account current insights in the areas of constraint logic programming, object-oriented languages, computational linguistics and knowledge representation

Test Case Generation for Object-Oriented Imperative Languages in CLP

Testing is a vital part of the software development process. Test Case Generation (TCG) is the process of automatically generating a collection of test cases which are applied to a system under test. White-box TCG is usually performed by means of symbolic execution, i.e., instead of executing the program on normal values (e.g., numbers), the program is executed on symbolic values representing arbitrary values. When dealing with an object-oriented (OO) imperative language, symbolic execution becomes challenging as, among other things, it must be able to backtrack, complex heap-allocated data structures should be created during the TCG process and features like inheritance, virtual invocations and exceptions have to be taken into account. Due to its inherent symbolic execution mechanism, we pursue in this paper that Constraint Logic Programming (CLP) has a promising unexploited application field in TCG. We will support our claim by developing a fully CLP-based framework to TCG of an OO imperative language, and by assessing it on a corresponding implementation on a set of challenging Java programs. A unique characteristic of our approach is that it handles all language features using only CLP and without the need of developing specific constraint operators (e.g., to model the heap)