Functional Logic Programming Languages Research Articles

Implementing a Library for Probabilistic Programming Using Non-strict Non-determinism

AbstractThis paper presentsPFLP, a library for probabilistic programming in the functional logic programming language Curry. It demonstrates how the concepts of a functional logic programming language support the implementation of a library for probabilistic programming. In fact, the paradigms of functional logic and probabilistic programming are closely connected. That is, language characteristics from one area exist in the other and vice versa. For example, the concepts of non-deterministic choice and call-time choice as known from functional logic programming are related to and coincide with stochastic memoization and probabilistic choice in probabilistic programming, respectively. We will further see that an implementation based on the concepts of functional logic programming can have benefits with respect to performance compared to a standard list-based implementation and can even compete with full-blown probabilistic programming languages, which we illustrate by several benchmarks.

Singular and plural functions for functional logic programming

AbstractModern functional logic programming (FLP) languages use non-terminating and non-confluent constructor systems (CSs) as programs in order to define non-strict and non-deterministic functions. Two semantic alternatives have been usually considered for parameter passing with this kind of functions: call-time choice and run-time choice. While the former is the standard choice of modern FLP languages, the latter lacks some basic properties – mainly compositionality – that have prevented its use in practical FLP systems. Traditionally it has been considered that call-time choice induces a singular denotational semantics, while run-time choice induces a plural semantics. We have discovered that this latter identification is wrong when pattern matching is involved, and thus in this paper we propose two novel compositional plural semantics for CSs that are different from run-time choice.We investigate the basic properties of our plural semantics – compositionality, polarity, and monotonicity for substitutions, and a restricted form of the bubbling property for CSs – and the relation between them and to previous proposals, concluding that these semantics form a hierarchy in the sense of set inclusion of the set of values computed by them. Besides, we have identified a class of programs characterized by a simple syntactic criterion for which the proposed plural semantics behave the same, and a program transformation that can be used to simulate one of the proposed plural semantics by term rewriting. At the practical level, we study how to use the new expressive capabilities of these semantics for improving the declarative flavor of programs. As call-time choice is the standard semantics for FLP, it still remains the best option for many common programming patterns. Therefore, we propose a language that combines call-time choice and our plural semantics, which we have implemented in the Maude system. The resulting interpreter is then employed to develop and test several significant examples showing the capabilities of the combined semantics.

Constructing a bidirectional transformation between BPMN and BPEL with a functional logic programming language

In this article we show how functional logic programming techniques can be used to construct a bidirectional transformation between structured process models of the business process modeling notation (BPMN) and executable models of the business process execution language (BPEL). We specify the abstract syntax of structured process models by a context-free hypergraph grammar. This grammar can be subsequently transformed into a graph parser using our previously developed G rappa framework of functional logic GRAPh PArser combinators. The G rappa framework has been implemented using the functional logic programming language Curry. Furthermore, we show how the constructed parsers can be enriched with semantic computations as required for the synthesis of BPEL from BPMN. Since our parser is a function implemented in a functional logic language, it can be applied in both directions. Thus, given a BPEL model, a corresponding BPMN graph can be constructed with the very same parser. Finally, logic-based parsers can be used for model completion and language generation in a straightforward way. In order to be self-contained, this article also surveys context-free hypergraph grammars, the concepts of the programming language Curry, the example languages BPMN and BPEL, and the ideas of the G rappa framework. Actually, this article is a literate Curry program and, as such, directly executable. Thus, it contains the complete concise source code of our application.

Constraint functional logic programming over finite domains

AbstractIn this paper, we present our proposal to Constraint Functional Logic Programming over Finite Domains (CFLP($\fd$)) with a lazy functional logic programming language which seamlessly embodies finite domain ($\fd$) constraints. This proposal increases the expressiveness and power of constraint logic programming over finite domains (CLP($\fd$)) 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\toy(fd)$, an implementation forCFLP($\fd$), and a comparison of our approach with respect toCLP($\fd$) 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 existingCLP($\fd$) systems and that clearly outperforms the closer approach toCFLP($\fd$).

Programmed Search in a Timetabling Problem over Finite Domains

Labeling is crucial in the performance of solving timetabling problems with constraint programming. Traditionally, labeling strategies are based on static and dynamic information about variables and their domains, and selecting variables and values to assign. However, the size of combinatorial problems tractable by these techniques is limited. In this paper, we present a real problem solved with constraint programming using programmed search based on the knowledge about the solution structure as a starting point for classical propagation and labeling techniques to find a feasible solution. For those problems in which solutions are close to the seed because of its structure, propagation and labeling can reach a first solution within a small response time. We apply our approach to a real timetabling problem, and we tackle its implementation with two different languages, OPL and TOY, using the constraint programming paradigm over finite domains. While OPL is a commercial, algebraic, and specific-purpose constraint programming language, TOY is a prototype of a general-purpose constraint functional logic programming language. We present the specification of the problem, its implementation with both languages, and a comparative performance analysis.

Implementing Relational Specifications in a Constraint Functional Logic Language

