Puri Arenas-Sánchez

A Semantic Framework for Functional Logic Programming with Algebraic Polymorphic Types

We propose a formal framework for functional logic programming, supporting lazy functions, non-determinism and polymorphic datatypes whose data constructors obey a given set C of equational axioms. On top of a given C, we specify a program as a set R of C-based conditional rewriting rules for defined functions. We argue that equational logic does not supply the proper semantics for such programs. Therefore, we present an alternative logic which includes C-based rewriting calculi and a notion of model. We get soundness and completeness for C-based rewriting w.r.t. models, existence of free models for all programs, and type preservation results.

Combining Layz Narrowing with Disequality Constraints

We investigate an extension of a lazy functional logic language, which uses term disequations both in programs and in computed answers. The semantic properties of the language are derived from the fact that it can be viewed as an instance of the CFLP(X)-scheme proposed in [Lo92] for constraint functional logic programming. In particular, the operational semantics for CFLP(X) — so called lazy constrained narrowing — is a computation mechanism parameterized by a constraint solver over the underlying domain. We define a constraint solver for our language, whose properties ensure completeness. As a further step towards implementation, we present an executable Prolog specification of the operational semantics, which has been implemented on top of a Prolog system. Experimental results have shown good performance.

Minimal Set Unification

A unification algorithm is said to be minimal for a unification problem if it generates exactly a complete set of minimal unifiers, without instances, without repetitions. Aim of this paper is to describe a new set unification algorithm minimal for a significant collection of sample problems that can be used as benchmarks for testing any set unification algorithm. To this end, a deep combinatorial study for such problems has been realized. Moreover, an existing naive set unification algorithm has been also tested in order to show its bad behavior for most of the sample problems.

Functional Plus Logic Programming with Built-In and Symbolic Constraints

In this paper we propose a lazy functional logic language, named SETA, which allows to handle multisets, built-in arithmetic constraints over the domain of real numbers, as well as various symbolic constraints over datatypes. As main theoretical results, we have proved the existence of free term models for all SETA programs and we have developed a correct and complete goal solving mechanism.

Embedding Multiset Constraints into a Lazy Functional Logic Language

In recent works, we have proposed a general framework for lazy functional logic programming with algebraic polymorphic types, i.e., parametric datatypes whose data constructors fulfill a given set of equational axioms. The aim of this paper is to investigate implementation techniques for an extended instance of this framework, namely, lazy functional logic programming with multisets and constraints. We consider a language (named Seta) which supports a polymorphic datatype Mset(α) along with specific constraints for multisets: strict equality (already present in the general framework), disequality, membership and non-membership. We describe a quite readable Prolog-based implementation which can be executed on top of any Prolog system that provides the ability to solve simple arithmetic constraints.

A Debugging Model for Lazy Narrowing

One of the main diiculties within all implementations of lazy narrowing consists of nding good control regimes which avoid repeated evaluations of arguments and minimize the risk of non termination. The demand driven control regime presented in 2] arose as an attempt of solving the mentioned problems. Nevertheless, such control regime makes quite hard to foresee the sequence of evaluations due to the delay of the evaluations of expressions until they are needed and the control of the searching of solutions. We propose a debugging model for a programming language BabLog which combines lazy functional, higher order and logic programming. Assume that DC = S n2N DC n and DF = S n2N DF n are disjoint ranked alphabets of data constructor and function symbols, respectively. The set of terms and expressions over (DC; DF) is deened in the natural way. A BabLog program P is a nite set of function deenitions, where a function symbol f is deened by a nite set of rules P f of the following form: f t 1 : : :t n | {z } head := condition ! e |{z} body where t i 2 terms, e 2 expressions and condition is a sequence of equalities between expressions. The computation of BabLogs goals (which have the same structure than conditions) is based on lazy narrowing under the demand driven control regime. Our model, based on the standard box-oriented model for logic programs, pretends to be a methodological tool to facilitate users the understanding of the operational semantics of BabLog. In our opinion, such kind of tools can help users to debug programs and nd easily possible programming bugs. Finally, this model can be applied to other existing lazy strategies for lazy narrowing, such that the na ve one, presented in 2]. The idea of applying the box model for debugging functional logic languages has been already treated in literature. Nevertheless, nothing is commented on laziness. In order to represent lazy narrowing, we propose to incorporate new kind of boxes 1], connected through their four associated ports: redo, fail, exit and call, in the natural way. The most relevant box in our model is the hnf-box associated to the evaluation to head normal form of a Total Function Application 2 tfa f e 1 : : :e n (f 2 ? An expression may have several head normal forms. In pure functional languages that …