Formal Software Specification Research Articles

Model checking strategy-controlled systems in rewriting logic

Rewriting logic and its implementation Maude are an expressive framework for the formal specification and verification of software and other kinds of systems. Concurrency is naturally represented by nondeterministic local transformations produced by the application of rewriting rules over algebraic terms in an equational theory. Some aspects of the global behavior of the systems or additional constraints sometimes require restricting this nondeterminism. Rewriting strategies are used as a higher-level and modular resource to cleanly capture these requirements, which can be easily expressed in Maude with an integrated strategy language. However, strategy-aware specifications cannot be verified with the builtin LTL model checker, making strategies less useful and attractive. In this paper, we discuss model checking for strategy-controlled systems, and present a strategy-aware extension of the Maude LTL model checker. The expressivity of the strategy language is discussed in relation to model checking, the model checker is illustrated with multiple application examples, and its performance is compared.

Metrics for quantifying evolutionary changes in Z specifications

SUMMARYThis article proposes metrics for quantifying changes throughout the evolution of formal software specifications in long living systems. Formal specifications play an important role in the software development life‐cycle by supporting refinement and proof and by providing a basis for comprehension and maintenance activities. However, specifications also undergo evolutionary changes, and these changes are hard to assess because of a lack of suitable measures.This paper proposes and analyzes a set of measures for estimating aspects of a specification's complexity and quality. The measures are based on existing measures for source code, but they have been redefined in the scope of formal Z specifications. Geared towards Z, they are then evaluated concerning their expressiveness by a case study that comprises more than 65,000 lines of specification text. Finally, the usability of the measures is demonstrated on the Z specification of the Web Service Definition Language during its evolution over a period of about 3 years. Copyright © 2013 John Wiley & Sons, Ltd.

Constraint diagrams can be used to interpret programspecification expressions: an evaluation experimentwith novice users

Constraint diagrams (CDs) are a graphical notation used for program specification. For the purposes of formal software specification using a visual method, Kent designed constraint diagrams as an intuitive approach to formally specify programs. This paper presents an experiment that evaluates the interpretation of constraint diagrams compared with natural language (NL) for understanding program specification statements. In a web-based training competition, participants were randomly divided into two groups and were given 8 training examples either on the CD notation or equivalent NL expression. Each example is followed by 3 questions about the specification statements. In total there were 24 questions presented in each notation. It was predicted that the CD participants would find that learning concepts and answering questions would be harder than those in the NL group, because they had no prior experience of the CD notation. Surprisingly despite the fact that CD notation was new for participants, the CD group spent less time answering the questions and achieved the same proportion of correct answers as the NL group. However, as predicted, they were less confident in their answers and they spent more time on the training examples to learn the new concepts.

Practical Aspects of Automated Deduction for Program Verification

Software is vital for modern society. It is used in many safety- or security-critical applications, where a high degree of correctness is desirable. Over the last years, technologies for the formal specification and verification of software—using logic-based specification languages and automated deduction—have matured and can be expected to complement and partly replace traditional software engineering methods in the future. Program verification is an increasingly important application area for automated deduction. The field has outgrown the area of academic case studies, and industry is showing serious interest. This article describes the aspects of automated deduction that are important for program verification in practise, and it gives an overview of the reasoning mechanisms, the methodology, and the architecture of modern program verification systems.

Selected MRP II Standard System requirements presented in Z‐notation

PurposeThe purpose of this paper is to present the ability of Z‐notation to formulate formal requirements specification of huge application software based on an example of the Manufacturing Resource Planning (MRP II) Standard System. Z‐notation is using formal transformation approach to obtain operating software instead of traditional programming. The original MRP II software requirement specification possesses descriptive form extended by list of control questions. To make formal requirements specification, the original specification must be extending by some definition taken after APICS Dictionary. The definitions respect such concept as: item, item code, location, and order.Design/methodology/approachWriting schemas based on subsystem order of MRP II Standard System and treating the system as three level structures (user interface, business logic, and database), the schemas described business logic level only. As a conclusion was necessity to extend descriptive requirements specification by definitions. The limited size of the presentation contains few examples of formalization process only mainly limited to the main schemas as: item system (full definition), inventory system, bill of material, work centers and routings, generic order system, master production schedule, and material requirement planning.FindingsAs a result of the research, it can be said that Z‐notation apparatus is sufficient to build requirements specifications of big application systems like MRP II, enterprise resource planning, or customer relationship management.Originality/valueLibraries of typical algorithms like MRP II designed through formal approach could replace traditional programming and open new prospects in the future development of broad computerization.

