Models and emerging trends of concurrent constraint programming

[1993] Proceedings Eighth Annual IEEE Symposium on Logic in Computer Science

We propose a framework for the analysis of concurrent constraint programming (ccp). Our approach is based on simple denotational semantics which approximate the usual semantics in the sense that they give a superset of the input-output relation of a ccp program. Analyses based on these semantics can be easily and efficiently implemented using standard techniques from the analysis of logic programs. 1 Introduction Concurrent constraint programming (ccp) [12, 13, 14] is a new programming paradigm which elegantly combines logical concepts and concurrency mechanisms. The computational model of ccp is based on the notion of constraint system, which consists of a set of constraints and an entailment (implication) relation. Processes interact through a common store. Communication is achieved by telling (adding) a given constraint to the store, and by *This work has been partially supported by ESPRIT BRA

Proceedings of the 18th …, 1991

Concurrent constraint programming Sar89,SR90] is a simple and powerful model of concurrent computation based on the notions of store-asconstraint and process as information transducer. The store-as-valuation conception of von Neumann computing is replaced by the notion that the store is a constraint (a nite representation of a possibly in nite set of valuations) which provides partial information about the possible values that variables can take. Instead of \reading" and \writing" the values of variables, processes may now ask (check if a constraint is entailed by the store) and tell (augment the store with a new constraint). This is a very general paradigm which subsumes (among others) nondeterminate data-ow and the (concurrent)(constraint) logic programming languages. This paper develops the basic ideas involved in giving a coherent semantic account of these languages. Our rst contribution is to give a simple and general formulation of the notion that a constraint system is a system of partial information (a la the information systems of Scott). Parameter passing and hiding is handled by borrowing ideas from the cylindric algebras of Henkin, Monk and Tarski to introduce diagonal elements and \cylindri cation" operations (which mimic the projection of information induced by existential quanti ers).

Theoretical Computer Science, 1997

Concurrent constraint programming (ccp), like most of the concurrent paradigms, has a mechanism of global choice which makes computations dependent on the scheduling of processes. This is one of the main reasons why the formal semantics of ccp is more complicated than the one of its deterministic and local-choice sublanguages. In this paper we study various subsets of ccp obtained by adding some restriction on the notion of choice, or by requiring con uency, i.e. independency from the scheduling strategy. We show that it is possible to de ne simple denotational semantics for these subsets, for various notions of observables. Finally, as an application of our results we develop a framework for the compositional analysis of full ccp. The basic idea is to approximate an arbitrary ccp program by a program in the restricted language, and then analyze the latter, by applying the standard techniques of abstract interpretation to its denotational semantics.

1997

Compositional semantics allow to reason about programs in an incremental way, providing the basis for the development of modular data-flow analysis. The major drawback of these semantics is their complexity. This observation applies in particular for concurren~ constralm programming ( ccp ). ln this work "-e consider an operational semantics of ccp by using sequences of pairs of finite constramts to represent ccp computatiOns which is equivalent to a denotational semantics, providing the basis for the development o.f an abstract interpretation framework for the analy~i~ of ccp .

1999

Concurrent constraint programming is classically based on asynchronous communication via a shared store. In previous work ([1, 2]), we presented a new version of the ask and tell primitives which features synchronicity, our approach being based on the idea of telling new information just in the case that a concurrently running process is asking for it. We turn in this paper to a semantic study of this new framework, called Scc. It is first shown to be different in nature from classical concurrent constraint programming and from CCS, a classical reference in traditional concurrency theory. This suggests the interest of new semantics for Scc. To that end, an operational semantics reporting the steps of the computations is presented. A denotational semantics is then proposed. It uses monotonic sequences of labelled pairs of input-output states, possibly containing gaps, and ending – according to the logic programming tradition – with marks reporting success or failure. This denotationa...

Artificial Intelligence, 1999

2002

