Constraint Logic Programming Language Research Articles

Fuzzy order-sorted feature logic

Order-Sorted Feature (OSF) logic is a knowledge representation and reasoning language based on function-denoting feature symbols and set-denoting sort symbols ordered in a subsumption lattice. OSF logic allows the construction of record-like terms that represent classes of entities and that are themselves ordered in a subsumption relation. The unification algorithm for such structures provides an efficient calculus of type subsumption, which has been applied in computational linguistics and implemented in constraint logic programming languages such as LOGIN and LIFE and automated reasoners such as CEDAR. This work generalizes OSF logic to a fuzzy setting. We give a flexible definition of a fuzzy subsumption relation which generalizes Zadeh's inclusion between fuzzy sets. Based on this definition we define a fuzzy semantics of OSF logic where sort symbols and OSF terms denote fuzzy sets. We extend the subsumption relation to OSF terms and prove that it constitutes a fuzzy partial order with the property that two OSF terms are subsumed by one another in the crisp sense if and only if their subsumption degree is greater than 0. We show how to find the greatest lower bound of two OSF terms by unifying them and how to compute the subsumption degree between two OSF terms, and we provide the complexity of these operations.

An Automatically Verified Prototype of the Android Permissions System

In a previous work we presented formal specifications of idealized formulations of the permission model of Android in the Coq proof assistant. This formal development is about 23 KLOC of Coq code, including proofs. In this work the Coq model is encoded in $$\{log\}$$ (‘setlog’)—a satisfiability solver and a constraint logic programming language— which is then used to automatically discharge most of the proofs performed in Coq. We show how the Coq model is encoded in $$\{log\}$$ and how automated proofs are performed. The resulting $$\{log\}$$ model is an automatically verified executable prototype of the Android permissions system. Detailed data on the empirical evaluation resulting after executing all the proofs in $$\{log\}$$ is provided. The integration of Coq and $$\{log\}$$ as to provide a framework featuring automated proof and prototype generation is discussed.

Declarative Programming with Intensional Sets in Java Using JSetL

Abstract Intensional sets are sets given by a property rather than by enumerating their elements. In a previous work, we have proposed a decision procedure for a first-order logic language which provides restricted intensional sets (RISs), i.e. a sub-class of intensional sets that are guaranteed to denote finite—though unbounded—sets. In this paper, we show how RIS can be exploited as a convenient programming tool also in a conventional setting, namely the imperative O-O language Java. We do this by considering a Java library, called JSetL, that integrates the notions of logical variable, (set) unification and constraints that are typical of constraint logic programming languages into the Java language. We show how JSetL is naturally extended to accommodate for RIS and RIS constraints and how this extension can be exploited; on the one hand, to support a more declarative style of programming and, on the other hand, to effectively enhance the expressive power of the constraint language provided by the library.

Application of CLP for technical objects construction with an exemplary bucket elevation

The paper presents the application of the Constraint Logic Programming (CLP) language for designing technical objects. The method was described and illustrated based with the help of on the bucket elevator design. The hierarchical structure of the object, way of system configuration and exemplary sets of fitted components are presented.

Kripke semantics for higher-order type theory applied to constraint logic programming languages

We define a Kripke semantics for Intuitionistic Higher-Order Logic with constraints formulated within Church's Theory of Types via the addition of a new constraint base type. We then define an executable fragment, hoHH(C), of the logic: a higher-order logic programming language with typed λ-abstraction, implication and universal quantification in goals and constraints, and give a modified model theory for this fragment. Both formal systems are shown sound and complete for their respective semantics.We also solve the impredicativity problem in λProlog semantics, namely how to give a definition of truth without appealing to induction on subformula structure. In the last section we give a simple semantics-based conservative extension proof that the language hoHH(C) satisfies a uniformity property along the lines of [39].

A new probabilistic constraint logic programming language based on a generalised distribution semantics

