There are more things in heaven and earth, Horatio,
than are dreamt of in your philosophy.

-- William Shakespeare, Hamlet

Chapter 1


Integrating multiple, independently-developed models of overlapping phenomena is the crux of multi-model design. Experience shows that this integration is a hard problem because of semantic mismatches between the models, and because current approaches make sub-optimal trade-offs between run-time performance and consistency of the models. Current practice involves employing one of two basic approaches: selective viewing, which may compromise performance for consistency, and aggregation-disaggregation, which may compromise consistency for run-time performance. Often, the precise conditions under which integration can be done effectively are not entirely clear. This dissertation addresses the integration of independently-developed models in a manner that reconciles demands for run-time performance and consistency of the models when concurrent interactions occur.

In this dissertation, we present a new approach, UNIFY , for integrating multiple models. The main contributions of this work are two-fold. First, we show that UNIFY improves on the run-time performance of selective viewing while simultaneously improving on the consistency provided by aggregation-disaggregation. In other words, it achieves a better balance of these competing concerns than either of the two approaches in use today. Our thesis is that multiple models can be integrated such that their joint execution is as consistent as selective viewing but with lower costs than selective viewing or aggregation-disaggregation. An approach that satisfies our thesis achieves "effective" joint execution. In this dissertation, we present requirements for effective joint execution, and show how current approaches fail to satisfy them. We define concurrent representations as the representations of jointly-executing models. We define maintaining consistency as ensuring that the states of representations do not conflict. Effective joint execution of multiple models can be achieved by maintaining consistency among their representations. Consistency maintenance among concurrent representations is the cornerstone of UNIFY .

The second contribution of this work is identifying the conditions under which multiple, independently-developed models can be integrated. This knowledge enables designers to produce models that can be composed later into a multi-model. Our work shows that existing models can be integrated only to the extent that they satisfy these conditions. The extent to which existing models do meet these conditions is not known, but the difficulty that designers experience in practice suggests that there is room for improvement. We present four fundamental observations about jointly-executing models, which form the basis of the techniques and processes that are part of UNIFY . We apply UNIFY to existing models and present guidelines for multi-model designers.

1.1 Background

Modelling is a method to study a phenomenon without involving the phenomenon itself. A model captures essential parts of a phenomenon, such as its constituent processes and interacting objects, which are called entities. Typically, models have representation, which is a means of describing objects and processes within a model. Simulation is a technique to execute models, typically on a computer. Modelling and simulation provide the opportunity to study a phenomenon relatively inexpensively, reproducibly and, by reducing the number of controlling factors, at a convenient level of abstraction.

Multiple models executing jointly may capture combined semantics that cannot be captured by any one model alone. Multiple models may be constructed in order to study different parts of a phenomenon. The multiple models together constitute a multi-model. When the multiple models execute at overlapping times and exchange information with one another, they are said to execute jointly. Davis and other researchers advocate jointly executing multiple models of a phenomenon [Davis93]. Constructing and maintaining a new model for every combination of semantics may involve high cost and effort on the part of designers. In contrast, simple and well-designed models executing jointly may be able to capture such semantics. Effective joint execution of well-designed models can lead to a multi-model that satisfies its users' requirements. Constructing well-designed models is an important task; however, we restrict our work to the effectiveness of joint execution. Multi-representation modelling (MRM) is the joint execution of multiple models of the same phenomenon.

