A Pattern System to Support Refining Informal Ideas into Formal Expressions

In Wide Area Networks (WANs)inconsistencies among the security policies of Administrative Domains (ADs) may cause severe security flaws. Recently, security policies are written in natural language and as they get more complicated, even for an expert it might be impossible to detect such inconsistencies. However, when a formal language is used, it might be possible to make verification of security policies by automated theorem proving tools. Due to the existence of mobile devices such as laptops, PDAs and mobile agents, we need a formal language that is capable of defining the concept of mobility. In this paper, we extend Mob adtl [1] according its refinement methodology to obtain a formal policy specification language for an 802.11 WLAN with enhanced security network.

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 error of overlooked requirement specification can be detected using 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’ which is formal method tools using Statechart. Also we applied the proposed method to safety-critical railway signaling systems for the formal requirement specification and analyzed the specification results.

In most studies of bridging between informal specifications, formal specifications are transformed from informal specifications after completion of specification of the whole system. Most of these formal specifications are used for rigorous study of the system in question, consistency checking, verification of behavior or support system synthesis. During the process of system specification, the strength of formal and informal methods are not complementing to each other. We identified a new specification approach which makes formal methods and informal methods complement each other to a greater extent. This new method interweaves formal methods with informal methods. We find out that this method leads to better quality of specifications, facilitate better changes management and maintenance. This is particular useful during initial specification of systems which is the first stage of specifying informal world in some formal languages. We report our preliminary findings of this novel approach in this paper and exemplify our approach with an example in JSD and CSP.

On the formal specification and verification of CIM architectures using LOTOS

Facilitating formal specification acquisition by using recursive functions on context-free languages

We introduce a simple conceptual framework for assessing a number of well known formal specification techniques w.r.t. their ability to model state-oriented and/or event-oriented aspects of system behaviour. By attributing a-priori equal importance to the notions of event and state, by explicitly recognizing the two derived, fundamental ways of thinking about system behaviours, and by assessing the bias of existing formal methods towards one or the other, one can make more conscious choices in the upper phases of software development, that is, in requirements elicitation and analysis, in the construction of abstract system models, and in the choice of formal languages for high- and low-level design. In particular, we assess the recently introduced model of abstract state processes, and the design choices behind its definition, in light of the introduced state-event framework.

Standardization of Formal Specification Languages

The complexity of designing concurrent and highly-evolving interactive systems has grown to a point where system verification has become a hurdle. Fortunately, formal verification methods have arrived at the right time. They detect errors, inconsistencies and incompleteness at early development stages of a system formally modeled using a formal specification language. -calculus (Milner, 1999) is one such formal language which provides strong mathematical base that can be used for verifying system specifications. But manually verifying the specifications of concurrent systems is a very tedious and error-prone work, especially if the specifications are large. Consequently, an automated verification tool would be essential for efficient system design and development. In addition, formal verification tools are vital ingredient to fully harness the potential of component-based software composition. The authors developed such an automated verification tool which is highly portable and seamlessly integrates with the visualization, reduction and performance evaluation tools introduced (Ahmad & Rahimi, 2008; Rahimi, 2006; Rahimi et al., 2001, 2008) to provide a comprehensive tool for designing and analyzing multi process/agent systems. Open-Bisimulation (Sangiorgi, 1996) concept is utilized as the theoretical base for the design and implementation of the tool which incorporates an expert system implemented in Java Expert System Shell (JESS) (Friedman-Hill, 2003).

SOFL is a formal language and method for system specification and design. It was developed by integrating Petri Nets, Data Flow Diagrams, and VDM-SL. As the major feature of the original SOFL method is to use structured techniques for analysis and specification, and object-oriented techniques for design and implementation, SOFL has its own implementation language that is similar to C++. However during our recent work of applying SOFL to software systems, the transformation of structured specifications to object-oriented implementations creates some difficulties, simply because of paradigms mismatch. In this paper we extend SOFL to a formal object-oriented language and method while keeping its structured features. This will allow powerful object-oriented reuse mechanisms, such as class inheritance and object composition, to be utilized in the early phases, and transformation from SOFL specifications to commercial object-oriented programming languages to be readily achieved.

