\documentclass[twocolumn]{IEEEtranUSMA}
\usepackage[dvips]{graphicx}
\usepackage{fancyheadings}
\usepackage{amsmath}


\begin{document}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%  Authors -- please include the title of your paper and authors' names
%%  here:

\title{Bi-level resolution in discrete simulations of network flow} 
\author{David A. Nash, 
\thanks{D. A. Nash: U. S. Military Academy, West Point, NY.} 
James A. Wall
\thanks{J. A. Nash: Texas A \& M University, College Station, TX.} 
}  

%%######################################################################
%%
%%  PLEASE DO NOT MODIFY ANYTHING BETWEEN THESE ## MARKS, THE PROCEEDINGS
%%  EDITORIAL STAFF WILL INCLUDE THE CORRECT PAGE NUMBERS:

\setcounter{page}{30}

\pagestyle{fancy}
\setlength{\headrulewidth}{0pt}
\lhead{}

\lfoot{ISBN 0-7803-9814-9/\$10.00 \copyright 2002 IEEE}
\cfoot{}
\rfoot{\thepage}

\lhead{}
\rhead{}

\maketitle
\thispagestyle{fancy}
%%
%%######################################################################


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%  Authors -- please include the abstract of your paper here:


\begin{abstract}

The behavior of many real-world systems may be modeled by discrete
quanta flowing through the vertices of a directed graph.  The
simulation of such systems may be accomplished in a straightforward
way by recreating the topology of the graph using data structures, and
associating a transformation with each vertex which will convert
inputs into appropriate outputs.  The outputs are then propagated to
adjacent vertices to simulate the notion of flow.  

If the connectivity of the graph representing the system is dense,
however, there may be unacceptable computational costs involved with
running the simulation using large numbers of nodes or quanta.  One
method of reducing these costs also has the beneficial side-effect of
focusing attention on a smaller subspace of the overall graph.  This
paper describes a technique for modeling flow through the network such
that it is possible to represent a portion of the nodes with complete
fidelity (a \emph{lossless} representation), and the remainder of the 
network as nodes whose behavior is assessed probabilistically.  This
two-tier approach offers the possibility of a significant savings in
computing time and core storage, while maintaining the vantage point
needed to gain insight into the behavior of the system of interest.

\end{abstract}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%  Authors -- please include the main portion of your paper here:

\section{Introduction}

The behavior of many real-world systems may be modeled by discrete
quanta flowing through the vertices of a directed graph.  This
representation is a variant of the \emph{semantic network}, which is a
well-known formalism for the expression of functional relationships
\cite{Barr81}. In terms of a graph, simulations may be described as
being chiefly concerned with analyzing the performance of nodes that
are engaged in the following cycle of activities: 

\begin{itemize}
\item Accepting inputs as they arrive,
\item Processing the inputs,
\item Forwarding the result to adjacent nodes in the network.
\end{itemize}

Examples of systems which lend themselves to this
paradigm include computer networks, manufacturing assembly lines, and
vehicular traffic.  Table~\ref{table:semnet} describes how the
approach may be applied to represent the main functional
characteristics of the example systems. In such domains, the salient
activities of the system can be modeled in terms of the movement of
entities from station to station. With every increment of time in the
simulation, entities are operated upon and propagated throughout the
network according to the constraints which govern the operation of the
system. 

\begin{table}[hbt]
\caption{Examples of the semantic network modeling scheme.}
\centering 
\begin{tabular}{|l|l|l|}                         \hline
Vertex      & Edge            &  Quantum \\ \hline\hline
computer    & communications  & packet\\ 
            & channel         &       \\ \hline 
subassembly & assembly        & end item\\ 
operator    & sequence        &         \\ \hline
intersection & roadway & automobile \\ \hline
\end{tabular}
\label{table:semnet}
\end{table}

