Interface timing verification with delay correlation using constraint logic programming

Handbook of Constraint Programming

The Constraint Satisfaction Problem (CSP) formalization has been a productive tool within Artificial Intelligence and related areas. The Finite CSP (FCSP) framework is presented here as a restricted logical calculus within a space of logical representation and reasoning systems. FCSP is formulated in a variety of logical settings: theorem proving in first order predicate calculus, propositional theorem proving (and hence SAT), the Prolog and Datalog approaches, constraint network algorithms, a logical interpreter for networks of constraints, the Constraint Logic Programming (CLP) paradigm and propositional model finding (and hence SAT, again). Several standard, and some not-so-standard, logical methods can therefore be used to solve these problems. By doing this we obtain a specification of the semantics of the common approaches. This synthetic treatment also allows algorithms and results from these disparate areas to be imported, and specialized, to FCSP; the special properties of FCSP are exploited to achieve, for example, completeness and to improve efficiency. It also allows export to the related areas. By casting CSP both as a generalization of FCSP and as a specialization of CLP it is observed that some, but not all, FCSP techniques lift to CSP and, perhaps, thereby to CLP. Various new connections are uncovered, in particular between the proof-finding approaches and the alternative model-finding approaches that have arisen in depiction and diagnosis applications.

Using artificial neural networks for constraint satisfaction problem

In object-oriented representation, inheritance determines the attributes of a given object, given its type. Conversely, recognition determines the type of an object, given its attributes. The author addresses the more general problem of recognition from constraints; arguing that it can be seen as a special case of the classical abduction process and that it can be implemented as an abduction operation on constraints. Abductive reasoning is common in most fields of artificial intelligence. Constraint logic programming (CLP) generalizes logic programming by replacing unification with constraint solving. He first explores the relationship between abduction and CLP and shows that CLP is a special case of abduction. A class of problems is then identified for which the usual unrestricted forms of abduction are unsuitable. Within the CLP framework a restricted form of abduction is formulated which is applicable to the whole class of problems, in which object-oriented recognition can be considered as a special case. >

In our previous work we elaborated a multifrequency test generation method (TPG) for detecting parametric and catastrophic faults in linear analog circuits. The method was formulated as an optimization problem which was solved by Sequential Quadratic Programming (SQP), a non-linear programming method available in MATLAB. Such standard optimization methods are based on and process local information and consequently cannot guarantee a global optimum. In this paper we propose a method based on Constraint Logic Programming (CLP) that solves the optimization problem in TPG as a series of Constraint Satisfaction Problems (CSPs). Our TPG method is fully automatic and provides right and guaranteed bounds on the global optima of a nonlinear function. The TPG method was implemented in CLP(BNR) Prolog. First, we illustrate the effectiveness of our approach on a number of nonlinear functions known to be difficult, and then we apply it to a realistic electronic circuit in the context of TPG. The two methods produce the same results except for one case where SQP falls into a local minimum. This could lead to a wrong test selection. Moreover, while the TPG took over a week of work using SQP, it was solved in a matter of minutes using CLP.

In recent years, several constraintdbased temporal reasoning frameworks have been proposed. They consider temporal points or intervals as domain elements linked by temporal constraints. Temporal reasoning in these systems is based on constraint propagation. In this paper, we argue that a language based on constraint propagation can be a suitable tool for expressing and reasoning about temporal problems. We concentrate on Constraint Logic Programming (CLP) which is a powerful programming paradigm combining the advantages of Logic Programming and the efficiency of constraint solving. However, CLP presents some limitations in dealing with temporal reasoning. First, it uses an “arc consistency” propagation algorithm which is embedded in the inference engine, cannot be changed by the user, and is too weak in many temporal frameworks. Second, CLP is not able to deal with qualitative temporal constraints. We present a general meta CLP architecture which maintains the advantages of CLP, but overcomes these two main limitations. Each architectural level is a finite domain constraint solver (CLP(FD)) that reasons about constraints of the underlying level. Based on this conceptual architecture, we extend the CLP(FD) language and we specialize the extension proposed on Vilain and Kautz’s Point Algebra, on Allen’s Interval Algebra and on the STP framework by Dechter, Meiri and Pearl. In particular, we show that we can cope effectively with disjunctive constraints even in an intervaldbased framework.

