A Categorical Semantics for Hierarchical Petri Nets
AA Categorical Semantics for Hierarchical PetriNets
Fabrizio Genovese Q [0000 − − − and Jelle Herold − − − University of PisaStatebox, Amsterdam NL [email protected] Statebox, Amsterdam NL [email protected]
Abstract.
We show how a particular flavor of hierarchical nets, wherethe firing of a transition in the parent net must correspond to an execu-tion in some child net, can be modelled utilizing a functorial semanticsfrom a free category – representing the parent net – to the category ofsets and spans between them. This semantics can be internalized viaGrothendieck construction, resulting in the category of executions of aPetri net representing the semantics of the overall hierarchical net. Weconclude the paper by giving an engineering-oriented overview of howour model of hiearchic nets can be implemented in a transaction-basedsmart contract environment.
This paper is the fourth installment in a series of works [9, 8, 7] devoted todescribing the semantics of extensions of Petri nets using categorical tools.Category theory has been applied to Petri nets starting in the nineties [14]. Themain idea is that we can use different flavors of free monoidal categories to describethe executions (or runs) of a net [13, 5]. The reason why this has been influentialis that it opened up a avenue of applying high-level methods to the study of Petrinets and their properties. For instance, in [2] the categorical approach allowedto describe gluing of nets leveraging on colimits and double categories, whilecategory-theory libraries such as [4] can be leveraged to implement nets in aformally verified way.In [9], we started another line of research, where we were able to definea categorical semantics for colored nets by means of monoidal functors. TheGrothendieck construction was then used to internalize this semantics, obtainingthe well-known result that colored nets can be “compiled back” to Petri nets.In [8, 7], we extended these ideas further, and we were able to characterizebounded nets and mana-nets – a new kind of nets useful to model chemicalreactions – in terms of generalized functorial semantics.This approach, based on the correspondence between slice categories and laxmonoidal functors to the category of span [15], has still a lot to give. In thispaper, we show how it can be used to model hierarchical nets. a r X i v : . [ m a t h . C T ] J a n F. Genovese and J. Herold
There are a lot of different ways to define hierarchical nets. For us, it meansthat we have one “parent” Petri net, and a bunch of “child” nets. A transitionfiring in the parent net corresponds to some kind of run happening in a corre-sponding child net. As such, the main net serves the purpose of orchestratingand coordinating the executions of many underlated child nets.This paper will contain very little new mathematics. Instead, we will justreinterpret results obtained in [9] to show how they can be used to modelhierarchical nets, moreover in a way that makes sense from an implementationperspective.
We start by recalling some basic facts about Petri nets and their categoricalformalization.
Notation 1.
Let S be a set; a multiset is a function S → N . Denote with S ⊕ the set of multisets over S . Multiset sum and difference (only partially defined)are defined pointwise, and will be denoted with ⊕ and (cid:9) , respectively. S ⊕ with ⊕ and the empty multiset is isomorphic to the free commutative monoid on S . Definition 1 (Petri net). A Petri net is a couple of functions T s,t −→ S ⊕ forsome sets T and S , called the set of places and transitions of the net, respectively. s, t are called input and output functions, respectively, or equivalently sourceand target .A morphism of nets is a couple of functions f : T → T (cid:48) and g : S → S (cid:48) suchthat the following square commutes, with g ⊕ : S ⊕ → S (cid:48)⊕ the obvious lifting of g to multisets: S ⊕ T S ⊕ S (cid:48)⊕ T (cid:48) S (cid:48)⊕ ss (cid:48) t (cid:48) tg ⊕ g ⊕ f Petri nets and their morphisms form a category, denoted
Petri . Details can befound in [14].
Definition 2 (Markings and firings). A marking for a net T s,t −→ S ⊕ is anelement of S ⊕ , representing a distribution of tokens in the net places. A transition u is eabled in a marking M if M (cid:9) s ( u ) is defined. An enabled transition can fire , moving tokens in the net. Firing is considered an atomic event, and themarking resulting from firing u in M is M (cid:9) s ( u ) ⊕ t ( u ) . Sequences of firings arecalled executions . The main insight of categorical semantics for Petri nets is that the informationcontained in a given net is enough to genereate a free symmetric strict monoidalcategory representing all the possible ways to run the net. There are multipleways to do this [16, 5, 6, 13, 1]. In this work, we embrace the individual-tokenphilosophy , where tokens are considered distinct and distinguishable, and thusrequire the category in Definition 3 to have non-trivial symmetries.
Categorical Semantics for Hierarchical Petri Nets 3
Definition 3 (Category of executions – individual-token philosophy).
Let N : T s,t −→ S ⊕ be a Petri net. We can generate a free symmetric strictmonoidal category (FSSMC) , F ( N ) , as follows: – The monoid of objects is the free monoid generated by S . Monoidal productof objects A, B is denoted with A ⊗ B . – Morphisms are generated by T : each u ∈ T corresponds to a morphism gener-ator ( u, su, tu ) , pictorially represented as an arrow su u −→ tu ; morphisms areobtained by considering all the formal (monoidal) compositions of generatorsand identities.A detailed description of this construction can be found in [13]. In this definition, objects represent markings of a net: A ⊕ A ⊕ B means“two tokens in A and one token in B ”. Morphisms represent executions of a net,mapping markings to markings. A marking is reachable from another one iffthere is a morphism between them. p t p v up p p t (cid:78) p v up p p t p v (cid:72) up p p t p v u (cid:72) p p t v up p p p p p p p p p p p Now we introduce the main object of study of the paper, hierarchical nets . As wepointed out in Section 1, there are many different ways to model hiearchy in Petrinets [10], often incompatible with each other. We approach the problem froma developer perspective, and want to model the idea that “firing a transition”amounts to call another process, and waiting for it to finish. This is akin tocalling subroutines in a piece of code. Moreover, we do not want to destroy thedecidability of the reachability relation for our nets, as it happens for otherhierarchical models such as the net-within-nets framework [11]. We consider thisto be a very important requirement for practical reasons.We will postpone any formal definition to Section 5. In here, we focus ongiving an intuitive explanation of what our requirements are.Looking at the net in Fig. 1, we see a net on the top, which we call parent . Toeach transition of the parent net is attached another net, which we call child . Wewant use the parent net to orchestrate the executions of the children: Connecting
F. Genovese and J. Herold
Fig. 1.
A hierarchical net. input and output places of a transition in the parent net with certain placesin the corresponding child, we can represent the orchestration by saying thateach time a transition in the parent fires, its input tokens are transferred to thecorresponding child, that takes them across until they reach a place connectedwith the output place in the parent. This way, the atomic act of firing a transitionin the parent net results into an execution of the corresponding child.
Fig. 2.
Replacing transitions in the parent net of Fig. 1 with its children.
Notice that we are not interesed in considering the semantics of such hier-archical net to be akin to the one in Fig. 2, where we replaced transitions inthe parent net with their corresponding children. There are two reasons for this:First, we want to consider transition firings in the parent net as atomic events,and replacing nets as above destroys this property. Secondly, such replacement isnot so conceptually easy given that we do not impose any relationship betweenthe topologies of the parent net and its children. Indeed, the leftmost transitionof the parent net in Fig. 1 consumes two inputs, while the corresponding leftmosttransition in its child only takes one. How do we account for this in specifying arewriting-based semantics for hierarchical nets?
We concluded the last section pointing out reasons that make defining a semanticsfor hiearchic nets less intuitive than one would initially expect. Embracing anengineering perspective, we could get away with some ad-hoc solution to concilethe fact that parent and child net topologies are unrelated. One possible way, forinstance, would be imposing constraints between shapes of the parent net andits children. But in defining things ad-hoc the possibility for unforeseen corner
Categorical Semantics for Hierarchical Petri Nets 5 cases and situations we do not know how to deal with becomes high. To avoidthis we embrace a categorical perspective, and define things up to some degreeof canonicity.Making good use of the categorical work already carried out on Petri nets, ourgoal is to leverage it and get to a plausible definition of categorical semantics forhierarchical nets. Our strategy is to consider a hierarchical net as an extension ofa Petri net: The parent net will be the Petri net we extend, whereas the childrennets will be encoded in the extension.This is exactly the main tenet of [9], that is, the idea of describing netextensions with different flavors of monoidal functors. Indeed, it is our intentionto show how the theory presented in [9], and originally serving a whole differentpurpose, can be reworked to represent hierarchical nets with minimal effort.As semantics, we will use strict monoidal functors, and name it local becausethe strict-monoidality requirement amounts to endow tokens with properties thatcannot be shared with other tokens. To understand this naming choice better itmay be worth to compare it with the notion of non-local semantics , defined interms of lax-monoidal-lax functors, that we gave in [8].
Definition 4 (Local semantics for Petri nets).
Given a strict monoidalcategory S , a Petri net with a local S -semantics is a pair (cid:0) N, N (cid:93) (cid:1) , consisting ofa Petri net N and a strict monoidal functor N (cid:93) : F ( N ) → S . A morphism F : (cid:0) M, M (cid:93) (cid:1) → (cid:0) N, N (cid:93) (cid:1) is just a strict monoidal functor F : F ( M ) → F ( N ) such that M (cid:93) = F (cid:35) N (cid:93) , where we denote composition in dia-grammatic order; i.e. given f : c → d and g : d → e , we denote their composite by ( f (cid:35) g ) : c → e .Nets equipped with S -semantics and their morphisms form a monoidal categorydenoted Petri S , with the monoidal structure arising from the product in Cat . In [9], we used local semantics to describe guarded Petri nets, using
Span asour category of choice. We briefly summarize this, as it will become useful later.
Definition 5 (The category Span).
We denote by
Span the 1-category ofsets and spans, where isomorphic spans are identified. This category is symmetricmonoidal. From now on, we will work with the strictified version of
Span ,respectively.
Notation 2.
Recall that a morphism A → B in Span consists of a set S and apair of functions A ← S → B . When we need to notationally extract this datafrom f , we write A f ←− S f f −→ B We sometimes consider the span as a function f : S f → A × B , thus we maywrite f ( s ) = ( a, b ) for s ∈ S f with f ( s ) = a and f ( s ) = b . Definition 6 (Guarded nets with side effects). A guarded net with sideeffects is an object of Petri
Span . A morphism of guarded nets with side effects isa morphism in
Petri
Span . F. Genovese and J. Herold
Example 1.
Let us provide some intuition behind the definition of
Petri
Span .Given a net N , its places (generating objects of F ( N )) are sent to sets. Transitions(generating morphisms of F ( N )) are mapped to spans. Spans can be understoodas relations with witnesses , provided by elements in the apex of the span: Eachpath from the span domain to its codomain is indexed by some element of thespan apex, as it is shown in Fig. 3. Witnesses allow to consider different pathsbetween the same elements. Moreover, an element in the domain can be sentto different elements in the codomain via different paths. We interpret this as non-determinism : The firing of the transition is not only a matter of the tokensinput and output, it also includes the path chosen, which we interpret as havingside-effects that are interpreted outside of our model. s s s z z Fig. 3.
Semantics in
Span
In Fig. 3 the composition of paths is the empty span: Seeing things from areachability point of view, the process given by firing the left transition and thenthe right will never occur. This can be made precise by recasting Definition 3.
Definition 7 (Markings for guarded nets).
Given a guarded Petri net withside effects (cid:0)
N, N (cid:93) (cid:1) , a marking for (cid:0)
N, N (cid:93) (cid:1) is a pair ( X, x ) where X is an objectof F ( N ) and x ∈ N (cid:93) X . We say that a marking ( Y, y ) is reachable from ( X, x ) ifthere is a morphism f : X → Y in F ( N ) such that N (cid:93) f ( x ) = y . In the span semantics we can encode externalities in the tips of the spans we sendtransitions to. That is, given a bunch of tokens endowed with some properties, tofire a transition we need to provide a witness that testifies how these propertieshave to be handled. The main intuition of this paper is that we can use sideeffects to encode the runs of some other net: To fire a transiton in the parentnet, we need to provide a trace of the corresponding child net. This can be madeprecise relying on the following high-level result:
Theorem 1 ([20, Section 2.4.3]).
Given a category A with enough limits, a category internal in A is a monad in Span ( A ) . Categories are monads in Span ,whereas strict monoidal categories are monads in
Span ( Mon ) , with Mon being
Categorical Semantics for Hierarchical Petri Nets 7 the category of monoids and monoid homomorphisms. A symmetric monoidalcategory is a bimodule in Span ( Mon ) , that is, a monad in Span ( Mon ) withextra structure. In particular, it follows that any free symmetric strict monoidal category canbe represented as a span of monoids N • dom ←−−− N → cod −−→ N • underlying a bimodule, with N • and N → , representing the objects and arrows ofthe category, respectively, both free. We will refer to such a span as the FSSMC N (in Span ( Mon ) ) . Definition 8 (Hierarchical nets – External definition). A hierarchicalnet is a functor F ( N ) → Span ( Mon ) defined as follows: – Each generating object A of F ( N ) is sent to a set F A , called the set ofaccepting states for the place A . – Each generating morphism A f −→ B is sent to a span with the following shape: ( (cid:73) f × N • f dom f ) × N → f ( cod f × N • f (cid:4) f )( (cid:73) f × N • f dom f ) ( cod f × N • f (cid:4) f ) F A N → f F BF A N • f N • f F B (cid:73) f dom f cod f (cid:4) f (cid:113)(cid:113) (cid:113) The FSSMC N f at the center of the span is called the child net associated to f ; the morphisms (cid:73) f and (cid:4) f are called play N f and stop N f , respectively. Unrolling the definition, we are associating to each generating morphism of F ( N ) – the parent net – a FSSMC – the child net. As the feet of the spanscorresponding to the child nets will in general be varying with the net themselves,we need to pre- and post- compose them with other spans to ensure composability: (cid:73) f and (cid:4) f represent morphisms that select the initial and accepting states of N f , that is, markings of N f in which the computation starts, and markings of N f in which the computation is considered as concluded. Notice how this alsosolves the problems highlighted in Section 3, as (cid:73) f and (cid:4) f mediate between theshape of inputs/outputs of the transition f and the shape of N f itself. Remark 1.
Interpreting markings as in Definition 7, We see that to fire f in theparent net we need to provide a triple ( a, x, b ), where: F. Genovese and J. Herold – a is an element of F A , witnessing that the tokens in the domain of f providea valid initial state for N f . – x is an element of N → f , that is, a morphism of N f , and hence an executionof the child net. – b is an element of F B , witnessing that the resulting state of the execution x is accepting , and can be lifted back to tokens in the codomain of f . Definition 9 (Category of hierarchical Petri nets).
Nets (cid:0)
N, N (cid:93) (cid:1) in thecategory
Petri
Span with N (cid:93) having the shape of Definition 8 form a subcategory,denoted with Petri , and called the category of hierarchical Petri nets .Remark 2.
Using the obvious forgetful functor
Mon → Set we obtain a functor
Span ( Mon ) → Span , which allows to recast our non-local semantics in a moreliberal setting. In particular, we could send a transition to spans whose compoentsare subsets of the monoids heretofore considered. That is, we could select onlya subset of the executions/states of the child net as valid witnesses to fire atransition in the parent.In doing so, everything we do in this work will go through smoothly, but weconsider this approach less elegant, thus we will not mention it anymore.
In Section 5 we defined hierarchical nets as nets endowed with a specific kindof functorial semantics to
Span . As things stand now, Petri nets correspond tocategories, while hierarchical nets correspond to functors. This difference makes itdifficult to say what a Petri net with multiple levels of hierarchy is: Intuitively itis easy to imagine that the children of a parent net N can be themselves parentsof other nets, which are thus “grandchildren” of N , and so on and so forth.In realizing this, we are blocked by having to map N to hierarchical nets,which are functors and not categories. To make such an intuition viable, weneed a way to internalize the semantics in Definition 8 to obtain a categoryrepresenting the executions of the hierarchical net.Luckily, there is a way to turn functors into categories, which relies onan equivalence between the category of slice categories over some C and lax-functors C →
Span [15]. This is itself the 1-categorical version of a more generalequivalence between the 2-category of slice categories over C and lax-normalfunctors to the category of profunctors (this has been discovered by B´enabou [3]and worked out in painful detail in [12]).Here, we gloss over these abstract motivations and just give a very explicitdefinition of what this means, as what we need is just a particular case of theconstruction we worked out for guarded nets in [9]. Definition 10 (Internalization).
Let (cid:0)
M, M (cid:93) (cid:1) ∈ Petri be a hierarchicalnet. We define its internalization , denoted (cid:82) M (cid:93) , as the following category: Categorical Semantics for Hierarchical Petri Nets 9 – The objects of (cid:82) M (cid:93) are pairs ( X, x ) , where X is an object of F ( M ) and x is an element of M (cid:93) X . Concisely: Obj (cid:82) M (cid:93) := (cid:8) ( X, x ) (cid:12)(cid:12) ( X ∈ Obj F ( M )) ∧ ( x ∈ M (cid:93) X ) (cid:9) . – A morphism from ( X, x ) to ( Y, y ) in (cid:82) M (cid:93) is a pair ( f, s ) where f : X → Y in F ( M ) and s ∈ S M (cid:93) f in the apex of the corresponding span connects x to y . Concisely: Hom (cid:82) M (cid:93) [( X, x ) , ( Y, y )] :=:= (cid:8) ( f, s ) (cid:12)(cid:12) ( f ∈ Hom F ( M ) [ X, Y ]) ∧ ( s ∈ S M (cid:93) f ) ∧ ( M (cid:93) f ( s ) = ( x, y )) (cid:9) . The category (cid:82) N (cid:93) , called the Grothendieck construction applied to N (cid:93) , pro-duces a place for each element of the set we send a place to, and makes a transitionfor each path between these elements, as shown below: (cid:32) Notice that in the picture above, on the left, each path between coloured dots isa triple ( a, x, b ) as in Remark 1. This amounts to promote every possible traceof the child net – together with a selection of initial and accepting states – toa transition in the parent net. This interpretation is justified by the followingtheorem, which we again proved in [9]:
Theorem 2.
Given any strict monoidal functor F ( N ) N (cid:93) −−→ Span , the category (cid:82) N (cid:93) is symmetric strict monoidal, and free.Thus (cid:82) N (cid:93) can be written as F ( M ) for some net M .Moreover, we obtain a projection functor (cid:82) N (cid:93) → F ( N ) which turns (cid:82) intoa functor, in that for each functor F : (cid:0) M, M (cid:93) (cid:1) → (cid:0) N, N (cid:93) (cid:1) there exists a functor (cid:98) F making the following diagram commute: (cid:82) M (cid:93) F ( M ) (cid:82) N (cid:93) F ( N ) Span π M π N F (cid:98) FM (cid:93) N (cid:93) Theorem 2 defines a functor
Petri
Span → FSSMC , the category of FSSMCsand strict monoidal functors between them. As
Petri is a subcategory of
Petri
Span , we can immediately restrict Theorem 2 to hierarchical nets. A net inthe form (cid:82) N (cid:93) for some hiearchic net (cid:0) N, N (cid:93) (cid:1) is called the internal categoricalsemantics for N (compare this with Definition 8, which we called external ). Remark 3.
Notice how internalization is very different from just copy-pasting achild net in place of a transition in the parent net as we discussed in Section 3.Here, each execution of the child net is promoted to a transition, preserving theatomicity requirement of transitions in the parent net.Clearly, now we can define hiearchic nets with a level of hiearchy higher than2 by just mapping a generator f of the parent net to a span where N f is in theform (cid:82) N (cid:93) for some other hierarchical net N , and the process can be recursivelyapplied any finite number of times, for each transition. We deem wise to spend a few words on why we consider this way of doing thingsadvantageous from an applicative point of view. Petri nets have been consideredas a possible way of producing software for a long time, with some startups evenusing them as a central tool in their product offer [18]. Providing some formof hierarchical calling is absolutely needed to make the idea of “Petri nets as aprogramming language/general purpose design tool” practical.Our definition of hierarchy has the great advantage of not making hiearchicnets more expressive than Petri nets. If this seems like a downside, notice thata consequence of this is that decidability of any reachability-related question isexactly as for Petri nets, which is a great advantage from the point of view ofmodel checking. Internalization, moreover, allows to compile hierarchical netsback to Petri nets, so that we can use already widespread tools for reachabilitychecking [19] without having necessarily to focus on producing new ones.Moreover, and actually more importantly, our span formalism works reallywell in modelling net behavior in a distributed setting. The parent and childrennets may exist on different machines, and are not required to be engineered in amonolithic fashion.To better understand this, imagine an infrastructure where each Petri net isconsidered as a piece of data with its own address (as it would be, for instance,if we were to implement nets as smart contracts on a blockchain). The way ofoperating Petri nets in this formalism is transactional : A user sends a messageconsisting of a net address, the transaction the user intends to fire, and sometransaction data. The infrastructure replies affirmatively or negatively if thetransaction can be fired, which amounts to accept or reject the transaction.Clearly this is particularly suitable for blockchain-related contexts and is how
Categorical Semantics for Hierarchical Petri Nets 11 applications such as [17] implement Petri nets in their services. dbbfe69836 t t t data:from: 832344009dto: dbbfe69836command: OKdata: From this point of view, a hierarchical net would work exactly as a standardPetri net, with the exception that in sending a transaction to the parent net theuser has also to specify, in the transaction data, a valid execution of the childnet corresponding to the firing transition. dbbfe69836 t t t t t t t t t data: t (cid:35) t from: 832344009dto: 2f9b1ee0dccommand: t (cid:35) t data:from: 2f9b1ee0dcto: 832344009dcommand: OKdata:from: 832344009dto: dbbfe69836command: OKdata: Again, from a smart contract standpoint, this means that the smart contractcorresponding to the parent net will call the contract corresponding to the childnet with some execution data, and will respond affirmatively to the user only ifthe generated call resolves positively.All the possible ways of executing the contracts above form a category,which is obtaining by internalizing the hierarchical net corresponding to themvia Theorem 2.Internalized categories being free, they are presented by Petri nets, which wecan feed to any mainstream model checker. Now, all sorts of questions aboutliveness and interaction of the contracts above can be analyzed by model-checkingthe corresponding internalized net.This provides an easy way to analyze complex contract interaction, relyingon tools that have been debugged and computationally optimized for decades.
In this work, we showed how a formalism for guarded nets already worked outin [9] can be used to define the categorical semantics of some particular flavorof hierarchical nets, which works particularly well from a model-checking anddistributed-implementation point of view. Our effort is again part of a moreample project focusing on characterizing the categorical semantics of extensionsof Petri nets by studying functors from FSSMCs to spans [8, 7].As a direction of future work, we would like to obtain a cleaner way ofdescribing recursively hierarchical nets. In this work, we relied on the Grothendieckconstruction to internalize a hierarchical net, so that we could use hierarchicalnets as children of some other another parent net, recursively. This feels a bit likethrowing all the carefully-typed information that the external semantics givesinto the same bucket, and as such it is a bit unsatisfactory. Ideally, we would liketo get a fully external semantics for recursively hierarchical nets, and generalizethe internalization result to this case.Another obvious direction of future work is implementing the findings herebypresented, maybe relying on some formally verified implementation of categorytheory such as [4].
Acknowledgements
The author was supported by the project MIUR PRIN2017FTXR7S “IT-MaTTerS” and by the Independent Ethvestigator Program.A video presentation of this paper can be found on Youtube at 4v5v8tgmiUM.
References [1] J. C. Baez, F. Genovese, J. Master, and M. Shulman.
Categories of Nets .2021. arXiv: (cit. on p. 2).
Categorical Semantics for Hierarchical Petri Nets 13 [2] J. C. Baez and J. Master. “Open Petri Nets”. In:
Mathematical Struc-tures in Computer Science doi :
10 . 1017 /S0960129520000043 . arXiv: (cit. on p. 1).[3] J. B´enabou. “Introduction to Bicategories”. In: J. B´enabou, R. Davis, A.Dold, J. Isbell, S. MacLane, U. Oberst, and J. .-E. Roos.
Reports of theMidwest Category Seminar . Vol. 47. Berlin, Heidelberg: Springer BerlinHeidelberg, 1967, pp. 1–77. doi : (cit. on p. 8).[4] F. Genovese, A. Gryzlov, J. Herold, A. Knispel, M. Perone, E. Post, andA. Videla. Idris-Ct: A Library to Do Category Theory in Idris . 2019. arXiv: (cit. on pp. 1, 12).[5] F. Genovese, A. Gryzlov, J. Herold, M. Perone, E. Post, and A. Videla.
Computational Petri Nets: Adjunctions Considered Harmful . 2019. arXiv: (cit. on pp. 1, 2).[6] F. Genovese and J. Herold. “Executions in (Semi-)Integer Petri Nets AreCompact Closed Categories”. In:
Electronic Proceedings in TheoreticalComputer Science
287 (2019), pp. 127–144. doi : (cit. on p. 2).[7] F. Genovese, F. Loregian, and D. Palombi. A Categorical Semantics forBounded Petri Nets . 2021. arXiv: (cit. on pp. 1,12).[8] F. Genovese, F. Loregian, and D. Palombi.
Nets with Mana: A Frameworkfor Chemical Reaction Modelling . 2021. arXiv: (cit. on pp. 1, 5, 12).[9] F. Genovese and D. I. Spivak. “A Categorical Semantics for Guarded PetriNets”. In:
Graph Transformation . Ed. by F. Gadducci and T. Kehrer.Vol. 12150. Lecture Notes in Computer Science. Cham: Springer Interna-tional Publishing, 2020, pp. 57–74. doi : (cit. on pp. 1, 2, 5, 8, 9, 12).[10] K. Jensen and L. M. Kristensen. Coloured Petri Nets . Berlin, Heidelberg:Springer Berlin Heidelberg, 2009. doi : (cit. on p. 3).[11] M. K¨ohler-Bußmeier. “A Survey of Decidability Results for ElementaryObject Systems”. In: Fundamenta Informaticae doi : (cit. on p. 3).[12] F. Loregian. Coend Calculus . 2019. arXiv: (cit. onp. 8).[13] J. Master. “Petri Nets Based on Lawvere Theories”. In:
MathematicalStructures in Computer Science doi : . arXiv: (cit. on pp. 1–3).[14] J. Meseguer and U. Montanari. “Petri Nets Are Monoids”. In: Informationand Computation doi : (cit. on pp. 1, 2).[15] D. Pavlovi´c and S. Abramsky. “Specifying Interaction Categories”. In: Category Theory and Computer Science . Ed. by E. Moggi and G. Rosolini.Red. by G. Goos, J. Hartmanis, and J. van Leeuwen. Vol. 1290. Lecture
Notes in Computer Science. Berlin, Heidelberg: Springer Berlin Heidelberg,1997, pp. 147–158. doi : (cit. on pp. 1, 8).[16] V. Sassone. “On the Category of Petri Net Computations”. In: TAPSOFT’95: Theory and Practice of Software Development . Ed. by P. D. Mosses,M. Nielsen, and M. I. Schwartzbach. Red. by G. Goos, J. Hartmanis, andJ. Leeuwen. Vol. 915. Berlin, Heidelberg: Springer Berlin Heidelberg, 1995,pp. 334–348. doi : (cit. on p. 2).[17] Statebox Team. Statebox, Compositional Diagrammatic Programming Lan-guage . 2017. url : https://statebox.org (cit. on p. 11).[18] Statebox Team. The Mathematical Specification of the Statebox Language .2019. arXiv: (cit. on p. 10).[19] University of Torino.
GreatSPN Github Page . 2018. url : https://github.com/greatspn/SOURCES (cit. on p. 10).[20] F. Zanasi. Interacting Hopf Algebras: The Theory of Linear Systems . 2018.arXiv:1805.03032 [cs, math]