Constraint Logic Programming Framework Research Articles

BOWL: augmenting the Semantic Web with beliefs

As the Semantic Web is an open, complex and constantly evolving medium, it is the norm, but not exception that information at different sites is incomplete or inconsistent. This poses challenges for the engineering and development of agent systems on the Semantic Web, since autonomous software agents need to understand, process and aggregate this information. Ontology language OWL provides core language constructs to semantically markup resources on the Semantic Web, on which software agents interact and cooperate to accomplish complex tasks. However, as OWL was designed on top of (a subset of) classic predicate logic, it lacks the ability to reason about inconsistent or incomplete information. Belief-augmented Frames (BAF) is a frame-based logic system that associates with each frame a supporting and a refuting belief value. In this paper, we propose a new ontology language Belief-augmented OWL (BOWL) by integrating OWL DL and BAF to incorporate the notion of confidence. BOWL is paraconsistent, hence it can perform useful reasoning services in the presence of inconsistencies and incompleteness. We define the abstract syntax and semantics of BOWL by extending those of OWL. We have proposed reasoning algorithms for various reasoning tasks in the BOWL framework and we have implemented the algorithms using the constraint logic programming framework. One example in the sensor fusion domain is presented to demonstrate the application of BOWL.

A new approach for investigating protein flexibility based on Constraint Logic Programming. The first application in the case of the estrogen receptor

We describe the potential of a novel method, based on Constraint Logic Programming (CLP), developed for an exhaustive sampling of protein conformational space. The CLP framework proposed here has been tested and applied to the estrogen receptor, whose activity and function is strictly related to its intrinsic, and well known, dynamics. We have investigated in particular the flexibility of H12, focusing on the pathways followed by the helix when moving from one stable crystallographic conformation to the others. Millions of geometrically feasible conformations were generated, selected and the traces connecting the different forms were determined by using a shortest path algorithm. The preliminary analyses showed a marked agreement between the crystallographic agonist-like, antagonist-like and hypothetical apo forms, and the corresponding conformations identified by the CLP framework. These promising results, together with the short computational time required to perform the analyses, make this constraint-based approach a valuable tool for the study of protein folding prediction.The CLP framework enables one to consider various structural and energetic scenarious, without changing the core algorithm. To show the feasibility of the method, we intentionally choose a pure geometric setting, neglecting the energetic evaluation of the poses, in order to be independent from a specific force field and to provide the possibility of comparing different behaviours associated with various energy models.

Modelling Multicast QoS Routing by using Best-Tree Search in And-or Graphs and Soft Constraint Logic Programming

We suggest a formal model to represent and solve the multicast routing problem in multicast networks. To attain this, we model the network adapting it to a weighted and-or graph, where the weight on a connector corresponds to the cost of sending a packet on the network link modelled by that connector. Then, we use the Soft Constraint Logic Programming (SCLP) framework as a convenient declarative programming environment in which to specify related problems. In particular, we show how the semantics of an SCLP program computes the best tree in the corresponding and-or graph: this result can be adopted to find, from a given source node, the multicast distribution tree having minimum cost and reaching all the destination nodes of the multicast communication. The costs on the connectors can be described also as vectors (multi-dimensional costs), each component representing a different Quality of Service metric value. Therefore, the construction of the best tree may involve a set of criteria, all of which are to be optimized (multi-criteria problem), e.g. maximum global bandwidth and minimum delay that can be experienced on a single link.

Reasoning about Temporal Context using Ontology and Abductive Constraint Logic Programming

The underlying assumptions for interpreting the meaning of data often change over time, which further complicates the problem of semantic heterogeneities among autonomous data sources. As an extension to the Context Interchange (COIN) framework, this paper introduces the notion of temporal context as a formalization of the problem. We represent temporal context as a multi-valued method in F-Logic; however, only one value is valid at any point in time, the determination of which is constrained by temporal relations. This representation is then mapped to an abductive constraint logic programming framework with temporal relations being treated as constraints. A mediation engine that implements the framework automatically detects and reconciles semantic differences at different times. We articulate that this extended COIN framework is suitable for reasoning on the Semantic Web.

Knowledge Integration to Overcome Ontological Heterogeneity: Challenges from Financial Information Systems

The shift towards global networking brings with it many opportunities and challenges. In this paper, we discuss key technologies in achieving global semantic interoperability among heterogeneous information systems, including both traditional and web data sources. In particular, we focus on the importance of this capability and technologies we have designed to overcome ontological heterogeneity, a common type of disparity in financial information systems. Our approach to representing and reasoning with ontological heterogeneities in data sources is an extension of the Context Interchange (COIN) framework, a mediator-based approach for achieving semantic interoperability among heterogeneous sources and receivers. We also analyze the issue of ontological heterogeneity in the context of source-selection, and offer a declarative solution that combines symbolic solvers and mixed integer programming techniques in a constraint logic-programming framework. Finally, we discuss how these techniques can be coupled with emerging Semantic Web related technologies and standards such as Web-Services, DAML+OIL, and RuleML, to offer scalable solutions for global semantic interoperability. We believe that the synergy of database integration and Semantic Web research can make significant contributions to the financial knowledge integration problem, which has implications in financial services, and many other e-business tasks.