Probabilistic logics combine the expressive power of logic with the ability to reason with uncertainty. Several probabilistic logic languages have been proposed in the past, each of them with their own features. We focus on a class of probabilistic logic based on Sato's distribution semantics, which extends logic programming with probability distributions on binary random variables and guarantees a unique probability distribution. For many applications binary random variables are, however, not sufficient and one requires random variables with arbitrary ranges, e.g. real numbers. We tackle this problem by developing a generalised distribution semantics for a new probabilistic constraint logic programming language. In order to perform exact inference, imprecise probabilities are taken as a starting point, i.e. we deal with sets of probability distributions rather than a single one. It is shown that given any continuous distribution, conditional probabilities of events can be approximated arbitrarily close to the true probability. Furthermore, for this setting an inference algorithm that is a generalisation of weighted model counting is developed, making use of SMT solvers. We show that inference has similar complexity properties as precise probabilistic inference, unlike most imprecise methods for which inference is more complex. We also experimentally confirm that our algorithm is able to exploit local structure, such as determinism, which further reduces the computational complexity.

Adding partial functions to Constraint Logic Programming with sets

AbstractPartial functions are common abstractions in formal specification notations such as Z, B and Alloy. Conversely, executable programming languages usually provide little or no support for them. In this paper we propose to add partial functions as a primitive feature to a Constraint Logic Programming (CLP) language, namely {log}. Although partial functions could be programmed on top of {log}, providing them as first-class citizens adds valuable flexibility and generality to the form of set-theoretic formulas that the language can safely deal with. In particular, the paper shows how the {log} constraint solver is naturally extended in order to accommodate for the new primitive constraints dealing with partial functions. Efficiency of the new version is empirically assessed by running a number of non-trivial set-theoretical goals involving partial functions, obtained from specifications written in Z.

Keynote III

Ruli Manurung is a full-time faculty member at the Faculty of Computer Science, Universitas Indonesia, where he currently serves as the Coordinator for the various computer science study programs. His research interests vary between natural language processing, computational creativity, artificial intelligence, evolutionary computation, and machine learning. He has co-authored more than 80 peer-reviewed journal papers, book chapters, and conference papers, winning Best Paper awards at several international conferences. He has also held 11 research grants, both international and national in scope. He obtained his Ph.D from the University of Edinburgh in 2004 for his work on the automatic generation of poetry. From 2003 to 2006 he was a Research Fellow at the University of Edinburgh on an EPSRC research project that concerned the development of an innovative system that provided language-impaired children with the ability to tell novel jokes. He will gives talk about experience working on poetry generation, an exciting and challenging instance of computational linguistic creativity. Poetry generation is an extremely difficult problem that requires intelligence, world and linguistic knowledge, and creativity. Many different AI methods have been applied to this problem, ranging from evolutionary algorithms, constraint logic programming, case-based reasoning, and natural language generation. He will first introduce a model of poetry generation as a state space search problem, where a goal state is a text that satisfies the three properties of meaningfulness, grammaticality, and poeticness. Such a model requires a rich representation of various linguistic aspects, such as phonetics, morphology, syntax, and semantics, and an architecture that allows a system to simultaneously reason with all of these aspects and how they interact with each other. Several research works will be presented that have focused on different aspects, namely metre, rhyme, semantics, and topicality. Sample output will be presented, as well as the results of some Turing Test-style evaluations.

Probabilistic spatio-temporal retrieval in smart spaces

A ‘smart space’ is one that automatically identifies and tracks its occupants using unobtrusive biometric modalities such as face, gait, and voice in an unconstrained fashion. Information retrieval in a smart space is concerned with the location and movement of people over time. Towards this end, we abstract a smart space by a probabilistic state transition system in which each state records the probabilities of presence of individuals in various zones of the smart space. We carry out track-based reasoning on the states in order to determine more accurately the occupants of the smart space. This leads to a data model based upon an occupancy relation in which time is treated discretely, owing to the discrete nature of events, but probability is treated as a real-valued attribute. Using this data model, we show how to formulate a number of spatio-temporal queries, focusing on the computation of probabilities, an aspect that is novel to this model. We present queries both in SQL syntax and also in CLP(R), a constraint logic programming language (with reals) which facilitates succinct formulation of recursive queries. We show that the answers to certain queries are better displayed in a graphical manner, especially the movement tracks of occupants of the smart space. We also define query-dependent precision and recall metrics in order to quantify how well the model is able to answer various spatio-temporal queries. We show that a query-dependent metric gives significantly better results for a class of occupancy-related queries compared with query-independent metrics.

An extended constraint deductive database: Theory and implementation

