Computing and Software

Model-versioning-in-the-large is concerned with complex scenarios involving multiple updates and multiple replicas of a model. The paper introduces tile systems as rephrasing of double categories in model versioning terms, and shows that the tile language enables a very general formalization of versioning concepts. The formalization makes the concepts amenable to algebraic analysis and provides a convenient notation for version system designers. It also allows one to formulate algebraic laws that a correct versioning system must or may want to satisfy.

There is a hidden intrigue in the title. CT is one of the most abstract mathematical disciplines, sometimes nicknamed "abstract nonsense". MDE is a recent trend in software development, industrially supported by standards, tools, and the status of a new "silver bullet". Surprisingly, categorical patterns turn out to be directly applicable to mathematical modeling of structures appearing in everyday MDE practice. Model merging, transformation, synchronization, and other important model management scenarios can be seen as executions of categorical specifications. Moreover, the paper aims to elucidate a claim that relationships between CT and MDE are more complex and richer than is normally assumed for "applied mathematics". CT provides a toolbox of design patterns and structural principles of real practical value for MDE. We will present examples of how an elementary categorical arrangement of a model management scenario reveals deficiencies in the architecture of modern tools automating the scenario.

A megamodel is a model, whose instances are systems of models and intermodel relationships. To be independent of a particular modeling language, typical megamodels reduce models and their relationships to unstructured nodes and edges, thus creating a significant gap between abstract megamodels and their concrete instances. We address this gap problem by mathematical means borrowed from category theory, and propose mapping-aware megamodels, which provide additional internal structure to nodes and edges, yet remain independent of modeling languages.

Triple graph grammars (TGGs) have been used successfully to analyze correctness and completeness of bidirectional model transformations, but a corresponding formal approach to model synchronization has been missing. This paper closes this gap by providing a formal synchronization framework with bidirectional update propagation operations. They are generated from a given TGG, which specifies the language of all consistently integrated source and target models. As our main result, we show that the generated synchronization framework is correct and complete, provided that forward and backward propagation operations are deterministic. Correctness essentially means that the propagation operations preserve and establish consistency while completeness ensures that the operations are defined for all possible inputs. Moreover, we analyze the conditions under which the operations are inverse to each other. All constructions and results are motivated and explained by a running example, which leads to a case study, using concrete visual syntax and abstract syntax notation based on typed attributed graphs.

We present Clafer (class, feature, reference), a class modeling language with first-class support for feature modeling. We designed Clafer as a concise notation for meta-models, feature models, mixtures of metaand feature models (such as components with options), and models that couple feature models and meta-models via constraints (such as mapping feature configurations to component configurations or model templates). Clafer allows arranging models into multiple specialization and extension layers via constraints and inheritance. We identify several key mechanisms allowing a meta-modeling language to express feature models concisely. Clafer unifies basic modeling constructs, such as class, association, and property, into a single construct, called clafer. We provide the language with a formal semantics built in a structurally-explicit way. The resulting semantics explains the meaning of hierarchical models whereby properties can be arbitrarily nested in the presence of inheritance and feature modeling constructs. The semantics also enables building consistent automated reasoning support for the language: to date, we implemented three reasoners for Clafer based on Alloy, Z3

Software development often involves a set of models defined in different metamodels, each model capturing a specific view of the system. We call this set a multimodel, and its elements partial or local models. Since partial models overlap, they may be consistent or inconsistent wrt. a set of global constraints. We present a framework for specifying overlaps between partial models and defining their global consistency. An advantage of the framework is that heterogeneous consistency checking is reduced to the homogeneous case yet merging partial metamodels into one global metamodel is not needed. We illustrate the framework with examples and sketch its formal semantics based on category theory.

Specification and maintenance of relationships between models are vital for MDE. We show that a wide class of such relationships can be specified in a compact and precise manner, if intermodel mappings are allowed to link derived model elements computed by corresponding queries. Composition of such mappings is not straightforward and requires specialized algebraic machinery. We present a formal framework, in which such machinery can be defined generically for a wide class of metamodel definitions. This enables algebraic specification of practical intermodeling scenarios, e.g., model merge.

Triple graph grammars (TGGs) have been used successfully to analyze correctness and completeness of bidirectional model transformations, but a corresponding formal approach to model synchronization has been missing. This paper closes this gap by providing a formal synchronization framework with bidirectional update propagation operations. They are generated from a TGG, which specifies the language of all consistently integrated source and target models. As a main result, we show that the generated synchronization framework is correct and complete, provided that forward and backward propagation operations are deterministic. Correctness essentially means that the propagation operations preserve consistency. Moreover, we analyze the conditions under which the operations are inverse to each other. All constructions and results are motivated and explained by a small running example using concrete visual syntax and abstract syntax notation based on typed attributed graphs.

Multiple (more than 2) model synchronization is ubiquitous and important for MDE, but its theoretical underpinning gained much less attention than the binary case. Specifically, the latter was extensively studied by the bx community in the framework of algebraic models for update propagation called lenses . We make a step to restore the balance and propose a notion of multiary delta lens. Besides multiarity, our lenses feature reflective updates, when consistency restoration requires some amendment of the update that violated consistency, and a reasonable Put Put law that requires compatibility of update propagation with update composition for a precisely specified restricted class of composable update pairs. We emphasize the importance of various ways of lens composition for practical applications of the framework, and prove several composition results.

