1514

IEEE TRANSACTIONS ON AUTOMATIC CONTROL, VOL. 43, NO. 11, NOVEMBER 1998

Boundedness Analysis of Finitely Recursive

ProcessesPart I: Concurrent Processes
Supratik Bose, Amit Patra, Member, IEEE, and Siddhartha Mukhopadhyay, Member, IEEE

AbstractIn the finitely recursive process (FRP) model of discrete event systems (DES), concepts about processes and process
operators have been introduced. An infinite set of process expressions or functions can be built recursively through function
composition using a few elementary operators. Given any process
realization, it is important to find out whether the process is
bounded, i.e., whether it has a finite state realization. In the
FRP setting this translates to the problem of finding out whether
the set of post-process expressions is finite or not. In Cieslak
and Varaiya (1990) it has been shown that the boundedness
problem is undecidable for general FRPs. This paper investigates
the decidability of the problem for subclasses of FRP. In Inan
and Varaiya (1988), it was conjectured that the set of functions
that can be recursively generated using the parallel composition
operator (PCO) and different change operators [i.e., without
using the Sequential Composition Operator (SCO)] will be finite
and FRPs constructed over this set of functions will naturally
be bounded. In the present work a counterexample has been
provided to disprove the conjecture about the finiteness of the
above set of functions. However, using a suitable post-process
computation procedure, it has been shown here that the FRPs,
built recursively over this set of functions, are bounded.
Index TermsBoundedness, discrete-event systems, finitely recursive processes, process algebra models.

Projection of on the process

Traces of the process
Alphabet function of the process
Termination function of the process
Deterministic projection operator.
Deterministic partial order (subprocess).
Deterministic marked process space.
Deterministic marked nonterminating process space.
Constant nonterminating process
Constant
.

terminating

process

Deterministic choice operator.

Sequential composition operator.
Parallel composition operator.
Local change operator
Local change operator
Global
Change
operator

NOMENCLATURE
Fixed finite collection of event symbols.
Set of finite length strings (also
called traces) formed with elements
of
Null string.
String containing a single event
String containing
Concatenation of the string
Followed by string
Language
Prefix-closed

Prefix closed if
Family of prefix-closed languages
over
Length of the string
repeated times.

Manuscript received October 25, 1996; revised December 2, 1997. Recommended by Associate Editor, E. K. P. Chong. This work was supported in part
by the University Grants Commissions Young Teachers Career Development
Award to S. Mukhopadhyay.
S. Bose was with the Department of Electrical Engineering, Indian Institute
of Technology, Kharagpur 721302, India. He is now with Siemens Information
Systems Limited, Bangalore, India.
A. Patra and S. Mukhopadhyay are with the Department of Electrical
Engineering, Indian Institute of Technology, Kharagpur 721302, India.
Publisher Item Identifier S 0018-9286(98)08494-3.
00189286/98$10.00 1998 IEEE

Global

change

operator

Set of constant symbols of

Set of constant symbols of
Signature over
Syntax set over
Semantics set over
Realization of the FRP
Algebraic

process

space

over

Set of post-process expressions of

Length of function expression
Subexpressions of
and are syntactically equivalent.
has a structure
and are semantically equivalent.
Minimum present alphabet function.
Minimum absent alphabet function.
where
where

BOSE et al.: BOUNDEDNESS ANALYSISPART I: CONCURRENT PROCESSES

Syntactic

transformations

over

Set of post-process expressions of

computed under transformation
Subsets of
Component expressions of
Merging

Closure

relation

over

Corresponding result of merging.

Tree representation of
Nodes of
Leaf nodes of
Number of leaf nodes of
Closure algorithm over
Recursive merging procedure over
Component expressions obtained
from realization
Variants of expressions of
Minimum locally present alphabet
function.
Syntactic transformations over
.
Subsets of
.
Child expressions of
.
Merging
relation
over
.
Corresponding result of merging.
Closure
algorithm
over
.
Recursive merging procedure over
.
I. INTRODUCTION

ISCRETE-EVENT systems (DESs) and their modeling,

analysis, observation, and control have been receiving
increasing attention in the last decade. Such systems are
characteristically asynchronous, event driven, often nondeterministic or admit choice of events by some unmodeled
mechanism (environment). They are generally modular and
made up of distinct subsystems that evolve concurrently and
with interactions in the form of interlocks, communication
via channels, or shared physical variables. In this work we
are concerned with the logical behavior of DESs, namely
the sequence of events that occurs in the system. Structural
properties such as liveness, reachability, etc. need to be
assessed or ensured by proper design. Furthermore, these
systems often are required to meet hard real-time deadlines.
It is difficult to capture all logical and qualitative features
of DESs efficiently in a single model. Attempts have been
made to use existing modeling tools from the field of computer
science. Notable among them are: finite state machines (FSM)

1515

[11], Petri nets (PN) [13], communicating sequential processes

(CSP) [6], calculus of communicating systems (CCS) [9],
timed transition models (TTM) [10], and finitely recursive
processes (FRP) [7]. Programming languages such as Ada and
Occam, as well as simulation languages such as GPSS, Simula,
etc., have also been used for simulating and controlling such
systems.
The process algebra models, including CSP, CCS, and FRP,
aim at describing complex DESs in terms of an algebra [5].
Such models are being investigated for nearly two decades
for providing clear mathematical semantics to programming
languages. Although used mainly in this context, the models
and the associated theories are useful to model general DES
dynamics.
The present work deals with the FRP formalism of DESs.
The basic unit of this model is a process, consisting of a trace
(set of prefix closed event sequences), an alphabet function,
and a termination function over the traces. There are a few
constant processes. Other processes can be built from the basic
processes, in a finite and recursive way, with the help of a
collection of operators. The set of operators for deterministic
processes includes the deterministic choice operator
(choosing a process or event among different alternatives),
(concurrent operation of
parallel composition operator
(sequential
processes), sequential composition operator
operation of processes), and local and global alphabet change
Recently a nondeterministic version
operators
of FRP has also been proposed [12]. However, the scope of this
paper is restricted only to the deterministic case. As a modeling
framework, FRP offers several advantages over other similar
frameworks. It facilitates modular and hierarchical model
building which itself is an advantage over flat modeling
paradigms such as the FSM. In general, the structure of a
process captures explicitly the physical and logical structure
of the underlying system. In terms of describing power it is
quite powerful and can model any FSM, PN, or deterministic
CSP.
For practical applicability of the model, it is important to
know if typical problems associated with a system, described
in this model, can be solved algorithmically, i.e., whether
these problems are decidable. The first step toward finding
algorithmic solutions of properties of any FRP is to find out
whether the process is bounded. An FRP is bounded if the
set of post-processes of the FRP, which defines the future
behavior of the process from a given point of its evolution
and which is analogous to the set of states, is finite. For
bounded FRPs, a finite state implementation is thus possible
and all related issues become solvable in principle. However,
for general FRPs, it has been shown that boundedness and
consequently several other issues like reachability, deadlock,
etc., are undecidable [3]. This has been a deterrent to the
practical use of the FRP formalism, since problems related
to a system cannot be solved algorithmically for arbitrary
processes.
It is therefore worthwhile to investigate whether there exist
subclasses of FRPs where boundedness is either guaranteed or
at least decidable. Such subclasses must also retain sufficient
modeling features in order to be able to capture real-world

