Checking of models built using a graphically based formal modelling language

The chapter presents a description of a novel modelling language called Alvis defined for the design of concurrent especially real-time systems. Alvis combines the advantages of formal methods and practical modelling languages. Based on CCS and XCCS process algebras, Alvis utilizes flexible graphical modelling of interconnections among agents and a high level programming language used for the description of agents behaviour. Each agent in a model can use rule-based systems to support its decisions. A small set of language statements and graphical concepts make Alvis easy to learn and use. The possibility of a formal model verification, makes Alvis a formal modelling language. Alvis modelling environment creates in parallel a model of the considered system and a labelled transition system (LTS graph) that is its formal representation. The LTS graph can be formally verified with the CADP toolbox. A survey of main Alvis features from practical point of view, is given in the chapter.

CSP# is a formal modeling language that emphasizes the design of communication in concurrent systems. PAT framework provides a model checking environment for the simulation and verification of CSP# models. Although the desired properties can be formally verified at the design level, it is not always straightforward to ensure the correctness of the system's implementation conforms to the behaviors of the formal design model. To avoid human error and enhance productivity, it would be beneficial to have a tool support to automatically generate the executable programs from their corresponding formal models. In this paper, we propose such a solution for translating verified CSP# models into C# programs in the PAT framework. We encoded the CSP# operators in a C# library-PAT.Runtime, where the event synchronization is based on the Monitor class in C#. The precondition and choice layers are built on top of the CSP event synchronization to support language-specific features. We further developed a code generation tool to automatically transform CSP# models into multi-threaded C# programs. We proved that the generated C# program and original CSP# model are equivalent on the trace semantics. This equivalence guarantees that the verified properties of the CSP# models are preserved in the generated C# programs. Furthermore, based on the existing implementation of choice operator, we improved the synchronization mechanism by pruning the unnecessary communications among the choice operators. The experiment results showed that the improved mechanism notably outperforms the standard JCSP library.

The fulfillment of time requirements is one of the major acceptance criteria of safety-critical and real-time systems. They are dictated by the environment of these systems and are often well known at the early phases of the development process. At the same time, the time behavior is a cross-cutting concern, not bordered by the behavioral design units, e.g. components or classes. This paper argues for consideration of the time behavior as an explicit model-based view on the system under development. It proposes a modeling language and an analysis method. The formal graphical modeling language allows the explicit notation of time requirements and the integration with the architectural and behavioral aspects of the system. The analysis method allows the developer to verify requirements in aspect of their consistency and completeness as well as to validate design concerning the fulfillment of time requirements. It supports modular development, for which results are presented.

In information systems engineering, conceptual models are constructed to assess existing information systems and work out requirements for new ones. As these models serve as a means for communication between customers and developers, it is paramount that both parties understand the models, as well as that the models form a proper basis for the subsequent design and implementation of the systems. New CASE environments are now experimenting with formal modeling languages and various techniques for validating conceptual models, though it seems difficult to come up with a technique that handles the linguistic barriers between the parties involved in a satisfactory manner. In this article, we discuss the theoretical basis of an explanation component implemented for the PPP CASE environment. This component integrates other validation techniques and provides a very flexible natural-language interface to complex model information. It describes properties of the modeling language and the conceptual models in terms familiar to users, and the explanations can be combined with graphical model views. When models are executed, it can justify requested inputs and explain computed outputs by relating trace information to properties of the models.

A model checker is an automatic tool that traverses a specific structure (normally a Kripke structure referred as the modelM) to check the satisfaction of some (temporal) logical propertyf. This is formally stated asM⊧f. For some formal notations, the modelMof a specificationS(written in a formal languageL) can be described as a labelled transition system (LTS). Specifically, it is not clear in general how usual tools such as SPIN, FDR, PAT, etc., create the LTS representation from a given process. Although one expects the coherence of the LTS generation with the semantics ofL, it is completely hidden inside the model checker itself. In this paper we show how to create a model checker forL, using a development approach based on its operational semantics. We use a systematic semantics embedding and the formal modeling using logic programming and analysis (FORMULA) framework to this end. We illustrate our strategy considering the formal language COMPASS modelling language (CML)—a new language that was based on CSP, VDM and the refinement calculus proposed for modelling and analysis of systems of systems. As FORMULA is based on satisfiability modulo theories solving, our model checker can handle communications and predicates involving data with infinite domains by building and manipulating a symbolic LTS. This goes beyond the capabilities of traditional CSP model checkers such as FDR and PAT. Moreover, we show how to reduce time and space complexities by simple semantic modifications in the embedding. This allows a more semantics-preserving tuning. Finally, we show a real implementation of our model checker in an integrated development platform for CML and its practical use on an industrial case study.