CSCW for Preparing Formal Software Specifications: Issues and Implementation

In this study, we concern with how a group of rectifiers can be worked on preparing and producing correct formal software specification and how can they communicate with each other. To address these subjects, we come into view of two different issues, collaborative issues and formal specification issues. Each of these issues is taken into consideration when we propose the solution of the subject that is a web-based model of Computer Supported Cooperative Work (CSCW) for Z specification document. This model provides software developers with web environment that supports them to collaborate and to help them to produce correct software formal specifications. A web-based prototype application system based on this model has been developed.

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.

Rapid development of a distributed shop floor control system from an XML model-based control software specification

As the level of distribution in a shop floor grows, the development of a distributed Shop Floor Control System (SFCS) is of significant interest. Since hand-woven control software is expensive and difficult to reconfigure, a formal methodology that supports generating control software rapidly is in need of exploitation. Although a number of approaches on such purposes have been presented, they lack some of following characteristics: (1) ease of modelling a nature of a distributed SFCS, (2) rapid modelling capability, (3) integrity between specification and development methodologies, and (4) automatic software development capability. The objective of the paper is to propose a rapid development methodology that fulfils given characteristics through a formal model-based control software specification. Specifically, formal models, a resource model and an Monitoring-Decision making-Execution (M-D-E) model are proposed to specify Unit of Control Devices (UCDs) and their control processes performed in a distributed manner. The formal models are represented in the XML format to make them neutral to any model-building or development tools. In addition, the distributed SFCS control engine, a middleware for rapid development, is proposed to develop control software automatically from the XML-compliant formal models. As a result, the proposed set of formal models and control engine organizes the rapid development methodology most appropriate for a distributed SFCS.

Preface: Volume 66, Issue 6

This part of the volume contains the papers accepted for presentation, as well as the extended abstract of the invited lecture by Madhav Marathe (Los Alamos National Laboratory, USA), at the Workshop on Algorithmic MeThods and Models for Optimization of Railways (ATMOS 2002) held in Málaga, Spain, on 13 July 2002, as a satellite event of ICALP 2002.Railway optimization problems are extremely complex and their efficient solution is a rather difficult task. Problems and user requirements need to be transformed into formal mathematical models that have to be as accurate as possible. Advanced mathematical methods and sophisticated algorithms are required to efficiently tackle the derived optimization problems. Development of efficient algorithms need to be alternated with experimental studies to exhibit the practical merits of the algorithms and provide useful prototype implementations. Formal models and methods need to be developed to evaluate the whole design process from requirements and specifications up to software prototyping. Consequently, the efficient solution of railway optimization problems requires a coordinated interdisciplinary effort from researchers in mathematical and combinatorial optimization, formal methods, foundations of software engineering, algorithm design, theory of computation, and algorithm engineering.The main aim of ATMOS 2002 just like the preceeding workshop ATMOS 2001 held as a satellite event of ICALP 2001, was to provide a forum for the exchange and dissemination of new ideas, techniques, and research in the field of railway optimization. In particular, the workshop is meant to bring together researchers from the above areas interested in all aspects of algorithmic methods and models for railway optimization, including those interested in formal software specification and implementation methods, and in formal domain and knowledge models of railway systems.The program committe selected 5 papers in an electronic meeting conducted from April 26 to April 30. The criteria for selection were perceived originality, quality, and relevance to the subject of the workshop. Considerable effort was devoted for the evaluation of the submissions and to providing the authors with helpful feedback. Each submission was reviewed by ar least four program committee members. However, submissions were not refereed in the thorough way that is customary for journal papers, and some of them represent reports of continuing research. It is expected that most of the papers in this volume will appear in finished form in scientific journals.We would like to thank all those who submitted papers for consideration, as well as the Program Committee members for their invaluable contribution. We gratefully acknowledge the dedicated work of ATMOS and ICALP's Organizing Committees, and the support of the Human Potential Programme of EU under contract no. HPRN-CT-1999-00104 (project AMORE).Konstanz, June 2002 Dorothea WagnerProgram Committee•Dines Bjorner (co-chair) (TU Lyngby, Denmark)•Leo Kroon (NS Reizigers, Utrecht, Holland)•Gabriele Di Stefano (Univ. of L'Aquila, Italy)•Anita Schöbel (Univ. Kaiserslautern)•Dorothea Wagner (co-chair) (Univ. of Konstanz, Germany)•Frank Wagner (Deutsche Bahn, Berlin, Germany)•Peter Widmayer (ETH Zurich, Switzerland)•Jim Woodcock (Univ. of Kent, UK)•Christos Zaroliagis (CTI & Univ. of Patras, Greece)