1516

IEEE TRANSACTIONS ON AUTOMATIC CONTROL, VOL. 43, NO. 11, NOVEMBER 1998

DES behavior. In general, such classes will be characterized

by appropriate restrictions on the use of operators in the
construction of process expressions. Since the major reason
behind undecidability of boundedness for general FRPs is
s and
s in the recurthe unrestricted use of both
sive procedure of generating functions through composition,
two subclasses of FRPs are formed here; one built over
and
and the other built over
and
In this part of the work, the boundedness properties
of the first subclass of FRPs have been explored. In [7], it
was conjectured that this set of recursively generated functions
is finite. However, a counterexample presented in this paper
shows that it is not true. This is a new result, and it leads
to a deeper investigation into the question of unboundedness
Interestingly, it has been found that,
in the absence of
because of the recursive structure of the FRPs, any FRP of
this subclass is actually bounded, in spite of the infiniteness
of the underlying set of functions. Thus boundedness for this
subclass of FRPs is guaranteed.
The paper is organized as follows. Section II presents the
basic definitions and results. In Section III, finiteness and
and
boundedness properties of FRPs, built over the
other change operators, are characterized. Some conclusions
from the work are presented in section IV.

The basic processes in this model are

for some
where

and

They are actually do-nothing processes, the former denoting

an unsuccessful termination or deadlock and the latter denoting
a successful termination.
a projection operator
is
For any
defined as follows. For any
length of

Clearly, for any

is either
or
where
The basic operators that have been defined over this model
are as follows.
: Given
and distinct
Definition 2.1
from
the DCO (denoted as
events
is defined as follows.
then
If
If
then

II. PRELIMINARIES
In this section, we shall briefly introduce the FRP model
of DESs and formulate the boundedness problem over this
model. However, the reader is requested to go through [7] or
[8] for detailed discussions on this model.
is the set
Let be a finite collection of event symbols.
For
of all possible event strings formed with elements from
then
example if
where denotes the null string. For any two strings
and
denotes the concatenation of the strings
and
Also,
Note that
(followed by)
The prefixes of
in [7] the null string was denoted as
will be
and
Let
be the set of
the string
where each process
processes formed over events from
is expressed formally as a 3-tuple
1) The set
is the prefix-closed set of traces
(event sequences) that can take place in
2)
is the alphabet function, so that
is the set of events
can execute or block after it has
generated the event sequence
3)
is the termination function where
represents successful termination of after
generation of the event sequence in
is a subprocess of
(denote it as
if
and
and
and
are equal,
if
, and
is the set of
processes which never terminate successfully.
describes the behavior of
after
The post process
has been generated in it:
a string

Definition 2.2
the
events and

: Given a process and collection of

is defined as follows:
is not the first
event of
for
including

Definition 2.3
of events and

the

: Given a process
and collection
is defined as follows:
is not in

For notational convenience, from now on, two types of

s and
s will be in use:
or
(mean) and
or
(meaning
),
ing
and
and similarly

BOSE et al.: BOUNDEDNESS ANALYSISPART I: CONCURRENT PROCESSES

Definition 2.4
composition

: Given
is defined as

and

the sequential

if
if

1517

Among the above operators, some are unary and some are
binary in nature. Each binary (unary) operator is actually a
function over two (one) processes. More complex functions
in multiple process arguments can be composed as process
expressions by repeated application of these operators. The
following definitions will be quite useful in representing such
a set of functions.
First, we define
a set of functional symbols (also called a
signature [5]) corresponding to the different process operators,
as follows.
Definition 2.6 (Signature): The signature set

if
otherwise.
Intuitively,
behaves initially as
Once
termiThe sequential composinates successfully, it behaves as
tion operator is a particularly important operator as it allows
recursive and re-entrant description.
between two proThe parallel composition operator
and
generates a new process (denoted by
cesses
which depicts the concurrent operation of two processes.
: The projection of a string
Definition 2.5
on a process (denoted by
) is defined as follows:

and
undefined if
if
if
Then, for processes
is defined as:

If

and

the parallel composition

then

iff
and

Corresponding to each element

we construct the
over processes in a natural way and then construct
function
For example
the set of functions

Similarly, we have functions corresponding to other elements

Formally
is the set of functions defined as follows:
of

Note that a clear distinction is being made between the

functional symbols (syntax) and the functions (semantics)
is a functional symbol, whereas
themselves. Thus
is a function from
to
The need for such a distinction
will be clear at a later stage.
be a collection of arbitrary
Let
processes.
and
Next, corresponding to the basic processes like
we define a set of constant function symbols
and constant functions as follows.
Definition 2.7 (Constant Symbols):

Finally
and

if
otherwise.

The process
after generating an event sequence
can execute an event from
iff both
and
execute the event synchronously. Otherwise, such
an event will be blocked because of lack of participation from
belongs to any of
one of the components. Otherwise, if
then, it can take
if it takes place in
since
cannot block
place in
such an event.

Note that
is an -argument function,
is the corresponding symbol, while
is a constant
process.
Definition 2.8 (Projection Symbols): For any

The
function simply yields its th argument. Note
and
with
that for any three positive integers

1518

IEEE TRANSACTIONS ON AUTOMATIC CONTROL, VOL. 43, NO. 11, NOVEMBER 1998

the function
belongs to both
and
However, in the first case it is an
-ary
function and in the second case it is an -ary function.
over a signature
After having a family of functions
for some
one can define recursively the infinite class
and the corresponding set of
of functional symbols
from
to as follows.
functions
): It is defined recursively as:
Definition 2.9 (

and
implies
where
has an arity
Definition 2.10

represent the same function. It can be easily checked that for

arbitrary processes

Definition 2.11 (Syntactic Equivalence): Given

and are syntactically equivalent
any of the following is true.
and are both
or
or
1)
2)
(meaning
has a structure
some

and

),

3)
5)
6)
7)

So the process

can be expressed as

as a function with multiple arguments.

