**1. Introduction**

Petri net is a graphical tool invented by Carl Adam Petri [13]. These are used for describing, designing and studying discrete event-driven dynamical systems that are characterized as being concurrent, asynchronous, distributed, parallel, random and/or nondeterministic. As a graphical tool, Petri net can be used for planning and designing a system with given objectives, more practically effective than flowcharts and block diagrams. As a mathematical tool, it enables one to set up state equations, algebraic equations and other mathematical models which govern the behavior of discrete dynamical systems. Still, there is a drawback inherent in representing discrete event-systems. They suffer from the state explosion problem as what will happen when a system is highly populated, i.e., initial state consists of a large number of places that are nonempty. This phenomenon may lead to an exponential growth of its reachability graph. This makes us to study the safe systems. The aim of this chapter is to present some basic results on 1-safe Petri nets that generate the elements of a Boolean hypercube as marking vectors. Complete Boolean hypercube is the most popular interconnection network with many attractive and well known properties such as regularity, symmetry, strong connectivity, embeddability, recursive construction, etc. For brevity, we shall call a 1-safe Petri net that generates all the binary *n*-vectors as marking vectors a *Boolean Petri net*. *Boolean Petri nets* are not only of theoretical interest but also are of practical importance, required in practice to construct control systems [1]. In this chapter, we will consider the problems of characterizing the class of Boolean Petri nets as also the class of *crisp* Boolean Petri nets, viz., the Boolean Petri nets that generate all the binary *n*-vectors exactly once. We show the existence of a disconnected Boolean Petri net whose reachability tree is homomorphic to the *n*-dimensional complete lattice *Ln*. Finally, we observe that characterizing a Boolean Petri net is rather intricate.

We begin by showing that a 1-safe *Star Petri net Sn* [5], with |*P*| = *n* and |*T*| = *n* + 1, having a central transition, is a Boolean Petri net; here, *P* is the set of its places and *T* is the set of its transitions. Often, it is desirable to have a crisp Boolean Petri net because one may possibly explore for existence of certain sequences of enabled transitions to fire toward initiating and completing a prescribed process that uses specified nodes of the Boolean lattice.