With such systems it is often the case that we are interested in
measuring the \emph{throughput} at various points in the graph.  These
measurements (or their aggregates) form the basis of conclusions
regarding the behavior of the real-world system being modeled.  In
terms of the example systems in Table~\ref{table:semnet}, typical
parameters of interest might include the number of packets passing a
particular point in the network over a given interval of time; the
number of end items completed per hour; or the net delay experienced
by vehicles while transiting a road network.  The algorithm which is
presented is particularly concerned with such systems, in the sense
that the system throughput is the experimental
parameter of primary interest.

The activity that the simulation models is accomplished by the flow of
inputs through the network.  At each node, something ``happens'' to
the input objects: they are operated upon, or, equivalently, they
participate in a simulated activity that may change them.  The nature
of the processing which takes place at each node typically involves
some measurable delay.  For example, a packet arriving at a node in
a simulation of a computer network may have to wait for packets that
had arrived previously to be transmitted before it can be serviced.
As a result, the use of a queue at each node models this behavior
conveniently.  This gives rise to a network of queues as the global
structure of the simulation.  To simplify the explanation of the
algorithm which follows, we assume that the activities represented by
each of the nodes can be explained in terms of a single queue; clearly
though, each node could itself subsume a network of queues.  As it is
well-established that flows through networks of queues can be isolated
with arbitrary boundaries \cite{Klei76}, the simplification will not
result in a loss of generality.  

In the problem domain, the time needed to propagate an input through a
node is equivalent to the time necessary to accomplish the
simulation of an event of interest.  In discrete systems, the ability
to model the transformation of a greater number of inputs per unit
time equates to a higher-performance simulator.  The proposed approach
describes a technique which allows for the selective enhancement or
diminution of the amount of detail with which the behavior of a node
is modeled, and the means to interface nodes operating at different
levels.  

\subsection{Multiresolution simulation}

The creation of simulations that model complex systems inevitably
requires the employment of a hierarchy of abstraction to represent the
functional and structural characteristics of the system of interest.
This is necessary in order to make the model conceptually approachable
\cite{Walc88}.  From an analytic point of view, the ability of a model
to produce useful insight often depends on the ability to temporarily
focus attention on individual components, while abstracting away
details relevant to the rest of the model \cite{Posn94}.  The ability
to produce these shifts in focus \emph{dynamically} (i.e., while the
simulation is still running) and yet retain the global validity of the
simulation can be a powerful tool in the analysis of simulation output
\cite{Pooc93}. 

The need for a restructuring approach to modeling was recognized early
in the employment of computing devices for system simulation and
optimization \cite{Bala65}.  \emph{Aggregation/disaggregation} is one
such technique.  This term encompasses a class of modeling
and problem-solving methods which finds application in a number of
domains, including dynamic programming \cite{Bean87}, mathematical
computation \cite{Limo92}, software development \cite{Shaw89}, and
protocol analysis \cite{Pran86}.  \cite{Zipk82} and later
\cite{Iwas93} agree that the aggregation step of an A/D approach
may be described as: \begin{itemize} 
\item Partitioning the event or signal space.
\item Replacing the contents of each partition with a set whose
cardinality is less than that of the original partition.
\item Operating on (e.g., draw inferences, observe flow, simulate some
activity, etc.) each partition, using the derived elements as inputs.
\end{itemize} \cite{Wall93} noted that where the semantic network
paradigm is employed to implement discrete simulations, the
partitioning step of an A/D method leads naturally to the 
use of time and space complexity as metrics for the performance of the
simulator.  

\subsection{Time and space complexity}

Finite computing resources imply a constraint on the fidelity of most
non-trivial simulations.  In addition to the previously discussed
cognitive benefits, the ability to model the components of a
simulated system at varying degrees of resolution is also desirable from
the computational perspectives of time and space complexity.  The
approach which will be described provides a way to garner savings in
the calculations needed to convey the central aspects of the system,
while also minimizing the core memory requirement.