the trace, alphabet, and termiFor any process
and
nation functions are denoted as
respectively, where
Remark 2.1 (Notational Simplification): From now on, for
the purpose of clarification we shall simplify our notations
by using standard infix notations recursively as
of
follows.
is written as
in simplified form.

if
is
For any
first
is expressed in notationally simplified form,
symbol is then removed, and finally
its outermost
is written as
The same rule is applied
and
Thus
for
is simplified as
For

if is
or
first
and
are expressed in notationally
simplified form and the outermost symbols are removed.
or
respectively.
Then is written as
and
are
After simplification, since both
associative in nature [7], whenever the removal of
the braces does not cause any confusion regarding the
scope of any of the functions, they will be removed.
will be expressed as
For example
As an example,
will be written as
A distinction between syntax and semantics is needed becan represent
cause different functional symbols in
the same function. For example, the syntactically distinct
and
(for some
)
expressions

for
and

and

4)
and

if

and

and
and
such that for every
there
with
and vice-versa.
exists
The above definition implies that
is syntactically
and
Also clearly
equivalent to both
is an equivalence relation. Because of the notational
implies that
simplification we can conclude that
A similar statement
none of the has a structure
also.
holds for
Definition 2.12 (Semantic Equivalence): Given
and are semantically equivalent,
if
and

Thus
and
are syntactically distinct but semantically equivalent.
Again it is easy to see that is an equivalence relation
Moreover is finer than i.e.,
over
implies
but not vice-versa.
Definition 2.13 (Length of Expressions and Subexpressions):
the length of
and set of subexFor
are defined recursively as follows.
pressions of
and
for
1)
or
2)
and
for
or
.
and
3)
for
or
The aim of defining all these operators is to provide a finite
The following
and recursive description of processes from
definitions and results show how it is achieved.
Definition 2.14 (Mutually Recursive Processes): A finite
is called a family of mutually recursive
set
if
processes (MRP) with respect to
we have
for some
Theorem 2.1:
is a family of MRP w.r.t.
iff
is the unique solution of
the recursive equation with consistent initial condition
(1)

BOSE et al.: BOUNDEDNESS ANALYSISPART I: CONCURRENT PROCESSES

where
that is

and each component

of

1519

is guarded,

(2)

and
is a suitable
with each
choice of initial alphabet and termination, such that
and
Proof: For the proof, see [7].
Definition 2.15 [Finitely Recursive Processes (FRP)]: A
is said to be a finitely recursive process
process
if it can be represented
(FRP) with respect to
where
is
as
is said to be a
of the form (2) and
realization of the FRP
Definition 2.16 (Algebraic Process Space): The collection
is denoted as
of all possible FRPs w.r.t
The algebraic process space
is defined as

Example 2.1 (Multiple Realizations of FRPs): A process

can have multiple FRP realizations. For example, consider the
process such that
Below we give three
and ) of the process
realizations (i.e.,
1)
2)
3)
Given any
let
and
represent respectively the initial alphabet
initial
, and the set of initial events (i.e., the
termination
where
events corresponding to one-length strings) of
is the unique solution of the equation
and
each equation of is of the form (2). These quantities can be
computed easily, in a recursive manner (as in [4]), using the
in the form of initial marking and
information present in
choices of the DCOs and the definition of different operators.
Consider for example the third realization of process
in Example 2.1. If
then
For any
with realization
and
the procedure to compute the postby syntactic substitution, such that
process expression
given in [7], is described below.
Definition 2.17 (Post-Process Computation): Given a set of
satisfying
and
processes
for some
the post-process
) is an element of
such
expression (denoted as
and is computed recursively
that
using the following rules.
where
and the equation

in
is of the form of (2), i.e.,
describing

Here

(Note:

if
and
if

if
if
Finally for
with realization
the set of postprocess expressions
is computed recursively
as follows.
1)
2)
Fact 2.1: It is easy to check that
is closed
under post-process operation, that is, if
with realization
for some
then for any
for some
Example 2.2 (Post-Process Expressions): Refer to the three
in Example 2.1.
for these
realizations of the process
three cases are as follows.
for realization (1).
1)
for re-

2)
alization (2).

for realization (3).

3)
Based on the definitions and results presented above, boundedness for FRPs can be defined as follows. Ideally a process
should be called bounded if the number of its distinct postprocesses is finite. This is because each distinct post-process
behaves as a state in a state machine realization of the process
and finiteness of the number of distinct post processes implies
a finite-state realization. If we use this definition, then the
process in Example 2.1 is bounded, irrespective of its three
realizations presented there.
Unfortunately there does not exist any general computation
mechanism to count the number of distinct post-processes of
with realizaan FRP. But, for any FRP
Fact 2.1 guarantees that for every
it will
tion
such that
be possible to find a
where
The expression
is obtained from by
as
simple syntactic substitutions along the event sequence
mentioned earlier. The definition of boundedness could then
with realization
be modified as follows. An FRP
is said to be bounded (under the post-process computation
the set of post-process expressions
procedure described) if
After computing g=; the outermost 1 symbol of (g=) is first
removed before placing it in (g= )[[0B]][[+C]] : It has not been shown explicitly. The same has been done in all subsequent cases where g= appears as
a proper subexpression. From now on, for any simplified expression g; g1 ; g2 ;
and event set C  6; each of g [[0C]] ; g [0C] ; g [[+C]] ; g [+C] ; g1 jjg2 ; g1 ; g2
will denote a simplified expression, where the outermost 1 symbol from each
of g; g1 ; g2 is implicitly removed before forming these expressions so that
there is no nested 1 symbol.
1 Note:

1520

IEEE TRANSACTIONS ON AUTOMATIC CONTROL, VOL. 43, NO. 11, NOVEMBER 1998

