Formal Executable Models Research Articles

OSM: Leveraging model checking for observing dynamic behaviors in aspect-oriented applications

In the intricate domain of software systems verification, dynamically model checking multifaceted system characteristics remains paramount, yet challenging. This research proposes the advanced observe-based statistical model-checking (OSM) framework, devised to craft executable formal models directly from foundational system code. Leveraging model checking predicates, the framework melds seamlessly with aspect-oriented programming paradigms, yielding a potent method for the analytical verification of varied behavioral attributes. Exploiting the transformative capacity of OSM framework, primary system code undergoes a systematic metamorphosis into multifaceted analysis constructs. This not only simplifies the model verification process but also orchestrates feature interactions using an innovative observing join point abstraction mechanism. Within this framework, components encompassing parsing, formal verification, computational analytics, and rigorous validation are intrinsically interwoven. Marrying the principles of model checking with aspect-oriented (AO) modularization, OSM framework stands as a paragon, proficiently scrutinizing and affirming system specifications. This ensures the unyielding performance of electronic health record systems amidst shifting preconditions. OSM framework offers runtime verification of both object-oriented and AO deployments, positioning itself as an indispensable open-source resource, poised to automate the enhancement of system performance and scalability.

MSL: A pattern language for engineering self-adaptive systems

In architecture-based self-adaptation of decentralized systems, design patterns have been introduced to ease the design of complex adaptation solutions that usually require the interaction of different MAPE-K (Monitor-Analyze-Plan-Execute over a shared Knowledge) control loops, each dealing with an adaptation concern of the managed system. Such MAPE patterns have been proposed by means of a graphical notation, but without a well-defined way to document them and to express the semantics of components interactions.In this paper, we propose an approach to overcome these limitations. We present a domain-specific language, called MSL for MAPE Specification Language, to define and instantiate MAPE patterns and to give semantics to some semantic variation points of the equivalent graphical notation for MAPE pattern. We also provide a formal semantics of the language by means of self-adaptive Abstract State Machines, an extension of the Abstract State Machines (ASMs) formalism to model self-adaptation. Such semantics definition comes with an automatic transformation of MSL models into formal executable models, and opens to the possibility of performing rigorous analysis (validation w.r.t. the adaptation requirements and verification of adaptation properties) of MSL models. Moreover, we present our current results toward a (long-term) realization of an MSL-centric framework, where MSL is the notation of a modeling front-end, on top of richer and more specific modeling, analysis, and implementation back-end frameworks.As proof of concept of our approach, we show the application of MSL and its formal support to a running case study in the field of home automation, by modeling an adaptive control of a virtual smart home developed with the OpenHAB runtime platform.

Scenario‐oriented reverse engineering of complex railway system specifications

AbstractIn this article, we present a scenario‐oriented modeling methodology dedicated to the analysis and the formalization of complex system specifications. The methodology relies on the SCOLA semiformal notation to describe scenarios and on a formal execution model described in the AltaRica 3.0 modeling language. We designed this methodology because we had to review thousands of pages of natural language specifications of a railway system in view of their validation with respect to safety constraints. We needed therefore some means to understand what the system was supposed to be and to do as well as to support a dialog with experts. This article aims at introducing the methodology and the modeling formalism that supports it as well as at discussing its application to the railway systems.

Synchronous-Reactive Semantic Modeling and Verification for Function Block Networks

Owing to the semantic ambiguities, it has hindered the promotion of IEC 61499 in the field of industrial automation. In order to solve the thorny problem, this paper proposes an implementation scheme for performing formal modeling and simulation verification of semantics of functional block networks. Based on the synchrony hypothesis, the formal execution model is defined according to the fixed point semantics assuming that the behavior of a component functional block is monotonic. Subsequently, through specifying the evaluation of function blocks (FBs) as a process of solving the least-fixed point problem and transforming the network topology into a directed graph, a connectivity attenuation-based algorithm is put forward to ascertain the optimal scheduling policy of FBs with the minimum overhead. Finally, by conducting the experiment for an industrial application, the feasibility and validity of the presented implementation scheme is proved.

