1. Introduction

2. Materials and Methods

2.3. An Algorithm for Mapping a Petri Net onto a CCA Process

Algorithm 1 translates a Petri net (see Sect. 2.1) into a CCA process. The algorithm takes in input a Petri net $(P,T,I,O,m_0)$ and returns in output a CCA process in the variable $cca\_str$. The initial marking $m_0$ assigns to each place a number of tokens. The execution of a transition updates the number of tokens in the input places and the output places of the transition according to (1). A semaphore is used to guarantee that the execution of a transition is atomic, i.e. at most one transition can be executed at a time. In order to execute, a transition must obtain the semaphore, otherwise the transition must wait until the semaphore is released by another transition. This semaphore is described in CCA by the ambient $\mathtt{lock}$ defined in (2). The semaphore is in the obtained state if the ambient contains a child ambient $\mathtt{on}\left[\mathtt{0}\right]$ and is in the released state otherwise.

$$\begin{array}{c}\mathtt{lock}[\hfill \\ !\mathtt{recv}\left(\right).::\mathtt{recv}\left(\mathtt{t}\right).\left\{\mathtt{on}\right[\mathtt{0}\left]\right|\mathtt{t}::\mathtt{recv}\left(\right).\mathtt{del}\mathtt{on}.\mathtt{send}\left(\right).\mathtt{0}\}\hfill \\ \left|\mathtt{send}\right().\mathtt{0}\hfill \\ ]\hfill \end{array}$$

(2)

The behaviour of the ambient $\mathtt{lock}$ can be explained as follows. Initially, the semaphore is in the released state, i.e. no transition is being executed. The ambient waits (using the capability $::\mathtt{recv}\left(\mathtt{t}\right)$) until a transition t is willing to obtain the semaphore, then creates a child ambient $\mathtt{on}\left[\mathtt{0}\right]$ to indicate that the semaphore is obtained by the transition t. The semaphore remains in the obtained state until it is released by the transition t (using the capability $\mathtt{t}::\mathtt{recv}\left(\right)$), in which case the child ambient $\mathtt{on}\left[\mathtt{0}\right]$ is deleted. The context-expression $\mathtt{lockOn}\left(\right)$ defined in Table 4 holds if the semaphore $\mathtt{lock}$ is in the obtained state, i.e. it contains a child ambient $\mathtt{on}\left[\mathtt{0}\right]$.

In Algorithm 1, the declaration of the context expression $\mathtt{lockOn}\left(\right)$ is created in line 2, together with other simulation directives such as the execution mode and the simulation length. In ccaPL, these declarations appear between the keywords “BEGIN_DECLS” and “END_DECLS”. The semaphore $\mathtt{lock}$ is created in line 3 of Algorithm 1. The following subsections explain how places and transitions are modelled in CCA.

Algorithm 1: Mapping a Petri net onto a CCA process

2.3.1. Modelling Places

In this section, we show how a place can be modelled as an ambient in CCA. For each place $p\in P$ an ambient of the same name is created in the line 7 of Algorithm 1. The general form of this ambient is given in Table 6. Initially, a place p contains $m_0\left(p\right)=x$ tokens. This is represented in Table 6 by the process “$\mathtt{send}\left(\mathtt{x}\right).\mathtt{0}$”. A child ambient to the ambient p is also created as “$\_(\mathtt{1000}+\mathtt{x})\left[\mathtt{0}\right]$”, e.g. if $\mathtt{x}=\mathtt{1}$ then the child ambient is “$\_\mathtt{1001}\left[\mathtt{0}\right]$”. This encoding reflects in the child ambient’s name the number of token in the ambient p and satisfies the property stated in Theorem 1. Therefore, the names of the child ambients of places can be compared instead of the number of tokens of these places. The behaviour of a place ambient p can be summarised as follows. A place ambient (see Table 6) waits until a transition it is connected to starts executing (see “$::\mathtt{recv}\left(\mathtt{v}\right)$”). It then deletes its current child ambient, updates its number of tokens according to (1) and creates a child ambient that reflects its new number of tokens. It also signals to the running transition that it has completed updating (see “$::\mathtt{send}\left(\right)$”). For example, the place ambients for the places red and black of the Petri net in Figure 1 are given in Table 7. The loop in line 5 of Algorithm 1 creates such a place ambient for each place $p\in P$ and composes them in parallel.

Definition 1.

Let $str\left(z\right)$ be the string representation of an integer value z. For example $str\left(0\right)=$“0” and $str\left(23\right)=$“23”.

Theorem 1.

Let n, x and y be 3 integers such that $n\ge 1$, $0\le x<{10}^n$, and $0\le y<{10}^n$. Then

$$x\ge y\iff str({10}^n+x)\ge str({10}^n+y).$$

