Graph rewriting for a partial ordering semantics of concurrent constraint programming

Saraswat recently introduced the framework of concurrent constraint programming [14]. The essence of the framework is that computations consist of concurrent agents interacting by communicating constraints. Several concurrent constraint programming languages have been defined. They differ in the kinds of constraints that can be used as well as the kinds of operations on constraints which are available. In this paper we introduce a very simple concurrent constraint language we call Lucy, designed to closely mimic the actor model of computation. Agents can communicate only by the posting of constraints upon bags (un-ordered collections possibly with duplicate elements). This very impoverished concurrent constraint language is a syntactic subset of Janus, a concurrent constraint language which closely resembles concurrent logic programming languages such as Guarded Horn Clauses [21], Strand [5], Parlog [2] and Flat Concurrent Prolog [13]. By identifying the subset of Janus which is an actor language, we elucidate the relationship between actors and concurrent logic programming (and its generalization as concurrent constraint programming). Lucy is best not thought of as a unification of logic and constraint programming with actor and object-oriented programming, but as the missing link between these programming language genera.

A problem which confronts the developers of concurrent logic programming (CLP) systems concerns the design of the programming environment, particularly the provision of debugging tools. Debugging tools are useful for many activities besides identifying bugs: they can help in program testing and demonstration, in software experiments, and in teaching the language semantics. For CLP languages the questions of what debugging tools should be provided, and of how they should be used, are still open. Although the languages are closely related to other logic programming and concurrent programming languages, they are sufficiently different that new debugging techniques are required. This paper describes a primarily channel-oriented debugging methodology and a set of debugging tools that we have developed in the light of our experience in using and teaching the CLP language Parlog. With these tools a programmer can test a program by observing communication on channels, opening up a process to examine the activity on internal channels and, if necessary, to check in detail the execution steps of a process. Almost all of the ideas, which are equally applicable to other CLP languages, have been implemented in two commercial Parlog systems. As well as fulfilling the needs of existing users of CLP languages, we believe that the tools emphasise the attractions of CLP as a concurrent programming paradigm, since they are made possible by the unique attributes of CLP.

We present a concurrent semantics for concurrent constraint (CC) programs with both ("committed choice") indeterminism and ("back-tracking") nondeterminism. The semantics extends the previous semantics for Indeterminate CC by (1) allowing each state to contain different or-parallel components and (2) splitting the concurrency relation into two to distinguish between and- and or-concurrency. Thereby, the construction produces a single representation (an And-or contextual net) that captures all the significant relations between events in program runs: concurrency, causal dependency, indeterminism and nondeterminism. We believe this is a first step towards the formal analysis of the concurrent semantics of practical CC languages containing both in- and non-determinism, such as AKL [HJ90].

Truly concurrent constraint programming

A concurrent semantics is a semantics where concurrency can be realistically represented and naturally described. Therefore we believe that every concurrent language should be provided with a formal concurrent semantics. Here we describe three concurrent semantics for concurrent constraint (cc) programs. They are all based on partial order structures relating the various objects involved in the program computations, so that objects not related by the partial order are concurrent, and those related are instead dependent on each other and thus need to be sequentialized. Furthermore, they all employ a distributed representation of the constraint system, so that several sources of useless sequentializations are avoided. The first one is based on a graph-rewriting description of the operational behaviour of cc programs, and consists of a partial order involving all objects of each (equivalence class of) computation(s). The second one uses a simpler notion of context-dependent rewriting for the operational semantics, and consists of an event structure, which is able to represent both the concurrency and the non-determinism present in a cc program but which relates only the computation steps, and not the objects. The last one, instead, consists of a contextual net (that is, a Petri net extended with context condiditions), which again represents both concurrency and nondeterminism and furthermore relates all objects and steps of the computations. The three semantics are compared and it is argued that the last one is the most suitable concurrent semantics for cc programs, since 1) contextual items are a general and elegant way of formalizing ask operations and avoiding their useless sequentialization, 2) nets allow a direct representation of concurrent information, as well as dependency and mutual exclusion (that is, nondeterminism). The information contained in any one of these semantics, possibly abstracted, can be of great help to a scheduler, in order to obtain an efficient execution of the program, or also to a compile-time optimizer.KeywordsPartial OrderOperational SemanticGraph ProductionMutual ExclusionGraph GrammarThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Constraint Logic Programming (CLP) is a language scheme for combining two declarative paradigms: constraint solving and logic programming. Concurrent Constraint Programming (CCP) is a declarative model for concurrency where agents interact by telling and asking constraints in a shared store. In a previous paper, we developed a framework for dynamic slicing of CCP where the user first identifies that a (partial) computation is wrong. Then, she marks (selects) some parts of the final state corresponding to the data (constraints) and processes that she wants to study more deeply. An automatic process of slicing begins, and the partial computation is “depurated” by removing irrelevant information. In this paper we give two major contributions. First, we extend the framework to CLP, thus generalizing the previous work. Second, we provide an assertion language suitable for both, CCP and CLP, which allows the user to specify some properties of the computations in her program. If a state in a computation does not satisfy an assertion then some “wrong” information is identified and an automatic slicing process can start. We thus make one step further towards automatizing the slicing process. We show that our framework can be integrated with the previous semi-automatic one, giving the user more choices and flexibility. We show by means of examples and experiments the usefulness of our approach.