The scheme of Hereditary Harrop formulas with constraints, HH(C), has been proposed as a basis for constraint logic programming languages. In the same way that Datalog emerges from logic programming as a deductive database language, such formulas can support a very expressive framework for constraint deductive databases, allowing hypothetical queries and universal quantifications. As negation is needed in the database field, HH(C) is extended with negation to get HH¬(C). This work presents the theoretical foundations of HH¬(C) and an implementation that shows the viability and expressive power of the proposal. Moreover, the language is designed in a flexible way in order to support different constraint domains. The implementation includes several domain instances, and it also supports aggregates as usual in database languages. The formal semantics of the language is defined by a proof-theoretic calculus, and for the operational mechanism we use a stratified fixpoint semantics, which is proved to be sound and complete w.r.t. the former. Hypothetical queries and aggregates require a more involved stratification than the common one used in Datalog. The resulting fixpoint semantics constitutes a suitable foundation for the system implementation.

Programming with partially specified aggregates in Java

Various forms of data aggregates, e.g., arrays, lists, sets, etc., are usually provided by programming languages, either as primitive entities or as additional features made available by standard libraries. In conventional programming languages these data structures are usually specified by completely and precisely enumerating all their constituent elements. Conversely, in (constraint) logic programming languages it is common to deal with partially specified aggregates where either some elements or some parts of the aggregate are left unknown. In this paper we consider the case where partially specified aggregates can occur in a conventional O-O programming language. Specifically, we consider partially specified lists and sets as provided by the Java library JSetL. The definition of such data structures is strongly based on the notion of logical (or constrained) variable usually provided by languages and libraries to support constraint programming. We show through simple examples using Java and JSetL how partially specified lists and sets, along with a few basic constraints over them, can be conveniently exploited in a number of common programming problems.

Logic-algebraic method based and constraints programming driven approach to AGVs scheduling

The subject matter of the study is the automated guided vehicle (AGV) operation synchronisation mechanisms in flexible manufacturing systems. The processes examination has to guarantee the collision-free and deadlock-free AGVs flow. The problem of determination of the rules coordinating access of the vehicles to the shared travel route intervals, ensuring the collision-free and deadlock-free execution of the repetitive processes was reduced to determination of the sufficient conditions of the form of a pair (initial state, a set of priority rules). In particular the problem of searching for a pair is defined in the form of the constraint satisfaction problem (CSP) and is solved with use of the logic programming techniques. The inference engine applied in the LAM is then easily implemented in a kind of constraint logic programming language. Proposed approach provides the framework allowing one to take into account both distinct, and imprecise data, in a unified way.

Checking modes of HAL programs

Recent constraint logic programming (CLP) languages, such as HAL and Mercury, require type, mode and determinism declarations for predicates. This information allows the generation of efficient target code and the detection of many errors at compile-time. Unfortunately, mode checking in such languages is difficult. One of the main reasons is that, for each predicate mode declaration, the compiler is required to appropriately re-order literals in the predicate's definition. The task is further complicated by the need to handle complex instantiations (which interact with type declarations and higher-order predicates) and automatic initialization of solver variables. Here we define mode checking for strongly typed CLP languages which require reordering of clause body literals. In addition, we show how to handle a simple case of polymorphic modes by using the corresponding polymorphic types.

Dealing with incomplete knowledge on CLP( FD ) variable domains

Constraint Logic Programming languages on Finite Domains, CLP( FD ), provide a declarative framework for Artificial Intelligence problems. However, in many real life cases, domains are not known and must be acquired or computed. In systems that interact with the outer world, domain elements synthesize information on the environment, they are not all known at the beginning of the computation, and must be retrieved through an expensive acquisition process.In this article, we extend the CLP( FD ) language by combining it with a new sort (called Incrementally specified Sets, I-Set ). In the resulting language, CLP( FD + I-Set ), FD variables can be defined on partially or fully unknown domains ( I-Set ). Domains can be linked each other through relations, and constraints can be imposed on them. We describe a propagation algorithm (called Known Arc Consistency (KAC)) based on known domain elements, and theoretically compare it with arc-consistency.The language can be implemented on top of different CLP systems, thus letting the user exploit different possible semantics for domains (e.g., lists, sets or streams). We state the specifications that the employed system should provide, and we show that two different CLP systems (Conjunto and { log }) can be effectively used.We provide motivating examples and describe promising applications.