of
is finite. In this definition boundedness is viewed as a
property of the particular realization of the FRP. Referring to
Examples 2.1 and 2.2, we then find that based on the second
definition, is bounded in its first realization but unbounded
in its second and third realizations.
it
In case of the second realization of the process
should be noted that the different syntactic expressions
are
This fact leads us
all semantically equivalent to
to formulate a definition of boundedness which is closer (in
spirit) to the first (ideal) definition of boundedness. Given
and
let
some FRP with realization
be some syntactic transformation over elements of
such that for any
Then, the simple post-process expression computation
procedure mentioned earlier can be modified by applying
this transformation along with syntactic substitution and one
can hope that many redundancies, like those present in second
in Example 2.2, will be taken care of by
realization of
the set of post-process
this transformation. Formally,
expressions, is computed as follows.
1)
2)
where
is computed by the recursive procedure
mentioned earlier. Finally, boundedness is defined as
below.
Definition 2.18 (Boundedness): An FRP
with realization
is said to be bounded under
the post-process expression computation procedure involving
(having the property that
some syntactic transformation
for any
and
if
is finite.
Note that, in this definition, boundedness becomes a property of the realization of the process with respect to a syntactic
substitution used in the computation of post-process expressions.
The following definitions and results will be useful in
defining suitable syntactic transformations to take care of
functional redundancies among function symbols.
First we present the concept of minimum present and
minimum absent alphabet in function symbols. Because of
and the
operators, given some
the
it is possible to have a lower
function
bound on the minimum set of events that is present (or
absent) everywhere in the alphabet along the traces of
irrespective of which particular
is chosen as the argument
Formally the definitions are as follows.
of
Definition 2.19 (Minimum Alphabets):
Minimum Present Alphabet:

The following lemma shows how to compute the minimum

alphabets. Before applying the lemma, it is assumed, however,
then
that in any subexpression of any if
is both
and
reduced [3]. In other words, within
all possible reductions like converting
into
and
into have been made before arriving
and no further simplification is
at the expression
possible.
Lemma 2.1: For

Proof: From the definition of minimum alphabets, it is

and
easy to see that
Also since the
argument processes can be arbitrary, we have
The rest follows naturally from the recurand the definition of minimum
sive structure of
alphabets.
The following facts can be established on the distributivity
s and
s over the
property of the
Fact 2.2: Contrary to what has been conjectured in [7], it
has been shown in [2] that, in general:
For example, let

Then
But

Minimum Absent Alphabet:

then
Whereas

where
In the above example, if
Now

BOSE et al.: BOUNDEDNESS ANALYSISPART I: CONCURRENT PROCESSES

1521

Fact 2.3: To the above examples from [2] we add the

following facts.
For example, let

It is easy to see by the example above that the function space

is an infinite set. In [7] it was conjectured that
is finite. In the next section, a counterexample
is, in fact,
will be presented which shows that
even
infinite. Since for general processes of
does not distribute over
(see Facts 2.2 and 2.3), it is
are
not known whether the processes from
bounded. But this distributivity can be achieved if we restrict
the process space (and the domain of different functions) to
(see Lemma 2.2). Now using
and
as
well as restricting the domain of each function to the processes
to
namely
of , we can define a set of functions from
in the same way as
is defined. The
same counterexample will show that this is also an infinite set
of functions. The choice of is also agreeable with the fact
does not contain
the major operator which
that
uses the termination functions of its argument processes. In
the next section we proceed to characterize the boundedness
property of

Then
If

but
for

any
and

then

From the above facts it is observed that the

and
operators in general do not distribute over
the
However, a sufficient condition under which
operator distributes over
is the following.
if there does not
Lemma 2.2a): For
such that
exist any
1)

III. BOUNDEDNESS ANALYSIS OF

2)
then
b): For
Proof: The first part of the lemma can be proved easily
by induction on the length of strings generated by both sides.
and
always match
Intuitively
in alphabet and traces. They can differ only in termination
function. The condition in the lemma guarantees the matching
of termination function also. (In fact, the example mentioned
in Fact 2.3 is a result of violation of the condition of this
lemma.) Part b) is straightforward from the fact that processes
trivially satisfy the condition mentioned in a). For
from
further details please refer to [1].
The boundedness property of general FRPs (under a procedure for computation of post-process expressions involving
a syntactic transformation) is said to be decidable if there
exists some general algorithm, which, given any arbitrary FRP
and its realization, will be able to decide on its boundedness
is
in a finite number of steps. Unfortunately,
an infinite set of functions. For example, note that each
is a distinct function and
of
Cieslak and Varaiya [3] have shown
belongs to
that the boundedness of general FRPs, under a direct postprocess expressions computation procedure, is undecidable.
and
in recursive deUnrestricted use of both
scription is the reason behind the undecidability mentioned
above. To avoid this, we divide into two overlapping parts
as follows.
Definition 2.20: Let
also
In this paper (and its companion), we investigate the boundedness issue of two major subclasses of FRPs, one involving
and the change operators, namely
the
(Part 1) and the other involving the
and the change
(Part 2).
operators, namely

We begin this section by showing, with a counterexample,

that an infinite set of functions can be composed even without
using the
Example 3.1 (Counterexample): Let
and define
and
We
first show that each element of the sequence of processes
is distinct, where

such that there are

applications of
applications of
in the definition.
Proof: To prove this, we show that

where there are altogether

Basis:

Hypothesis: For some

s and

and

s.

let

where there are altogether

s and
Induction Step: By definition

s.

as

By induction, our claim about the structure of

is true.
is a distinct process.
Hence each element of

1522

of

IEEE TRANSACTIONS ON AUTOMATIC CONTROL, VOL. 43, NO. 11, NOVEMBER 1998

As a result, each element of

where

is a distinct member

such that there are

applications of
and
applications of
Thus
is infinite. Since
is used in the construction of this example,
no
is infinite.
this example also shows that
Infiniteness of
leads us to the question whether
are bounded under the postprocesses of
process expression computation procedure involving some
suitable syntactic transformation.
with realization
Given any process
and
we define a syntactic transforon elements of the symbol set
This
mation
transformation reduces large classes of semantically equivalent
function symbols into a unique symbol, while satisfying the
for all
fact that
The suffix of
indicates that the transformation
uses
, and as a result it is not semanticsthe equation
preserving for arbitrary processes. We intend to show
is a finite set.
is composed of two syntactic transThe transformation
and
, presented below. Transformation
formations,
takes care of the redundancies that are present in the multiple application of different change operators. Transformation
removes redundant expressions from the arguments of a
Definition 3.1 (Transformation
is defined as follows.

): Given

where
Since we are dealing
for any process, if the set of traces
with processes from
contains only the null string then the process must be
for some
as

if

if
Thus, in case of a
transformation
function expression involving
removes redundancy in individual argument expressions.2
In case of change operators the following transformations
take place.
1) Multiple applications of the same types of change ops and
s) are converted into a sinerators
gle application of the same operator. For example,
will be converted into
2) Redundant event symbols in the parameters of
and
are removed with the help
of minimum present and absent alphabets. Thus
is converted into
If
is empty, the corresponding
operator symbol
and
is removed. Similarly, in case of

if

2 In order to avoid nested 1 symbol, after computing individual C

(fi );
F1
the outermost 1 symbol is implicitly removed before putting it within
m
jj
i=1 CF 1 (fi ): The same holds true for any subsequent case where CF 1 (1)
appears as a proper subexpression.

instead of minimum present and minimum

and
are used.
absent alphabets,
3) Among the different change operators, an order is
as the innermost operator,
imposed, with
and
followed by
The reader may note that the chosen ordering among
change operator symbols is unique, in the sense that
there does not exist any other ordering into which any
arbitrary arrangement of change operator symbols can
be converted, while preserving the semantics. Thus,
will be converted into
for example,

