Formal Specification Methods Research Articles

Formally proving whether the software implementation of models applied in instrumentation and control systems conform to the specified requirements

Research objective is to study the possibility to formally validate whether the model’s software implementation meets all the specified requirements of the systems, the model of which can be represented in the form of finite-state automata. Research relevance. At one of the first stages, the development of software for instrumentation and control systems provides for the creation of the system model. The model is based on the terms of reference, specification, and various a priori information. Most of the models for engineering systems in the modern mining industry (conveyor systems, ventilation systems, etc.) can be described in terms of the finite state automaton model. Such a model can be applied to solve diverse tasks. The next step is to implement the model in whole or in part. In this context, the task arises to determine the model’s software implementation conformity to its initial description. Results. One way to solve the task is to formally prove that the software model possesses the properties which are provided in the specification (description) of the initial model. By the example of the mine conveyor system, the paper illustrates the application of the method which consists in the software implementation of the corresponding finite-state automaton model, forecasting whether the model possesses the properties through theorems and their subsequent proof by applying special software. Conclusions. Formal methods of specification, development, and verification of system models’ software implementation together with other methods make it possible to improve the quality and reliability of solutions under development.

Debugging Smart Contract’s Business Logic Using Symbolic Model Checking

Smart contracts are a special type of programs running inside a blockchain. Immutable and transparent, they provide means to implement fault-tolerant and censorship-resistant services. Unfortunately, its immutability causes a serious challenge of ensuring that a business logic and implementation is correct upfront, before publishing in a blockchain. Several big accidents have indeed shown that users of this technology need special tools to verify smart contract correctness. Existing automated checkers are able to detect only well known implementation bugs, leaving the question of business logic correctness far aside. In this work, we present a symbolic model-checking technique along with a formal specification method for a subset of Solidity programming language that is able to express both state properties and trace properties; the latter constitutes a weak analogy of temporal properties. We evaluate the proposed technique on the MiniDAO smart contract, a young brother of notorious TheDAO. Our Proof-of-Concept was able to detect a non-trivial error in the business logic of this smart contract in a few seconds.

Formal Specification of Adaptable Semantic Web Services Composition

This article proposes a formal specification method for Web services composition based on context-aware semantic planning graph technique. The authors first use a graph planning technique to conceive an adaptable semantic Web services composition. They use an ontology based context model for extending Web services descriptions with information about the most suitable context for its use. Then, the composition problem is transformed into a semantic context aware graph planning problem to build a set of best-composed Web services based on the user's context. Because of the error-prone nature of the Web services composition process, and with the integration of context information in this process, the complexity of Web services-based systems is increasing, hence the need for formal specification and verification approaches of such systems. The authors seek to use CCA calculus, to formalize Web services composition expressed in terms of adaptable OWL-S, and transform the description of workflow patterns into the description patterns in terms of CCA, a calculus for context-aware ambients.

Extended Covering Arrays for Sequence Coverage

Although combinatorial testing has been widely studied and used, there are still some situations and requirements that combinatorial testing does not apply to well, such as a system under test whose test cases need to be performed contiguously. For thorough testing, the testing requirements are not only to cover all the interactions among factors but also to cover all the value sequences of every factor. Generally, systems under test always involve constraints and dependencies in or among test cases. The constraints among test cases have not been effectively specified. First, we introduce extended covering arrays that can achieve both t-way combinatorial coverage and t-wise sequence coverage, and propose a clocked computation tree logic-based formal specification method for specifying constraints. Then, Particle Swarm Optimization (PSO) based Extended covering array Generator (PEG) is elaborated. To evaluate the constructed test suites, a method for verifying the constraints’ validity is presented, and kernel functions for measuring the coverage are also introduced. Finally, the performance of the proposed PEG is evaluated using several sets of benchmark experiments for some common constraints, and the feasibility and usefulness of PEG is validated.

Systematic review of aspect-oriented formal method