We show how the algebra of (finite, binary) relations and the features of the integrated functional logic programming language Curry can be employed to solve problems on relational structures (like orders, graphs, and Petri nets) in a very high-level declarative style. The functional features of Curry are used to implement relation algebra and the logic features of the language are combined with BDD-based solving of boolean constraints to obtain a fairly efficient implementation of a solver for relational specifications.

Lazy Context Cloning for Non-Deterministic Graph Rewriting

We define a rewrite strategy for a class of non-confluent constructor-based term graph rewriting systems and prove its correctness. Our strategy and its extension to narrowing are intended for the implementation of non-strict non-deterministic functional logic programming languages. Our strategy is based on a graph transformation, called bubbling, that avoids the construction of large contexts of redexes with distinct replacements, an expensive and frequently wasteful operation executed by competitive complete techniques.

Evaluation strategies for functional logic programming

Recent advances in the foundations and the implementations of functional logic programming languages originate from far-reaching results on narrowing evaluation strategies. Narrowing is a computation similar to rewriting which yields substitutions in addition to normal forms. In functional logic programming, the classes of rewrite systems to which narrowing is applied are, for the most part, subclasses of the constructor-based, possibly conditional, rewrite systems. Many interesting narrowing strategies, particularly for the smallest subclasses of the constructor-based rewrite systems, are generalizations of well-known rewrite strategies. However, some strategies for larger non-confluent subclasses have been developed just for functional logic computations. This paper discusses the elements that play a relevant role in evaluation strategies for functional logic computations, describes some important classes of rewrite systems that model functional logic programs, shows examples of the differences in expressiveness provided by these classes, and reviews the characteristics of narrowing strategies proposed for each class of rewrite systems.

Uniform Lazy Narrowing

Needed narrowing is a complete and optimal operational principle for modern declarative languages which integrate the best features of lazy functional and logic programming. We investigate the formal relation between needed narrowing and another (not so lazy) narrowing strategy which is the basis for popular implementa- tions of lazy functional logic languages. We demonstrate that needed narrowing and lazy narrowing are computationally equivalent over the class of uniform programs introduced in (16,17). We also introduce a complete refinement of lazy narrowing, called uniform lazy narrowing, which is still equivalent to needed narrowing over the aforementioned class. Since actual implementations of functional logic languages are based on the transformation of the original program into a uniform one—which is then executed using a lazy narrowing strategy—our results can be thought of as a formal basis for the correctness of these implementations. Functional logic programming (11) allows us to integrate some of the best features of the classical declarative paradigms, namely functional and logic programming. The operational semantics of the integrated languages is usually based on narrowing, an evaluation mecha- nism which combines the reduction principle of functional languages with the instantiation of unbound variables used in logic programming. Lazy evaluation is a significant feature of functional (logic) programming languages since it avoids unnecessary computations and al- lows programs to deal with infinite data structures. Due to its optimality properties, needed narrowing (5) is currently considered the best lazy narrowing strategy. It generalizes Huet and Levy's (15) call-by-need reduction in order to deal with logical variables and unification. This work investigates and clarifies the formal relation between needed narrowing and another (not so lazy) narrowing strategy which was introduced in (22)—where it is called lazy narrowing—and is the basis for the implementation of several lazy functional logic languages like, e.g., (12,16,22). Our main contributions are the following:

Evaluation Strategies for Functional Logic Programming

Recent advances in the foundations and the development of functional logic programming languages originate from far-reaching results on narrowing evaluation strategies. Narrowing is a computation similar to rewriting which yields substitutions in addition to normal forms. In functional logic programming, the classes of rewrite systems to which narrowing is applied are, for the most part, subclasses of the constructor-based, possibly conditional, rewrite systems. Many interesting narrowing strategies, particularly for the smallest subclasses of the constructor-based rewrite systems, are generalizations of well-known rewrite strategies. However, some strategies for larger non-confluents subclasses have been developed just for functional logic computations. In this paper, I will discuss the elements that play a relevant role in evaluation strategies for functional logic programming, describe some important classes of rewrite systems that model functional logic programs, show examples of the differences in expressiveness provided by these classes, and review the characteristics of narrowing strategies proposed for each class of rewrite systems.

Typed Logical Variables in Haskell

We describe how to embed a simple typed functional logic programming language in Haskell. The embedding is a natural extension of the Prolog embedding by Seres and Spivey [16]. To get full static typing we need to use the Haskell extensions of quantified types and the ST-monad.

Relating Natural Deduction and Sequent Calculus for Intuitionistic Non-Commutative Linear Logic

We present a sequent calculus for intuitionistic non-commutative linear logic (INCLL), show that it satisfies cut elimination, and investigate its relationship to a natural deduction system for the logic. We show how normal natural deductions correspond to cut-free derivations, and arbitrary natural deductions to sequent derivations with cut. This gives us a syntactic proof of normalization for a rich system of non-commutative natural deduction and its associated λ-calculus. INCLL conservatively extends linear logic with means to express sequencing, which has applications in functional programming, logical frameworks, logic programming, and natural language parsing.