## List of Accepted Papers

Manuel Montenegro, Ricardo Peña and Clara Segura. A Simple Region Inference Algorithm for a First-Order Functional Language |

Abstract: Safe is a first-order eager language with facilities for programmercontrolled destruction and copying of data structures. It provides also regions, i.e. disjoint parts of the heap, where the program allocates data structures. The runtime system does not need a garbage collector and all allocation/deallocation actions are done in constant time. The language is aimed at inferring and certifying upper bounds for memory consumption in a Proof Carrying Code environment. Some of its analyses have been presented elsewhere. In this paper we present an inference algorithm for annotating programs with regions which is both simpler to understand and more efficient than other related algorithms. Programmers are assumed to write programs and to declare datatypes without any reference to regions. The algorithm decides the regions needed by every function. It also allows polymorphic recursion with respect to regions. We show convincing examples of programs before and after region annotation, prove the correctness and optimality of the algorithm, and give its asymptotic cost. |

Yuki Kato and Koji Nakazawa. Type Checking and Inference Are Equivalent in Lambda Calculi with Existential Types |

Abstract: This paper shows that type-checking and type-inference problems areequivalent in domain-free lambda calculi with existential types, that is, type-checking problem is Turing reducible to type-inference problem and vice versa. A decision problem P is said to be Turing reducible to another problem Q when there is a computable function F such that for any instance p of P, F(p) is an instance of Q which holds if and only if p holds. In this paper, the equivalence is proved for two variants of domain-free lambda calculi with existential types: one is an implication and existence fragment, and the other is a negation, conjunction and existence fragment. Implication, negation, and conjunction in logic correspond to the functional type, the continuation type, and the product type, respectively. This result gives another proof of undecidability of type inference in the domain-free calculi with existence. |

Petra Hofstedt and Kazunori Ueda. Realizing Multiparadigm Programming based on Hierarchical Graph Rewriting |

Abstract: The paper presents the new multiparadigm programming language CCFLwhich allows the description of concurrent processes and of non-deterministic behavior and it discusses the compilation of CCFL programs into the hierarchical graph rewriting language LMNtal. LMNtal aims at the unification of paradigms of computation and supports by its features and structure the transformation of CCFL programs such that we reached clear and simple compilation schemata. |

Rafael del Vado Vírseda and Ignacio Castiñeiras Pérez. A Theoretical Framework for the Declarative Debugging of Functional Logic Programs with Lambda Abstractions |

Abstract: In this paper, we extend the declarative method for diagnosing wrong computed answers in first-order lazy functional logic programs to the higher-order setting of the simply typed lambda calculus, where programs are presented by conditional pattern rewrite systems. Our approach generalizes and combines declarative debugging techniques previously developed for less expressive declarative programming paradigms involving applicative rewrite rules instead of lambda abstractions and higher-order unification. Debugging starts with the observation of a wrong computed answer which the user regards as incorrect w.r.t. an intended model that provides a declarative description of the program's semantics. Debugging proceeds by exploring an abridged proof tree built on a higher-order rewriting logic with lambda abstractions that provides a purely declarative view of the computation. Finally, debugging ends with the detection of a defined function rule in the program that is incorrect w.r.t. the intended model. We prove the logical correctness of the debugging method for any sound goal solving system whose computed answers are logical consequences of the program. |

Javier Álvez and Francisco Javier López-Fraguas. A Complete Axiomatization of Strict Equality over Infinite Trees |

Abstract: Computing with data values that are some kind of trees ---finite, infinite, rational--- is at the core of declarative programming, either logic, functional or functional-logic. Understanding the logic of trees is therefore a fundamental question with impact in different aspects, like language design, including constraint systems or constructive negation, or obtaining methods for verifying and reasoning about programs. The theory of true equality over finite or infinite trees is quite well known. In particular, a seminal paper by Maher proved its decidability and gave a complete axiomatization of the theory. However, the sensible notion of equality for functional and functional-logic languages with a lazy evaluation regime is strict equality, a computable approximation to true equality for possibly infinite and partial trees. In this paper, we investigate the first order theory of strict equality, arriving to remarkable and not obvious results: the theory is again decidable and admits a complete axiomatization, not requiring predicate symbols other than strict equality itself. Besides, the results stem from an effective ---taking into account the intrinsic complexity of the problem--- decision procedure that can be seen as a constraint solver for general strict equality constraints. |

Francisco Javier Lopez-Fraguas, Enrique Martin-Martin and Juan Rodriguez-Hortala. Advances in type systems for Functional-Logic Programming |