The proof of Theorem 1 can be done by induction on n as follows.

Proof. 

Let $\parallel z\parallel$ denote the number of digit in a non-negative integer z. For example $\parallel 0\parallel =1$, $\parallel 23\parallel =2$, and $\parallel 100\parallel =3$.

Base case:

Prove that the theorem holds for $n=1$.

We have: $0\le x<10\Rightarrow \parallel x\parallel =1$. Similarly $\parallel y\parallel =1$. Therefore $x\ge y\Rightarrow str(10+x)=$“$1x$” $\ge str(10+y)=$“$1y$”.

Reversely, “$1x$” ≥“$1y$” ⇒ “x” ≥ “y”. And since $\parallel x\parallel =1$ and $\parallel y\parallel =1$, it follows that $x\ge y$.

Induction case:

Suppose that the theorem holds for n and prove that the theorem also holds for $n+1$.

• If $0\le x<{10}^n$, and $0\le y<{10}^n$, then $0\le x<{10}^{n+1}$, and $0\le y<{10}^{n+1}$. Let $str({10}^n+x)=$“$1\overline{x}$” and $str({10}^n+y)=$“$1\overline{y}$”, for some strings $\overline{x}$ and $\overline{y}$. It follows that $str({10}^{n+1}+x)=$“$10\overline{x}$” and $str({10}^{n+1}+y)=$“$10\overline{y}$”. In string comparison, “$1\overline{x}$” ≥ “$1\overline{y}$” ⇔ “$10\overline{x}$”≥ “$10\overline{y}$”. We conclude that $x\ge y\iff str({10}^{n+1}+x)\ge str({10}^{n+1}+y).$
• If ${10}^n\le x<{10}^{n+1}$, and $0\le y<{10}^n$, then $\parallel x\parallel \ge \parallel y\parallel +1$. Let $str({10}^{n+1}+x)=$“$1\sigma \overline{x}$” and $str({10}^{n+1}+y)=$“$10\overline{y}$”, for some digit $\sigma \ge 1$ and strings $\overline{x}$ and $\overline{y}$ of equal length n. Since $\sigma \ge 1$, “$1\sigma \overline{x}$” ≥ “$10\overline{y}$” is always true. Therefore we conclude that $x\ge y\iff str({10}^{n+1}+x)\ge str({10}^{n+1}+y).$
• If ${10}^n\le x<{10}^{n+1}$, and ${10}^n\le y<{10}^{n+1}$, then let $x=\sigma \times {10}^n+x^{\prime }$ and $y=\theta \times {10}^n+y^{\prime }$, for some integers $x^{\prime }<{10}^n$ and $y^{\prime }<{10}^n$, and digits $\sigma \ne 0$ and $\theta \ne 0$. There are 2 cases: $\sigma =\theta$ or $\sigma \ne \theta$.

  -

  If $\sigma =\theta$, then $x\ge y\iff (\sigma \times {10}^n+x^{\prime }\ge \sigma \times {10}^n+y^{\prime })\iff x^{\prime }\ge y^{\prime }\iff str({10}^n+x^{\prime })\ge str({10}^n+y^{\prime })\iff str(\sigma \times {10}^n+x^{\prime })\ge str(\sigma \times {10}^n+y^{\prime })\iff str({10}^{n+1}+\sigma \times {10}^n+x^{\prime })\ge str({10}^{n+1}+\sigma \times {10}^n+y^{\prime })\iff str({10}^{n+1}+x)\ge str({10}^{n+1}+y)$.

  -

  If $\sigma \ne \theta$, let $str({10}^{n+1}+x)=$ “ $1\sigma \overline{x^{\prime }}$” and $str({10}^{n+1}+y)=$ “$1\theta \overline{y^{\prime }}$”, for some strings $\overline{x^{\prime }}$ and $\overline{y^{\prime }}$. It follows that “$1\sigma \overline{x^{\prime }}$” > “$1\theta \overline{y^{\prime }}$” $\iff \sigma >\theta \iff \sigma \times {10}^n>\theta \times {10}^n\iff \sigma \times {10}^n+x^{\prime }>\theta \times {10}^n+y^{\prime }\iff x>y$.

  Therefore, we conclude that $x\ge y\iff str({10}^{n+1}+x)\ge str({10}^{n+1}+y)$.

  □

2.3.2. Modelling Transitions

