127 research outputs found
Constraint compiling into rules formalism constraint compiling into rules formalism for dynamic CSPs computing
14 pagesIn this paper we present a rule based formalism for filtering variables domains of constraints. This formalism is well adapted for solving dynamic CSP. We take diagnosis as an instance problem to illustrate the use of these rules. A diagnosis problem is seen like finding all the minimal sets of constraints to be relaxed in the constraint network that models the device to be diagnose
Towards declarative diagnosis of constraint programs over finite domains
The paper proposes a theoretical approach of the debugging of constraint
programs based on a notion of explanation tree. The proposed approach is an
attempt to adapt algorithmic debugging to constraint programming. In this
theoretical framework for domain reduction, explanations are proof trees
explaining value removals. These proof trees are defined by inductive
definitions which express the removals of values as consequences of other value
removals. Explanations may be considered as the essence of constraint
programming. They are a declarative view of the computation trace. The
diagnosis consists in locating an error in an explanation rooted by a symptom.Comment: In M. Ronsse, K. De Bosschere (eds), proceedings of the Fifth
International Workshop on Automated Debugging (AADEBUG 2003), September 2003,
Ghent. cs.SE/030902
COLAB : a hybrid knowledge representation and compilation laboratory
Knowledge bases for real-world domains such as mechanical engineering require expressive and efficient representation and processing tools. We pursue a declarative-compilative approach to knowledge engineering. While Horn logic (as implemented in PROLOG) is well-suited for representing relational clauses, other kinds of declarative knowledge call for hybrid extensions: functional dependencies and higher-order knowledge should be modeled directly. Forward (bottom-up) reasoning should be integrated with backward (top-down) reasoning. Constraint propagation should be used wherever possible instead of search-intensive resolution. Taxonomic knowledge should be classified into an intuitive subsumption hierarchy. Our LISP-based tools provide direct translators of these declarative representations into abstract machines such as an extended Warren Abstract Machine (WAM) and specialized inference engines that are interfaced to each other. More importantly, we provide source-to-source transformers between various knowledge types, both for user convenience and machine efficiency. These formalisms with their translators and transformers have been developed as part of COLAB, a compilation laboratory for studying what we call, respectively, "vertical\u27; and "horizontal\u27; compilation of knowledge, as well as for exploring the synergetic collaboration of the knowledge representation formalisms. A case study in the realm of mechanical engineering has been an important driving force behind the development of COLAB. It will be used as the source of examples throughout the paper when discussing the enhanced formalisms, the hybrid representation architecture, and the compilers
Applying constraint solving to the management of distributed applications
Submitted to DOA08We present our approach for deploying and managing distributed component-based applications. A Desired State Description (DSD), written in a high-level declarative language, specifies requirements for a distributed application. Our infrastructure accepts a DSD as input, and from it automatically configures and deploys the distributed application. Subsequent violations of the original requirements are detected and, where possible, automatically rectified by reconfiguration and redeployment of the necessary application components. A constraint solving tool is used to plan deployments that meet the application requirements.Postprin
Constraint-based specifications for system configuration
Declarative, object-oriented configuration management systems are widely used, and
there is a desire to extend such systems with automated analysis and decision-making.
This thesis introduces a new formulation for configuration management problems based
on the tools and techniques of constraint programming, which enables automated
decision-making.
We present ConfSolve, an object-oriented declarative configuration language, in
which logical constraints on a system can be specified. Verification, impact analysis,
and the generation of valid configurations can then be performed. This is achieved via
translation to the MiniZinc constraint programming language, which is in turn solved
via the Gecode constraint solver. We formally define the syntax, type system, and
semantics of ConfSolve, in order to provide it with a rigorous foundation. Additionally
we show that our implementation outperforms previous work, which utilised an SMT
solver, while adding new features such as optimisation.
We next develop an extension of the ConfSolve language, which facilitates not
only one-off configuration tasks, but also subsequent re-configurations in which the
previous state of the system is taken into account. In a practical setting one does not
wish for a re-configuration to deviate too far from the existing state, unless the benefits
are substantial. Re-configuration is of crucial importance if automated configuration
systems are to gain industry adoption. We present a novel approach to incorporating
state-change into ConfSolve while remaining declarative and providing acceptable
performance
Computing explanations for interactive constraint-based systems
Constraint programming has emerged as a successful paradigm for modelling
combinatorial problems arising from practical situations. In many of those situations,
we are not provided with an immutable set of constraints. Instead, a user
will modify his requirements, in an interactive fashion, until he is satisfied with
a solution. Examples of such applications include, amongst others, model-based
diagnosis, expert systems, product configurators.
The system he interacts with must be able to assist him by showing the consequences
of his requirements. Explanations are the ideal tool for providing this
assistance. However, existing notions of explanations fail to provide sufficient information.
We define new forms of explanations that aim to be more informative.
Even if explanation generation is a very hard task, in the applications we consider,
we must manage to provide a satisfactory level of interactivity and, therefore, we
cannot afford long computational times.
We introduce the concept of representative sets of relaxations, a compact set of
relaxations that shows the user at least one way to satisfy each of his requirements
and at least one way to relax them, and present an algorithm that efficiently computes
such sets. We introduce the concept of most soluble relaxations, maximising
the number of products they allow. We present algorithms to compute such relaxations
in times compatible with interactivity, achieving this by indifferently making
use of different types of compiled representations. We propose to generalise
the concept of prime implicates to constraint problems with the concept of domain
consequences, and suggest to generate them as a compilation strategy. This sets a
new approach in compilation, and allows to address explanation-related queries in
an efficient way. We define ordered automata to compactly represent large sets of
domain consequences, in an orthogonal way from existing compilation techniques
that represent large sets of solutions
Temporal Constraint Satisfaction Problems and Difference Decision Diagrams: A Compilation Map
International audienceThe frameworks dedicated to the representation of quantitative temporal constraint satisfaction problems, as rich as they are in terms of expressiveness, define difficult requests - typically NP-complete decision problems. It is therefore adventurous to use them for an online resolution. Hence the idea to compile the original problem into a form that could be easily solved. Difference Decision Diagrams (DDDs) have been proposed by [1] as a possible way to cope with this difficulty, following a compilation-based approach. In this article, we draw a compilation map that evaluates the relative capabilities of these languages (TCSP, STP, DTP and DDD) in terms of algorithmic efficiency, succinctness and expressiveness
- âŠ