Currently, two basic approaches exist for executing multiple models jointly: selective viewing and aggregation-disaggregation. We explain these approaches with a brief example. Consider a chemical reaction for which two models exist: a molecular model, ModelA , and an atomic model, ModelB . Since the reaction can be studied from both perspectives, it may be required for the models to execute jointly. In the selective viewing approach, the more detailed model of the two, in this case ModelB , is executed alone. The execution of ModelA is emulated by selecting a view, i.e., filtering information, from the state of ModelB when necessary. Since only ModelB is executed, maintaining consistency between the two models is straightforward. However, since ModelB is more detailed, executing it entails higher resource consumption than ModelA . Moreover, since ModelA is not executed, selective viewing does not capture the combined semantics of the two models. In the aggregation-disaggregation approach, as far as possible, the less detailed model of the two, in this case ModelA , is executed alone. When more detail is required, the execution of ModelA is suspended and ModelB is executed. Subsequently, when detail is not required, the execution of ModelB may be suspended and the execution of ModelA resumed. Since ModelA is less detailed, executing it entails lower resource consumption cost than ModelB . Since the currently-executing model may change at different times, maintaining consistency between the models is important for maintaining semantic continuity. However, for reasons that we will explain in §4.1, maintaining consistency in this manner is hard, i.e., it can be error-prone and resource-intensive. Moreover, aggregation-disaggregation does not capture the combined semantics of the two models because at any given time only one of the models is executed.

Both these approaches are based on sound principles; however, we show that they can fail to achieve effective MRM in many instances [Reyn97]. Selective viewing is based on the principle that high detail is more important than performance or abstraction. Aggregation-disaggregation is based on the principle that performance and abstraction can be gained by providing high detail infrequently. Rigidly adhering to one principle or the other has caused MRM to become ineffective in many instances. With our approach, UNIFY , we show how to balance these competing principles, thus eliminating problems inherent in alternative approaches.

1.2 UNIFY -- An Overview

UNIFY is a framework for maintaining consistency among representations of jointly-executing models. It is based on four fundamental observations that capture general characteristics of jointly-executing models [Reyn97]. Current MRM approaches encounter a number of problems because they have failed to appreciate these characteristics. The fundamental observations indicate that consistent MRM can be achieved at a lower cost than other approaches by maintaining consistency among multiple representations when concurrent interactions occur.

When multiple models of the same phenomenon execute jointly, significant problems can arise if the models conflict. Eliminating or avoiding these conflicts has been a hard problem for MRM designers. Some multi-models may satisfy their users' requirements despite such conflicts. However, we believe that maintaining consistency among the representations of a multi-model is a systematic and disciplined approach for constructing multi-models that satisfy their users' requirements. This approach benefits multi-models that require consistency, as we will show in the rest of this dissertation. This approach benefits multi-models that tolerate relaxed or no consistency as well, because it shows how other requirements for effective joint execution can be satisfied.

We avoid problems encountered in current approaches by making multiple representations of an entity co-exist at all times within a Multiple Representation Entity (MRE). For example, in Figure 1, E1 is an MRE for an entity in multiple models, ModelA and ModelB . An MRE is a contrast to selective viewing and aggregation-disaggregation, wherein either the entity in ModelA or the entity in ModelB , but not both, would exist at any given time. As we will show in §2.1, designers in many domains, such as multi-resolution graphical models, hierarchical autonomous agents and molecular modelling have adopted approaches similar to creating MREs. MREs, a part of UNIFY , maintain the representations of multiple models at all times.

An MRE permits concurrent changes to any of its representations. Changes to states of representations occur as a result of interactions among objects and processes. Interactions are means by which objects and processes communicate or try to influence the behaviour of one another. Interactions may change multiple representations of objects or processes.

One challenge in UNIFY is maintaining consistency among multiple representations when the state of any representation changes. In Figure 1, when E1 interacts with either E2 or E3, the multiple representations within E1 must be consistent. A Consistency Enforcer (CE) maintains consistency among the multiple representations within an MRE by capturing relationships among parts of the representations. A CE consists of an Attribute Dependency Graph (ADG) and mapping functions. An ADG captures dependencies among representations. When the state of a representation changes, a CE traverses an ADG to determine how the state of other representations must change. The CE performs the actual changes by invoking application-specific mapping functions that translate changes in one attribute to changes in others. As part of UNIFY , we show how to construct an ADG, select mapping functions and construct a CE for an MRE.

