We develop a model for timed, reactive computation by extending the asynchronous, untimed concurrent constraint programming model in a simple and uniform way. In the spirit of process algebras, we develop some combinators expressible in this model, and reconcile their operational, logical and denotational character. We show how programs may be compiled into finite-state machines with loop-free computations at each state, thus guaranteeing bounded response time. 1 Introduction and Motivation Reactive systems [12,3,9] are those that react continuously with their environment at a rate controlled by the environment. Execution in a reactive system proceeds in bursts of activity. In each phase, the environment stimulates the system with an input, obtains a response in bounded time, and may then be inactive (with respect to the system) for an arbitrary period of time before initiating the next burst. Examples of reactive systems are controllers and signal-processing systems. The primary issu...

We develop a compositional proof-system for the partial correctness of concurrent constraint programs. Soundness and (relative) completeness of the system are proved with respect to a denotational semantics based on the notion of strongest postcondition. The strongest postcondition semantics provides a justification of the declarative nature of concurrent constraint programs, since it allows to view programs as theories in the specification logic. 1 Introduction Concurrent constraint programming ([24, 25, 26]) (ccp, for short) is a concurrent programming paradigm which derives from replacing the store-as-valuation conception of von Neumann computing by the storeas -constraint model. Its computational model is based on a global store, represented by a constraint, which expresses some partial information on the values of the variables involved in the computation. The concurrent execution of different processes, which interact through the common store, refines the partial information of...

We present a simple and powerful generalized algebraic semantics for constraint logic programs that is parameterized with respect to the underlying constraint system. The idea is to abstract away from standard semantic objects by focusing on the general properties of any --possibly non-standard -- semantic definition. In constraint logic programming, this corresponds to a suitable definition of the constraint system supporting the semantic definition. An algebraic structure is introduced to formalize the notion of a constraint system, thus making classical mathematical results applicable. Both top-down and bottom-up semantics are considered. Non-standard semantics for constraint logic programs can then be formally specified using the same techniques used to define standard semantics. Different nonstandard semantics for constraint logic languages can be specified in this ...

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

This paper presents a precise connection between a non-commutative version of intuitionistic linear logic (INLL) and concurrent constraint programming (cc). The contribution of this paper is twofold: ffl on the one hand, we refine existing logical characterizations of operational aspects of concurrent constraint programming, by providing a logical interpretation of finer observable properties of cc programs, namely successes and suspensions. ffl on the other ha...

Abstract. We present the natural confluence of higher-order hereditary Harrop formulas (HH formulas) as developed concretely in λProlog, Constraint Logic Programming (CLP, [JL87]), and Concurrent Constraint Programming (CCP, [Sar93]) as a fragment of (intuitionistic, higher-order) logic. The combination is motivated by the need for a simple executable, logical presentation for static and dynamic semantics of modern programming languages. The power of HH formulas is needed for higher-order abstract syntax, and the power of constraints is needed to naturally abstract the underlying domain of computation. Underpinning this combination is a sound and complete operational interpretation of a two-sided sequent presentation of (a large fragment of) intuitionistic logic in terms of behavioral testing of concurrent systems. Formulas on the left hand side of a sequent style presentation are viewed as a system of concurrent agents, and formulas on the right hand side as tests against this evolving system. The language permits recursive definitions of agents and tests, allows tests to augment the system being tested and allows agents to be contingent on the success of a test. We present a condition on proofs, operational derivability (OD), and show that the operational semantics generates only operationally derivable proofs. We show that a sequent in this logic has a proof iff it has an operationally derivable proof. 1

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.

We present an expressiveness study of linearity and persistence of processes. We choose the π-calculus, one of the main representatives of process calculi, as a framework to conduct our study. We consider four fragments of the π-calculus. Each one singles out a natural source of linearity/persistence also present in other frameworks such as Concurrent Constraint Programming (CCP), Linear CCP, and several calculi for security. The study is presented by providing (or proving the non-existence of) encodings among the fragments, a processes-as-formulae interpretation and a reduction from Minsky machines. 1

The tcc model is a concurrent constraint programming formalism for timed, reactive and deterministic computation. A remarkable feature of the tcc model is that programs and specifications are given in the same language. In this report we develop an extension of tcc that allows the specification of nondeterministic computation. We call this extension the ntcc model. The ntcc model is based upon ideas from both concurrent constraint programming and CCS-like models. The expressiveness of ntcc is illustrated by showing derived constructs such as parameterless recursion, cells and value-broadcasting processes, and by specifying temporal requirements such as eventuality, time-bounded response and time-bounded invariance. We claim the applicability of ntcc by modeling reactive system examples of RCX controllers. We present ongoing work on a denotational semantics and a proof system for the model. In the spirit of Process Algebra, we also define a behavioral equivalence for the ntcc model based upon the notion of (weak) bisimulation.

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