The design of acoustic models is key to a reliable connection between acoustic waveform and linguistic message in terms of individual speech units. We present an original application of concurrent constraint programming in this important area of spoken language processing. The application presented here employs concurrent constraint programming – represented by Mozart/Oz [1] – to overcome the problem of sparse training data in order to provide context-dependent acoustic models for automatic speech recognition.

We present a formalism for programming complex multiagent reactive systems in a structured manner. The motivation behind this work is to obtain a simple semantic framework for such reactive systems. The approach followed is to build upon a timed extension of concurrent constraint programs that have been used to present an elegant declarative framework for reactive systems.Timed concurrent constraint (TCC) programs are extended with the primitives for defining and manipulating ambients that contain TCC programs. The extension is simple and conservative, in the sense that TCC programs are a subset of the new formalism - Mobile Timed Concurrent Constraints (MTCC).KeywordsOperational SemanticQuiescent StateConstraint SystemParallel CompositionConservative ExtensionThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Recent research in security and protocol verification has shown an important need for probabilistic formal concurrent models. Indeed, the use of probabilities in formal models allows to define and check quantitative properties which are usefull for a lot of applications, such as probabilistic anonymity, failures or information leakage. Several recent research showed very interesting situations for these properties [1]. Research on probabilistic models is also a topic of interest from the mathematical point of view. Topics include relations between probability and non-determinism, expressivity, processus equivalence and denotational semantics. Research domains for these topics include probabilistic process algebras, concurrent constraint programming and domain theory. Interesting references can be found in [2,3].

The molecular mechanisms of cell communication with the environment involve many concurrent processes governing dynamically the cell function. This concurrent behavior makes traditional methods, such as differential equations, unsatisfactory as a modeling strategy since they do not scale well when a more detailed view of the system is required. Concurrent Constraint Programming (CCP) is a declarative model of concurrency closely related to logic for specifying reactive systems, i.e., systems that continuously react with the environment. Agents in CCP interact by telling and asking information represented as constraints (e.g., x > 42). In this paper we describe a modeling strategy for cellular signaling systems based on a temporal and probabilistic extension of CCP. Starting from an abstract model, we build refinements adding further details coming from experimentation or abstract assumptions. The advantages of our approach are: due to the notion of partial information as constraints in CCP, the model can be straightforwardly extended when more information is available; qualitative and quantitative information can be represented by means of probabilistic constructs of the language; finally, the model is a runnable specification and can be executed, thus allowing for the simulation of the system. We outline the use of this methodology to model the interaction of G-protein-coupled receptors with their respective G-proteins that activates signaling pathways inside the cell. We also present simulation results obtained from an implementation of the framework.KeywordsConcurrent ProcessGuanosine TriphosphateGlycogen BreakdownProcess CalculusGuanosine DiphosphateThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Comparative metric semantics for concurrent prolog