On proving left termination of constraint logic programs

The Constraint Logic Programming (CLP) Scheme merges logic programming with constraint solving over predefined domains. In this article, we study proof methods for universal left termination of constraint logic programs. We provide a sound and complete characterization of left termination for ideal CLP languages which generalizes acceptability of logic programs. The characterization is then refined to the notion of partial acceptability , which is well suited for automatic modular inference. We describe a theoretical framework for automation of the approach, which is implemented. For nonideal CLP languages and without any assumption on their incomplete constraint solvers, even the most basic sound termination criterion from logic programming does not lift. We focus on a specific system, namely CLP(R), by proposing some additional conditions that make (partial) acceptability sound.

Efficient Interval Linear Equality Solving in Constraint Logic Programming

Existing interval constraint logic programming languages, such as BNR Prolog, work under the framework of interval narrowing and are deficient in solving systems of linear constraints over real numbers, which constitute an important class of problems in engineering and other applications. In this paper, we suggest to separate linear equality constraint solving from inequality and non-linear constraint solving. The implementation of an efficient interval linear constraint solver, which is based on the preconditioned interval Gauss-Seidel method, is proposed. We show how the solver can be adapted to incremental execution and incorporated into a constraint logic programming language already equipped with a non-linear solver based on interval narrowing. The two solvers share common interval variables, interact and cooperate in a round-robin fashion during computation, resulting in an efficient interval constraint arithmetic language CIAL. The CIAL prototypes, based on CLP(R), are constructed and compared favorably against several major interval constraint logic programming languages.

Solving constraint optimization problems from CLP-style specifications using heuristic search techniques

Presents a framework for efficiently solving logic formulations of combinatorial optimization problems using heuristic search techniques. In order to integrate cost, lower-bound and upper-bound specifications with conventional logic programming languages, we augment a constraint logic programming (CLP) language with embedded constructs for specifying the cost function and with a few higher-order predicates for specifying the lower and upper bound functions. We illustrate how this simple extension vastly enhances the ease with which optimization problems involving combinations of Min and Max can be specified in the extended language CLP* and we show that CSLDNF (Constraint SLD resolution with Negation as Failure) resolution schemes are not efficient for solving optimization problems specified in this language. Therefore, we describe how any problem specified using CLP* can be converted into an implicit AND/OR graph, and present an algorithm called GenSolve which can branch-and-bound using upper and lower bound estimates, thus exploiting the full pruning power of heuristic search techniques. A technical analysis of GenSolve is provided. We also provide experimental results comparing various control strategies for solving CLP* programs.

Constructive negation and constraint logic programming with sets

The aim of this paper is to extend theConstructive Negation technique to the case ofCLP(SeT), a Constraint Logic Programming (CLP) language based on hereditarily (and hybrid) finite sets. The challenging aspects of the problem originate from the fact that the structure on whichCLP(SeT) is based is notadmissible closed, and this does not allow to reuse the results presented in the literature concerning the relationships betweenCLP and constructive negation.

On the Number of Rule Applications in Constraint Programs

We predict the maximal number of rule applications, i.e. worst-case derivation lengths of computations, in rule-based constraint solver programs written in the CHR language. CHR are a committed-choice concurrent constraint logic programming language consisting of multi-headed guarded rules. The derivation lengths are derived from rankings used in termination proofs for the respective programs. We are especially interested in rankings that give us a good upper bound, we call such rankings tight. Based on test-runs with randomized data, we compare our predictions with empirical results by considering constraint solvers ranging from Boolean and terminological constraints to arc-consistency and path-consistency.

A Constraint Based Structure Description Language for Biosequences

We report an investigation into how constraint solving techniques can be used to search for patterns in sequences (or strings) of symbols over a finite alphabet. We define a constraint-based structure description language for biosequences, and give the definition of an algorithm to solve the structure searching problem as a CSP. The methodology which we have developed is able to describe two-dimensional structure of biosequences, such as tandem repeats, stem loops, palindromes and pseudo-knots. We also report on an implementation of the language in the constraint logic programming language clp(FD), with test results of a simple searching algorithm, and results from a preliminary implementation in C++ using consistency checking techniques from solving CSP.