This paper is a further step towards application of the Model-Based Systems Engineering (MBSE) paradigm, using standardized, graphical, and executable system modeling languages. It presents further development of Modelica graphical Modeling Language (ModelicaML), a UML Profile for Modelica, which enables an integrated modeling and simulation of system requirements and design (for systems including both hardware and software). This approach combines the power of the OMG UML/SysML standardized graphical notation for system and software modeling, and the modeling and simulation power of Modelica. It facilitates the creation of executable system-specification and analysis models that can simulate time-discrete (or eventbased) and time-continuous system behavior.

As the complexity of the safety-critical system grows, the difficulty for safety engineers to validate and ensure system safety increases too. Formal languages have been introduced as an alternative to natural language (NL) requirement descriptions. Sometimes, the safety requirements are put forward in natural language such as requirements from stakeholders and nonexperts. The transformation and verification work of the requirements are completed manually. A tool called DODT can semi-automatically transforms NL requirements into semi-formal boilerplate requirements which reduce the manual work of transformation largely. Alloy is a formal modeling language which is amenable to automatic analyses. We use it as a tool to make safety analysis taking benefit from the model-based aspect of Alloy and its expressiveness for the specification of the properties to check. In this paper, we combine DDOT with Alloy. The attributes we use in boilerplates can be transformed into Alloy sentences easily. Hence, the formal requirements can be expressed in Alloy easily and checked by Alloy Analyzer, reducing manual work largely. Last, we illustrate our method with a fire detection system.

Today we are witnessing the necessity to align Business and Information Technology (IT) as well as a change in the role of IT from an enabler to an industrial sector in its own right. Based on the assumption that businesses in different sectors of the economy will require IT for different reasons and in different ways, this article introduces the EU project plugIT that aspires to develop an IT-Socket that will realize the vision of businesses "plugging-in" to IT. Three demonstration scenarios deal with: (1) "Certification" of IT infrastructure to stay compliant with regulations, (2) "Virtual Organisation" by evolving the current service orientation to a higher and more business driven abstraction as well as, (3) "Governance" of IT infrastructure introducing business context into highly distributed and complex systems. The IT-Socket follows a model-driven approach by introducing graphical modelling languages as mediators between the domain experts and IT. The research challenge is to link human interpretable graphical models – partly semi-formal – with machine interpretable semantic formalisms to enable: (1) a tighter involvement of domain experts when expressing formal knowledge specifying business requirements on IT infrastructure and services, (2) different graphical modelling languages for different views on the IT-Socket to provide modelling languages the domain expert is used to work with as well as, (3) a domain specific notation for semantics by integrating formal concepts of semantics with the graphic notation from modelling languages.

In this article I present a formal model for the cultural evolution of counterintuitive cultural messages, specifically, religious ideas. This model tries to account for the reproduction of counterintuitive religious ideas by introducing a new parameter: the means of cultural communication by which those ideas are transmitted. Means of cultural communication can be classified alongside a continuum that goes from the cognitively optimal to the cognitively costly. Very simple intuitive messages may replicate weakly if they are transmitted through cognitively costly means of communication, and conversely, highly counterintuitive messages will reproduce without difficulty if they are transmitted through cognitively optimal means of communication. The formal model I propose in this study is based on a new version of the model put forward by Joseph Henrich to account for the Tasmanian case of cultural loss.

