Teresa Hortalá-González

Constraint functional logic programming over finite domains

In this paper, we present our proposal to Constraint Functional Logic Programming over Finite Domains (CFLP(ℱ𝐷) with a lazy functional logic programming language which seamlessly embodies finite domain (ℱ𝐷) constraints. This proposal increases the expressiveness and power of constraint logic programming over finite domains (CLP(ℱ𝐷) by combining functional and relational notation, curried expressions, higher-order functions, patterns, partial applications, non-determinism, lazy evaluation, logical variables, types, domain variables, constraint composition, and finite domain constraints. We describe the syntax of the language, its type discipline, and its declarative and operational semantics. We also describe 𝑇𝑂𝑌 (ℱ𝐷), an implementation for CFLP(ℱ𝐷), and a comparison of our approach with respect to CLP(ℱ𝐷) from a programming point of view, showing the new features we introduce. And, finally, we show a performance analysis which demonstrates that our implementation is competitive with respect to existing CLP(ℱ𝐷) systems and that clearly outperforms the closer approach to CFLP(ℱ𝐷).

Solving Combinatorial Problems with a Constraint Functional Logic Language

This paper describes a proposal to incorporate finite domain constraints in a functional logic system. The proposal integrates functions, higher-order patterns, partial applications, non-determinism, logical variables, currying, types, lazyness, domain variables, constraints and finite domain propagators.The paper also presents TOY(FD), an extension of the functional logic language TOYthat provides FD constraints, and shows, by examples, that TOY(FD) combines the power ofconstraint logic programming with the higher-order characteristics of functional logic programming.

On the cooperation of the constraint domains ℋ, ℛ, and ℱ in cflp

This paper presents a computational model for the cooperation of constraint domains and an implementation for a particular case of practical importance. The computational model supports declarative programming with lazy and possibly higher-order functions, predicates, and the cooperation of different constraint domains equipped with their respective solvers, relying on a so-called constraint functional logic programming (CFLP) scheme. The implementation has been developed on top of the CFLP system , supporting the cooperation of the three domains ℋ, ℛ, and ℱ , which supply equality and disequality constraints over symbolic terms, arithmetic constraints over the real numbers, and finite domain constraints over the integers, respectively. The computational model has been proved sound and complete w.r.t. the declarative semantics provided by the CFLP scheme, while the implemented system has been tested with a set of benchmarks and shown to behave quite efficiently in comparison to the closest related approach we are aware of.

Toy(FD): sketch of operational semantics

In [2] we proposed the integration of finite domain (FD) constraints into the functional logic programming language TOY, and, as result, presented the language TOY(FD). We showed that TOY(FD), integrates the best features of existing functional and logic languages into FD constraint solving. This paper describes a sketch (due to space limitations) of the TOY(FD), operational semantics that consists of a novel combination of lazy evaluation and FD constraint solving.

A Constraint Functional Logic Language for Solving Combinatorial Problems

We present CFLP(FD), a constraint functional logic programming approach over finite domains (FD) for solving typical combinatorial problems. Our approach adds to former approaches as Constraint Logic Programming (CLP), and Functional Logic Programming (FLP) both expressiveness and further efficiency by combining combinatorial search with propagation. We integrate FD constraints into the functional logic language TOY. CFLP(FD) programs consist of TOY rules with FD constraints declared as functions. CFLP(FD) seamlessly combines the power of CLP over FD with the higher order characteristics of FLP.

Cooperation of constraint domains in the TOY system

This paper presents a computational model for the cooperation of constraint domains, based on a generic Constraint Functional Logic Programming (CFLP) Scheme and designed to support declarative programming with functions, predicates and the cooperation of different constraint domains equipped with their respective solvers. We have developed an implementation in the CFLP system TOY, supporting an instance of the scheme which enables the cooperation of symbolic Herbrand constraints, finite domain integer constraints, and real arithmetic constraints. We provide a theoretical result and an analysis of benchmarks showing a good performance with respect to the closest related approach we are aware of

Programming with TOY ( FD )

In [1] we presented the language TOY(FD) that integrates the best features of existing functional and logic languages, as well as finite domain (FD) constraint solving. We believe that TOY(FD) is more flexible and expressive than the existing approaches of constraint logic programming on finite domain (CLP(FD)) as it integrates FD constraint solving, lazy evaluation, higher order applications of functions and constraints, polymorphism, type checking, composition of functions (and, in particular, constraints), combination of relational and functional notation, and a number of other characteristics. These features allow to write more concise programs, therefore increasing the expressivity level.