Directly executable formal models of middleware for MANET and Cloud Networking and Computing

The article considers some “directly executable” formal models that are suitable for the specification of computing and networking in the cloud environment and other networks which are similar to wireless networks MANET. These models can be easily programmed and implemented on computer networks.

Reasoning About LLVM Code Using Codewalker

This paper reports on initial experiments using J Moore's Codewalker to reason about programs compiled to the Low-Level Virtual Machine (LLVM) intermediate form. Previously, we reported on a translator from LLVM to the applicative subset of Common Lisp accepted by the ACL2 theorem prover, producing executable ACL2 formal models, and allowing us to both prove theorems about the translated models as well as validate those models by testing. That translator provided many of the benefits of a pure decompilation into logic approach, but had the disadvantage of not being verified. The availability of Codewalker as of ACL2 7.0 has provided an opportunity to revisit this idea, and employ a more trustworthy decompilation into logic tool. Thus, we have employed the Codewalker method to create an interpreter for a subset of the LLVM instruction set, and have used Codewalker to analyze some simple array-based C programs compiled to LLVM form. We discuss advantages and limitations of the Codewalker-based method compared to the previous method, and provide some challenge problems for future Codewalker development.

A rewriting framework and logic for activities subject to regulations

Activities such as clinical investigations (CIs) or financial processes are subject to regulations to ensure quality of results and avoid negative consequences. Regulations may be imposed by multiple governmental agencies as well as by institutional policies and protocols. Due to the complexity of both regulations and activities, there is great potential for violation due to human error, misunderstanding, or even intent. Executable formal models of regulations, protocols and activities can form the foundation for automated assistants to aid planning, monitoring and compliance checking. We propose a model based on multiset rewriting where time is discrete and is specified by timestamps attached to facts. Actions, as well as initial, goal and critical states may be constrained by means of relative time constraints. Moreover, actions may have non-deterministic effects, i.e. they may have different outcomes whenever applied. We present a formal semantics of our model based on focused proofs of linear logic with definitions. We also determine the computational complexity of various planning problems. Plan compliance problem, for example, is the problem of finding a plan that leads from an initial state to a desired goal state without reaching any undesired critical state. We consider all actions to be balanced, i.e. their pre- and post-conditions have the same number of facts. Under this assumption on actions, we show that the plan compliance problem is PSPACE-complete when all actions have only deterministic effects and is EXPTIME-complete when actions may have non-deterministic effects. Finally, we show that the restrictions on the form of actions and time constraints taken in the specification of our model are necessary for decidability of the planning problems.

Colored Petri nets

Formal executable models enable systematic evaluation of system designs prior to implementation and deployment.

A survey of race bug detection techniques for multithreaded programmes

SummaryAs multithreaded programmes become popular to fully utilize multicore CPUs, many race bug detection techniques have been developed to find concurrency errors in multithreaded programmes effectively. Because these techniques have different views on target programme execution and detect race bugs of various types, it is difficult to characterize, compare and improve race bug detection techniques. This paper presents a formal execution model, which can uniformly represent various views of race bug detection techniques on target programme execution. Then, this paper classifies 43 race bug detection techniques according to their target race bugs. We classify race bugs on whether or not a bug violates operation block specification and/or data association specification. This survey provides researchers with a clear top‐down view of various race bug detection techniques. In addition, the concrete examples of various race bugs in this survey can help field engineers avoid race bugs in their multithreaded programmes. Copyright © 2014 John Wiley & Sons, Ltd.

Petri nets as a framework for the reconstruction and analysis of signal transduction pathways and regulatory networks

Petri nets are directed, weighted bipartite graphs that have successfully been applied to the systems biology of metabolic and signal transduction pathways in modeling both stochastic (discrete) and deterministic (continuous) processes. Here we exemplify how molecular mechanisms, biochemical or genetic, can be consistently respresented in the form of place/transition Petri nets. We then describe the application of Petri nets to the reconstruction of molecular and genetic networks from experimental data and their power to represent biological processes with arbitrary degree of resolution of the subprocesses at the cellular and the molecular level. Petri nets are executable formal language models that permit the unambiguous visualization of regulatory mechanisms, and they can be used to encode the results of mathematical algorithms for the reconstruction of causal interaction networks from experimental time series data.