Timed CSP extends CSP by introducing a capability to quantify temporal aspects of sequencing and synchronization. It is a powerful language to model real time reactive systems. However, there is no verification tool support for proving critical properties over systems modelled using Timed CSP. In this work, we construct a reasoning method using Constraint Logic Programming (CLP) as an underlying reasoning mechanism for Timed CSP. We start with encoding the semantics of Timed CSP in CLP, which allows a systematic translation of Timed CSP to CLP. Powerful constraint solver like CLP($\mathcal{R}$) is then used to prove traditional safety properties and beyond, e.g., reachability, deadlock-freeness, timewise refinement relationship, lower or upper bound of a time interval, etc. Counter-examples are generated when properties are not satisfied. Moreover, our method also handles useful extensions to Timed CSP. Finally, we demonstrate the effectiveness of our approach through case study of standard real time systems.

Constraint Logic Programming (CLP) is a language scheme for combining two declarative paradigms: constraint solving and logic programming. Concurrent Constraint Programming (CCP) is a declarative model for concurrency where agents interact by telling and asking constraints in a shared store. In a previous paper, we developed a framework for dynamic slicing of CCP where the user first identifies that a (partial) computation is wrong. Then, she marks (selects) some parts of the final state corresponding to the data (constraints) and processes that she wants to study more deeply. An automatic process of slicing begins, and the partial computation is “depurated” by removing irrelevant information. In this paper we give two major contributions. First, we extend the framework to CLP, thus generalizing the previous work. Second, we provide an assertion language suitable for both, CCP and CLP, which allows the user to specify some properties of the computations in her program. If a state in a computation does not satisfy an assertion then some “wrong” information is identified and an automatic slicing process can start. We thus make one step further towards automatizing the slicing process. We show that our framework can be integrated with the previous semi-automatic one, giving the user more choices and flexibility. We show by means of examples and experiments the usefulness of our approach.

Constraint logic programming (CLP) has demonstrated its ability to handle difficult problems coming from operation research. We think that this approach is relevant to perform program analyses too. However, program analysis often requires solvers for second order constraints, i.e. mainly fixpoint equations, that are not available in CLP languages. In this paper, we present, the language Toupie that is designed to solve such constraints. Toupie uses an extension of Bryant's binary decision diagrams to encode relations which makes it possible to handle relations with huge numbers of elements.

We present a CLP(FD)-based constraint solver able to deal with unbounded domains. It is based on constraint propagation, resorting to enumeration if all other methods fail. An important aspect is detecting when enumeration was complete and if this has an impact on the soundness of the result. We present a technique which guarantees soundness in the following way: if the constraint solver finds a solution it is guaranteed to be correct; if the constraint solver fails to find a solution it can either return the result "definitely false" in case it knows enumeration was exhaustive, or "unknown" in case it was aborted. The technique can deal with nested universal and existential quantifiers. It can easily be extended to set comprehensions and other operators introducing new quantified variables. We show applications in data validation and proof.

