Concurrent Constraint Programming Language Research Articles

Dynamic Slicing for Concurrent Constraint Languages

Concurrent Constraint Programming (CCP) is a declarative model for concurrency where agents interact by telling and asking constraints (pieces of information) in a shared store. Some previous works have developed (approximated) declarative debuggers for CCP languages. However, the task of debugging concurrent programs remains difficult. In this paper we define a dynamic slicer for CCP (and other language variants) and we show it to be a useful companion tool for the existing debugging techniques. We start with a partial computation (a trace) that shows the presence of bugs. Often, the quantity of information in such a trace is overwhelming, and the user gets easily lost, since she cannot focus on the sources of the bugs. Our slicer allows for marking part of the state of the computation and assists the user to eliminate most of the redundant information in order to highlight the errors. We show that this technique can be tailored to several variants of CCP, such as the timed language ntcc, linear CCP (an extension of CCPbased on linear logic where constraints can be consumed) and some extensions of CCP dealing with epistemic and spatial information. We also develop a prototypical implementation freely available for making experiments.

Subexponential concurrent constraint programming

In previous works we have shown that linear logic with subexponentials (SELL), a refinement of linear logic, can be used to specify emergent features of concurrent constraint programming (CCP) languages, such as preferences and spatial, epistemic and temporal modalities. In order to do so, we introduced a number of extensions to SELL, such as subexponential quantifiers for the specification of modalities, and more elaborated subexponential structures for the specification of preferences. These results provided clear proof theoretic foundations to existing systems. This paper goes in the opposite direction, answering positively the question: can the proof theory of linear logic with subexponentials contribute to the development of new CCP languages? We propose a CCP language with the following powerful features: 1) computational spaces where agents can tell and ask preferences (soft-constraints); 2) systems where spatial and temporal modalities can be combined; 3) shared spaces for communication that can be dynamically established; and 4) systems that can dynamically create nested spaces. In order to provide the proof theoretic foundations for such a language, we propose a unified logical framework (SELLS⋒) combining the extensions of linear logic with subexponentials mentioned above, and showing that this new framework has interesting proof theoretical properties such as cut-elimination and a sound and complete focused proof system.

Dynamic Spaces in Concurrent Constraint Programming

Concurrent constraint programming (CCP) is a declarative model for concurrency where agents interact with each other by posting (telling) and asking constraints (formulas in logic) in a shared store of partial information. With the advent of emergent applications as security protocols, social networks and cloud computing, the CCP model has been extended in different directions to faithfully model such systems as follows: (1) It has been shown that a name-passing discipline, where agents can communicate local names, can be described through the interplay of local (∃) processes along with universally (∀) quantified asks. This strategy has been used, for instance, to model the generation and communication of fresh values (nonces) in mobile reactive systems as security protocols; and (2) the underlying constraint system in CCP has been enhanced with local stores for the specification of distributed spaces. Then, agents are allowed to share some information with others but keep some facts for themselves. Recently, we have shown that local stores can be neatly represented in CCP by considering a constraint system where constraints are built from a fragment of linear logic with subexponentials (SELL⋒). In this paper, we explore the use of existential (⋓) and universal (⋒) quantification over subexponentials in SELL⋒ in order to endow CCP with the ability to communicate location (space) names. The resulting CCP language that we obtain is a model of distributed computation where it is possible to dynamically establish new shared spaces for communication. We thus extend the sort of mobility achieved in (1) –for variables – to dynamically change the shared spaces among agents – (2) above. Finally, we argue that the new CCP language can be used in the specification of service oriented computing systems.

A Secure Non-monotonic Soft Concurrent Constraint Language

We present a fine-grained security model to enforce the access control on the shared constraint store in Concurrent Constraint Programming (CCP) languages. We show the model for a non-monotonic version of Soft CCP (SCCP), that is an extension of CCP where the constraints have a preference level associated with them. Crisp constraints can be modeled in the same framework as well. In the considered non-monotonic soft version (NmSCCP), it is also possible to remove constraints from the store. The language can be used for coordinating agents on a common store of information that represents the set of shared resources. In such scenarios, it is clearly important to enforce the integrity and confidentiality rights on the resources, in order, for instance, to hide part of the information to some agents, or to prevent an agent to consume too many resources. Finally, we present a bisimulation relation to check equivalence between two programs written in this language.

Studying cancer-cell populations by programmable models of networks

We draw the basic lines for an approach to build mathematical and programmable network models, to be applied in the study of populations of cancer-cells at different stages of disease development. The methodology we propose uses a stochastic Concurrent Constraint Programming language, a flexible stochastic modelling language employed to code networks of agents. It is applied to (and partially motivated by) the study of differently characterized populations of prostate cancer cells. In particular, we prove how our method is suitable to systematically reconstruct and compare different mathematical models of prostate cancer growth—together with interactions with different kinds of hormone therapy—at different levels of refinement. Moreover, we show our technique at work in analysing the nature of noise and in the possible presence of competing mechanisms in the models proposed.

Towards a Unified Framework for Declarative Structured Communications