In modeling discrete flow, the most straightforward approach is to
instantiate data structures representing the quanta of interest, and
maintain state information which may be used to ``move'' the quantum
from node to node.  While it is easily implemented, this technique can
be costly in terms of storage space and computational complexity.
Considering that may be necessary to process every quantum at each 
node, it is easy to see that the complexity of processing with each
advance of the system clock is formed as the product of the number of
nodes and the number of quanta.

The technique which this paper suggests reduces the effort associated
with moving the individual entities.  This is achieved by replacing the
quantum-by-quantum handling at each node with an aggregate equivalent
output.  This aggregate is determined by a probability distribution
which is specified by the analyst.  For example, consider a
simulation of routing in a computer network.  As items become
available for transmission at each node, they may be examined
individually and routed as required by their destination and the
routing algorithm.  Alternatively, one could specify the probability
of a packet having a particular destination, and use the arrival rate
to calculate the number of nodes to transmit to the appropriate
subsequent station.  In either case, the throughput of the node in
question is preserved; however, the identities of the packets
in the latter approach are \emph{not} preserved.  This characteristic 
identifies the abstraction process as a \emph{partial morphism}, as
defined by \cite{Fish88}.  

\section{Notation and assumptions}

Let $G$ be a graph containing $n$ vertices, which are given by
$\vec{V}=\{v_{1},v_{2}, \ldots ,v_{n}\}$.  The connectivity of $G$ is
specified by a symmetric adjacency matrix $C$ such that $v_{i}$ is
adjacent to $v_{j}$ iff $c_{ij} \neq 0$.  To begin, the analyst must
designate which of the nodes $v_{k} \in V$ will be modeled losslessly
(high resolution), and which will be modeled probabilistically.  These
choices indicate the observable level of detail at that node.  

Globally, a simulation will operate in either entirely high
resolution mode, entirely low resolution mode, or a mixed mode in
which some nodes are high resolution, and the remainder low.  Figure
~\ref{fig:nodes} shows a typical system.  The two levels of resolution
are defined in the following way.  Nodes which operate at level 0
model the entity arrival phenomenon at the highest possible
resolution: each discrete entity which flows through the node (e.g.,
every packet, every connection, etc.) is accounted for and processed in a way that allows the
examination of a node's activity on an entity-by-entity basis. Nodes
operating at level 1 model entity arrivals by means of a probability density
function,  where the parameters which define the distribution control
the intensity of the arrival phenomenon.  

\begin{figure}
\begin{center}
\leavevmode
\includegraphics[height=2.5in]{nodefig.eps}
\caption{A typical system operating in mixed-resolution mode.}
\label{fig:nodes}
\end{center}
\end{figure}

We associate the following characteristics with each vertex:

{\tt
\begin{tabbing}
{\bf ty}\={\bf pe} node\_type {\bf is} \\
 \> {\bf re}\={\bf cord}   \\
 \> \> num\_of\_params : \= {\bf integer} \\
 \> \> resolution :      \> {\bf integer} \\
                          
 \> \> param\_list :     \> list({\bf float})  \\
 \> \> event\_list :     \> list(event) \\
 \> \> state\_queue :    \> list(entity) \\
 \> \> state\_value :    \> {\bf integer} \\ 
 \> {\bf end record}
\end{tabbing}}

The {\tt num\_of\_params} attribute indicates the number of parameters
necessary to specify the governing distribution if it is a level 1 node,
and 1 otherwise.  The {\tt param\_list} attribute is a linked list of the
necessary attributes, which is empty in the case of a level 0 node.
{\tt state\_queue} is the structure which maintains the entities in
level 0 nodes that are awaiting processing; it is empty in level 1
nodes.  {\tt state\_value} is the analogue of {\tt state\_queue} which
is appropriate for level 1 nodes.

The final abstraction which must be defined is {\tt event\_list}
attribute.  Each node maintains a list which describes either the
entities scheduled to arrive at the node and their source vertices
(for nodes operating at level 0), or the equivalent arrival rate of
entities to be received from the adjacent vertex (for nodes operating
at level 1).  The logical structure for an event in the list is:

{\tt
\begin{tabbing}
{\bf ty}\={\bf pe} event {\bf is} \\
  \> {\bf re}\={\bf cord}        \\
  \> \> event\_value : \= {\bf float} \\
  \> \> arrival\_list :  \> list(entity) \\
  \> \> source :       \> {\bf integer} \\
  \> {\bf end record} 
\end{tabbing}}

The {\tt source} attribute indicates the index of the vertex in
$\vec{V}$ responsible for the production of the event.  Events are
created by applying either a routing algorithm or sets of
probabilities to the ultimate destinations of entities that have
already been serviced, and are prepared for departure.  The event
itself is either an average aggregate arrival rate, or a list of
actual entities.  We denote the \emph{i}th event in the event list
associated with the node $v_{k}$ as $L_{k}[i]$.  The event list has an
associated size, which is the subscript of the last event, denoted
$L_{k}${\tt .size}.

In the algorithm pseudocode which follows, sections which appear in
italics denote actions whose precise nature will vary according to the
context of the description and implementation details of the system.

\section{The algorithm}

\subsection{Global approach}

{\tt
\begin{tabbing}
{\bf be}\={\bf gin} \\
 \> \emph{Classify paths} \\
 \> {\bf whi}\={\bf le not}(finished) {\bf loop} \\
 \> \> \emph{Change resolutions} \\
 \> \> \emph{Generate outputs} \\
 \> \> \emph{Process inputs} \\
 \> {\bf end loop} \\
{\bf end}
\end{tabbing}}

\subsection{Phase 1: Classify paths}

This step will create an $n \times n$ matrix $H$, whose entries
$h_{ij}
\in \{-1, 0, 1\}$ describe the nature of the connections between nodes
in $G$, in terms of the two levels of resolution discussed previously.
It need only be accomplished once, at the beginning of the run, unless
the entries in $C$ change dynamically.  Changes to $H$ needed to
reflect modifications of resolution are accomplished in Phase 2.  The
resulting entries are interpreted as shown in Table ~\ref{hvals}.

{\tt
\begin{tabbing}
{\tt \bf for} \= y {\bf in} 1 ..\ n {\tt \bf loop} \\
 \> for \= x {\bf in} 1 ..\ n {\tt \bf loop} \\
 \> \> {\tt \bf if} \= $C[x,y] == 1$ {\tt \bf then} \\
 \> \> \> {\tt \bf if} \= $v_{x} == v_{y}$ {\tt \bf then} \\
 \> \> \> \> $H[x,y] := H[y,x] := 1$ \\
 \> \> \> {\tt \bf else} \\
 \> \> \> \> $H[x,y] := H[y,x] := -1$ \\
 \> \> \> {\tt \bf end if} \\
 \> \> {\tt \bf else} \\
 \> \> \> $H[x,y] := H[y,x] := 0$ \\
 \> \> {\tt \bf end if} \\
 \> {\tt \bf end loop} \\
{\tt \bf end loop}  
\end{tabbing}}

\begin{table}[htb]
\caption{Interpretation of values in $H$.}
\centering 
\begin{tabular}{|c|c|}                         \hline
$h_{ij}$  & Implication regarding  $v_{i}$ and $v_{j}$ \\ \hline\hline
-1        & different resolutions \\                      \hline
0         & not connected \\                              \hline
1         & same resolutions \\                           \hline
\end{tabular}
\label{hvals}
\end{table}

\subsection{Phase 2: Change resolutions}

During this phase,  the ability to change a node's resolution is incorporated.