Soft Constraint Logic Programming and Generalized Shortest Path Problems

In this paper we study the relationship between Constraint Programming (CP) and Shortest Path (SP) problems. In particular, we show that classical, multicriteria, partially ordered, and modality-based SP problems can be naturally modeled and solved within the Soft Constraint Logic Programming (SCLP) framework, where logic programming is coupled with soft constraints. In this way we provide this large class of SP problems with a high-level and declarative linguistic support whose semantics takes care of both finding the cost of the shortest path(s) and also of actually finding the path(s). On the other hand, some efficient algorithms for certain classes of SP problems can be exploited to provide some classes of SCLP programs with an efficient way to compute their semantics.

Sets and constraint logic programming

In this paper we present a study of the problem of handling constraints made by conjunctions of positive and negative literals based on the predicate symbols =, ∈,∪ and || (i.e., disjointness of two sets) in a (hybrid) universe of finite sets . We also review and compare the main techniques considered to represent finite sets in the context of logic languages. The resulting contraint algorithms are embedded in a Constraint Logic Programming (CLP) language which provides finite sets—along with basic set-theoretic operations—as first-class objects of the language. The language—called CLP( SET )—is an instance of the general CLP framework, and as such it inherits all the general features and theoretical results of this scheme. We provide, through programming examples, a taste of the expressive power offered by programming in CLP( SET ).

ACLP: Abductive Constraint Logic Programming

This paper presents the framework of Abductive Constraint Logic Programming (ACLP), which integrates Abductive Logic Programming (ALP) and Constraint Logic Programming (CLP). In ACLP, the task of abduction is supported and enhanced by its non-trivial integration with constraint solving. This integration of constraint solving into abductive reasoning facilitates a general form of constructive abduction and enables the application of abduction to computationally demanding problems. The paper studies the formal declarative and operational semantics of the ACLP framework together with its application to various problems. The general characteristics of the computation of ACLP and of its application to problems are also discussed. Empirical results based on an implementation of the ACLP framework on top of the CLP language of ECLiPSe show that ACLP is computationally viable, with performance comparable to the underlying CLP framework on which it is built. In addition, our experiments show the natural ability for ACLP to accommodate easily and in a robust way new or changing requirements of the original problem. ACLP thus combines the advantages of modularity and flexibility of the high-level representation afforded by abduction together with the computational effectiveness of low-level specialised constraint solving.

CLP( χ) for automatically proving program properties

Various proof methods have been proposed to solve the implication problem, i.e. proving that properties of the form: ∀( P→ Q) – where P and Q denote conjunctions of atoms – are logical consequences of logic programs. Nonetheless, it is commonplace to say that it is still quite a difficult problem. Besides, the advent of the constraint logic programming scheme constitutes not only a major step towards the achievement of efficient declarative logic programming systems but also a new field to explore. By recasting and simplifying the implication problem in the constraint logic programming (CLP) framework, we define a generic proof method for the implication problem, which we prove sound from the algebraic point of view. We present four examples using CLP( N ), CLP( RT ), CLP( Σ ∗ ) and RISC-CLP( R ). The logical point of view of the constraint logic programming scheme enables the automation of the proof method. At last, we prove the unsolvability of the implication problem, we point out the origins of the incompleteness of the proposed proof method and we identify two classes of programs for which we give a decision procedure for the implication problem.

Constraint logic programming framework for integrated decision supports

Decision support systems provide decision-makers with an interactive environment for analyses of information with various models to help solve unstructured problems. Constraint logic programming as an improvement of logic programming can be used as a tool for the development of such decision support systems. Constraint logic programming is an integrated paradigm of logic modelling and mathematical programming. It has a modelling and analysis capacity for problems containing both qualitative and quantitative constraints; it has well-established declarative and procedural semantics, which reduce the model builder's burden to specify problem solving procedures as a part of a model. In this paper, we demonstrate the use of constraint logic programming as a potential decision support system tool, focusing on the model representation and analysis aspects.

Generalized semantics and abstract interpretation for constraint logic programs

We present simple and powerful generalized algebraic semantics for constraint logic programs that are parameterized with respect to the underlying constraint system. The idea is to abstract away from standard semantic objects by focusing on the general properties of any—possibly nonstandard—semantic definition. In constraint logic programming, this corresponds to a suitable definition of the constraint system supporting the semantic definition. An algebraic structure is introduced to formalize the notion of a constraint system, thus making classical mathematical results applicable. Both top-down and bottom-up semantics are considered. Nonstandard semantics for constraint logic programs can then be formally specified using the same techniques used to define standard semantics. Different nonstandard semantics for constraint logic languages can be specified in this framework. In particular, abstract interpretation of constraint logic programs can be viewed as an instance of the constraint logic programming framework itself.