Aspect-oriented modelling is used in a growing number of business and software development projects. However, the plethora of unstandardised aspect-oriented approaches is preventing companies from adapting aspect-oriented software development methods into a formal method. Both aspect-orientation and formal methods have evolved separately and little has been done to investigate the benefits of the possible integration of these two fields. Therefore, in this paper we aim to present a survey of the approaches used to date in the application of the aspect-oriented paradigm to formal methods of specification. We also systematically review some of the techniques and approaches that combine both concepts together and discuss the problems and issues that arise in relation to the combination of formal methods and aspect orientation. In addition, we identify the open research questions to highlight potential areas of future research.

Systematic review of aspect-oriented formal method

Aspect-oriented modelling is used in a growing number of business and software development projects. However, the plethora of unstandardised aspect-oriented approaches is preventing companies from adapting aspect-oriented software development methods into a formal method. Both aspect-orientation and formal methods have evolved separately and little has been done to investigate the benefits of the possible integration of these two fields. Therefore, in this paper we aim to present a survey of the approaches used to date in the application of the aspect-oriented paradigm to formal methods of specification. We also systematically review some of the techniques and approaches that combine both concepts together and discuss the problems and issues that arise in relation to the combination of formal methods and aspect orientation. In addition, we identify the open research questions to highlight potential areas of future research.

Towards formal open standards: formalizing a standard’s requirements

Open standardization seems to be very popular among software developers as it simplifies the standard's adoption by the software engineering. Formal specification methods, while very promising, are being adopted slowly as the industry seems to have little motivation to move into this territory. In this paper the authors present (1) the idea of applying formal specification techniques to open standards' specifications, and (2) an example of a formal specification of the Rich Site Summary (RSS) v2.0 open standard. The authors provide evidence for the advantages of the open standards formal specification over natural language documentations: formal specifications are more concise, less ambiguous, more complete with respect to the original documentation and, when using certain kinds of specification languages, executable and reusable as they support module inheritance. The merging of formal specification methods and open standards allows (1) a more concrete standard design; (2) an improved understanding of the environment under design; (3) an enforced certain level of precision into the specification, and also (4) provides software engineers with extended property checking/verification capabilities, especially if they opt to use any algebraic specification language. The authors showcase how the RSS standard can be formally specified using an algebraic specification language and demonstrate how can that be beneficial.

An Integration of UML Sequence Diagram with Formal Specification Methods—A Formal Solution Based on Z

UML Diagrams are considered as a main component in requirement engineering process and these become an industry standard in many organizations. UML diagrams are useful to show an interaction, behavior and structure of the system. Similarly, in requirement engineering, formal specification methods are also being used in crucial systems where precise information is required. It is necessary to integrate System Models with such formal methods to overcome the requirements errors i.e. contradiction, ambiguities, vagueness, incompleteness and mixed values of abstraction. Our objective is to integrate the Formal Specification Language (Z) with UML Sequence diagram, as sequence diagram is an interaction diagram which shows the interaction and proper sequence of components (Methods, procedures etc.) of the system. In this paper, we focus on components of UML Sequence diagram and then implement these components in formal specification language Z. And the results of this research papers are complete integrated components of Sequence diagram with Z schemas, which are verified by using tools and model based testing technique of Formal Specifications. Results can be more improved by integrating remaining components of Sequence and other UML diagrams into Formal Specification Language.

UML Profile for Modeling Multi Decisional Reactive Agent System

A Reactive System is a system engaged in stimulus-response behavior in order to produce desirable effects on its environment at a specific time. The failures of developing such a system are usually caused by design errors despite of several various tests and simulations made by the developer. Indeed, it is essential to avoid these errors at an advanced level of the application's life cycle by using a formal specification and verification method. Moreover, the Multi Decisional Reactive Agent (MDRA) approach is devoted to specify and verify such a system. On the other side, modeling the system processes is primordial to describe either its internal or external behavior; however, MDRA is only supported by a BPMN which models its external activities. For this reason, there is a necessity to make easier modeling the MDRA behaviors by using an appropriate method. Furthermore, UML profile provides an extension mechanism to adapt UML for modeling a particular domain, it also specializes UML on each context and introduces new concepts and rules. In this paper, we propose an approach that combines both formal specification and semi-formal modeling which helps designers to specify their application through an UML profile responding to the characteristics of MDRA.