{\tt
\begin{tabbing}
{\bf if} \= (\emph{analyst wants to change a node's resolution}) {\bf then} \\
 \> input (node\_to\_be\_changed, new\_mode) \\
 \> $x :=$ node\_to\_be\_changed \\
 \> $v_{x} :=$ new\_mode \\
 \> {\bf fo}\={\bf r} i {\bf in} 1 ..\ n {\bf loop} \\
 \> \> {\bf if} \= $C[x,i] == 1$ {\bf then} \\
 \> \> \> {\bf if} \= $v_{x} == v_{i}$ {\bf then} \\
 \> \> \> \> $H[x,i] := H[i,x] := 1$ \\
 \> \> \> {\bf else} \\
 \> \> \> \> $H[x,i] := H[i,x] := -1$ \\
 \> \> \> {\bf end if} \\
 \> \> {\bf else} \\
 \> \> \> $H[x,i] := H[i,x] := 0$ \\
 \> \> {\bf end if} \\
 \> {\bf end loop} \\
 \> {\bf if} \= (new\_mode == 0) \\
 \> \> \emph{(Instantiate entities coincident with magnitude} \\
 \> \> \emph{of }state\_value\emph{, and store in }state\_queue\emph{.)} \\
 \> \> state\_value := 0 \\
 \> {\bf else} \\
 \> \> \emph{(Count number of entities in} state\_queue\emph{,}\\
 \> \> \emph{and set }state\_value\emph{ equal to this number.)} \\
 \> {\bf end if} \\
{\bf end if}
\end{tabbing}}

As described, the algorithm allows for only one node's resolution to
be changed per iteration.  Though it could easily be modified to allow for
multiple changes, this has been omitted for the sake of clarity.  When
a change in resolution is indicated for node $v_{k}$, $C$ is consulted
to determine the resolutions of any adjacent nodes.  $H$ is updated
accordingly to indicate the new resolution relationships.  Finally,
steps are taken to account for the state of the node prior to the
change.  

\subsection{Phase 3: Generate outputs}

The next step of an iteration sequence is to create ``flow'' in the
network.  This simulates the movement of entities between nodes, which
enables the processing that is available at subsequent vertices.

{\tt
\begin{tabbing}
{\bf fo}\={\bf r} k {\bf in} 1 ..\ n {\bf loop} \\
 \> {\bf fo}\={\bf r} i {\bf in} 1 .. $E_{k}$.size {\bf loop} \\
 \> \> $L_{e_{ki}}[$\emph{next}$]$.source := $v_{k}$ \\
\\
 \> \> \verb+% Local and remote at different resolutions:+ \\
\\
 \> \> {\bf if} \= ($H[k,e_{ki}] == -1$) {\bf then} \\
 \> \> \> {\bf if} \= ($v_{k} == 0$) {\bf then} \\
 \> \> \> \> \emph{(Count number of entities from } state\_queue \\
 \> \> \> \> \emph{that have been serviced, and convert to } \\
 \> \> \> \> \emph{equivalent average arrival rate $\lambda$.)} \\
 \> \> \> \> $L_{e_{ki}}[$\emph{next}$]$.event\_value := $\lambda$ \\
 \> \> \> {\bf else} \\
 \> \> \> \> \emph{(Instantiate entities coincident with proportion} \\
 \> \> \> \> \emph{of }state\_value \emph{that have been serviced)} \\ 
 \> \> \> \> $L_{e_{ki}}[$\emph{next}$]$.event\_list := \emph{instantiated entities}\\
 \> \> \> {\bf end if} \\
\\
 \> \> \verb+% Local and remote at same resolution:+ \\
\\
 \> \> {\bf else} \\
 \> \> \> {\bf if} ($v_{k} == 0$) {\bf then} \\
 \> \> \> \> $L_{e_{ki}}[$\emph{next}$]$.event\_list:=\emph{entities
from }$v_{k}$ \\
 \> \> \> \> \emph{that have been serviced} \\
 \> \> \> {\bf else} \\
 \> \> \> \> $L_{e_{ki}}[$\emph{next}$]$.event\_value := \emph{(proportion of } \\
 \> \> \> \> state\_value \emph{which have been serviced)} \\
 \> \> \> {\bf end if} \\
 \> \> {\bf end if} \\
 \> {\bf end loop} \\
{\bf end loop}
\end{tabbing}}

Where adjacent nodes are operating at the same level of resolution,
the creation of flow is straightforward.  In high-resolution mode, the
entities that have completed processing at the current node are
deleted from its event list, and appended to the subsequent node's
event list.  In low resolution, the appropriate incremental arrival
rate is assigned to the incoming node's {\tt state\_value} attribute.
Accommodating the mixed resolution interface involves the synthesis of
either a corresponding arrival rate, or a list of entities, depending
upon the resolution of the remote node.

\subsection{Phase 4: Process inputs}

The final phase of an iteration addresses the system-specific
processing taking place at each node.

{\tt
\begin{tabbing}
{\bf fo}\={\bf r} k {\bf in} 1 ..\ n {\bf loop} \\
 \> {\bf if} \= ($v_{k} == 0$) \\
 \> \> {\bf fo}\={\bf r} i in 1 ..\ $L_{k}$.size {\bf loop} \\
 \> \> \> \emph{(Process event list as appropriate)} \\
 \> \> {\bf end loop} \\
 \> {\bf else} \\
 \> \> \emph{(Process using aggregate arrival rate as appropriate)} \\
 \> {end if} \\
{\bf end loop} 
\end{tabbing}}

\section{Performance}

Assume a system of $n$ nodes.  We will consider the worst-case
complexity, in terms of both computing power and storage space, as the
situation which exists when every node operates at its highest
resolution.  Let the connectivity among these nodes be distributed as
a random variable ${\bf X}$, and the number of entities present at any
particular node at time $t$, ${\bf Y}(t)$.  As well, let $\tau_{h}$
represent the time needed to instantiate or process an entity in high
resolution, and $\tau_{l}$ the time needed to conduct processing in a
node operating at low resolution.  Clearly it may not take the same
amount of time to instantiate or process nodes at high resolution; we
assume that these times are constant and the same for the purpose of
characterizing the time complexity only.  Since we assume that every
node operates at the same (high) resolution, the time needed to
generate outputs is approximately $n \tau_{h} E[{\bf X}]$. The time
needed to process the inputs is $n \tau_{h} E[{\bf Y}(t)]$.  Therefore
the aggregate worst-case iteration time in purely high resolution mode
is $T_{\tt it(h)} = n\tau_{h}(E[{\bf X}] + E[{\bf Y}(t)])$.  In terms
of space, $nE[{\bf Y}(t)]$ times the size of {\tt event\_type} is
required to accommodate the expected size of the queue at each node.

Now suppose that of the $n$ nodes, some number $s$ of them operate at low
resolution. The time needed to generate the outputs is given by 

\begin{eqnarray} 
T_{o} & = & n \tau_{l} E[{\bf X}]\left( \frac{s}{n} \right)+n\tau_{h}E[{\bf X}]
\left( \frac{n-s}{n} \right)  \\
      & = & s \tau_{l} E[{\bf X}] + (n-s) \tau_{h} E[{\bf X}] \\
      & = & [s(\tau_{l} - \tau_{h}) + n  \tau_{h} ] E[{\bf X}]
\end{eqnarray}

Processing the inputs is determined similarly as  

\begin{eqnarray}
T_{i} & = & (n-s) \tau_{h} E[{\bf Y}(t)] + s \tau_{l} 
\end{eqnarray}

The total iteration time in mixed mode is therefore approximately

\begin{equation}
\begin{split}
T_{\tt it(m)} &= [s( \tau_{l} - \tau_{h}) + n  \tau_{h} ] E[{\bf X}]
+ (n-s) \tau_{h} E[{\bf Y}(t)] + s \tau_{l}\\
   &= (s\tau_{l} - s\tau_{h} + n\tau_{h}) E[{\bf X}] + (n\tau_{h} - s\tau_{h}) E[{\bf Y}(t)] + s\tau_{l} \\
   &= s\tau_{l}(1 + E[{\bf X}]) - s\tau_{h}(E[{\bf X}] + E[{\bf
Y}(t)]) + \\
   &  \hspace{1.5in} n\tau_{h}(E[{\bf X}] + E[{\bf Y}(t)]) \\
   &= s\tau_{l}(1 + E[{\bf X}]) + \tau_{h}(n-s)(E[{\bf X}] + E[{\bf Y}(t)])
\end{split}
\end{equation}

Regarding storage space, $(n-s)E[{\bf Y}(t)] + s$ times the size of {\tt
event\_type} will be needed.

We may now evaluate the anticipated speedup using the mixed mode
approach over modeling all nodes at the highest resolution as  

\begin{eqnarray}
\begin{split}
S &= \frac{T_{\tt it(h)}}{T_{\tt it(m)}} \\
  &= \frac{n\tau_{h}(E[{\bf X}] + E[{\bf Y}(t)])}{s\tau_{l}(1 +
E[{\bf X}]) + \tau_{h}(n-s)(E[{\bf X}] + E[{\bf Y}(t)])} \label{eq:S}
\end{split}
\end{eqnarray}

\begin{figure}
\begin{center}
\leavevmode
\includegraphics[height=2in]{surf.eps}
\caption{Speedup factor as a function of \emph{n} and \emph{s}.}
\label{fig:speed}
\end{center}
\end{figure}

We note that the significant extreme values of $S$ are

\begin{eqnarray}
\lim_{s \rightarrow 0} (S) & = & \frac{n\tau_{h}(E[{\bf X}] + E[{\bf
Y}(t)])}{\tau_{h}n(E[{\bf X}] + E[{\bf Y}(t)])} = 1 \\
\lim_{s \rightarrow n} (S) & = & \frac{n\tau_{h}(E[{\bf X}] + E[{\bf
Y}(t)])}{n\tau_{l}(1 + E[{\bf X}])} \\
  & = & \left( \frac{\tau_{h}}{\tau_{l}}\right) \left( \frac{E[{\bf X}] + E[{\bf Y}(t)]}{1 + E[{\bf X}]} \right)
\end{eqnarray}

If we assume that ${\bf Y(t)}$ is covariance stationary, then both
$E[{\bf X}]$ and $E[{\bf Y}(t)]$ are constant for a given simulation.
We can then simplify equation~\ref{eq:S} by letting $\alpha = \tau_{h}(E[{\bf
X}]+E[{\bf Y}(t)])$, and $\beta = \tau_{l}(1+E[{\bf X}])$, and writing

\begin{equation}
S(n,s) = \frac{\alpha n}{\beta s + \alpha n + \alpha s} = \frac{\alpha
n}{\alpha n + (\beta - \alpha)s}
\end{equation} 

This function is discontinuous where $\alpha n = (\alpha - \beta) s$,
as evidenced by the steep gradient in figure~\ref{fig:speed}, and
undefined for $s>n$.

The comparative reduction in storage space is calculated as 

\begin{eqnarray}
R & = & \frac{nE[{\bf Y}(t)]}{(n-s)E[{\bf Y}(t)] + s}
\end{eqnarray}

Again we have the extreme values

\begin{eqnarray}
\lim_{s \rightarrow 0} (R) & = & \frac{nE[{\bf Y}(t)]}{nE[{\bf Y}(t)]}
= 1 \\
\lim_{s \rightarrow n} (R) & = & \frac{nE[{\bf Y}(t)]}{n} = E[{\bf Y}(t)]
\end{eqnarray}

\section{Conclusions}

From a simulation perspective, a model is only useful if its employment
results in the faithful duplication of the relevant characteristics of the
system of interest. Complex systems may incorporate more detail than
can reasonably be represented using available computing resources.  The
notion of multiresolution simulation accommodates such situations by
allowing the simulator to selectively enhance or supress details as
needed to satisfy resource constraints, and maintain the fidelity of
the output.  The proposed implementation of the multiresolution approach
achieves this end by reducing both the computational burden and
storage space required to model systems using the network flow
paradigm.   

\bibliographystyle{ieeetr}
\bibliography{paper34}
\end{document}