We introduce geometric consideration into the theory of formal languages. We aim to shed light on our understanding of global patterns that occur on infinite strings. We utilise methods of geometric group theory. Our emphasis is on large scale geometries. Two infinite strings have the same large scale geometry if there are colour preserving bi-Lipschitz maps with distortions between the strings. Call these maps quasi-isometries. Introduction of large scale geometries poses several questions. The first question asks to study the partial order induced by quasi-isometries. This partial order compares large scale geometries; as such it presents an algebraic tool for classification of global patterns. We prove there is a greatest large scale geometry and infinitely many minimal large scale geometries. The second question is related to understanding the quasi-isometric maps on various classes of strings. The third question investigates the sets of large scale geometries of strings accepted by computational models, e.g. Buchi automata. We provide an algorithm that describes large scale geometries of strings accepted by Buchi automata. This links large scale geometries with automata theory. The fourth question studies the complexity of the quasi-isometry problem. We show the problem is Σ 3 0-complete thus providing a bridge with computability theory. Finally, the fifth question asks to build algebraic structures that are invariants of large scale geometries. We invoke asymptotic cones, a key concept in geometric group theory, defined via model-theoretic notion of ultra-product. Partly, we study asymptotic cones of algorithmically random strings thus connecting the topic with algorithmic randomness.

In this work the protocol WorldFIP for industrial communication networks, is specified with the formal specification language LOTOS. This specification is the foundation of new work lines such as efficiency analysis of WorldFIP performance with simulations in critical applications, the generation of benchmark patterns for conformance tests of WorldFIP communications equipment, and the proposal of new advances in the fieldbus area. Standardization institutions can benefit largely by this implemented methodology of formal specification, because some uncertainties in their description issues can be detected easily during the standard development, if a formal specification language is used at this stage.

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.

Despite their potential, formal methods have had difficulty gaining acceptance in the industrial sector. Some complaints are based on supposed impracticality: many consider formal methods to be an approach to system specification and analysis that requires a large learning time. Contributing to this scepticism is the fact that some types of formal methods have not yet been proven to handle systems of realistic complexity. To learn more about how to design formal specification languages that can be used for complex systems and require minimal training, we developed a formal specification of an English language specification of the vertical flight control system similar to that found in the MD-11. This paper describes the lessons learned from this experience.

In this paper we study the combination of object-oriented and formal methods and more specifically the mapping of object models, that are used in business information system development methods, into the formal specification language of the B method. We retain as the starting point of our study a common core of object concepts accepted by most of the groups: object, entity, association, is-a link. The first aim is to formalize these concepts. The main idea is to organize the specification around sets of object identities. Thus associations are modelled using relations between these sets and is-a links are modelled by inclusion constraints between these sets. The second aim is to modularise the final formal specification. Our purpose is to keep as much as possible the initial object diagram structure in the formal specification. Thus each entity is mapped into one abstract machine, an association is put in a specific machine according to its own properties, inheritance is simulated by using the existing links between abstract machines.

Summary form only given. We are developing a specification and proof environment, called PREVAIL, which is to support several input languages (currently, only VHDL is supported) and which proposes a set of proof tools to verify appropriate descriptions/specifications. Nqthm is one of these tools, and we are working at defining an induction-based method to validate concurrent systems using this prover. To give such systems a formal specification, our first task was to choose between VHDL and one of the formal languages that can be of interest to hardware/software developers. Using a simple but significant reactive system as a running example, we give a comparative evaluation of VHDL and two formal languages: the ISO Formal Description Technique LOTOS, and the computational model UNITY. Thus we draw conclusions about the accuracy of each one of them with respect to different aspects (sequential behaviours, communications, non determinism, fairness, etc.).