We present a unified framework for the declarative analysis of structured communications. By relying on a (timed) concurrent constraint programming language, we show that in addition to the usual operational techniques from process calculi, the analysis of structured communications can elegantly exploit logic-based reasoning techniques. We introduce a declarative interpretation of the language for structured communications proposed by Honda, Vasconcelos, and Kubo. Distinguishing features of our approach are: the possibility of including partial information (constraints) in the session model; the use of explicit time for reasoning about session duration and expiration; a tight correspondence with logic, which formally relates session execution and linear-time temporal logic formulas.

Towards a specification of the ToonTalk language

ToonTalk is a child-oriented programming language whose environment is an animated virtual world, with objects that children can pick up and use as in a game, such as birds, trucks, and robots, providing direct child-oriented metaphors for programming constructs. Actions performed by a programmer's avatar with these objects are both code and coding. ToonTalk is a powerful system, not just a “toy” system: it is based upon concurrent constraint programming languages, and programs written in languages such as Flat Guarded Horn Clauses and Flat Concurrent Prolog can be straight-forwardly constructed in ToonTalk. However, there is not a specification of ToonTalk, for ready implementation in other environments. We propose that the ToonTalk language lies not in the animations displayed by the current environment, but on the actions performed by the programmer with virtual world objects; we present a description and analysis of the methods the ToonTalk language provides to programmers for expressing programs.

A Framework for Timed Concurrent Constraint Programming with External Functions

The timed concurrent constraint programming language (tccp in short) was introduced for modeling reactive systems. This language allows one to model in a very intuitive way typical ingredients of these systems such as timeouts, preemptions, etc. However, there is no natural way for modeling other desirable features such as functional computations, for example for calculating arithmetic results. In fact, although it is certainly possible to implement such kind of operations, each single step of the computation takes time in tccp, and avoiding interferences with the intended overall behavior of the (reactive) system is quite involved.In this paper, we propose an extension of tccp for modeling instantaneous computations which improves the expressiveness of the language, in the sense that operations that are cumbersome to implement in pure tccp, are executed by calling an efficient, external functional engine, while the tccp programmer can focus on the pure, and usually more complex, reactive part of the system. We also describe a case study which motivates the work, and discuss how the new capability presented here can also be used as a new tool for developers from the verification point of view.

Monotonic Set-Extended Prefix Rewriting and Verification of Recursive Ping-Pong Protocols

Ping-pong protocols with recursive definitions of agents, but without any active intruder, are a Turing powerful model. We show that under the environment sensitive semantics (i.e. by adding an active intruder capable of storing all exchanged messages including full analysis and synthesis of messages) some verification problems become decidable. In particular we give an algorithm to decide control state reachability, a problem related to security properties like secrecy and authenticity. The proof is via a reduction to a new prefix rewriting model called Monotonic Set-extended Prefix rewriting (MSP). We demonstrate further applicability of the introduced model by encoding a fragment of the ccp (concurrent constraint programming) language into MSP.

A semantic framework for the abstract model checking of tccp programs

The Timed Concurrent Constraint programming language ( tccp) introduces time aspects into the Concurrent Constraint paradigm. This makes tccp especially appropriate for analyzing timing properties of concurrent systems by model checking. However, even if very compact state representations are obtained thanks to the use of constraints in tccp, large state spaces can still be generated, which may prevent model-checking tools from verifying tccp programs completely. Model checking tccp programs is a difficult task due to the subtleties of the underlying operational semantics, which combines constraints, concurrency, non-determinism and time. Currently, there is no practical model-checking tool that is applicable to tccp. In this work, we introduce an abstract methodology which is based on over- and under-approximating tccp models and which mitigates the state explosion problem that is common to traditional model-checking algorithms. We ascertain the conditions for the correctness of the abstract technique and show that this preliminary abstract semantics does not correctly simulate the suspension behavior, which is a key feature of tccp. Then, we present a refined abstract semantics which correctly models suspension. Finally, we complete our methodology by approximating the temporal properties that must be verified.

Abstract Model Checking of tccp programs

The Timed Concurrent Constraint programming language (tccp) introduces time aspects into the Concurrent Constraint paradigm. This makes tccp especially appropriate to analyze by model checking timing properties of concurrent systems. However, even if very compact state representations are obtained thanks to the use of constraints in tccp, large state spaces can be still generated which may prevent model checking tools from verifying tccp programs completely. In this paper, we introduce an abstract methodology which is based on over- and under-approximating tccp models and mitigates the state explosion problem which is common to traditional model checking algorithms. We ascertain the conditions for the correctness of the abstract technique and show that, due to the timing aspects of the language, this semantics does not correctly simulate the suspension behavior, which is a key feature of tccp. Then, we present a refined abstract semantics which correctly models suspension.

On the Expressive Power of Temporal Concurrent Constraint Programming Languages: (invited talk)

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 work we study the expressive power of some of these languages. In particular, we show that: (1) recursive procedures with parameters can be encoded into parameterless recursive procedures with dynamic scoping, and viceversa. (2) replication can be encoded into parameterless recursive procedures with static scoping, and viceversa. (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). The undecidability result holds even if the process variables take values from a fixed finite domain.(Joint work with Mogens Nielsen and Frank D. Valencia)

