Mercedes Hidalgo-Herrero

AN OPERATIONAL SEMANTICS FOR THE PARALLEL LANGUAGE EDEN

The functional parallel language Eden — suitable for the description of parallel and concurrent algorithms in a distributed setting — is an extension of Haskell with a set of coordination features. In this paper we present a formal operational semantics for the kernel of Eden, or more precisely, for a λ-calculus widened with explicit parallelism and potentially infinite communication channels. Eden overrides the lazy nature of Haskell on behalf of parallelism. This interplay between laziness and eagerness is accurately described by the semantics proposed here, which is based on Launchburys natural semantics for lazy evaluation, and is expressed through a two-level transition system: a lower level for the local and independent evaluation of each process, and an upper one for the coordination between all the parallel processes in the system. As processes are created either under demand or in a speculative way, different scheduling strategies are possible — ranging from a minimal one that only allows the main thread to evolve, to a maximal one that evolves in parallel every active binding.

Continuation Semantics for Parallel Haskell Dialects

The aim of the present work is to compare, from a formal semantic basis, the different approaches to the parallelization of functional programming languages. For this purpose, we define a continuation semantics model which allows us to deal with side-effects and parallelism. To verify the suitability of our model we have applied it to three programming languages that introduce parallelism in very different ways, but whose common functional kernel is the lazy functional language Haskell.

Analyzing the influence of mixed evaluation on the performance of Eden skeletons

A key point in the efficiency of parallel programs is the distribution of computation among processes. Haskell parallel dialects--like Eden--use mixed lazy and strict evaluation, and parallel performance is determined by the strategy used. We investigate how alternative evaluation models influence Eden skeletons performance using an implementation of Edens operational semantics. More concretely, we have chosen the parallel Divide-and-Conquer skeleton for our comparative analysis. Here we show the measures obtained for a simple program but using different mixed evaluation strategies, and we analyze the advantages and drawbacks of each of them.

Using Maude and Its Strategies for Defining a Framework for Analyzing Eden Semantics

Abstract Eden is a parallel extension of the functional language Haskell. On behalf of parallelism Eden overrides Haskells pure lazy approach, combining a non-strict functional application with eager process creation and eager communication. We desire to investigate alternative semantics for Eden in order to analyze the consequences of some of the decisions adopted during the language design. In this paper we show how to implement in Maude the operational semantics of Eden in such a way that semantic rules can be modified easily. Moreover, other semantic features can be implemented by means of parameterized modules that allow to instantiate in different ways several parameters of the semantics but without modifying the semantic rules.

Testing learning strategies

In this paper we present an experiment designed to test whether an automatic system can learn a set of rules in a similar way as human beings learn the same set of rules. In order to do that, we have conducted two experiments. The first of them has been done with a group of seventy people, while the second one has been done by running an automatic learning system designed by ourselves. The paper contains the results of both tests, and a comparison of the learning curves of both types of subjects: humans and automatic agents. We also analyze the differences and similarities by considering how humans and agents construct their knowledge about the rules. By using both types of analysis, we study how close is the learning process of our automatic agents to obtaining a success in a Turing test.

The Role of Indirections in Lazy Natural Semantics

Launchbury defines a natural semantics for lazy evaluation and proposes an alternative version which introduces indirections, eliminates blackholes and does not update closures. Equivalence of both semantics is not straightforward. In this paper we focus on the introduction of indirections during \(\beta \)-reduction and study how the heaps, i.e., the sets of bindings, obtained with this kind of evaluation do relate with the heaps produced by substitution. As a heap represents the context of evaluation for a term, we first define an equivalence that identifies terms with the same meaning under a given context. This notion of context equivalence is extended to heaps. Finally, we define a relation between heap/term pairs to establish the equivalence between Launchbury’s alternative natural semantics and its corresponding version without indirections.

A parallel skeleton for genetic algorithms

Nowadays, most users own multicore computers, but it is not simple to take advantage of them to speedup the execution of programs. In particular, it is not easy to provide a parallel implementation of a concrete genetic algorithm. In this paper we introduce a parallel skeleton that given a sequential implementation automatically provides a corresponding parallel implementation of it. In order to do it, we use a parallel functional language where skeletons can be defined as higherorder functions. Thus, the parallelizing machinery is defined only once, and it is reused for any concrete application of the skeleton to a concrete problem.

Formalizing Interchange Competences

An important aspect in multi-agent cognitive systems is being able to provide negotiation facilities to agents. In this article we deal with this problem by presenting a formal environment allowing to specify preferences. Moreover, our framework describes how to perform exchanges among the entities involved in the system. The exchanges are not restricted to material goods, as we introduce capabilities to deal with intangible goods. The description of the system is formalized by using a simple process algebra that allows dealing with entities organized in a hierarchical way.

Testing Entities in a Parallel Cognitive Language

We present a programming environment to help studying the behavior of cognitive models. The core of the environment is a programming language based on high-level constructions that allow the easy development of general schemes that can be used (and even modified) without requiring knowledge about the underlying language. In addition, we have introduced observation facilities to the language to help analyzing how each process takes its own decisions. Thus, we can analyze not only the external behavior of each entity, but also how it constructs its knowledge. Moreover, our framework also provides visualizing facilities

Comparing Problem Solving Strategies for NP-hard Optimization Problems

NP-complete problems are particularly hard to solve. Unless P=NP, any algorithm solving an NP-complete problem takes exponential time in the worst case. The intrinsic difficulty of NP-complete problems when we try to optimally solve them with computers seems to apply to humans too. Intuitively, solving NP-complete problems requires taking a series of choices where each choice we take disables many subsequent choices, but the scope of dependencies between these mutually exclusive choices cannot be bound. Thus, the problem cannot be split into smaller subproblems in such a way that their solutions can be computed independently and easily combined for constructing the global solution as it happens in divide and conquer algorithms. Moreover, for each choice, the space of subsequent subproblems to be considered for all possible choice elections does not collapse into a polynomial size set as it happens in dynamic programming algorithms. Thus, intuitively, in NP-complete problems any choice may unboundedly affect any other, and this difficulty seems to puzzle humans as much as computers. In this paper we conduct an experiment to systematically analyze the performance of humans when solving NP-complete problems. For each problem, in order to measure partial fulfillment of the decision problem goal, we consider its NP-hard optimization version. We analyze the human capability to compute good suboptimal solutions to these problems, we try to identify the kind of problem instances which make humans compute the best and worst solutions including the dependance of their performance on the size of problem instances, and we compare their performance with computational heuristics typically used to approximately solve these problems. We also interview experiment participants in order to infer the most typical strategies used by them in experiments, as well as how these strategies depend on the form and size of problem instances.