Also

will

be

converted

into

where
and
4) The
over the

operator is made to distribute

Thus
is rewritten as

In this case, preservation of

semantics is possible as the processes are obtained from
and not from
(see Lemma 2.2).
The various cases are summarized in Table I. Certain special
cases are listed below.
if

if

if

if
To illustrate the transformation
we give an example
here.
be the collection of the
Example 3.2: Let
following equations:

Also let be as shown in the equation at the bottom of the

next page. Then we have the second equation shown at the
bottom of the next page.
Note that
distributes over the
s.
While distributing, it takes out event symbols and
and
Also,
from
and
and
presence of in
make
presence of in initial alphabet of
redundant. Similarly absence of and presence of in
and presence of in
initial set of events of
make
over
and
redundant.
Definition 3.2: To express the properties of the transformaformally, we define three subsets of
as
tion

BOSE et al.: BOUNDEDNESS ANALYSISPART I: CONCURRENT PROCESSES

1523

TABLE I
SYNTACTIC TRANSFORMATION

^ := (B 0
Note that in Column 3, B

~ := (

0 C ) [ C^

\ C \ F (g)) [ (C 0 F (g)) C

00

^ := (B 0
and C
=

\ C \ F (g)).

0 F (CF (f )):

follows:

are subsets of

Finally
1)

2)

is defined recursively as follows.

whenever
no
can be decomposed further as
and not all s are in
whenever
and no
can be decomposed further as

Note that
together include arbitrary process expressions with two characteristic features: the first being the
fixed order among the change operator symbols, and the
in distributed form
second is the appearance of
over
The following lemma formally expresses the properties of
Lemma 3.1: For any
and
we have
1)
2)
3)
4)
5)
6)
7)
8)
Proof: The claims can be proved together with the help
of structural induction on the construction of
The proof is mechanical but tedious as it involves exhaustive
enumeration and analysis of all possible structures that
might possess. The formal proof is given in [1].

CF 1

~ := (B 0
In column 5, B

0 C ) [ (B \ C \ F (g))
0

and

Informally, however, the results are easy to see. Claims (1)(6)

are related to the structure obtained after application of
on
As is evident from the steps of the transformation,
converts an
these claims are true because each step of
expression by imposing the particular order among the change
operators and removing the redundant event symbols. Since the
transformation acts recursively on every subexpression, each
of them also satisfies these claims. Claim (7) is satisfied since,
cannot make any structural conversion of
obviously,
an expression which already satisfies (1)(6) and naturally
satisfies these. Finally, the last claim follows from the fact
that each step of the transformation is syntax-preserving for
satisfying
the argument processes
reduces a substantial amount of redundancy from
But a major remaining task is to prevent redundant functional symbols from appearing as arguments of
Symbols like
with
which are semantically equivalent (but
syntactically distinct) will not be identified to be so even after
application of
The approach to remove this redundancy emerges out of the
following observation. Consider for example the expression
For any
Obviously then
Moreover, for any event string from

its component that takes place in

[within

] and the component that

are identical and totally
takes place in the outermost
does not have any
synchronous. As a result, the
, and we can have
effect on the traces of outermost

1524

IEEE TRANSACTIONS ON AUTOMATIC CONTROL, VOL. 43, NO. 11, NOVEMBER 1998

the following semantically equivalent reduction:

expression, even if
turns out to be a singleton.
cannot be a variant of any component
Thus
expression even if its component set is a singleton containing
Referring to Example 3.2, we find that
three components, which are

Similarly, for a given realization

if

has

and

is empty, then

and
For any functional symbol from
in order
to achieve the above kind of reductions, we need to identify
its minimal (in terms of minimum present alphabet) trace generating subexpression(s), (called component expression(s))
genwhich, when applied (as functions) on
erate the same trace as the original functional symbol. For
example for the expression
the component expressions will be
and
Definition 3.3 (Component and Variant Expressions): For
and
the set of component
is the set of expressions
expressions of namely
such that
is obtained as an interleaving of the
and the expressions are minimal in the
traces of
sense of minimal present alphabet. Formally
if

if
if

In the first three cases of the above definition, note that:

is a singleton; 2) for the set of pro1)
3)
cesses
In these three cases is said to be a variant of the
component expression of and finally 4) being variant to
the same component expression is an equivalence relation.
Note also, the difference between the third and the
fourth cases in the above definition. In the third case
So it truncates the traces of
and as a result
is a component
is a
expression in its own right and
variant of this component expression. On the other hand, in
the three outermost
the last case, where
change operators do not in any way affect the traces generated
As a result, one searches for the minimal
by
trace generating (component) expressions from individual
In such a case,
cannot be a variant of any component

and
Remark 3.1 (Tree Representation): Any
can be expressed in the form of a tree
such
the leaf nodes
that the root node contains the expression
contain the variants of different component expressions of
, and the intermediate nodes contain the subexpressions of
which are not variants of any component expression of
Formally the tree is constructed recursively as follows:
2) If any node contains some
1) The root node contains
or
expression of the form
or
such that
then the node is not expanded further as the expression itself is
a variant of some component expression; and 3) if it contains
then
some expression such that
children are created, one each containing each
denotes the set of nodes in
and
denotes the set of leaf nodes. For any node
denotes the expression contained in it.
Example 3.3: Consider the processes in Example 3.2.
Clearly,
Let
is in
If we construct
it will have
a root node containing and two immediate children nodes,
and
containing
respectively. Each of these nodes will have an identical set
and
of two children (leaf) nodes containing
respectively. The tree generated is shown in Fig. 1.
In order to remove redundant arguments of
we now
identify a set of conditions under which a functional symbol
can merge into another symbol
to form a single symbol,
such that
for
say,
but
We say
merges into
and express it as
where
is the binary merging relation. We also
require that after merging, the resultant expression, namely
has the same structural properties as mentioned
should be an
in Lemma 3.1. In other words,
To keep these conditions of
element of
merging general and amenable to easy computation, we use
in the form of
and
only local information from
This information is local as it can be obtained without
computing any post process expression.
): Given
Definition 3.4 (Merging:
if any of the following is satisfied.
and
1)
2)
(say)] and

or

or

BOSE et al.: BOUNDEDNESS ANALYSISPART I: CONCURRENT PROCESSES

Fig. 1. Tree(f ) for

1525

P P2[[0B]] )[[+C ]] jj(P1 jjP2[[0B]])[[+C ]]:

= ( 1 jj

4)

3)
and
In the above cases the result of merging
into expression
namely
is (to be defined below)
for the argument

where

and

is reflexive and transitive, i.e.,