©2012 Kansal et al., licensee InTech. This is an open access chapter distributed under the terms of the Creative Commons Attribution License (http://creativecommons.org/licenses/by/3.0),which permits unrestricted use, distribution, and reproduction in any medium, provided the original work is properly cited. ©2012 Kansal et al., licensee InTech. This is a paper distributed under the terms of the Creative Commons Attribution License (http://creativecommons.org/licenses/by/3.0), which permits unrestricted use, distribution, and reproduction in any medium, provided the original work is properly cited.

For example, in the design of generalized switches such as those used to control automatic machines [1], suppose that we have a sequence of *n* terminals each of which can be either at a prescribed low-voltage (denoted by zero '0') or at a prescribed high-voltage (denoted by unity, '1'). It is required to arrange them so that every one of the 2*<sup>n</sup>* sequences of *n* bits, corresponding to the 2*<sup>n</sup>* binary n-tuples, can appear on the terminals [1]. Now that *Qn*, the binary *n*-cube, is known to be Hamiltonian (in the sense that there exists an all-vertex covering cycle) one can design a "Hamiltonian switch" using a crisp Boolean Petri net that triggers operation of a machine exactly once after 2*<sup>n</sup>* successive switching moves along the prescribed Hamiltonian cycle in *Qn*. The 'switch design' may be imagined to be an arbitrary connected graph of order 2*n*, where connection between a pair (*u*, *v*) of nodes would mean that *v* is to be the terminal that needs to be turned on after the terminal corresponding to *u* (which may or may not be in an active state depending on the machine design). Therefore, a good characterization of such Boolean Petri nets is needed. This problem is still open. Many specific classes of such 1-safe Petri nets have been found [5–7]. Also, many fundamental issues regarding Boolean Petri nets emerge from this study.

where arcs are either from a place to a transition or from a transition to a place. No two of the same kind being adjacent. Hence, Petri nets have a well known graphical representation in which transitions are represented as boxes and places as circles with directed arcs interconnecting places and transitions, to represent the flow relations. The initial marking is represented by placing a token, shown as a black dot, in the circle representing a place *pi*, whenever *<sup>μ</sup>*0(*pi*) = 1, 1 <sup>≤</sup> *<sup>i</sup>* <sup>≤</sup> *<sup>n</sup>* <sup>=</sup> <sup>|</sup>*P*|. In general, a *marking <sup>μ</sup>* is a mapping *<sup>μ</sup>* : *<sup>P</sup>* −→ **<sup>N</sup>**. A

**Definition 2.** *Let C* = (*P*, *<sup>T</sup>*, *<sup>I</sup>*−, *<sup>I</sup>*+, *<sup>μ</sup>*) *be a Petri net. A transition t* <sup>∈</sup> *T is said to be enabled at <sup>μ</sup> if and only if I*−(*p*, *t*) ≤ *μ*(*p*)*,* ∀*p* ∈ *P. An enabled transition may or may not 'fire' (depending on whether or not the event actually takes place). After firing at μ, the new marking μ*� *is given by the rule*

(*p*) = *<sup>μ</sup>*(*p*) <sup>−</sup> *<sup>I</sup>*−(*p*, *<sup>t</sup>*) + *<sup>I</sup>*+(*p*, *<sup>t</sup>*)*, for all p* <sup>∈</sup> *P.*

*<sup>μ</sup>*<sup>0</sup> *<sup>t</sup>*<sup>1</sup> −→ *<sup>μ</sup>*<sup>1</sup> *<sup>t</sup>*<sup>2</sup> −→ *<sup>μ</sup>*<sup>2</sup> *<sup>t</sup>*<sup>3</sup> −→ *<sup>μ</sup>*<sup>3</sup> ··· *tk* −→ *<sup>μ</sup>k*,

*t*1, *t*2, *t*3,..., *tk*

have been successively fired to transform the *initial marking μ*<sup>0</sup> into the *terminal* marking *μk*. The whole of this sequence of transformations is also written in short as *<sup>μ</sup>*<sup>0</sup> *<sup>σ</sup>* −→ *<sup>μ</sup>k*, where

A marking *μ* is said to be *reachable from μ*0, if there exists a firing sequence of transitions which successively fire to reach the state *μ* from *μ*0. The set of all markings of a Petri net *C* reachable from a given marking *μ* is denoted by *M*(*C*, *μ*) and, together with the arcs of the

Petri net *C*, denoted by *R*(*C*, *μ*0). In particular, if the reachability graph has no semicycle then

A place in a Petri net is *safe* if the number of tokens in that place never exceeds one. A Petri

The *preset* of a transition *t* is the set of all input places to *t*, i.e., •*t*={*p* ∈ *P* : *I*−(*p*, *t*) > 0}. The

preset and postset are • *<sup>p</sup>*={*<sup>t</sup>* <sup>∈</sup> *<sup>T</sup>* : *<sup>I</sup>*+(*p*, *<sup>t</sup>*) <sup>&</sup>gt; <sup>0</sup>} and *<sup>p</sup>*•={*<sup>t</sup>* <sup>∈</sup> *<sup>T</sup>* : *<sup>I</sup>*−(*p*, *<sup>t</sup>*) <sup>&</sup>gt; <sup>0</sup>}, respectively. **Definition 3.** *Let C* = (*P*, *<sup>T</sup>*, *<sup>I</sup>*−, *<sup>I</sup>*+, *<sup>μ</sup>*0) *be a Petri net with* <sup>|</sup>*P*<sup>|</sup> <sup>=</sup> *n and* <sup>|</sup>*T*<sup>|</sup> <sup>=</sup> *m, the incidence*

*matrix I* = [*aij*] *is an n* <sup>×</sup> *m matrix of integers and its entries are given by aij* <sup>=</sup> *<sup>a</sup>*<sup>+</sup>

*number of arcs from place pi to its output transition tj i.e., in other words, I* <sup>=</sup> *<sup>I</sup>*<sup>+</sup> <sup>−</sup> *<sup>I</sup>*−.

*ij =I*+(*pi*, *tj*) *is the number of arcs from transition tj to its output place pi and a*<sup>−</sup>

, represents what in standard terminology is called the *reachability graph* of the

said to be *directly reachable* from *μ*. Hence, it is clear, what is meant by a sequence like

), and we write *μ*

*t* −→ *μ*�

•={*<sup>p</sup>* <sup>∈</sup> *<sup>P</sup>* : *<sup>I</sup>*+(*p*, *<sup>t</sup>*) <sup>&</sup>gt; <sup>0</sup>}. Similarly, *<sup>p</sup>*�

*th* component

Boolean Petri Nets 383

, whence *μ*� is

*s*

*ij where*

*ij* − *a*<sup>−</sup>

*ij =I*−(*pi*, *tj*) *is the*

marking *<sup>μ</sup>* can hence be represented as a vector *<sup>μ</sup>* <sup>∈</sup> **<sup>N</sup>***n*, *<sup>n</sup>* <sup>=</sup> <sup>|</sup>*P*|, such that the *<sup>i</sup>*

of *μ* is the value *μ*(*pi*), viz., the number of tokens placed at *pi*.

*μ*�

We say that *t fires at μ* to yield *μ*� (or, that *t fires μ* to *μ*�

which simply represents the fact that the transitions

it is called the *reachability tree* of the Petri net.

*postset* of *t* is the set of all output places from *t*, i.e., *t*

net is *safe* if all its places are safe.

form *<sup>μ</sup><sup>i</sup> tr* −→ *<sup>μ</sup><sup>j</sup>*

*a*+

*σ* = *t*1, *t*2, *t*3,..., *tk* is called the corresponding *firing sequence*.