Another challenge in UNIFY is ensuring that the effects of interactions that occur at overlapping simulation times are applied correctly. For example, in Figure 1, E1's behaviour must be meaningful even when E2 and E3 interact with E1 concurrently . Interactions occurring at overlapping times are called concurrent interactions. Concurrent interactions may be dependent, i.e., have related effects, for example, precluding or enhancing one another. Traditionally, concurrent interactions have been serialized, i.e., applied one after another in some arbitrary order. However, serialization can cause incorrect behaviour because the effects of dependent concurrent interactions are not reflected meaningfully. For example, in a model of a chemical reaction, E1 may represent some quantity of an acid, E2 may represent a reagent and E3 a catalyst. Adding a reagent or catalyst is an interaction in this model. When both E2 and E3 are added to E1, the rate of the reaction may increase more than the sum of the increases caused by adding either E2 or E3 alone. Serialization can capture the sum of the increases, but not the increase caused when both E2 and E3 are added. Therefore, in this model, serialization produces incorrect results. As part of UNIFY , we present a taxonomy of interactions that captures the semantic relations among concurrent interactions and presents mechanisms to resolve them. Also, we show how to construct an Interaction Resolver (IR) for an MRE in order to resolve the effects of dependent concurrent interactions.

MREs, ADGs, a taxonomy of interactions, and processes for constructing a CE and an IR are part of UNIFY . Multi-model designers can achieve consistent MRM at lower cost than other approaches by applying these techniques and processes.

1.3 Requirements for Effective MRM

In jointly-executing models, entities in all models must interact consistently and cost-effectively. Although these requirements seem self-evident, alternative techniques for MRM often fail to satisfy them. We measure the success of an MRM approach by analysing whether the approach satisfies these requirements.

Often, multi-models are unsatisfactory because they become inconsistent or expensive. An effective MRM approach must satisfy at least the following reasonable requirements:

  1. R1: Multi-representation Interaction : Entities in each model may initiate and receive interactions that may cause changes to the entities concurrently. Dependent concurrent interactions must be permitted.
  2. R2: Multi-representation Consistency : The representations of jointly-executing models must be consistent with one another. Temporal consistency requires that two entities interacting with a third entity at overlapping simulation times have consistent views of the third entity. Mapping consistency requires that entity properties common to different models be translated such that repeated translations in a given period do not cause abnormal behaviour in the entity during that period. Multi-representation consistency is interesting only if the multiple models are related to one another.
  3. R3: Cost-effectiveness : The costs of simulating multiple models and maintaining consistency among them should be lower than alternative approaches.

These requirements represent the conditions under which multiple models can be integrated effectively. We will evaluate UNIFY and alternative MRM approaches such as aggregation-disaggregation and selective viewing with regard to these requirements. We will consider an MRM approach sufficient only if it satisfies all three requirements.

1.4 Claims and Contributions

UNIFY benefits the practice of modelling and simulation because it enables designers to build consistent multi-models with lower run-time costs than other approaches. We have examined the problem of joint execution of multiple models in detail, and created general and useful techniques for consistency maintenance in concurrent representations. Rather than conceiving a detailed solution for every application we analysed, we concentrated on a process that MRM designers may modify for their applications.

We present a sufficient and practical framework for MRM. Our framework, UNIFY , is a sufficient approach to MRM because it satisfies the three requirements for MRM: R1, R2 and R3. Moreover, UNIFY is a practical approach to MRM because it can be applied in conjunction with a methodology for specifying models.

The major contributions of our work are the fundamental observations, MREs, ADGs, the taxonomy of interactions, a cost study and the guidelines for designers. All of these contributions further the existing practice in modelling and simulation. The taxonomy of interactions offers a spectrum of solution choices for resolving concurrent interactions in any domain. We expect UNIFY to be useful in a variety of domains, such as hierarchical autonomous agents, climate modelling and graphical modelling.

A substantial benefit of our work to multi-model designers is a set of guidelines for consistency maintenance. The guidelines lead designers from their joint execution requirements to the design of consistent MREs. We augment Object Model Templates -- a methodology for specifying objects and the interactions among them -- with specifications for concurrent interactions. Incorporating UNIFY into an existing specification methodology enables designers to understand our work in terms of techniques already familiar to them. The guidelines provide designers with an easy reference for incorporating consistency maintenance in their models.