On the Expressive Power of Concurrent Constraint Programming Languages

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 from a fixed finite domain.

Linear Concurrent Constraint Programming: Operational and Phase Semantics

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.

Scheduling of Time-Triggered Real-Time Systems

This paper introduces a new class of applications for constraint programming. This new type of application originates out of a special class of real-time systems, enjoying increasing popularity in areas such as automotive electronics and aerospace industry. Real-time systems of this kind are time triggered in the sense that their overall behavior is globally controlled by a recurring clock tick. Being able to compute an appropriate pre-runtime schedule automatically is the major challenge for such an architecture. What makes this specific off-line scheduling problem somewhat untypical is that a potentially indefinite, periodic processing has to be mapped onto a single time window. In this article we will show how this problem can be solved by constraint programming and we will describe which techniques from traditional scheduling and real-time computing led to success and which failed when confronted with a large-scale application of this type. The techniques that proved to be the most successful were special global constraints and an elaborate search heuristics from Operations Research. Also for finding a valid schedule mere serialization is shown to be sufficient. The actual implementation was done in the concurrent constraint programming language Oz.

Executing Formal Specifications with Concurrent Constraint Programming

We have implemented a technique for execution of formal, model-based specifications. The specifications we can execute are written at a level of abstraction that is close to that used in nonexecutable specifications. The specification abstractions supported by our execution technique include using quantified assertions to directly construct post-state values, and indirect definitions of post-state values (definitions that do not use equality). Our approach is based on translating specifications to the concurrent constraint programming language AKL. While there are, of course, expressible assertions that are not executable, our technique is amenable to any formal specification language based on a finite number of intrinsic types and pre- and postcondition assertions.

LΩUI: Lovely ΩMEGA User Interface

Abstract. The capabilities of a automated theorem prover's interface are essential for the effective use of (interactive) proof systems. L Ω UI is the multi-modal interface that combines several features: a graphical display of information in a proof graph, a selective term browser with hypertext facilities, proof and proof plan presentation in natural language, and an editor for adding and maintaining the knowledge base. L Ω UI is realized in an agent-based client-server architecture and implemented in the concurrent constraint programming language Oz.

A Fully Abstract Semantics for Concurrent Constraint Programming

A compositional and fully abstract semantics for concurrent constraint programming is developed. It is the first fully abstract semantics which takes into account both non-determinism, infinite computations, and fairness. We present a simple concurrent constraint programming language, whose semantics is given by a set of reduction rules augmented with fairness requirements. In the fully abstract semantics we consider two aspects of a trace, viz. the function computed by the trace (the functionality) and the set of input and output data (the limit of the trace). We then derive the fully abstract semantics from the set of traces using a closure operation. We give two proofs of full abstraction; the first relies on the use of a syntactically infinite context. The second proof requires only a finite context, but assumes as input a representation of the function to be computed by the context. Finally, we examine the algebraic properties of the programming language with respect to the fully abstract semantics. It turns out that the non-deterministic selection operation can be defined using operations derived from parallel composition and the usual set-theoretic operations on sets of traces.

Data-parallel concurrent constraint programming

With the advent of cost-effective massively parallel computers, researchers conjecture that the future concurrent constraint programming system is composed of a massively parallel constraint solver as the back-end with a concurrent inference engine as the front-end (Cohen, Comm. ACM 33 (7) (1990) 52–68). This paper represents, to the best of our knowledge, the first attempt to build a concurrent constraint programming system on a massively parallel SIMD computer. A concurrent constraint programming language called Firebird is presented. Firebird can handle finite domain constraints and supports both concurrency and data-parallelism. As a result, it is suitable for implementation on both multiprocessors and SIMD computers. Concurrency arises from the stream and-parallelism of committed-choice logic programming languages. Our SIMD implementation supports or-parallelism but stream and-parallelism is implemented sequentially. In a nondeterministic derivation step, one of the domain variables is selected to create a choice point. All possible alternatives are attempted in parallel. Data-parallelism is exploited in the resulting or-parallel execution. In this paper, we first present the Firebird computation model. We then present an SIMD implementation of the Firebird language on the DECmpp massively parallel computer based on the data-parallel abstract machine (DPAM). A performance analysis of the system is also presented.

A hierarchy of constraint systems for data-flow analysis of constraint logic-based languages

Many interesting analyses for constraint logic-based languages are aimed at the detection of monotonic properties, that is to say, properties that are preserved as the computation progresses. Our basic claim is that most, if not all, of these analyses can be described within a unified notion of constraint domains. We present a class of constraint systems that allows for a smooth integration within an appropriate framework for the definition of non-standard semantics of constraint logic-based languages. Such a framework is also presented and motivated. We then show how such domains can be built, as well as construction techniques that induce a hierarchy of domains with interesting properties. In particular, we propose a general methodology for domain combination with asynchronous interaction (i.e., the interaction is not necessarily synchronized with the domains' operations). By following this methodology, interesting combinations of domains can be expressed with all the semantic elegance of concurrent constraint programming languages.