The tcc paradigm is a formalism for timed concurrent constraint programming. Several tcc languages di#ering in their way of expressing infinite behavior have been proposed in the literature. In this paper

The tcc paradigm is a formalism for timed concurrent constraint programming. Several tcc languages differing in their way of expressing infinite behavior have been proposed in the literature. In this paper we study the expressive power of some of these languages. In particular, we show that (1) recursion using procedures with parameters is behaviorally equivalent to parameterless procedures with dynamic scoping, that (2) replication is behaviorally equivalent to parameterless procedures with static scoping, and that (3) the languages from (1) are strictly more expressive than the languages from (2). Furthermore, we show that behavioral equivalence is undecidable for the languages from (1), but decidable for the languages from (2). Both undecidability results hold even if the process variables take values from a fixed finite domain.

. Although very simple and elegant, Linda-style coordination models lack the notion of time, and are therefore not able to precisely model real-life coordination applications, featuring time-outs and soft real-time constraints. This paper aims at introducing time in these models. To that end, we consider two notions of time, relative time and absolute time, and, for each notion, two types of features. On the one hand, with respect to relative time, we describe two extensions: (i) a delay mechanism to postpone the execution of communication primitives, and (ii) explicit deadlines on the validity of tuples and on the duration of suspension of communication operations. On the other hand, for absolute time, we introduce: (iii) a wait primitive capable of waiting till an absolute point of time, and (iv) time intervals, both on tuples in the data store and on communication operations. The resulting four coordination models are analyzed and compared both from the semantics viewp...

The ntcc process calculus is a timed concurrent constraint programming (ccp) model equipped with a first-order linear-temporal logic (LTL) for expressing process specifications. A typical behavioral observation in ccp is the strongest postcondition (sp). The ntcc sp denotes the set of all infinite output sequences that a given process can exhibit. The verification problem is then whether the sequences in the sp of a given process satisfy a given ntcc LTL formula.

Abstract Concurrent constraint programming (ccp) is a model of concurrency for systems in which agents (also called processes) interact with one another by telling and asking information in a shared medium. Timed (or temporal) ccp extends ccp by allowing agents to be constrained by time requirements. The novelty of timed ccp is that it combines in one framework an operational and algebraic view based upon process calculi with a declarative view based upon temporal logic. This allows the model to benefit from two well-established theories used in the study of concurrency. This essay offers an overview of timed ccp covering its basic background and central developments. The essay also includes an introduction to a temporal ccp formalism called thentcc calculus. 1

. We propose an axiomatic semantics for the synchronous language Gentzen, which is an instantiation of the paradigm Timed Concurrent Constraint Programming. We view Gentzen as a prototype of the class of state-oriented synchronous languages, since it oers the basic constructs that are shared by the languages in the class. Since synchronous concurrency cannot be simulated by arbitrary interleaving, we cannot exploit \head normal forms", on which axiomatic theories for asynchronous process calculi are based. 1

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 this paper we consider the denotational semantics for tcc, and we extend it to a ”collecting ” semantics for utcc based on closure operators over sequences of constraints. Relying on this semantics, we formalize the first general framework for data flow analyses of tcc and utcc programs by abstract interpretation techniques. The concrete and abstract semantics we propose are compositional, thus allowing us to reduce the complexity of data flow domain. Thus, different analyses can be performed by instantiating the framework. We illustrate how it is possible to reuse abstract domains previously defined for logic programming, e.g., to perform a groundness analysis for tcc programs. We show the applicability of this analysis in semantics to exhibit a secrecy flaw in a security protocol. We have developed a prototypical implementation of our methodology and we have implemented the abstract domain for security to perform automatically the secrecy analysis. 1

Abstract. The Concurrent Constraint Paradigm (cc in short) is a simple and highly expressive formalism for modeling concurrent systems where agents execute asynchronously, interacting among them by adding and consulting constraints in a global store. The cc model replaces the notion of store-as-valuation with the notion of store-as-constraint. There exist several programming languages that extend the cc model by introducing a notion of time. The notion of time allows us to represent concurrent and reactive systems. The different definitions for time make each language better suited for modeling a specific kind of application (deterministic embedded systems, non-deterministic reactive systems, etc.). This paper studies the relation between the universal timed concurrent constraint language (utcc in short) and the timed concurrent constraint language (tccp). We show how utcc can be mapped into tccp by means of a transformation that preserves the original behavior. We also prove the correctness of the transformation. 1