A confluent calculus for concurrent constraint programming

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.

[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

1995

Abstract. Concurrent Constraint Programming (CCP) has been the subject of growing interest as the focus of a new paradigm for concurrent computation. Like logic programming it claims close relations to logic. In fact CCP languages are logics in a certain sense that we make precise in this paper.

Information and Computation, 2001

In this paper we give a logical semantics for the class CC of concurrent constraint programming languages and for its extension LCC based on linear constraint systems. Besides the characterization in intuitionistic logic of the stores of CC computations, we show that both the stores and the successes of LCC computations can be characterized in intuitionistic linear logic. We illustrate the usefulness of these results by showing with examples how the phase semantics of linear logic can be used to give simple "semantical" proofs of safety properties of LCC programs.

1998

The-calculus is a formal model of concurrent computation based on the notion of naming. It has an important role to play in the search for more abstract theories of concurrent and communicating systems. In this paper we augment the-calculus with a constraint store and add the notion of constraint agent to the standard-calculus concept of agent. We call this extension the +-calculus. We also extend the notion of barbed bisimulation to de ne behavioral equivalence for the +-calculus and use it to characterize some equivalent behaviors derived from constraint agents. The paper discusses examples of the extended calculus showing the transparent i n teraction of constraints and communicating processes.

2009

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 analyses. We show that our method is sound and parametric w.r.t. the abstract 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 the context of reactive systems. Furthermore, we make also use of the abstract 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.

Lecture Notes in Computer Science, 2014

Concurrent constraint programming (ccp) is a well-established model of concurrency for reasoning about systems of multiple agents that interact with each other by posting and querying partial information on a shared space. (Weak) bisimilarity is one of the most representative notions of behavioral equivalence for models of concurrency. A notion of weak bisimilarity, called weak saturated bisimilarity (≈ sb), was recently proposed for ccp. This equivalence improves on previous bisimilarity notions for ccp that were too discriminating and it is a congruence for the choice-free fragment of ccp. In this paper, however, we show thaṫ ≈ sb is not a congruence for ccp with nondeterministic choice. We then introduce a new notion of bisimilarity, called weak full bisimilarity (≈ f), and show that it is a congruence for the full language of ccp. We also show the adequacy of ≈ f by establishing that it coincides with the congruence induced by closing≈ sb under all contexts. The advantage of the new definition is that, unlike the congruence induced by≈ sb , it does not require quantifying over infinitely many contexts.

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.

Information and Computation, 2000

We study a timed concurrent constraint language, called tccp, which is obtained by a natural timed interpretation of the usual ccp constructs: action-prefixing is interpreted as the next-time operator and the parallel execution of agents follows the scheduling policy of maximal parallelism. Additionally, tccp includes a simple primitive which allows one to specify timing constraints. We define the operational semantics of tccp by means of a transition system and we define a denotational model which is fully abstract with respect to the usual notion of observables (that is, the results of terminating computations). Moreover, we study the semantics and expressive power of the notion of maximal parallelism underlying the computational model of tccp: We define a fully abstract semantics for a sublanguage of tccp, called ccpm, which essentially is concurrent constraint programming, provided that we interpret the parallel operator in terms of maximal parallelism rather than of interleaving. We show that tccp is strictly more expressive than ccpm which, in its turn, is strictly more expressive than ccp.

Proceedings of the 12th international ACM SIGPLAN symposium on Principles and practice of declarative programming - PPDP '10, 2010

The Constraint Simplification Rules (CSR) subset of CHR and the flat subset of LCC, where agent nesting is restricted, are very close syntactically and semantically. The first contribution of this paper is to provide translations between CSR and flat-LCC. The second contribution is a transformation from the full LCC language to flat-LCC which preserves semantics. This transformation is similar to λ-lifting in functional languages. In conjunction with the equivalence between CHR and CSR with respect to original operational semantics, these results lead to semantics-preserving translations from full LCC to CHR and conversely. Immediate consequences of this work include new proofs for CHR linear logic and phase semantics, relying on corresponding results for LCC, plus an encoding of the λ-calculus in CHR. * A preliminary version of this work was presented at the CHR'09 workshop (informal proceedings). comparably to CHR constraints. Linear logic leads to a natural semantics for classical CC languages as well [8]. More recently, a precise declarative semantics for CHR has been described in linear logic [10]. Related work The translation from full LCC to CHR relies on ask-lifting. This is a transformation comparable to the λ-lifting [14] for functional languages: the common idea is the materialization of the environment in data structures, i.e. values in functional languages or tokens in LCC. The adaptations of functional concepts in LCC languages have been initiated with the embedding of closures and modules [13]. Flattening nested programming structures was suggested in [15] for connecting the Celf system [16] to CHR but no formal transformation seems to have been published. Encoding for RAM machines into CHR [29] showed that CHR was expressive enough to embed imperative style programming. The encoding of λ-calculus and closures shows that CHR can as well host programs written in a functional style. The CHR linear-logic semantics [10] is close to the previous work on the LCC semantics [8]: the present paper formally describes the intuitions behind this transposition.