We propose a new kind of nets, called contextual nets, where events may have both preconditions and postconditions, as in the classical case, and also positive or negative context conditions. Positive context conditions are to be interpreted as elements which are needed for the event to occur, but which are not affected by the occurring of the event. Instead, negative context conditions are elements which must not be present for the event to take place.The importance of an explicit representation of positive context elements is twofold. Firstly, it allows a faithful representation of systems where the notion of “reading without consuming” is commonly used, like database systems, concurrent constraint programming, or any computation framework based on shared memory. Secondly, it allows to specify directly and naturally a level of concurrency greater than in classical nets. In fact, two events with different preconditions but with the same positive context may occur both in any order and also simultaneously. It is important to note that no other formalism for specifying distributed systems has such feature, not even Petri nets, where the “read” operation does not exists and it is instead modelled through a “rewrite” operation (i.e., a loop), which however does not allow the simultaneous execution of two tasks which read the same resource. Of course a context situation may be simulated in classical nets by creating as many copies of the context as are the users, but this would lead to a very unrealistic (and also more costly) description of the real situation. Negative context conditions are instead very natural to use in systems or languages where negation is present.In this paper we provide contextual nets with two process-based semantics which both are able to represent all and only the computations of a net and express the correct level of true-concurrency. Moreover, we show that contact situations, as well as negative context conditions, do not add any additional power, and we investigate the relationship between contextual nets and classical nets in terms of their processes.
[1]
Tilak Agerwala,et al.
Comments on capabilities, limitations and “correctness” of Petri nets
,
1973,
ISCA '73.
[2]
Hartmut Ehrig,et al.
Tutorial introduction to the algebraic approach of graph grammars
,
1986,
Graph-Grammars and Their Application to Computer Science.
[3]
Francesca Rossi,et al.
Contextual Occurence Nets and Concurrent Constraint Programming
,
1993,
Dagstuhl Seminar on Graph Transformations in Computer Science.
[4]
Wolfgang Reisig,et al.
Petri Nets: Applications and Relationships to Other Models of Concurrency
,
1986,
Lecture Notes in Computer Science.
[5]
Ugo Montanari,et al.
Modelling Concurrent Accesses to Shared Data via Petri Nets
,
1994,
PROCOMET.
[6]
Wolfgang Reisig.
Petri Nets: An Introduction
,
1985,
EATCS Monographs on Theoretical Computer Science.
[7]
Ugo Montanari,et al.
Modeling Serializability via Process Equivalence in Petri Nets
,
1992
.
[8]
John Wylie Lloyd,et al.
Foundations of Logic Programming
,
1987,
Symbolic Computation.
[9]
J. W. Lloyd,et al.
Foundations of logic programming; (2nd extended ed.)
,
1987
.
[10]
Maciej Koutny,et al.
Invariant Semantics of Nets with Inhibitor Arcs
,
1991,
CONCUR.
[11]
Francesca Rossi,et al.
Graph Rewriting for a Partial Ordering Semantics of Concurrent Constraint Programming
,
1993,
Theor. Comput. Sci..
[12]
Vijay A. Saraswat,et al.
Concurrent constraint programming
,
1989,
POPL '90.
[13]
Tilak Agerwala,et al.
Comments on capabilities, limitations and “correctness” of Petri nets
,
1973,
ISCA 1973.
[14]
J. Lloyd.
Foundations of Logic Programming
,
1984,
Symbolic Computation.
[15]
Francesca Rossi,et al.
Graph Grammars as Context-Dependent Rewriting Systems: A Partial Ordering Semantics
,
1992,
CAAP.
[16]
Maciej Koutny,et al.
Structure of Concurrency
,
1991,
Theor. Comput. Sci..
[17]
Francesca Rossi,et al.
True Concurrency in Concurrent Constraint Programming
,
1991,
ISLP.