Our work will benefit many modellers. Designers may incorporate consistency in their applications by following our guidelines. Analysts may examine the justification behind the guidelines. Our analyses of MRM approaches cautions modellers entering the field of MRM: joint execution is neither trivial nor easy. Finally, we have laid the foundation for future explorations and refinements.

1.5 Evaluation

In this dissertation, we show how multi-model designers can achieve consistency similar to selective viewing but at a lower cost than either selective viewing or aggregation-disaggregation. We show how designers can employ an ADG, mapping functions, a taxonomy of interactions and policies for concurrent interactions in order to maintain consistency within an MRE when concurrent interactions occur. We measure the costs involved in executing multiple models jointly and show that these costs are lower in UNIFY than in selective viewing and aggregation-disaggregation. We show how UNIFY satisfies the requirements for effective MRM, R1, R2 and R3, while other approaches do not even if they make similar assumptions as we do. We apply the techniques and processes in UNIFY to four multi-models in order to provide empirical evidence that UNIFY is a practical framework. Finally, we show how UNIFY can be applied in conjunction with Object Model Template, a methodology for specifying multi-models.

The three MRM requirements, R1, R2 and R3, capture desirable goals for the joint execution of multiple models. Satisfying these requirements supports our thesis that a multi-model can be constructed in a consistent manner and with reduced run-time costs. The requirements themselves do not outline an approach for effective MRM. In other words, approaches other than UNIFY for achieving effective MRM are possible. Finally, the requirements may be part of a larger set of requirements for the joint execution of multiple models. Identifying the members of the larger set is a topic for future work.

Our work presents a general approach for effective MRM. We do not address how effective MRM can be achieved for specific models. However, we do present the conditions under which such models may be executed jointly. We provide techniques and processes that designers can employ to satisfy most of these conditions. We have been unable to provide techniques for achieving compatible time-steps (discussed in §3.3.3). Although this inability is a limitation of our work, we show how compatible time-steps eliminate inconsistencies caused by time-step differentials, thus benefiting multi-model designers. We regard our work as a preliminary step towards a detailed framework that guides designers in the design of their multi-models. We expect that UNIFY , with future additions, will be that framework.

We envision designers routinely constructing simple models that can be integrated and jointly executed as a multi-model. A number of issues must be resolved before this vision becomes reality. For example, constructing models can be complex, verifying them can be difficult and reconciling the semantic differences between them can cause problems. Our work addresses only one of these important issues: the joint execution of the models. Our work focusses on consistency maintenance in concurrent representations. We show that maintaining consistent representations for multiple models that execute jointly leads to effective MRM.

1.6 Outline

In Chapter 2, we briefly present applications that adopt the approach of maintaining concurrent representations. Detailed discussions of these applications are in Appendix A. We present alternative MRM approaches wherein concurrent representations are not maintained. Also, we present work related to key concepts in UNIFY . In Chapter 3, we lay the foundation for UNIFY by introducing and defining terms that we will use throughout this dissertation. Also, we discuss the criteria that we will use to evaluate MRM approaches. In Chapter 4, we present and justify some fundamental observations about MRM. These observations arise from empirical studies of many MRM applications. Any solution to the MRM problem must incorporate these observations. Our approach recommends maintaining consistency among concurrent representations of multiple models. We present our framework-based approach to MRM, UNIFY , in Chapter 5 and discuss the technical challenges with such an approach. In Chapter 6, we address the first challenge -- keeping multiple representations consistent when interactions change any representation. In Chapter 7, we address the second challenge -- resolving the effects of concurrent interactions. In Chapter 8, we present a process for applying the techniques that are part of UNIFY and present guidelines for designers of multi-model applications. In Chapter 9, we evaluate UNIFY and briefly present case studies of applying it. We present the case studies in detail in Appendices B, C, D and E. We conclude in Chapter 10 by discussing the contributions of our work to the practice of modelling and simulation and presenting some areas for future work.