Graph Rewriting for a Partial Ordering Semantics of Concurrent Constraint Programming

Abstract The concurrent constraint logic programming framework extends both logic programming and concurrent logic programming in that a program consists of the concurrent execution of agents which add (i.e., “tell”) and check (i.e., “ask”) constraints on a shared set of variables, and whose behaviour is described by a set of clauses. This formulation is very general and can be seen as a concurrent logic programming shell which is parametrized w.r.t. the underlying constraint system. Graphs and graph grammars can be conveniently used to describe such a framework, and the modelling is so elegant and expressive that they provide what we believe is the most natural abstract machine for concurrent constraint programming. In fact, basic notions like the possibility of asking or telling a constraint into the shared store are very easy to express in the algebraic approach to graph rewriting. More precisely, the shared store is represented as a (hyper)graph, where nodes are variables and arcs are constraints or agents. Then, both the entailment relation of the underlying constraint system and the local behaviour of agents is expressed by suitable sets of graph productions, which transform the current global state of the system into a new one. Finally, each computation is represented by a graph derivation. In our setting the shared store is not seen as one constraint, but as a set of constraints which possibly share variables. This is in contrast with all the operational and denotational semantics already proposed for the concurrent constraint paradigm, which treat the shared store as a monolith and, thus, are not useful for deriving any information about the causal dependencies among the agents or the maximal degree of parallelism. On the contrary, our approach can easily express such information in the form of a partial ordering associated to each graph derivation. This can be regarded as the first attempt to give a true-concurrency semantics to concurrent constraint programming and, more generally, to graph grammars.