EM-BrA2CE v0.1: A Vocabulary and Execution Model for Declarative Business Process Modeling

In management theory of the last decades, much importance has been attached to a process-oriented perspective on organizational (re)structuring. Yet to date, organi-zations still experience difficulties in applying this process-oriented perspective to the design and maintenance information systems. The root of the problem lies with a procedural representation of business processes that contains inadequate information for computer systems to provide flexible automated business process support. The counter-part of a procedural representation is a declarative one that explicitly takes into account the business concerns that govern business processes. Recently, a number of process modeling languages have appeared that could be identified as declarative languages. These modeling languages have very distinct knowledge representation backgrounds, often lack a formal execution model and often only model one aspect of the many business concerns that exist in reality. What is needed are meaningful ways to combine several kinds of expressions, called business rule types, independently of the used methods for knowledge representation and reasoning. In this paper, we present the EM-BrA2CE (Enterprise Modeling using Business Rules, Agents, Activities, Concepts and Events) Framework, a unifying vocabulary and execution model for declarative process modeling. The vocabulary is described in terms of the Semantics for Business Vocabulary and Rules (SBVR) standard and the execution model is presented as a Colored Petri Net (CP-Net). In addition, we show how declarative process models can contribute to the model-driven design of Service-Oriented Architectures.

A Model-based Integration and Testing Method to Reduce System Development Effort

New methods and techniques are needed to reduce the very costly integration and test effort (in terms of lead time, costs, resources) in the development of high-tech multi-disciplinary systems. To facilitate this effort reduction, we propose a method called model-based integration. This method allows to integrate formal executable models of system components that are not yet physically realized with available realizations of other components. The combination of models and realizations is then used for early analysis of the integrated system by means of validation, verification, and testing. This analysis enables early detection and prevention of problems that would otherwise occur during real integration, resulting in a significant reduction of effort invested in the the real integration and test phases. This paper illustrates how models of components, developed for model-based integration, can be used for automated model-based testing, which allows time-efficient determination of the conformance of component realizations with respect to their requirements. The combination of model-based integration and model-based testing is practically illustrated in a realistic industrial case study. Results obtained from this study encourage further research on model-based integration as a prominent method to reduce the integration and test effort.

An open animation tool: application to telecommunication systems

This paper presents an animation environment based on an open and flexible architecture. Its flexible architecture allows animating different animation sources (formal and executable language like SDL or scenario languages like MSC or UML sequence diagrams). The animation multimedia user interface allows integrating different multimedia objects and different types of representations. This animation environment has been intensively used for telecommunication applications at different levels of a service and network architecture: service animation from the user’s point of view or from the service logic point of view (service logic and service feature logics), protocols and application programming interface (such as OSA/PARLAY) animation, service interaction analysis. Animation helps obtaining a comprehensive and user-friendly interface for education, and investigation of system behaviour from different points of view, in particular from a client point of view. Specifically applied to formal executable models (using SDL, for example), the tool helps checking properties of the system behaviour, and showing whether it really fulfils user expectations.

Specification-based prototyping for embedded systems

Specification of software for safety critical, embedded computer systems has been widely addressed in literature. To achieve the high level of confidence in a specification's correctness necessary in many applications, manual inspections, formal verification, and simulation must be used in concert. Researchers have successfully addressed issues in inspection and verification; however, results in the areas of execution and simulation of specifications have not made as large an impact as desired. In this paper we present an approach to specification-based prototyping which addresses this issue. It combines the advantages of rigorous formal specifications and rapid systems prototyping. The approach lets us refine a formal executable model of the system requirements to a detailed model of the software requirements. Throughout this refinement process, the specification is used as a prototype of the proposed software. Thus, we guarantee that the formal specification of the system is always consistent with the observed behavior of the prototype. The approach is supported with the NIMBUS environment, a framework that allows the formal specification to execute while interacting with software models of its embedding environment or even the physical environment itself (hardware-in-the-loop simulation).