Similarly to a place, a transition can be modelled as an ambient. Indeed, Algorithm 1, in the lines 9-25, creates for each transition $\mathtt{t}\in T$ an ambient named $\mathtt{t}$ of the form described in Table 8. The ambient uses the context-expression $state(p,x)$ defined in Table 4 to check if a place ambient p has a child ambient x. Note that the name of a child ambient of a place is encoded to reflect the number of tokens of that place and satisfies the property stated in Theorem 1. In Table 8, the variables p1, ..., pn denote the input places of the transition and q1, ..., qk denote the input and output places of the transition. The behaviour of the ambient is an iterative process, which waits until the semaphore $\mathtt{lock}$ is released, then obtains the semaphore $\mathtt{lock}$ (line 2 in Table 8). It then reads the markings of the transition’s input places (line 3) and checks if all the input places are enabled (line 4), in which case the number of tokens of each place connected to it is updated according to (1) (line 5). Finally, the process releases the semaphore $\mathtt{lock}$ and gets ready for further execution (lines 6 and 7). An example of transition ambient is given in Table 9 for the transition rr of the Petri net in Figure 1.

In summary, the CCA process generated by Algorithm 1 for a Petri net is the parallel composition of the semaphore $\mathtt{lock}$, all the place ambients and all the transition ambients. For example, the CCA process generated for the Petri net of Figure 1 is presented in Table 10.

2.3.3. Complexity of the Algorithm

It is important to discuss the complexity of the algorithm in terms of the execution time, and the size of the CCA process produced in output in comparison to the size of the Petri net received in input. For a Petri net of n places and m transitions, Algorithm 1 takes $O\left(n\right)$ time to generate the place ambients (see the loop in line 5) and $O\left(nm\right)$ time to generate the transition ambients (see the loop in line 9). Therefore the overall time complexity of Algorithm 1 is $O\left({\tilde{n}}^2\right)$, where $\tilde{n}=max(n,m)$; i.e. the execution time is in the order of the square of the size of the input. Besides, the algorithm creates for each place two ambients (see lin 5): a place ambient with a child ambient as depicted in Table 6. However, a single ambient is created for each transition in line 9 of Algorithm 1. The general form of a transition ambient is depicted in Table 8. Finally, a unique semaphore ambient named lock (see (2)) is created in line 3. Thus, the total number of ambients created is $2\times n+m+1$, and so the size of the CCA process generated by Algorithm 1 is in the order of $O\left(\tilde{n}\right)$, i.e. the size of the CCA process generated in output grows linearly with the size of the Petri net in input. The proposed algorithm is thus efficient and scalable. An implementation of the algorithm in Python (version 3.10.11) is given in Appendix A so the mapping of a Petri net onto a CCA process can be done automatically at a click of a button.

3. Results

4. Discussion

5. Conclusion

References