Towards Industrial Formal Specification of Programmable Safety Systems

Formal methods for specification and verification are promising in developing programmable logic controller (PLC) programs in manufacturing industry. Particularly this holds for safety PLCs, used to protect humans and equipment from injuries and damages. An important challenge though, is the development of formal specifications, typically a tough task for control engineers. This brief proposes a systematic work procedure that can be used as a first step of developing formal specifications of safety PLC programs in industry. The work procedure intends to facilitate the development of relevant formal properties for safety PLC program components. The formal specifications can be used for automatic formal verification of the components, using model checking techniques. This brief shows how the work procedure has been applied to industrial safety components, resulting in relevant and nontrivial specifications.

An event based formal specification method to diabetic’s behavior monitor system

Abstract Modern medical monitor systems shoulder the responsibility of patients’ surveillance. Such life-critical systems steering by software will put patient’s life in peril if they try in vain to satisfy patient’s requirements. As a prelude to reliable software construction of such systems, formal specification of the software behavior has been noted as an effective method because it is susceptible of formal verification. Among other life-critical systems, Continuous Infusion Insulin Pump (CIIP) is a popular medical monitor system that shoulders the responsibility of diabetic’s sugar regulation. This paper aims to present a specification-based formal method to CIIP behavior as a prelude to the CIIP formal verification.

Towards Sustainable Development of Energy-Aware Systems

Smart devices have pervaded our society and encouraged lifestyles that depend on them. One of the fundamental requirements for a successful dependency is that the general public be aware of the energy limitations of these devices and to stay in control of energy consumption. In this paper, the authors propose a formal specification method that takes energy into account. They propose two development approaches that can use these specifications to develop energy-aware systems in a sustainable manner.

Modeling of Distributed Control System in Intelligent Buildings Based on Colored Petri Net

Distributed control systems consist of sensors, actuators and controllers, interconnected by communication networks and are characterized by a high number of concurrent process. This work presents a proposal for a procedure to model and analyze communication networks for distributed control systems in intelligent building. The approach considered for this purpose is based on the characterization of the control system as a discrete event system and application of coloured Petri net as a formal method for specification, analysis and verification of control solutions. With this approach, we develop the models that compose the communication networks for the control systems of intelligent building, which are considered the relationships between the various buildings systems. This procedure provides a structured development of models, facilitating the process of specifying the control algorithm. An application example is presented in order to illustrate the main features of this approach.

Integrating top-down and scenario-based methods for constructing software specifications

How to achieve a complete and consistent software specification by construction is an important issue for software quality assurance but still remains an open problem. The difficulty lies in the fact that the assurance of the completeness needs user’s judgments and the specification keeps changing as requirements analysis progresses. To allow the user to easily make such judgments and to reduce chances for creating inconsistencies due to frequent specification modifications, in this paper we describe an intuitive, formal, and expressive specification method that integrates top-down decompositional and scenario-based compositional methods. The decompositional method is used at an informal level with the goal of achieving a complete coverage of the user’s functional requirements, while the compositional method is used to precisely define the functionality of each scenario and to construct complex scenarios by composition of simple scenarios in a formal, intuitive language called SOFL. Combination of the decompositional and compositional processes can facilitate the analyst in completing a specification in a hierarchical structure. We present an example to illustrate how the integrated method is used in practice and describe a software support tool for the method.

Analysis of the Formal Specification Application for Train Control Systems

Many critical control systems are developed using formal methods. When software applied to such systems is developed, the employment of formal methods in the software requirements specification and verification will provide increased assurance for such applications. Earlier errors of overlooked requirement specification can be detected using the formal specification method. Also, the testing and full verification to examine all reachable states using model checking to undertake formal verification are able to be completed. In this paper, we proposed an eclectic approach to incorporate Z(Zed) formal language and 'Statemate MAGNUM', formal method tools using Statechart. Also we applied the proposed method to train control systems for the formal requirement specification and analyzed the specification results.