Often the most effective diagrams are those which are very simple. However there is a strong tendency, particularly prevalent in visual formal modelling and specification languages, to take a diagrammatic language which at core is very simple, and then add many extensions and features to make it more expressive - often making it so expressive that the diagrams produced in the language are no longer readable; or at least, the diagrams are no longer obviously a more effective form of representation than a text-based one. Both the design of effective visual formal modelling and specification languages, and the effective formalisation of (the semantics of) such visual languages requires the unification of results from visual language theory, cognitive science, empirical psychology and graphic design. Integrating results from such diverse fields is a non-trivial task, which may be approached through a decomposition of the study of issues of effectiveness in diagrammatic languages according to analogous understandings of (written and spoken) natural languages.

Multi-touch gestures like swipe and pinch have introduced a new interaction paradigm that is currently used in developing mobile applications. Such applications can include different user gestures that cause different results for different interactions with the same user interface element. Testing such user interaction is complex. We present a formal task-based approach to automate testing of user gestures in mobile applications. In previous work, we used TaMoGolog, a formal task modelling language built on the top of the Golog family of high-level programming languages, for evaluating user interfaces along the development process. In this work, we present MobiGolog that extends TaMoGolog to support the testing of users' multi-touch gestures in the developing and developed mobile applications.

As a result of recent changes in the IT, where the role of IT has shifted from an enabler to an industrial sector in its own right, the necessity to provide framework which would allow seamless alignment of the business and IT rose. The goal was to allow the stakeholders from the business as well as IT perspective to model the requirements for the IT service provisioning using the modeling languages they are familiar with and to apply semantic technologies as a mediator that will allow translation between them. IT-Socket, the model based approach for business and IT alignment, developed in the European Research project – plugIT, aims to realize the vision of businesses “plugging-in” to IT by introducing graphical modeling languages as mediators between the domain experts and IT. The research challenges identified include the ability to perform integration and translation between graphical modeling languages by building the reference ontology, enabling automatic generation of machine interpretable domain ontologies from graphical models and allowing automatic translation between domain ontologies. The results of the application of the IT-Socket for business and IT alignment are presented within three use cases: (1) “Certification” of IT infrastructure, (2) “Virtual Organization” by evolving the current service orientation to a higher and more business driven abstraction and (3) “Governance” of IT infrastructure.

Business process management encompasses a variety of tasks that can be solved system-aided but usually require formal process representations, i.e. process models. However, it requires a significant effort to learn a formal process modeling language like, for instance, BPMN. Among others, this is one reason why companies often still stick to informal textual process descriptions. However, in contrast to formal models, information from natural language text usually cannot be automatically processed by algorithms. Hence, recent research also focuses on annotated textual process descriptions to make text machine processable. While still human-readable, they additionally contain annotations following a formal scheme. Thus, they also enable automated processing by, for instance, formal reasoning and simulation. State-of-the-art techniques for automatically annotating textual process descriptions are either based on hand-crafted rule sets or artificial neural networks. Maintaining complex rule sets requires a significant manual effort and the approaches using neural networks suffer from rather low result quality. In this paper we present an approach based on Semantic Parsing and Graph Convolutional Networks that avoids manually defined rules and provides significantly better results than existing techniques based on neural networks. A comprehensive evaluation using multiple data sets from both academia and industry shows encouraging results and differentiates between several applied text features.

This paper presents a novel prototype platform that uses the same LaTeX mark-up language, commonly used to typeset mathematical content, as an input language for modeling optimization problems of various classes. The platform converts the LaTeX model into a formal Algebraic Modeling Language (AML) representation based on Pyomo through a parsing engine written in Python and solves by either via NEOS server or locally installed solvers, using a friendly Graphical User Interface (GUI). The distinct advantages of our approach can be summarized in (i) simplification and speed-up of the model design and development process (ii) non-commercial character (iii) cross-platform support (iv) easier typo and logic error detection in the description of the models and (v) minimization of working knowledge of programming and AMLs to perform mathematical programming modeling. Overall, this is a presentation of a complete workable scheme on using LaTeX for mathematical programming modeling which assists in furthering our ability to reproduce and replicate scientific work.

The monograph provides a detailed presentation of the main approaches to the creation of formalized descriptions of various objects, processes, and systems based on visual modeling tools. The evolution of visual models based on graph representations is examined. A classification of visual information modeling tools is presented. Information is provided on the principles of applying domain modeling methods based on formal visual modeling languages. The monograph may be useful to a wide range of readers, including experienced specialists in the field of information modeling of various processes, systems, and technologies.