Formal specification synthesis using requirements particle networks

On Formal Specification of Software Components and Systems

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.

Software for mission-critical systems is sometimes analysed using formal specification to increase the chances of the system behaving as intended. When sufficient insights into the system have been obtained from the formal analysis, the formal specification is realised in the form of a software implementation. One way to realise the system's software is by automatically generating it from the formal specification -- a technique referred to as code generation. However, in general it is difficult to make guarantees about the correctness of the generated code -- especially while requiring automation of the steps involved in realising the formal specification. This PhD dissertation investigates ways to improve the automation of the steps involved in realising and validating a system based on a formal specification. The approach aims to develop properly designed software tools which support the integration of formal methods tools into the software development life cycle, and which leverage the formal specification in the subsequent validation of the system. The tools developed use a new code generation infrastructure that has been built as part of this PhD project and implemented in the Overture tool -- a formal methods tool that supports the Vienna Development Method. The development of the code generation infrastructure has involved the re-design of the software architecture of Overture. The new architecture brings forth the reuse and extensibility features of Overture to take into account the needs and requirements of software extensions targeting Overture. The tools developed in this PhD project have successfully supported three case studies from externally funded projects. The feedback received from the case study work has further helped improve the code generation infrastructure and the tools built using it.

Formal synthesis is the process of generating a program satisfying a high-level formal specification. In recent times, effective formal synthesis methods have been proposed based on the use of inductive learning. We refer to this class of methods that learn programs from examples as formal inductive synthesis. In this paper, we present a theoretical framework for formal inductive synthesis. We discuss how formal inductive synthesis differs from traditional machine learning. We then describe oracle-guided inductive synthesis (OGIS), a framework that captures a family of synthesizers that operate by iteratively querying an oracle. An instance of OGIS that has had much practical impact is counterexample-guided inductive synthesis (CEGIS). We present a theoretical characterization of CEGIS for learning any program that computes a recursive language. In particular, we analyze the relative power of CEGIS variants where the types of counterexamples generated by the oracle varies. We also consider the impact of bounded versus unbounded memory available to the learning algorithm. In the special case where the universe of candidate programs is finite, we relate the speed of convergence to the notion of teaching dimension studied in machine learning theory. Altogether, the results of the paper take a first step towards a theoretical foundation for the emerging field of formal inductive synthesis.

A recent method combines model checkers with specifica- tion-based mutation analysis to generate test cases from formal software specifications. However high-level software specifications usually must be reduced to make analysis with a model checker feasible.

The domain of transformation systems has been introduced to provide a general integration framework for formal specifications. In this chapter an application of the integration approach to less formal software specifications is discussed. For that purpose models given in the Unified Modeling Language (UML) are considered: class diagrams for the specification of the structure and architecture of the system, and statechart and sequence diagrams for the specification of its behaviour. Analogous to the applications to specification formalisms presented in the previous chapters, the basic idea here is to interpret specifications semantically by sets of transformation systems, exhibit their correspondences, and thereby to check whether a common interpretation of all considered specifications is possible. As opposed to the former examples, however, the investigation cannot be completely formal, since the semantics of the given UML languages is not formally defined. That means the correctness of the transformation system semantics cannot be formally proved. To cope with this situation the interpretation will be open w.r.t. certain semantic decisions, which is then treated as parameters of possible admissible interpretations. On the other hand, the interpretation in the transformation system reference model provides the means for the formalisation and thus precision of the considered software specification languages.KeywordsState MachineUnify Modeling LanguageClass DiagramSequence DiagramClass GraphThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

High quality software components require a representation that allows the implementation-independent description of the structure and behavior of software components. Hence, the static as well as the dynamic structure of the system has to be represented in a structured way. Graph transformation systems support static and dynamic modeling through a single computational framework for the sake of correctness, maintainability, and integrity. The framework introduced along with the corresponding tool, UPGraDE (Universal Programmed Graph Grammar Development Environment), which is based on the universal graph language GRASP (GRAph grammar with Set Productions). Any type of system can be specified through a minimal set of operations (syntax) and rules to specify the behavior of any type of software (semantics). The UPGraDE Environment, consisting of several totally transparent interconnected modules, performing well defined tasks, is a highly modular and extensible environment suited for nearly every GRASP development purpose.

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.

Software quality enhancement can be achieved in the near term through use of a systematic program testing methodology. The methodology attempts to relate functional software testcases with formal software specifications as a means to achieve correspondence between the software and its specifications. To do this requires generation of appropriate testcase data. Automatic testcase generation is based on a priori knowledge of two forms of internal structure information: a representation of the tree of subschema automatically identified from within each program text, and a representation of the iteration structure of each subschema. This partition of a large program allows for efficient and effective automatic testcase generation using straightforward backtracking techniques. During backtracking a number of simplifying, consolidating, and consistency analyses are applied. The result is either (1) early recognition of the impossibility of a particular program flow, or (2) efficient generation of input variable specifications which cause the testcase to traverse each portion of the required program flow. A number of machine output examples of the backtracking facility are given, and the general effectiveness of the entire process is discussed.

A requirement is a feature of the system or a description of something the system is capable of doing in order to fulfill the system's purpose. Building a data warehouse is a very challenging task. Most of the data ware house project fails to meet the business requirements and business goals because of the improper requirement engineering phase. The Requirement Engineering (RE) is the most important phase of the software development life cycle (SDLC). This phase results into a large document written in natural language that converts the incomplete, imprecise requirements and wishes of the potential users into complete, precise and formal specifications. This formal specification is known as SRS i.e. Software Requirement Specification. These Requirements are transformed into information package in the form of dimensions, hierarchies and facts to build a data warehouse. Hospital can be seen as an example of a complex system. This paper considers Hospital as a case study for which a software system has been developed taking the mentioned approach into account. In this paper we study information package for Hospital Automation System.

Specification and Verification of Safe Software Systems

Quality of service considerations have to be included in the whole protocol engineering cycle. The authors present an integrated approach for the design of communication protocols, including: performance enhanced formal specification of communication protocols, formal requirement specification, statistical performance analysis out of the enhanced formal specification, and verification of bounded performance properties out of the formal specification. >

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

Conventional data models are not satisfactory for modelling data base application systems. The features that they provide are too low level and representational to allow the semantics of a data base to be directly expressed in the schema. The semantic data model (SDM) has been designed as a natural application modelling mechanism that can capture and express the structure of an application environment. The features of the SDM correspond to the principal intensional structures naturally occurring in contemporary data base applications. Furthermore, facilities for expressing derived (redundant) information are an essential part of the SDM; derived information is as prominent in an SDM schema as is primitive data. The SDM is designed to enhance the effectiveness and usability of computerized data bases. It can serve as a formal specification and documentation mechanism for a data base, can support a variety of powerful user interface facilities, and can be used as a tool in the data base design process.

The transformational programming, method of algorithm derivation starts with a formal specification of the result to be achieved (which provides no indication of how the result is to be achieved), plus some informal ideas as to what techniques will be used in the implementation. The formal specification is then transformed into an implementation, by means of correctness-preserving refinement and transformation steps. The informal ideas are used to guide the selection of transformations to apply: since they only guide the selection of valid transformations, the ideas do not themselves have to be formalised.