Most universities in Belgium do research in AI and offer AI courses to students. The largest part of the research is into the more classical AI subjects, such as logic programming and theorem proving. However, sub-symbolic AI is also investigated. It seems that all Belgian Universities have their own distinct flavour of research. Below, we present the different Belgian universities in alphabetical order. The Facultes Universitaires Notre Dame de la Paix Namur (University of Namur) has a group called ‘semantics and computational logic’ led by B. Le Charlier and P. Schobbens. This group is theoretically oriented and although their interests are broader than just AI, some of their research is into computational logic, automated theorem proving and formalisation of agentbased systems. The Katholieke Universiteit Leuven (Flemish catholic university of Leuven) has different groups working on artificial-intelligence subjects. First of all, there is the group on declarative languages and artificial intelligence led by M. Bruynooghe. The artificialintelligence interest of this group is into knowledge representation and machine learning, with research themes such as data mining, constraint logic programming, reasoning with time, natural-language processing and learning in agents. They are also involved in the Robocup simulation league. Second, there is a group doing research into intelligent mobile robots led by H. Van Brussel and J. De Schutter. This group is part of the mechanical engineering department. Finally, there is a group at the economy department, led by J. Vanthienen and M. Verhelst, that investigates knowledge systems and modelling. At the Limburgs Universitair Centrum (Limburg University Centre) M. Gyssens of the theoretical computer science group works on the structure and complexity of constraint satisfaction problems. J. Van den Bussche of the same group works on implementation of query languages for data mining. The Universite Catholique de Louvain (French catholic university of Louvain) has several small groups investigating different AI subjects. Computational linguistics is investigated by E. Milgrom and S. Granger. Logic programming is investigated by Y. Deville. A. Thayse investigates natural-language processing, P.J. Courtois investigates self-organising systems, P. Van Hentenryck works on optimisation and constraint satisfaction and Y. Kamp investigates collective intelligence. The Universite de Liege (Montefiore) (University of Liege) has D. Gribomont working on verification methods, automatic theorem proving and formal logic. The Universitaire Instelling Antwerpen (University of Antwerp) has the centre for Dutch language and speech, led by W. Daelemans. Part of the research of this institute is purely linguistic, but a great deal of research is also performed into (memory-based) machine learning of natural language, using large corpora of text, as well as into intelligent processing of text. The Universit Libre de Bruxelles (French Free University of Brussels) has the IRIDIA (Institut de Recherches Interdisciplinaires et de Developpements en Intelligence Artificielle) group led by M. Dorigo and H. Bersini. The main research interests are: ‘belief representation and AI-techniques for process control and classification’ and ‘nature-inspired heuristics for the solution of combinatorial and continuous space optimisation problems’. Sub-symbolic techniques are

Constraint Logic Programming (CLP) languages extend logic programming by allowing the use of constraints from different domains such as real numbers or Boolean functions. They have proved to be ideal for expressing problems that require interactive mathematical modeling and complex combinatorial optimization problems. However, CLP languages have mainly been considered as research systems, useful for rapid prototyping, by not really competitive with more conventional programming languages where efficiency is a more important consideration. One promising approach to improving the performance of CLP systems is the use of powerful program optimizations to reduce the cost of constraint solving. We extend work in this area by describing a new optimizing compiler for the CLP language CLP(ℛ). The compiler implements six powerful optimizations: reordering of constraints, removal of redundant variables, and specialization of constraints which cannot fail. Each program optimization is designed to remove the overhead of constraint solving when possible and keep the number of constraints in the store as small as possible. We systematically evaluate the effectiveness of each optimization in isolation and in combination. Our empirical evaluation of the compiler verifies that optimizing compilation can be made efficient enough to allow compilation of real-world programs and that it is worth performing such compilation because it gives significant time and space performance improvements.

The job of the constraint programmer is to use mathematical constraints to model real world constraints and objects. In this book, Kim Marriott and Peter Stuckey provide the first comprehensive introduction to the discipline of constraint programming and, in particular, constraint logic programming. The book covers the necessary background material from artificial intelligence, logic programming, operations research, and mathematical programming. Topics discussed range from constraint-solving techniques to programming methodologies for constraint programming languages. Because there is not yet a universally used syntax for constraint logic programming languages, the authors present the programs in a way that is independent of any existing programming language. Practical exercises cover how to use the book with a number of existing constraint languages.

Recently a logic programming language AC was proposed by Mellarkod et al. (2008) to integrate answer set programming (ASP) and constraint logic programming. Similarly, Gebser et al. (2009) proposed a CLINGCON language integrating ASP and finite domain constraints. These languages allow new efficient inference algorithms that combine traditional ASP procedures and other methods in constraint programming. In this paper we show that a transition system introduced by Nieuwenhuis et al. (2006) to model SAT solvers can be extended to model the "hybrid" Acsolver algorithm by Mellarkod et al. developed for simple AC programs and the Clingcon algorithm by Gebser et al. for clingcon programs. We define weakly-simple programs and show how the introduced transition systems generalize the Acsolver and Clingcon algorithms to such programs. Finally, we state the precise relation between AC and CLINGCON languages and the Acsolver and Clingcon algorithms.

We extend the Constraint Logic Programming (CLP) formalism in order to handle semiring-based constraints. This allows us to perform in the same language both constraint solving and optimization. In fact, constraints based on semirings are able to model both classical constraint solving and more sophisticated features like uncertainty, probability, fuzziness, and optimization. We then provide this class of languages with three equivalent semantics: model-theoretic, fix-point, and proof-theoretic, in the style of classical CLP programs.