1. Petri, C.A. Kommunikation mit Automaten (Communication with Automata). Phd thesis, University of Bonn, 1962.
2. Murata, T. Petri nets: Properties, analysis and applications. Proceedings of the IEEE 1989, 77, 541–580.
3. Hoare, C. Communicating Sequential Processes; Prentice Hall, 1985.
4. Milner, R. Communication and Mobile Systems: The π-Calculus; Cambridge University Press, 1999.
5. Fournet, C.; Gonthier, G. The reflexive CHAM and the join-calculus, New York, NY, USA, 1996; POPL ’96, p. 372–385. [CrossRef]
6. Siewe, F.; Zedan, H.; Cau, A. The Calculus of Context-aware Ambients. Journal of Computer and System Sciences 2011, 77, 597–620.
7. Siewe, F. ccaPL: A CCA Programming Environment. https://fsiewe.afrilocode.net/CCA/index.html (accessed: 23 November 2023).
8. Cardelli, L.; Gordon, A.D. Mobile Ambients. Theoretical Computer Science 2000, 240, 177–213.
9. Alfakeeh, A.S.; Al-Bayatti, A.H.; Siewe, F.; Baker, T. Agent-based negotiation approach for feature interactions in smart home systems using calculus of the context-aware ambient. Transactions on Emerging Telecommunications Technologies 2022, 33, e3808.
10. Siewe, F.; Yang, H. Privacy protection by typing in ubiquitous computing systems. Journal of Systems and Software 2016, 120, 133–153. [CrossRef]
11. Atbaiga, N.; Siewe, F. Formal Specification of a Context-aware Whiteboard System in CCA. In Proceedings of the In Proceedings of the Libyan International Conference on Electrical Engineering and Technology (LICEET 2018), Tripoli, Libya, 2018.
12. Mennicke, S. A Petri Net Semantics for the Join-Calculus. Technical report, Technical Report, TU Braunschweig. Available at https://www. tu-braunschweig …, 2012.
13. Yao, W.; He, X. Mapping Petri nets to concurrent programs in CC++. Information and Software Technology 1997, 39, 485–495. [CrossRef]
14. Korečko, t.; Sobota, B. Petri Nets to B-Language Transformation in Software Development. Acta Polytechnica Hungarica 2014, 11, 187–206.
15. Boukelkoul, S.; Redjimi, M. Mapping between Petri nets and DEVS models. In Proceedings of the 2013 3rd International Conference on Information Technology and e-Services (ICITeS), 2013, pp. 1–6. [CrossRef]
16. Marsan, M.A.; Balbo, G.; Conte, G.; Donatelli, S.; Franceschinis, G. Modelling with generalized stochastic Petri nets. ACM SIGMETRICS performance evaluation review 1998, 26, 2.
17. van der Aalst, W.M.P. Putting high-level Petri nets to work in industry. Computers in Industry 1994, 25, 45–54. [CrossRef]
18. AT&T Labs-Research. Graphviz Distribution. http://www.research.att.com/sw/tools/graphviz/download.html (accessed: 23 November 2023).
19. Chaum, D. The Dining Cryptographers Problem: Unconditional Sender and Recipient Untraceability. J. Cryptol. 1988, 1, 65–75.
20. Mazaré, L. Using unification for opacity properties. In Proceedings of the In Proceedings of the Workshop on Issues in the Theory of Security (WITS’04), 2004, pp. 165–176.
21. Bryans, J.W.; Koutny, M.; Ryan, P.Y.A. Modelling Opacity Using Petri Nets. Electr. Notes Theor. Comput. Sci. 2005, 121, 101–115.
22. Best, E.; Devillers, R.; Hall, J.G. The box calculus: A new causal algebra with multi-label communication. In Proceedings of the Advances in Petri Nets 1992; Rozenberg, G., Ed., Berlin, Heidelberg, 1992; pp. 21–69.
23. Koutny, M.; Esparza, J.; Best, E. Operational Semantics for the Petri Box Calculus. In Proceedings of the CONCUR ’94: Concurrency Theory; Jonsson, B.; Parrow, J., Eds., Berlin, Heidelberg, 1994; pp. 210–225.
24. Cerone, A. Implementing Condition/Event Nets in the Circal Process Algebra. In Proceedings of the 5th International Conference on Fundamental Approaches to Software Engineering, FASE `02; Jonsson, B.; Parrow, J., Eds., Springer-Verlag, 2002; pp. 49–63.
25. Milner, R. Bigraphs for Petri nets. In Proceedings of the Advanced Course on Petri Nets. Springer, 2003, pp. 686–701.
26. Sassone, V.; Sobociński, P. A congruence for Petri nets. Electronic Notes in Theoretical Computer Science 2005, 127, 107–120.
27. Leifer, J.J.; Milner, R. Transition systems, link graphs and Petri nets. Mathematical Structures in Computer Science 2006, 16, 989–1047.
28. Khomenko, V.; Meyer, R.; Hüchting, R. A polynomial translation of pi-calculus FCPs to safe Petri nets. Logical Methods in Computer Science 2013, 9.
29. Khomenko, V.; Germanos, V. Modelling and Analysis Mobile Systems Using-calculus (EFCP). In Transactions on Petri Nets and Other Models of Concurrency X; Springer, 2015; pp. 153–175.
30. Degano, P.; De Nicola, R.; Montanari, U. A distributed operational semantics for CCS based on condition/event systems. Acta Informatica 1988, 26, 59–91.
31. Goltz, U. CCS and Petri nets. In LITP Spring School on Theoretical Computer Science; Springer, 1990; pp. 334–357.
32. Busi, N.; Gorrieri, R. Distributed semantics for the π-calculus based on Petri nets with inhibitor arcs. The Journal of Logic and Algebraic Programming 2009, 78, 138–162.
33. Dam, M. Model Checking Mobile Processes. Information and Computation 1996, 129, 35–51.
34. Sangiorgi, D.; Walker, D. The π-calculus: A Theory of Mobile Processes; Cambridge University Press, 2001.
35. van Glabbeek, R.; Vaandrager, F. Petri net models for algebraic theories of concurrency. In Proceedings of the PARLE Parallel Architectures and Languages Europe; de Bakker, J.W.; Nijman, A.J.; Treleaven, P.C., Eds. Springer Berlin Heidelberg, 1987, pp. 224–242.
36. Degano, P.; Nicola, R.D.; Montanari, U. A distributed operational semantics for CCS based on condition/event systems. Acta Informatica 1988, 26, 59–91.
37. Siewe, F.; Germanos, V.; Zeng, W. Analysing Petri Nets in a Calculus of Context-Aware Ambients. In Proceedings of the 2020 IEEE 44th Annual Computers, Software, and Applications Conference (COMPSAC). IEEE Computer Society, 2020, pp. 1647–1652.
38. Gorrieri, R.; Montanari, U. On the implementation of concurrent calculi in net calculi: two case studies. Theoretical Computer Science 1995, 141, 195–252.
39. Taubner, D.A. Finite Representations of CCS and TCSP Programs by Automata and Petri Nets; Springer Berlin, Heidelberg, 1989.