## Section: New Results

### Foundations of Concurrency

Distributed systems have changed substantially in the recent past with the
advent of phenomena like social networks and cloud computing. In the previous
incarnation of distributed computing the emphasis was on consistency, fault
tolerance, resource management and related topics; these were all characterized
by *interaction between processes*. Research proceeded along two lines: the
algorithmic side which dominated the Principles Of Distributed Computing
conferences and the more process algebraic approach epitomized by CONCUR where
the emphasis was on developing compositional reasoning principles. What marks
the new era of distributed systems is an emphasis on managing access to
information to a much greater degree than before.

#### Models and Emerging Trends of Concurrent Constraint Programming

The *Concurrent constraint programming (ccp)* paradigm focuses on information
access and therefore it is suited for this new era of concurrent systems. Ccp
singles out the fundamental aspects of asynchronous systems whose agents (or
processes) evolve by accessing information in a global medium,
represented as constraints over the variables of the system.
Agents communicate by posting and querying partial information in the medium.
This covers a vast variety of systems as those arising in biological phenomena, reactive systems, net-
centric computing and the advent of social networks and cloud computing. In [17]
we surveyed the main applications, developments and current trends of ccp.

#### Efficient computation of program equivalence for confluent concurrent constraint programming

The development of algorithms and automatic verification procedures for ccp have hitherto been far too little considered. To the best of our knowledge there is only one existing verification algorithm for the standard notion of ccp program (observational) equivalence. In [25] we first showed that this verification algorithm has an exponential-time complexity even for programs from a representative sub-language of ccp; the summation-free fragment (ccp+). We then significantly improved on the complexity of this algorithm by providing two alternative polynomial-time decision procedures for ccp+ program equivalence. Each of these two procedures has an advantage over the other. One has a better time complexity. The other can be easily adapted for the full language of ccp to produce significant state space reductions. The relevance of both procedures derives from the importance of ccp+. This fragment, which has been the subject of many theoretical studies, has strong ties to first-order logic and an elegant denotational semantics, and it can be used to model real-world situations. Its most distinctive feature is that of confluence, a property we exploit to obtain our polynomial procedures.

#### Abstract Interpretation of Temporal Concurrent Constraint Programs

Timed concurrent constraint programming (tcc) is a declarative model for concurrency offering a logic for specifying reactive systems, i.e. systems that continuously interact with the environment. The universal tcc formalism (utcc) is an extension of tcc with the ability to express mobility. Here mobility is understood as communication of private names as typically done for mobile systems and security protocols. In [15] we considered the denotational semantics for tcc, and we extended it to a “collecting” semantics for utcc based on closure operators over sequences of constraints. Relying on this semantics, we formalized a general framework for data flow analyses of tcc and utcc programs by abstract interpretation techniques. The concrete and abstract semantics we proposed are compositional, thus allowing us to reduce the complexity of data flow analyses. We showed that our method is sound and parametric with respect to the abstract domain. Thus, different analyses can be performed by instantiating the framework. We illustrated how it is possible to reuse abstract domains previously defined for logic programming to perform, for instance, a groundness analysis for tcc programs. We showed the applicability of this analysis in the context of reactive systems. Furthermore, we made also use of the abstract semantics to exhibit a secrecy flaw in a security protocol. We also showed how it is possible to make an analysis which may show that tcc programs are suspension free. This can be useful for several purposes, such as for optimizing compilation or for debugging.

#### Foundations of Probabilistic Concurrent Systems

In [24] we introduced a formal proof system for compositional verification of probabilistic concurrent processes. Properties are expressed using a probabilistic modal $\mu $-calculus, and the proof system is formulated as a sequent calculus in which sequents are given a quantitative interpretation. A key feature is that the probabilistic scenario is handled by introducing the notion of Markov proof, by which each proof in the system is interpreted as a Markov Decision Process, with the proof only considered valid in the case that the value of the MDP is zero.