Formal Software Specification with Refinements and Modules of Typed Graph Transformation Systems

Graph transformation systems are a formal specification technique for software systems that support the rule based specification of the dynamic behaviour of a system.Their main advantages are the intuitive visual representation of states and state transformations as graphs on the one hand, and the fully formal semantics on the other hand, that allow precise statements about the specification and tool support. In this paper we introduce refinements and modules for typed graph transformation systems to support the software specification development in both dimensions: modules for the horizontal structuring of a specification, i.e., its composition from feasible parts, and refinements for the development over time.

A theory-based representation for object-oriented domain models

Formal software specification has long been touted as a way to increase the quality and reliability of software; however, it remains an intricate, manually intensive activity. An alternative to using formal specifications directly is to translate graphically based, semiformal specifications into formal specifications. However, before this translation can take place, a formal definition of basic object oriented concepts must be found. The paper presents an algebraic model of object orientation that defines how object oriented concepts can be represented algebraically using an object oriented algebraic specification language O-SLANG. O-SLANG combines basic algebraic specification constructs with category theory operations to capture internal object class structure, as well as relationships between classes.

Computing with words in formal methods

Formal methods are used to improve the quality of complex computer software by means of documenting system specifications in a precise and structured manner, the most popular specification language for formal methods is Z. However, based on classical set theory and classical logic, this mathematical language can only deal effectively with well-defined problems. This is a disadvantage that classical set operators and classical predicate logic can offer to formal methods. In this paper, the theory of fuzzy information granulation is discussed with an attempt to build toward flexible formal software specifications in which many aspects of human reasoning and natural language can be effectively addressed in mathematical terms. In other words, the tolerance of imprecision necessarily required in many real-life software systems can be represented in the clear and structured mathematics of the fuzzy information granulation theory within the extended framework of formal methods. © 2000 John Wiley & Sons, Inc.

Integrating semi-formal and formal software specification techniques

In this paper, we report on the integration of informal, semiformal and formal system specification techniques. We present a framework for system specification called TRADE, within which several well-known semiformal specification techniques are placed. TRADE is based on an analysis of structured and object-oriented requirements specification methods. In this paper, we combine TRADE with the logic-based specification language Albert II and show that this leads to a coherent formal and semiformal requirements specification. We illustrate our approach with examples taken from a large distributed telecommunication application case study, performed in the context of the Esprit project 2RARE.

Formal Specification Applied to Control Systems Development

Formal software specification languages are becoming sufficiently powerful to consider their use in application domains as realistic. This paper reports on a project aiming at the application of formal specification notations and techniques in the development of real-time control applications. It puts emphasis on the development of reliable control systems by means of the integration of a formal specification notation in the controller development process. This paper discusses the application of ASTRAL (Ghezzi and Kemmerer, 1991a) for the requirements specification of a robot control system. It shows that formal specification provides a useful extension to current modelling capabilities in the application domain