Abstract: Type systems are widely used in programming languages as a powerful toolproviding safety to programs, and forcing the programmers to write code in a clearer way. Functional-logic languages have inherited Damas & Milner type system from their functional part due to its simplicity and popularity. In this paper we address a couple of aspects that can be subject of improvement. One is related to a problematic feature of functional-logic languages not taken under consideration by standard systems: it is known that the use of opaque HO patterns in left-hand sides of program rules may produce undesirable effects from the point of view of types. We re-examine the problem, and propose a Damas & Milner-like type system where certain uses of HO patterns (even opaque) are permitted while preserving type safety, as proved by a subject reduction result that uses HO-let-rewriting, a recently proposed operational semantics for HO functional logic programs. At the same time that we formalize the type system, we have made the effort of technically clarifying additional issues: one is the different ways in which polymorphism of local definitions can be handled, and the other is the overall process of type inference in a whole program. |

Nacho Castiñeiras and Fernando Sáenz. Integrating ILOG CP technology into TOY |

Abstract: Currently, our constraint functional logic programming system TOY uses the SICStus Prolog finite domain (FD) constraint solver. In this work, we integrate the ILOG CP FD constraint solving technology into the system TOY , with the aim of improving its applicability. We describe our implementation of ILOG CP into TOY emphasizingthe communication between them. Performance results are reported. |

Michael Leuschel, Salvador Tamarit and German Vidal. Fast and Accurate Strong Termination Analysis with an Application to Partial Evaluation |

Abstract: A logic program strongly terminates if it terminates for anyselection rule. Clearly, considering a particular selection rule (like Prolog's leftmost selection rule) allows one to prove more goals terminating. In contrast, a strong termination analysis gives valuable information for those applications in which the selection rule cannot be fixed in advance (e.g., partial evaluation, dynamic selection rules, parallel execution). In this paper, we introduce a fast and accurate size-change analysis that can be used to infer conditions for both strong termination and quasi-termination of logic programs. In the paper we also provide several ways to increase the accuracy of the analysis without sacrificing scalability. In the experimental evaluation, we show that the new algorithm is up to three orders of magnitude faster than the previous implementation, meaning that we can efficiently deal with realistic programs exceeding 25,000 lines of Prolog. |

Manuel Hernandez. A Taxonomy of Some Right-to-Left String-Matching Algorithms |

Abstract: This work presents a taxonomy of some exact string-matchingalgorithms. The taxonomy is based on results obtained by using logic program transformation over an initial, naive and nondeterministic specification. The string-matching algorithms report whether a pattern occurs in a text by comparing character to character, from right to left, the pattern and a portion of the text. A derivation of the search part and some notes about the preprocessing part of each algorithm is presented. The derivations show several design decisions behind each algorithm, and allow us to organize the algorithms within a taxonomic tree, giving us a better understanding of these algorithms and possible mechanical procedures to derive them. |

Makoto Hamana. Semantic Labelling for Proving Termination of Combinatory Reduction Systems |

Abstract: We give a method of proving termination of higher-orderrewrite rules in Klop's format combinatory reduction system (CRS). The format CRS essentially covers the usual pure higher-order functional programs such as Haskell. Our method to prove termination, called higher-order semantic labelling, is an extension of a method known in the theory of term rewriting. This attaches semantics of the arguments to each function symbol. We systematically define the labelling by using the complete algebraic semantics of CRS, \Sigma-monoids. We also examine the power of higher-order semantic labelling by several examples. This includes an interesting example from the viewpoint of functional programming and semantics; we show termination of the monad of the lambda terms. |

Stephan Falke and Deepak Kapur. Termination of Context-Sensitive Rewriting with Built-In Numbers and Collection Data Structures |

Abstract: Context-sensitive rewriting is a restriction of rewriting that can be used toelegantly model declarative specification and programming languages such as Maude. Furthermore, it can be used to model lazy evaluation in functional languages such as Haskell. Building upon our previous work on an expressive and elegant class of rewrite systems (called CERSs) that contains built-in numbers and supports the use of collection data structures such as sets or multisets, we consider context-sensitive rewriting with CERSs in this paper. This integration results in a natural way for specifying algorithms in the rewriting framework. In order to prove termination of this kind of rewriting automatically, we develop a dependency pair framework for context-sensitive rewriting with CERSs, resulting in a flexible termination method that can be automated effectively. Several powerful termination techniques are developed within this framework. An implementation in the termination prover AProVE has been successfully evaluated on a large collection of examples. |

andre rauber du bois, gerson cavalheiro and juliana vizzotto. pFun: A semi-explicit parallel purely functional language |

Abstract: In this paper we present the design and implementation of$p$Fun, a semi-explicit parallel purely functional language. Parallelism is introduced in $p$Fun through annotations. These annotations indicate expressions that can be evaluated in parallel with the rest of the program. Task creation, synchronization and scheduling of computations on processors are managed automatically by $p$Fun's runtime system. $p$Fun's programming model and runtime system are described, and preliminary measurements of the current prototype implementation on an SMP-machine, a Beowulf Cluster and an small heterogeneous GRID are presented. |