and if
and
then
However, it is asymmetric
in general.
Proof: The claims are obvious for the first case of
merging.
and
have
In the second case note that
identical traces. This is because
The termination function is identically equal to zero. Clearly,
their parallel composition will also have the same trace
and termination function. Now, first, we have to show that
as stated in Definition 3.4, and
are identical processes. To see this, we first explain how
and are formed. Since both s are from
from Lemma 3.1 we have, for
1)
2)
and
where
and
3)
and
Now

See the equation shown at the bottom of the page.

The following lemma formally states the property of the
Also in the proof of the lemma we
merging relation
explain how we have arrived at the definition of
in different cases.
and
Lemma 3.2: Given
if
then
1)
2)
3)

is rewritten as follows:

From definition of

1526

IEEE TRANSACTIONS ON AUTOMATIC CONTROL, VOL. 43, NO. 11, NOVEMBER 1998

to

when

is given in the Example 3.2 and

and
It should
be noted that it is never possible for some event to occur in
such that it occurs in the component
alone. This is simply because
and
have identical traces. Thus application of
does
not represent any extra blocking constraint for the component
as far as its operation in
is concerned. The
third condition says that, in this case,
and

where
and

are merging compatible and they can be

For
merged to form
the formal proof the reader is referred to [1].
Note that in case 3) of Definition 3.4 if
is a proper subset of
(which also equals
) then
is defined, but
is not defined. In case
and
these two sets are equal, both
will be defined. However, they will be syntactically distinct even though
Example 3.4: Consider

