Details
Semcheck -- Constraints between modeling perspectives
Semcheck is realized by a bridge from the modeling environment (e.g. ADOxx) to the ConceptBase.cc server. The bridge translates models and meta models to the Telos language used in ConceptBase.cc. General examples for mapping modeling language descriptions to ConceptBase are available at
http://merkur.informatik.rwth-aachen.de/pub/bscw.cgi/3810007
in particular
http://merkur.informatik.rwth-aachen.de/pub/bscw.cgi/3869501
The lecture on SemCheck (slides, 30+ pages demo script, all software and examples) is available from this site under the section 'Tool-Download':
http://austria.omilab.org/psm/content/semcheck/download?view=download
The Domain of SemCheck
Enterprises are complex and dynamic organizations that can hardly be understood from a single viewpoint. Enterprise modelling tackles this problem by providing multiple, specialized modelling languages, each designed for representing information about the enterprise from a given viewpoint. The OMiLAB initiative promotes the use of meta-modelling to design such domain-specific languages and to provide them by an open repository to the community. In this OMiLAB project, we discuss how this meta-modelling approach can be combined with the design of integrity constraints that span multiple modelling languages. Semcheck provides the services of the ConceptBase system as a constraint checker for modelling languages created by modelling tols like ADOxx.
This document describes a tool that is designed to support the open modeling environment by providing semantic integrity checking services (SemCheck), which can be used to analyze interrelated models formulated to find errors and to extract information from the models.
We describe first the software that is needed to use the SemCheck services. Then, a first case study shows how the constructs of the ArchiMate enterprise architecture language can be supported, in particular to implement traceability services for ArchiMate implementations. The next chapter presents services for the 4EM suite of enterprise modeling languages. The focus here is to support integrity and query services for cross-notational links. The last part reports on the current state of integration of SemCheck into the open ADOxx modeling toolkit. The examples source files referred to by this document come with the own Creative Commons licenses. They allow in any case the non-commercial use, in particular the use in academic context.
Hence, SemCheck has no particular modeling domain but it is rather a tool to enhance any modeling language implementation that builds upon metamodeling.
Goal of the lecture
The goal of the lecture is to motivate the challenge of integrating multiple modeling perspectives that are encoded in heterogeneous modeling languages. Some or all of these modeling perspectives may be domain-specific and created ad hoc by means of a metamodeling toolkit such as ADOxx. This makes the management of the interrelationship between these modeling languages a difficult task, in particular because the combination of models shall be complete and consistent at the end of a modeling phase.
The lecture promotes the uses of a Datalog-based logic using a uniform representation for model elements. Constraints can then be formulated with predicates ranging over constructs of multiple modeling languages. The lecture includes three major case studies for which rhe source code is provided. Students can replay the examples and create their own modeling languages plus accompanying constraints.
At the end of the lecture, students shall understand the principles that lead to the need to check constraints across model language boundaries. They also shall be able to apply the logic-based approach to self-selected combinations of modeling languages, e.g. a process modeling language combined with a data modeling language.
Concepts and theories
The main concepts are metamodeling and a special logic, called Datalog, as implemented by the ConceptBase system. The metamodeling part is building on the ADOxx abstraction levels (models, meta models, meta² models) but also extending it. Specifically, the data model Telos of ConceptBase uses a single data structure of quadruples (called propositions) to represent an model element regardless of their abstraction level. Even attributes, relations, instantiations, and specializations are represented as propositions.
The set of propositions forms the so-called extensional database upon which deductive rules, integrity constraints, and queries are formulated. The latter two are just special forms of deductive rules. The set of deductive rules forms the so-called intensional database. The rules derive facts from existing or already derived facts. The formal semantics is based on a fixpoint operation, which derived new facts until no more facts can be derived.The theory behind this fixpoint semantics ensures that all derivable facts are derived in a finite number of steps.
The key terms used in the lecture are:
object: any proposition regardless of its abstraction level
class: any object that is declared as class of other objects in an instantiation relation (x in c).
attribute: an attribute m with a value or a relation to another object (x m y)
subclass: and object c that has some superclass d, expressed as (c isA d)
The reader should be familiar with the syntax of first order logic, since it is used to express deductive rules, integrity constraints, and queries.
Short description of the method and the tools used
SemCheck is build upon ConceptBase. ConceptBase is a multi-user deductive database system with an object-oriented (data, class, metaclass, meta-metaclass, etc.) makes it a powerful tool for metamodeling and engineering of customized modeling languages. The system is accompanied by a highly configurable graphical user interface that builds upon the logic-based features of the ConceptBase server.
Unlimited metaclass hierarchies. ConceptBase.cc can represent information at the data level (example data, traces of process executions etc.), the class level (schemas, process definitions etc.), the metaclass level (constructs of modeling languages), the meta-metaclass level (constructs for defining modeling languages), and so forth. There are no fixed hierarchies but rather the notion of instantiation between two objects, one being the instance, the other the class. There are also classes whose instances span over several metaclass hierarchies. For example, the class Proposition has all objects as instances, regardless of their abstraction level.
Uniform object representation. All objects are represented in a uniform quadruple data structure called P-facts (or "propositions") pioneered by the developers of the Teloslanguage. Objects, their attributes, specializations, and instantiations are all represented as P-facts. By this, for example, attributes of objects can have attributes and are instances of other attributes. Even specialization between attributes is fully supported.
Logical expressions. Deductive rules, integrity constraints, and queries are expressed in first-order logic formulas. Internally, the system transforms them into Horn clauses interpreted by a Datalog-based evaluation machine. Logical expressions in ConceptBase.cc can range over class of objects regardless of its type (node vs. link) and its abstraction level. Datalog is known for being the most robust computational system for evaluating logical expressions.
Active rules. Active rules update the database or call external routines as a reaction to events. The execution follows the Event-Condition-Action scheme (ECA). Updates to the database are formulated via Tell/Untell/Retell commands. External routines (e.g. for invoking a script to send an email) can be incrementally added to the database using a simple Prolog-based programming interface.
Functional expressions. ConceptBase supports functional and arithmetic expressions to define computation within models. Functions can be recursively defined much like in Functional Programming. For example, the length of the shortest path between two nodes is defined as the minimum of the lengths of the shortest path between the successors of the start node and the end node. Functional expressions are particularily useful for defining complex metrics on models. Aggregation functions such as SUM and AVG are predefined.
Short description of case studies and exercises for application
The lecture includes 3 cases studies exemplifying the principles of constraints crossing multiple modeling languages.
The first case study is a partial implementation of ArchiMate. This case study shows that diffrent link types cross the ArchiMate layers (business, application, IT infrastructure). A set of rules is defined that allow modelers to trace dependencies accross the ArchiMate layers, such as finding out which business services depend on a certain database system specified in the IT infrastructure.
The second case study is a partial implementation of the 4EM enterprise modeling method. 4EM uses interface constructs tolink the perspectives. The case study shows howqueries can be used to extract the interface constructs and to assess whether there are any “modeling islands”, i.e. constructs in one perspective that are not transitively linked to constructs of some other modeling perspective.
Finally, the last case study shows how integrity constraints and rules at the highest abstraction level can be used to formalize and extrend the capabilities of the ADOxx meta² model. The case study uses the ADOxx representation of the ER modeling language as an example.
Further references are available at:
http://austria.omilab.org/psm/content/semcheck/info
(complete tutorial with 30+ pages demonstration script, lecture slides, and all source codes)
(official ConceptBase home page with download of the sofware)
https://gitlab.com/mjeu/conceptbasecc
(GitLab repository with all ConceptBase sources plus make environment)
Contact: M. Jeusfeld, University of Skövde, Box 408, S-54128 Skövde, Sweden
2019-06-12/M.Jeusfeld
