A decompilation of the pi-calculus and its application to termination

We study the correspondence between a concurrent lambda-calculus in administrative, continuation passing style and a pi-calculus and we derive a termination result for the latter

Feasible reactivity in a synchronous pi-calculus

Reactivity is an essential property of a synchronous program. Informally, it guarantees that at each instant the program fed with an input will `react' producing an output. In the present work, we consider a refined property that we call ` feasible reactivity'. Beyond reactivity, this property guarantees that at each instant both the size of the program and its reaction time are bounded by a polynomial in the size of the parameters at the beginning of the computation and the size of the largest input. We propose a method to annotate programs and we develop related static analysis techniques that guarantee feasible reactivity for programs expressed in the S-pi-calculus. The latter is a synchronous version of the pi-calculus based on the SL synchronous programming model

Describing and treating marginality in the Italian peripheries. Some advice from a UK case study

Even though they have been considered out of fashion for years in the mainstream public debate, research practices and urban policies, the peripheries of the big cities are still a problem in Italy. Due to the economic crises and its effects at the urban scale, especially in terms of urban poverty and social exclusion, the problems of these areas are clearly increased without appropriate tools. Moreover, the spatial effects of the spread of urban marginality have not been sufficiently included in urban planning practices, neither in the deprived areas of the inner city nor in the outskirts. Nonetheless, the claim for “policies for the peripheries” does not indicate the intention to develop a sector of specific policies, but the need to identify and integrate more effective actions and strategies for these fragile urban environments. In this framework, the paper presents and discusses, first, the deficiencies of the Italian debate and the consequent inadequacy of public urban policies, and second, some relevant approaches coming from the British context that could be useful for better intervene on our territories

On convergence-sensitive bisimulation and the embedding of CCS in timed CCS

We propose a notion of convergence-sensitive bisimulation that is built just over the notions of (internal) reduction and of (static) context. In the framework of timed CCS, we characterise this notion of `contextual' bisimulation via the usual labelled transition system. We also remark that it provides a suitable semantic framework for a fully abstract embedding of untimed processes into timed ones. Finally, we show that the notion can be refined to include sensitivity to divergence

Full Orbit Sequences in Affine Spaces via Fractional Jumps and Pseudorandom Number Generation

Let $n$ be a positive integer. In this paper we provide a general theory to produce full orbit sequences in the affine $n$-dimensional space over a finite field. For $n=1$ our construction covers the case of the Inversive Congruential Generators (ICG). In addition, for $n>1$ we show that the sequences produced using our construction are easier to compute than ICG sequences. Furthermore, we prove that they have the same discrepancy bounds as the ones constructed using the ICG.Comment: To appear in Mathematics of Computatio

Reactive concurrent programming revisited

In this note we revisit the so-called reactive programming style, which evolves from the synchronous programming model of the Esterel language by weakening the assumption that the absence of an event can be detected instantaneously. We review some research directions that have been explored since the emergence of the reactive model ten years ago. We shall also outline some questions that remain to be investigated

Using symmetries in reinforcement learning of bimanual robotic tasks

The learning of bimanual robotic tasks, i.e., tasks executed by two manipulators together, can be particularly important in the new scenarios opened by the rise of humanoid robotics, one of the most interesting trend currently in the field. The work presented wants to build a method to simplify the dimensionality of parameter space in this particular context, exploiting the presence of symmetries between the movements executed by the two arms. The aim is to develop a reduced-order representation of the bimanual motion, with the purpose of increase the speed of learning process. In chapter 1, kinematics of the used robots is studied, in order to know how to correctly command the position of the robots while executing a task. Robotic movements are then modeled using Probabilistic Movement Primitives (ProMPs), a stochastic interpretation of robot movements (details in chapter 2). The first objective is to develop a symmetrization method for those kind of policies, and this part is treated in chapter 3. This will give the chance of representing the movement of two robotic arms, with only a single ProMP (instead of two, one for each arm), from which obtain the second policy applying symmetrization. In this way the amount of parameters representing motion can be halved. The most common kind of symmetry is the one defined by a plane, but also other cases can be explored, e.g., spherical or cylindrical symmetry. If the symmetry surface is not explicitly given in the bimanual task description, it is critical to have a reliable method to estimate it in order to exploit it in the learning process. In chapter 4 it is reported a way to obtain this estimation of the parameters describing the symmetry surface from the initially demonstrated trajectories. Finally, in chapter 5 it is defined a symmetric policy representation for bimanual task, that depends only on a single ProMP and a symmetry surface. The effectiveness of this parameter reduction has been tested applying it in reinforcement learning of some tasks, in comparison to the results obtained by the standard way of proceeding, that model the bimanual task with two separated ProMPs, one for each robotic arm

Certifying cost annotations in compilers

We discuss the problem of building a compiler which can lift in a provably correct way pieces of information on the execution cost of the object code to cost annotations on the source code. To this end, we need a clear and flexible picture of: (i) the meaning of cost annotations, (ii) the method to prove them sound and precise, and (iii) the way such proofs can be composed. We propose a so-called labelling approach to these three questions. As a first step, we examine its application to a toy compiler. This formal study suggests that the labelling approach has good compositionality and scalability properties. In order to provide further evidence for this claim, we report our successful experience in implementing and testing the labelling approach on top of a prototype compiler written in OCAML for (a large fragment of) the C language