Clearly
It is then obvious
as defined in the second
that
have identical trace,
condition, and
termination and initial alphabet. Also, for any string
other than the empty string
Hence
From the final form of
it can be easily seen that
belongs to
as it satisfies the first six
conditions of Lemma 3.1. From the second condition, it is
easy to see that
(if
) or
(otherwise). From the above it is also obvious that
is
reflexive and transitive.
We now proceed to prove the lemma for case 3) of Definition 3.4. Because of the special structure obtained after
given any
the
application of
can be considered as the set of trace
elements of
This is because
is
generating components of
formed via interleaving of traces of processes corresponding to these individual component expressions. The
symbol and the different
and
symbols
only add to the blocking capability of different components
For example, consider the symbol
joined by
which clearly belongs
For any three sets X; Y; Z we have X 0 Y = (X [ Z ) 0 (Y [
Z 0 X )): Here we take X = F (h) [ C1i ; Y = B2i and Z = C1j :
4 Note: For any three sets X; Y ; Y ; (X 0 Y ) [ (X 0 Y ) = X 0\2
1 2
1
2
i=1 Yi :
We take X = F (h) [ C11 [ C12 and Yi = (B2i [ (C1j 0 (F (h) [ C1i ))):
5 Note: Y = (B t [ B ai [ (C j 0 ( (h) [ C i ))) and B t \ (B ai [
i
2
2
1
2
2
1
F
j
(C1 0 (F (h) [ C1i ))) =  for both i = 1; 2: Then Y1 \ Y2 =
j
(B2t [ (\i2=1 (B2ai [ (C1 0 (F (h) [ C1i ))))):
6 Note: If Y  X; Y = Y [ Y ; Y \ Y =  then (X 0 Y ) [ Z =
1
2 1
2
(X 0 Y1 [ (Y2 0 Z )) [ (Z \ X \ Y1 ) [ (Z 0 X ): Here X = F (h) [
C11 [ C12 ; Y1 = B2t ; Y2 = B2a ; Z = C21 [ C22 :
3 Note:

expression
when
and
The expression is in
for the in Example 3.2. It can be merged

into

the

function

either

or
However,
further merging among subexpressions in both cases would
result in the unique expression
As demonstrated in Example 3.4, after one obtains
further merging
an expression
may be possible among the components of
To exhaust all merging possibilities we define a
as follows. For any
recursive merging procedure
defines a
and
set such that for
such that
and
Definition 3.5 (Recursive Merging Procedure ):
then
If
If
then
given below.
Step M.1: Let
elements among

is computed using the steps

denote the set of syntactically distinct

and
1)
2) Partition
such that
are in the same
and
partition iff both
Let there be partitions and the th partition
be
3)
is a singleton and

BOSE et al.: BOUNDEDNESS ANALYSISPART I: CONCURRENT PROCESSES

4)

1527

Step M.1 (RL-0):

Step M.2: Compute

and

as follows:

such that

or

such that

but

by RL-

such that
Step M.3:

compute
(say).8

and

Step M.2 (RL-0):

Step M.4: Compute

Step M.3 (RL-0): The step is not required.
Step M.4 (RL-0):

Step M.5: If
with
Finally if
least one

go to
Otherwise

is

of

Step M.5 (RL-0):

and at
nonempty, then
where

RL-1: Computation of
Step M.1 (RL-1):

if
if
by RLExample 3.5: Once again consider the expression presented
in Example 3.4. Let

when
and
The
with respect to the
expression is in
presented in 3.2. Here we show the steps that
follows to
prevent further merging in the resultant expression.
RL-0 (Recursion Level 0): We have the computation of
.

Step M.2 (RL-1)Step M.5 (RL-1): They are similar to

those of (RL-0). Finally

RL-2: Computation of

7 Note: In order to compute M (jjm v ); we first partition the set V

i=1 i
using both-ways merging compatibility as an equivalence relation. All the
components of a single partition are first merged in some arbitrary order and
then M is applied on it so that we get a unique collection of expressions. At
the end, among elements of V ; no both-ways merging is possible.
8 Note: V is the set of elements from V each of which neither merges into
3
any other element of V ; nor any other element of V merges into it. V4 is the
set of elements from V neither of which merges into any other element of
V ; but there are other element(s) of V which merge into it. Naturally, each
element in V ; which is not in V3 [ V4 ; merges into one or more elements
of V4 : In the following step the above merging takes place recursively using
the transformation M which results in a unique collection of expressions
irrespective of the order of merging.

9 By Definition 3.4, M (g ; g ) is in C
(
n (Gjj ; 5~ )) and M apm 1 2
F1
plies Mm (1; 1) recursively. In spite of that, we had to apply CF 1 (1)
in this case to take care of the possibility that when M (jjm
i=1 vi ) turns
out to be a singleton, h[[+C ]][0B ][+C ] will not have the structure as
described in Lemma 3.1. For example, without the application of the final

[+C ] )[[+C ]] ) will result in a singleton

1 (1); M ((Pi jjPi
[+C ][[+C ]] which does not belong to C (
n (Gjj ; 5~ ))
P
i
F1
C
F

set containing

by RL-

RL-3: Computation of
Step M.1 (RL-3):

Step M.2 (RL-3)Step M.5 (RL-3): They are similar to

those of (RL-0). Finally

1528

IEEE TRANSACTIONS ON AUTOMATIC CONTROL, VOL. 43, NO. 11, NOVEMBER 1998

Example 3.6: Given the process equations

in
Example 3.2, consider the following functional symbols
Let
in
Careful study will show the following.
1)
2)
But obviously

To take care of the second one,

should be applied recursively among the subexpresssion of any variant expression
also.
All the above are combined in the transformation
Definition 3.6 (Transformation
): The transformation
is defined as
follows:

and
where
and

lent. The component

if
are not syntactically equiva-

is present in

as the variant

and in
it is present as the variant
In the case of
and
it is just the opposite. At this stage it should be
in
can
noted that each variant of the component

if

where

is defined as follows:

be replaced by an overbounding variant, namely

while maintaining the semantics. The same holds true for the
also. In other words
expression

The recursive merging procedure

alone does not do the job
of replacing each variant of some component expression by a
unique overbounding variant.
Again, with respect to same set of process equations
in Example 3.2, consider the functional symbol
in
Note
as
itself is a component expresthat
sion because of the presence of outermost
There is an obvious scope of redundancy removal at the
subexpression level of the component, namely replacing
by
But
stops at the component level and does not do any merging
among the subexpressions of a component.
To take care of the first possibility, instead of applying
on
an expression we can first construct the set
From Definition 3.4, it can be easily seen that
and for any
such that
for any
for some
where
We use this fact and instead of
is
applied on the expression which is the parallel composition
of the expressions of the above set. In the above set the
different variants of the same component, as well as different
subexpressions formed with these variants, will be present.
As a result of merging, these variants will get merged into
a unique overbounding (in the sense of minimum present
alphabet) component of the same variant and finally this
unique variant will enter into all the relevant subexpressions
in place of the original variant. Clearly the procedure
of
will be semantics-preserving and it will take care of the first
shortcoming of

if
if
and

is a singleton.

Note that, the Closure part takes care of replacing the

different variants of the same component by a unique variant.
itself takes care of possible merging
The transformation
within the subexpressions of any component/variant.
Example 3.7: Consider the following expressions in
with respect to the process equations
in Example 3.2:

To find
note that
for
but we have the equation shown at the bottom of the page.
according to the algorithm
Next we compute

In the first iteration

BOSE et al.: BOUNDEDNESS ANALYSISPART I: CONCURRENT PROCESSES

1529

After partitioning
and doing both-ways merging among
we get
elements of

Lemma 3.3: The transformation

satisfies the following
properties.
1) Irrespective of the order of merging in the steps of
results in a unique expression.
if
then
2) For
a)
b)
where
c) if

then
such that
and

Also
At the end of the while loop,
Among the expressions of
the first element (i.e.,

and
in any order and then applying

Among the expressions of

are
the second element of

the second element of

singleton set

of

and
those which merge in to
are

Merging them into

we get the set

those which merge in to

Merging them into

and then applying
we get the

So

In this set, the second element clearly merges into the

as
we
third one. So in the second iteration, using this
get the unique collection of expressions (new ) containing
in which
the first and third expressions of the previous
no further merging is possible.
Then

together imply
d)
3) For
Proof Outline: Intuitively, the results of the lemma are easy
to see from the following facts.
1) From Lemma 3.2 we see that the merging operation preserves the components, the semantics for the argument
, and results in an expression in
2) After applying
over the arguments of outermost
s in any subexpression, no further merging among
s is possible.
the arguments of the outermost
3) During computation of Closure, one extracts all the
different variants of the components that are present in
So after applying
an expression and puts them in
over elements of
it is obvious that each variant of
identical component gets replaced by a unique variant of
the same component in the resultant expressions, while
preserving the semantics.
ensures that this
4) Finally, the recursive procedure
is applied in every subexpression level
Closure and
of a component/variant. Formal proof of the lemma is
given in [1].
Definition 3.7 (Transformation
): Let
such that
Lemma 3.4: Given
satisfies the following: 1)
2)
3)
Proof: The proof is straightforward from Lemmas 3.3
and 3.1.
For two reasons, the expressions obtained after applying
cannot be considered to be in some normal form. First,
the resultant expressions are not semantically equivalent in
general; they are semantically equivalent only for the argument
This is because we use local information in the
and
in the transformation. Moreover,
form of
the transformation does not ensure that any two function
expressions that are semantically equivalent in general or for
will be converted into a unique expression.
the argument
Thus, some redundant function expressions in general, may
remain even after applying
Consider the infinite sequence of functions
, presented
in the counterexample 3.1. Given some processes
such that
it can be easily seen
Thus, given some FRP realization
that
though transformation
removes a substantial

1530

IEEE TRANSACTIONS ON AUTOMATIC CONTROL, VOL. 43, NO. 11, NOVEMBER 1998

amount of redundancy,
remains an infinite
set in general.
with
However, for any arbitrary FRP
we will show that while the set of postrealization
is infinite, (see Case 2 of Examples 2.1
process expressions
computed by the procedure for comand 2.2), the set
putation of post-process expressions involving transformation
is finite.
): For
Definition 3.8 (Computation of
with realization
the computation proceis the same as presented in previous section. The
dure of
is
set of postprocess expressions
now computed recursively as follows:

If

then

The finiteness of
follows from two important
observations.
Observation 1: During the computation of the post
operators do
process expressions, we find that 1)
not accumulate giving rise to new components; 2) because of
redundant application of change operators
application of
are avoided; 3) new components are generated only when
are
post-processes of any subexpression of the form
computed.
As a result, components of any expression from
are from a finite set
defined below.
in
Definition 3.9: Give any process
with realization
we define a set of components
as follows:

where the

expressions are obtained from the equations in

Since is assumed to be a finite set,

is also finite.
Observation 2: Because of the particular structural
for any expression of the form
property ensured by
from
components of any
cannot be a subset of components of some other
These two observations, together with finiteness of
ensure finite length of expressions in
and consequently the finiteness of
Lemma 3.5: For
with realization
Proof: The proof of the lemma follows from the two
claims given below.
Claim 1:
Proof of this claim is straightforward from the definition of
and by taking as
Claim 2: For
with realization
if
and
then

The claim is proved by induction on the structure of which

For further information the reader
belongs to
is referred to [1].
Our next result shows that the set of expressions of
whose components belong to a finite set
, is itself finite.
such as
Lemma 3.6: The set
is finite.
Proof: To prove this lemma, given any element in
we first represent it as a tree as mentioned in Remark 3.1.
be
Let the set of possible variants of expressions of
Because of finiteness of the symbol set
denoted as
and
it is obvious that
is a finite set. Note
are in
that all the leaf node expressions of
Since
is in
by Lemma 3.3, if
is of
then
the form
so that
More loosely speaking, it is never
or vice
possible that
denotes the set of leaf nodes of
versa, where
Since
is finite, from the above statement we can easily
the number of leaf
conclude that for any
of the
is bounded. The upper bound is to
nodes
denote some arbitrary
be computed as follows. Let
For any
denotes the
family of subsets of
Then
number of expressions in

Since for any

is bounded, from the particular
it can be easily concluded that
structure of
of
This in turn
there is an upper bound on length
implies that is finite.
Finally we state the main result about the boundedness of
processes of
Theorem 3.1: Any
in
is bounded under
the post-process computation procedure involving transformation
Proof: From Lemmas 3.5 and 3.6, it can be easily seen
and hence it is finite. Thus is bounded.
that
We can also conclude that the infinite set of semantically
different process expressions of Counterexample 3.1 canin
not be generated as post-process expressions of some

IV. CONCLUSION
In the present work we have discussed the boundedness
and the change operators.
property of FRPs built over
alone does not guarantee
We have shown that removal of
finiteness of the underlying function space. However, using
suitable syntactic transformations along with the computation
procedure for the post-process expressions, it has been possible
and the change
to show that the FRPs built over
operators are bounded. It can also be shown that if
is removed along with
the underlying set of functions
becomes finite [1].

BOSE et al.: BOUNDEDNESS ANALYSISPART I: CONCURRENT PROCESSES

1531

In the case of FRPs built with

and change operators,
one major limitation of the present work is the applicability
instead of
As explained in
of boundedness results on
fails to
Facts 2.2 and 2.3, for processes in
in general, as it may change some of
distribute over
into
for some
the post-processes that are
though trace and alphabets always remain the same after
distribution. is the class of processes that definitely satisfies
the condition of distribution as given in Lemma 2.2. For
in
if it can somehow be
some process
guaranteed beforehand that the condition of Lemma 2.2. is
can be used in post-process computation of
met, then
that process in a straighforward way. A second option is
or more
to consider modification in the definition of
specifically in the definition of termination function. But this
may pose a difficulty in construction of supervisor processes
which normally run concurrently with plant processes and
decide on overall termination via blocking.
The second limitation arises from the fact that modeling
flexibility of this subclass is restricted. Since it does not include
it cannot model stacks, reentrant codes etc.
In the companion paper we investigate the boundedness
or those
problem for processes that do not involve the
and
can be used only under certain
in which the
restrictions.

[11] P. J. G. Ramadge and W. M. Wonham, The control of discrete event

systems, in Proc. IEEE, Special Issue on Discrete Event Dynamic
Systems, vol. 77, no. 1, pp. 8198, Jan. 1989.
[12] S. Bose, S. Mukhopadhyay, and A. Patra, A nondeterministic extension
over finitely recursive process model, Discrete Event Dynamic Syst.:
Theory and Appl., vol. 7, pp. 243274, 1997.
[13] T. Murata, Petri nets: Properties, analysis and applications, in Proc.
IEEE, vol. 77, no. 4, pp. 541580, Apr. 1989.

REFERENCES
[1] S. Bose, Finitely recursive process models for discrete event systemsAnalysis and extension, Ph.D. dissertation, Dept. Electrical
Engineering, I.I.T. Kharagpur, 1995.
[2] R. A. Cieslak, Undecidability results and real time semantics for finitely
recursive processes, Ph.D. dissertation, Dept. E. E. and C. S., Univ.
California, Berkeley, 1988.
[3] R. A. Cieslak and P. P. Varaiya, Undecidability results for deterministic
communicating sequential processes, IEEE Trans. Automat. Contr., vol.
35, pp. 10321039, Sept. 1990.
, Simulating finitely recursive processes in LISP, Discrete Event
[4]
Dynamic Syst.: Theory and Appl., vol. 1, pp. 373392, 1992.
[5] M. Hennessy, Algebraic Theory of Processes. Cambridge, MA: M.I.T
Press, 1988.
[6] C. A. R. Hoare, Communicating Sequential Processes. New Delhi,
India: Prentice-Hall, 1985.
[7] K. Inan and P. P. Varaiya, Finitely recursive process models for discrete
event systems, IEEE Trans. Automat. Contr., vol. 33, pp. 626639, July
1988.
[8]
, Algebras of discrete event models, in Proc. IEEE, Special
Issue on Discrete Event Dynamic Systems, vol. 77, no. 1, pp. 2438,
Jan. 1989.
[9] R. Milner, Communication and Concurrency. London, U.K.: Prentice
Hall Int., 1989.
[10] J. S. Ostroff and W. M. Wonham, A framework for real-time discrete
event control, IEEE Trans. Automat. Contr., vol. 35, pp. 386397, Apr.
1990.

Supratik Bose was born in Asansol, India, on

July 10, 1968. He received the B.Tech., M.Tech,
and Ph.D. degrees from the Electrical Engineering
Department, IIT Kharagpur, in 1990, 1992, and
1996, respectively.
He worked as a Scientist in the Centre for Artificial Intelligence and Robotics, Bangalore, India,
from 1995 to 1997. Currently, he is a Senior Systems Engineer for Siemens Information Systems
Limited, Bangalore. His areas of interest include
real-time and discrete-event systems, systems programming and network security.

Amit Patra (M89) received the B.Tech., M.Tech.,

and Ph.D. degrees from the Indian Institute of Technology, Kharagpur, in 1984, 1986, and 1990, respectively. He visited the Ruhr University, Bochum,
during 1992 and 1993 as a Post-Doctoral Fellow of
the AvH foundation.
He is an Associate Professor in the Department
of Electrical Engineering, Indian Institute of Technology. His research interests include discrete-event
systems, fault detection, and diagnosis and real-time
control. He has published 50 research papers and is
the co-author of a research monograph in the LNCIS Series published by
Springer Verlag.
Dr. Patra received the Young Engineer Award of the Indian National
Academy of Engineering in 1996 and the Young Teachers Career Award
from the All India Council for Technical Education in 1995.

Siddhartha Mukhopadhyay (M91) received the

B.Tech., M.Tech., and Ph.D. degrees from the Indian
Institute of Technology, Kharagpur, in 1985, 1988,
and 1991, respectively.
He is an Associate Professor in the Department
of Electrical Engineering, Indian Institute of Technology. His research interests include discrete-event
systems, fault detection, and diagnosis and real-time
systems. He has published 35 research papers.
Dr. Mukhopadhyay received the Young Scientist
Award of the Indian National Science Academy in
1996 and the Young Teachers Career Award from the University Grants
Commission of India, in 1993.