The tcc model is a formalism for reactive concurrent constraint programming. We present a model of temporal concurrent constraint programming which adds to tcc the capability of modeling asynchronous and nondeterministic timed behavior. We call this tcc extension the ntcc calculus. We also give a denotational semantics for the strongestpostcondition of ntcc processes and, based on this semantics, we develop a proof system for linear-temporal properties of these processes. The expressiveness of ntcc is illustrated by modeling cells, timed systems such as RCX controllers, multi-agent systems such as the Predator/Prey game, and musical applications such as generation of rhythms patterns and controlled improvisation.

Lecture Notes in Computer Science, 2002

The ntcc calculus is a model of non-deterministic temporal concurrent constraint programming. In this paper we study behavioral notions for this calculus. In the underlying computational model, concurrent constraint processes are executed in discrete time intervals. The behavioral notions studied reflect the reactive interactions between concurrent constraint processes and their environment, as well as internal interactions between individual processes. Relationships between the suggested notions are studied, and they are all proved to be decidable for a substantial fragment of the calculus. Furthermore, the expressive power of this fragment is illustrated by examples.

Lecture Notes in Computer Science, 1994

Because of synchronization based on blocking ask, some of the most important techniques for data flow analysis of (sequential) constraint logic programs (clp) are no longer applicable to cc languages. In particular, the generalized approach to the semantics, intended to factorize the (standard) semantics so as to make explicit the domain-dependent features (i.e. operators and semantic objects which may be influenced by abstraction) becomes useless for relevant applications. A possible solution to this problem is based on a more abstract (non-standard) semantics: the success semantics, which models non suspended computations only. With a program transformation (NoSynch) that simply ignores synchronization, we obtain a clp-like program which allows us to apply standard techniques for data flow analysis. For suspension-free programs the success semantics is equivalent to the standard semantics thus justifying the use of suspension analysis to generate sound approximations. A second transformation (Angel ) is introduced, applying a different abstraction of synchronization in possibly suspending programs and resulting in a framework which is adequate to suspension analysis. Applicability and accuracy of these solutions are investigated.

Theoretical Computer Science, 1993

Lecture Notes in Computer Science, 1996

Concurrent constraint programming is classically based on asynchronous communication via a shared store. Synchrony can be achieved by forcing concurrently running ask and tell primitives to synchronise on \new common information". This paper outlines this framework, called Scc, and develops an algebraic semantics for it. The Scc framework is shown to share similarities with both the traditional concurrent constraint setting and algebraic languages like CCS but also to have major di erences which requires the use of new techniques in formulating the algebraic semantics. Among these are the introduction of an auxiliary communication operator to handle the treatment of synchrony and the extension of the concept of cylindric algebras by allowing the hiding of the empty set of variables in order to permit local computations. More importantly, new axioms have been introduced to describe our variants of the tell and ask primitives. The algebraic semantics is proved to be sound and complete with respect to a compositional operational semantics which is also presented in the paper.

BRICS Report Series, 2002

The tcc paradigm is a formalism for timed concurrent constraint programming. Several tcc languages differing in their way of expressing infinite behaviour have been proposed in the literature. In this paper we study the expressive power of some of these languages. In particular, we show that:<dl compact="compact"><dt>(1)</dt><dd>recursive procedures with parameters can be encoded into parameterless recursive procedures with dynamic scoping, and vice-versa.</dd><dt>(2)</dt><dd>replication can be encoded into parameterless recursive procedures with static scoping, and vice-versa.</dd><dt>(3)</dt><dd>the languages from (1) are strictly more expressive than the languages from (2).</dd></dl>Furthermore, we show that behavioural equivalence is undecidable for the languages from (1), but decidable for the languages from (2). The undecidability result holds even if the process variables take values...

Electronic Notes in Theoretical Computer Science, 2006

Constraint-based concurrency is a simple and elegant formalism of concurrency with monotonic mobile channels, whose history started in early 1980's as a subfield of logic programming. Although it has hardly been recognized as process calculi, there is a close connection between them. In this paper we try to convey the essence of constraint-based concurrency to the process calculi community. We also describe how it smoothly evolved into LMNtal (pronounced "elemental"), a language model based on hierarchical graph rewriting.

ACM Computing Surveys, 1996