Software design requires deployment of interdependent models conforming to different metamodels. This set of models is called a multimodel, and it must satisfy a set of global constraints regulating interaction of the multimodel components. A straightforward approach to global consistency checking would require merging component metamodels modulo their overlap, adding, perhaps, new global constraints to this merge, merging component models modulo their overlap, and checking the latter merge against the constraints in the former one. Being a natural definition for global consistency, these steps can not be used algorithmically because of two major practical drawbacks: they involve costly (meta)model matching to specify overlaps, and require building big and unfeasible merged metamodels and models. The present paper makes two contributions. First, it presents a new algorithm to check each global constraint individually, and as local as possible, i.e., only using those (meta)model elements that affect the validity of the constraint. Second, it develops a mathematical foundation that allows us to formally prove that this individual local consistency checking is sound and complete w.r.t. the definition of global consistency.

Software design requires deployment of a collection of interdependent models conforming to different metamodels. These so-called multi-models present different views of interest and may be consistent only if they simultaneously satisfy a set of global constraints. A straightforward approach to global consistency checking is to run constraint validations on the model union (merge). These validations are carried out by reduction to a small view (localization) of the model merge. It turns out that this ”merge-prior-to-localization”-approach is not efficient because of considerable matching and merging workload. We propose to perform early localization in order to reduce the data space which is subject to the search for commonalities. The algorithm is based on a new method for formally specifying the inter-relation of an arbitrary number of heterogeneously typed models. Behind the scenery we utilize valuable theorems of category theory.

In Model-Driven Engineering, bidirectional transformations are key to managing consistency and synchronization of related models. Deltalenses are a exible algebraic framework designed for specifying deltabased synchronization operations. Since model consistency is usually not a one-to-one correspondence, the synchronization process is inherently ambiguous, and consistency restoration can be achieved in many dierent ways. This can be seen as an uncertainty reducing process: the unknown uncertainty at design-time is translated into known uncertainty at run-time by generating multiple choices. However, many current tools only focus on a specic strategy (an update policy) to select only one amongst many possible alternatives, providing developers with little control over how models are synchronized. In this paper, we propose to extend the delta-lenses framework to cover incomplete transformations producing a multitude of possible solutions to consistency restoration. This multitude is m...

Model management tools contain common aspects that are frequently reinvented for each tool. Platform specific solutions to common problems may vary by language, however, the high-level specifications should be the same. Design patterns seek to communicate these common specifications in an abstract way that enables reuse, improves understanding and eases communication. In this paper, we present a library of fundamental design patterns based on mathematical foundations that are used as building blocks to specify more complex patterns which describe more concrete model management scenarios.

There is a hidden intrigue in the title. CT is one of the most abstract mathematical disciplines, some-times nicknamed ”abstract nonsense”. MDE is a recent trend in software development, industrially supported by standards, tools, and the status of a new ”silver bullet”. Surprisingly, categorical pat-terns turn out to be directly applicable to mathematical modeling of structures appearing in everyday MDE practice. Model merging, transformation, synchronization, and other important model man-agement scenarios can be seen as executions of categorical specifications. Moreover, the paper aims to elucidate a claim that relationships between CT and MDE are more complex and richer than is normally assumed for ”applied mathematics”. CT provides a toolbox of design patterns and structural principles of real practical value for MDE. We will present examples of how an elementary categorical arrangement of a model management scenario reveals deficiencies in the architecture of modern tools auto...

Technological importance of traceability mappings is wellknown. The paper argues that traceability mappings are also fundamental for semantics: we present a simple example showing that specifying (model-to-model) model transformations without traceability makes their semantics essentially incomplete. We also show that the traceability mapping from the transformed to the original model should correlate with a corresponding mapping from the target to the source metamodel. Moreover, the transformation can be seen as the result of execution of the metamodel mapping, and the latter thus appears as (a special encoding of) the transformation definition.

A graphical formalized language is proposed for specifying systems of views over database schemas. The language is based on the notion of arrow (mapping) between data schemas and is suitable for any data model for which schema mappings are defined. In particular, the constructs of query, query language, view and view integration can be consistently expressed in this arrow formalism and correspondingly specified. This gives rise to a general graph-based framework for specifying complex view systems. Basic constructions of the language and the entire framework as well can be considered as specialization of very general constructs developed in the mathematical category theory.

* Supported by Bell Canada through the Bell University Labs, NSERC and Ontario Centres Of Excellence markable duality between them. The results of the paper can then be seen as an (important yet) particular case of this general duality theory. Contents 3 Sample scenario 3.1 Example of relational schema integration

Requirements engineering (RE) is an inherently piecemeal and dynamic process. Arrangement, correlation and integration of models presenting different views of the system are an important component of the requirements engineer's work. If manually performed, these operations are error-prone and time consuming and, thus, an integrated computer-aided environment for them would be very useful. In the paper, we present an extendable framework that provides a formalization and a generic integration pattern for scenario management. The framework is based on mathematical category theory machinery of algebraic operations with higher-order graphs. We demonstrate how the framework works by a (not entirely trivial) example of scenario integration. A distinctive feature of our integration pattern is an essential use of derived elements: for setting correspondences between views we augment view scenarios with derived executions. We show that this augmentation is essential for a proper integration: information explicitly specified in one view can be implicit in another view, where it is derived from the information considered basic in that view.