OASIS is a formal approach for the specification of object oriented conceptual models. In OASIS conceptual schemas of information systems are represented as societies of interacting concurrent objects. Animating such models in order to validate the specification of information systems is a topic of interest in requirements engineering. Thus a basic execution model for OASIS specifications has been developed. Concurrent Logic Programming is a suitable paradigm for distributed computation allowing a natural representation of concurrence. Using Concurrent Logic Programming, OASIS specifications are animated according to OASIS execution model. In this work, we show how OASIS concepts are directly mapped into concurrent logic programming concepts. To illustrate our ideas, an example of a bank account codified in KL1 is given and parts of the program that animates its corresponding OASIS specification are shown. This work has been developed in the context of a CASE tool supporting the OASIS approach. Our aim is to build a module for animation and validation of specifications. A preliminary version of this module is presented.

The use of types to deal with access capabilities of program entities is becoming increasingly popular.In concurrent logic programming, the first attempt was made in Moded Flat GHC in 1990, which gave polarity structures (modes) to every variable occurrence and every predicate argument. Strong moding turned out to play fundamental rôles in programming, implementation and the in-depthunderstanding of constraint-based concurrent computation.The moding principle guarantees that each variable is written only once and encourages capability-conscious programming. Furthermore, it gives less generic modes to programs that discard or duplicate data, thus providing the view of “data as resources.” A simple linearity system built upon the mode system distinguishes variables read only once from those read possibly many times, enabling compile-time garbage collection. Compared to linear types studied in other programming paradigms, the primary issue in constraint-based concurrency has been to deal with logical variables and highly non-strict data structures they induce.In this paper, we put our resource-consciousness one step forward and consider a class of ‘ecological’ programs which recycle or return all the resources given to them while allowing concurrent reading of data structures via controlled aliasing. This completely recyclic subset enforces us to think more about resources, but the resulting programs enjoy high symmetry which we believe has more than aesthetic implications to our programming practice in general.The type system supporting recyclic concurrent programming gives a [−1, +1] capability to each occurrence of variable and function symbols (constructors), where positive/negative values mean read/write capabilities, respectively, and fractions mean non-exclusive read/write paths. The capabilities are intended to be statically checked or reconstructed so that one can tell the polarity and exclusiveness of each piece of information handled by concurrent processes. The capability type system refines and integrates the mode system and the linearity system for Moded Flat GHC. Its arithmetic formulation contributes to the simplicity.The execution of a recyclic program proceeds so that every variable has zero-sum capability and the resources (i.e., constructors weighted by their capabilities) a process absorbs match the resources it emits. Constructors accessed by a process withan exclusive read capability can be reused for other purposes.The first half of this paper is devoted to a tutorial introduction to constraint-based concurrency in the hope that it will encourage crossfertilization of different concurrency formalisms.KeywordsLogic ProgramMode GraphLogical VariableMode ConstraintProgram ClauseThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Concurrent Constraint Programming (ccp) is a well-established declarative framework from concurrency theory. Its foundations and principles e.g., semantics, proof systems, axiomatizations, have been thoroughly studied for over the last two decades. In contrast, the development of algorithms and automatic verification procedures for ccp have hitherto been far too little considered. To the best of our knowledge there is only one existing verification algorithm for the standard notion of ccp program (observational) equivalence. In this paper we first show that this verification algorithm has an exponential-time complexity even for programs from a representative sub-language of ccp; the summation-free fragment (ccp\+). We then significantly improve on the complexity of this algorithm by providing two alternative polynomial-time decision procedures for ccp\+ program equivalence. Each of these two procedures has an advantage over the other. One has a better time complexity. The other can be easily adapted for the full language of ccp to produce significant state space reductions. The relevance of both procedures derives from the importance of ccp\+. This fragment, which has been the subject of many theoretical studies, has strong ties to first-order logic and an elegant denotational semantics, and it can be used to model real-world situations. Its most distinctive feature is that of confluence, a property we exploit to obtain our polynomial procedures.

The tcc model is a formalism for reactive concurrent constraint programming. In this paper we propose a model of temporal concurrent constraint programming which adds to tcc the capability of modeling asynchronous and non-deterministic timed behavior. We call this tcc extension the ntcc calculus. The expressiveness of ntcc is illustrated by modeling cells and asynchronous bounded broadcasting, by specifying temporal requirements such as response and invariance, and by modeling timed systems such as RCX controllers. We present a denotational semantics for modeling the strongest-postcondition behavior of ntcc processes, and, based on this semantics, we develop a proof system for proving linear temporal properties of these processes.