Security Policy Development: Towards a Life-Cycle and Logic-Based Verification Model

Although security plays a major role in the design of software systems, security requirements and policies are usually added to an already existing system, not created in conjunction with the product. As a result, there are often numerous problems with the overall design. In this paper, we discuss the relationship between software engineering, security engineering, and policy engineering and present a security policy life-cycle; an engineering methodology to policy development in high assurance computer systems. The model provides system security managers with a procedural engineering process to develop security policies. We also present an executable Prolog-based model as a formal specification and knowledge representation method using a theorem prover to verify system correctness with respect to security policies in their life-cycle stages.

Formal Verification and Visualization of Security Policies

Verified and validated security policies are essential components of high assurance computer systems. The design and implementation of security policies are fundamental processes in the development, deployment, and maintenance of such systems. In this paper, we introduce an expert system that helps with the design and implementation of security policies. We show how Prolog is used to verify system correctness with respect to policies using a theorem prover. Managing and visualizing information in high assurance computer systems are challenging tasks. To simplify these tasks, we show how a graph-based visualization tool is used to validate policies and provide system security managers with a process that enables policy reviews and visualizes interactions between the system’s entities. The tool provides not only a representation of the formal model, but also its execution. The introduced executable model is a formal specification and knowledge representation method.

CmUML - A UML based Framework for Formal Specification of Concurrent, Reactive Systems.

Complex software systems possess concurrent and reactive behaviors requiring precise specifications prior to development. Lamport's transition axiom method is a formal specification method which combines axiomatic and operational approaches. On the other hand Unified Modeling Language (UML), a de facto industry standard visual language, lacks suitable constructs and semantics regarding concurrency aspects. Though UML includes action semantics, its higher level constructs and object semantics are inconsistent. Motivated by Lamport's approach, this paper proposes a UML based specification framework 'cmUML' ('cm' for concurrent modules) for formal specification of concurrent, reactive systems without object level diagrams and OCL. The framework integrates higher level diagrams of UML and addresses various concurrency issues including exception handling. It combines UML-RT and UML/ SPT profile as the latter defines a core package for concurrency and causality. Further the framework includes the characteristic safety and liveness aspects of concurrent systems. The proposed framework is in contrast with existing approaches based on low level primitives (semaphore, monitors). The paper includes several specification examples validating the proposed framework.

Formal Specification and Verification of Real-Time Systems using Graph Grammars

Abstract The importance of real-time systems has enormously increased in the last decade. Application areas that typically need real-time models include railroad systems, intelligent vehicle highway systems, avionics, multimedia and telephony. To assure that such systems are correct, additionally to prove that they provide the required functionality, time constraints must be satisfied. There are already formal specification methods for real-time systems, but most of them are difficult to use by software developers, that are usually not very familiar with mathematical notation but rather specify systems using the objectoriented paradigm. In this paper we propose a formal approach to specify and analyze real-time systems that has an object-oriented flavor. This approach is based on Object-Based Graph Grammars (OBGGs), a formal description technique suitable for the specification of asynchronous distributed systems, and intuitive even for nontheoreticians. We extend OBGGs to enable explicit modeling of time constraints, and define the semantics of the specifications via transition systems. Finally, we translate timed OBGGs to Timed Automata, a formal notation that is wide spread in the area of real-time systems modeling and allows the automatic verification of properties.

On Formal Specification of Software Components and Systems

Reasoning about software systems developed using components begins with component-level specifications, from which system-level specifications are derived. While sound compositional reasoning is a strength of formal specification methods, practical experience with systems construction leads us to expect surprises when two components that were never intended to be combined are composed. Component specifications, like any other human artifact, are likely to be in error. Composition throws the mistakes in one component against those in another, leading to unexpected and often bizarre behavior.We review the theory of formal software specification and apply it to the combination of component specifications into system-level properties, where deficiencies in component specifications can be strangely reflected. We conclude that desirable properties of system specifications do not always arise from those same properties at the component level.