Using Constraint Programming to Design an Option‐based Decision Support System

AbstractFinancial options and futures give investors the opportunity to form complex strategies that meet their investment objectives for risk management. However, this opportunity gives rise to a difficult task: finding a desired strategy from among a large number of possible strategies. This paper describes an intelligent decision‐support system for generating option‐based investment strategies by using constraint programming, which is an integrated framework of Artificial Intelligence and Logic Programming. In this system, constraint programming acts as a bridge between qualitative and quantitative analyses in decision processes. In qualitative analysis, logical reasoning with hypotheses is used to automatically create complex strategies through abstract matching with investors' profiles. Here, abstract matching can be regarded as symbolic computation for producing qualitatively reasonable strategies. In quantitative analysis, a set of complete solutions that satisfy user‐supplied constraints are obtained by constraint satisfaction and optimization. A constraint language based on the framework of Constraint Logic Programming has been developed in order to integrate these symbolic and numerical computations in a uniform way. The resulting system written in this language has the following features. (1) Unlike rule‐based expert systems, the constraint‐based system can create novel investment strategies. (2) A smooth transition from qualitative to quantitative analyses can be naturally achieved due to the constraint language. (3) Qualitative analysis can reduce search complexity, because the analysis focuses on a small set of qualitative distinctions in solution space. These features indicate the usefulness of constraint programming for designing intelligent decision‐support systems.

Heuristics and look-ahead integration to solve constraint satisfaction problems efficiently

Logic programming languages, such asProlog, allow a declarative specification of Constraint Satisfaction Problems (CSPs), freeing the user from specifying more or less complex control directives. However, the price to pay for such flexibility is a loss of efficiency, which makes Logic Programming inadequate to solve CSPs of even moderate size and complexity. To extend the range of applicability of logic programming, several improvements have been proposed. The use of heuristics is one such improvement. Although this usually forces the user to specify some form of control (thus abandoning the pure declarative nature of a logic program), these specifications can be made declarative by making use of some appropriate meta-predicates. Another extension to logic programming that improves its efficiency, is the active use of constraints, as done in the various formulations of constraint logic programming languages. In particular, the use of finite domains is quite adequate to implement look-ahead schemes to efficiently solve several types of CSPs. In this paper, we discuss the complementary nature of heuristics and look-ahead schemes and present a constraint logic programming framework that integrates both these techniques. Results obtained with a time-tabling problem executed on a prototype that implements such a framework are presented, and show that significant efficiency improvements can be achieved when compared with the separate use of the two techniques.

A constraint logic programming framework for constructing DNA restriction maps

Restriction mapping is an important computational problem in molecular biology, particularly in genetic engineering and DNA sequencing. It is different in that it is not only a purely computational problem but involves an interaction between experimental data collection procedures and the mapping algorithms. Consequently, the problem is loosely defined and in practice requires a flexible and versatile algorithm. We describe a framework for solving many restriction mapping problems in the constraint logic programming language CLP( R ) which takes advantage of the declarative and powerful features of constraint logic programming. A CLP( R ) algorithm is developed for solving a simple restriction mapping problem. The algorithm is the extended to handle more complex variations of restriction mapping such as fragments with erros, circular maps, multiple enzymes and partial digests. The mapping variants are integrated within the same framework and differ in the constraints required to define the kind of map consistency. Various search heuristics and control strategies to improve the search process are also incorporated as constraints.

Graph rewriting for a partial ordering semantics of concurrent constraint programming

The concurrent constraint logic programming framework extends both logic programming and concurrent logic programming in that a program consists of the concurrent execution of agents which add (i.e., “tell”) and check (i.e., “ask”) constraints on a shared set of variables, and whose behaviour is described by a set of clauses. This formulation is very general and can be seen as a concurrent logic programming shell which is parametrized w.r.t. the underlying constraint system. Graphs and graph grammars can be conveniently used to describe such a framework, and the modelling is so elegant and expressive that they provide what we believe is the most natural abstract machine for concurrent constraint programming. In fact, basic notions like the possibility of asking or telling a constraint into the shared store are very easy to express in the algebraic approach to graph rewriting. More precisely, the shared store is represented as a (hyper)graph, where nodes are variables and arcs are constraints or agents. Then, both the entailment relation of the underlying constraint system and the local behaviour of agents is expressed by suitable sets of graph productions, which transform the current global state of the system into a new one. Finally, each computation is represented by a graph derivation. In our setting the shared store is not seen as one constraint, but as a set of constraints which possibly share variables. This is in contrast with all the operational and denotational semantics already proposed for the concurrent constraint paradigm, which treat the shared store as a monolith and, thus, are not useful for deriving any information about the causal dependencies among the agents or the maximal degree of parallelism. On the contrary, our approach can easily express such information in the form of a partial ordering associated to each graph derivation. This can be regarded as the first attempt to give a true-concurrency semantics to concurrent constraint programming and, more generally, to graph grammars.