Reliability aspects of computer-based safety systems for nuclear power plants / Aspekte der Zuverlässigkeit rechnergestützter Leitsysteme für Kernkraftwerke.

The engineering process described here with the corresponding tools makes it possible to generate from the same formal software specification, which by virtue of its manner of representation is intelligible both to process engineers and to instrumentation and control engineers, both the executable code for the target system and the code for performance of the function test for validation against the plant simulators. Within this engineering process, the TELEPERM XS tools reviewed by experts constitute, as part of an automated procedure, a sturdy link between the specification, the instrumentation and control functions in the verification and validation steps, and the documentation on the one hand and the functions implemented in the target system on the other. Even by comparison with the already high safety standards of system design attained by service-proven hardwired protection systems, computer-based automation systems achieve a significant quality improvement.

Automatic derivation of formal software specifications from informal descriptions

SPECIFIER, an interactive system which derives formal specifications of data types and programs from their informal descriptions, is described. The process of deriving formal specifications is viewed as a problem-solving process. The system uses common problem-solving techniques such as schemas, analogy, and difference-based reasoning to derive formal specifications. If an informal description is a commonly occurring operation for which the system has a schema, then the formal specification is derived by instantiating the schema. If there is a no such schema, SPECIFIER tries to find a previously solved problem which is analogous to the current problem. If the problem found is directly analogous to the current problem, it applies an analogy mapping to obtain a formal specification. On the other hand, if the analogy found is only approximate, it solves the directly analogous part of the problem by analogy and performs difference-based reasoning using the remaining (unmatched) parts to transform the formal specification obtained by analogy to a formal specification for the entire original problem. >

Formal Specification of the Software for a Reactor Safety System

For achievement of highly dependable software the use of formal specification techniques is a must, and an associated tool support is necessary.As an example for a technique and tool environment, the specification system CIP is introduced. CIP (Computer-aided, Intuition-guided Programming) was originally developed at the Technical University of München. It supports the formal specification of software and assists the program development by stepwise transformation. A high level specification is transformed by the application of rules into lower level representation, the lowest level being the programming language level. The transformations preserve the correctness of the specifications.The use of this environment is demonstrated by an example from a safety related reactor control system. Advantages of this approach as well as drawbacks and limitations are explained.

An environment for Ada software development based on formal specification

This report gives an overview of the current status and plans to construct a prototype environment of advanced tools for software and hardware development based on the use of wide-spectrum languages. The wide-spectrum languages include Anna (ANNotated Ada), and TSL (Task Sequencing Language). The tools described here provide interactive aid at all stages in the system development process. Special emphasis is placed on distributed computing, both in providing tools for handling parallelism in the subject system, and in designing tools that utilize parallelism in the programming environment. Applications of these tools include requirements analysis, formal specification, rapid prototyping, testing, formal verfication and construction of self-testing Ada software for multi-processor systems.The report describes an existing environment of prototype tools supporting applications of Anna and TSL to formal specification and testing of Ada software. The new environment tools will be based on component tools already developed at Stanford and proven to be portable to various Ada environments. All tools are implemented in Ada and are intended to interface with standard components of Ada programming environments.

Approaching a formal framework for graphics software standards

A graphics software standard has to specify precisely what the software is expected to do. For this purpose, the paper exhibits a formal framework for the specification of software modules which may be structured hierarchically and which may be based on abstract data types. An important aspect concerns the special mathematical semantics of the data types: The semantics of a type is its class of all finitely generated models. This semantics enables a uniform definition of a standard which, nevertheless, may cover a large variety of implementations on very different graphics hardware devices. The kernel of this approach is some axiomatic characterization of the notion of finitely generated images. Another important aspect is that, from such a formal software specification, an implementation may be derived. At least in principle, the careful documentation of such a program derivation could serve as a basis for a verification-oriented certification of graphics standard implementations.

The EEC workshop on formal specification of graphics software standards

This article is a report of the EEC Workshop on the Formal Specification of Graphics Software Standards, held in June 1982. The need for formal specification of graphics software is first examined, then two possible approaches, the programming language approach and the systems approach, are examined. The implications for the certification process are also examined.