MODELLING SYSTEM SPECIFICATIONS ON A FINITE STATE MACHINE

Traditional structured analysis and design methods have been criticized because the methods lack formality to provide a design for rigorous development. Several approaches have been developed for verifying a design by integrating traditional structured analysis and design methods with formal specification languages. However, the integration of traditional structured analysis and design methods with formal specification languages may confuse the problem definition and understanding with the attempt to define system structures and algorithms in the design phase. In addition, formal specification languages may add complexity to the design due to the complexity of the language syntax and semantics. In this paper, we are presenting an approach to verification of a structured design in HOS without using formal specification languages. Rules for the partial and total correctness of the design are also discussed.

Our discussion assumes parallel or distributed computer systems that allow dynamic migration of processes between processors. Because the overall performance of these systems is strongly dependent on the overheads of migration, it is vital that migration be implemented as efficiently as possible. However, efficient implementations are often complex implementations and thus we have a conflict between performance and correctness. We cannot make the conflict go away, but we should be able to find ways of describing migration designs such that it is easy for system developers to make changes (for performance reasons) and see straight away what the implications for correctness are. We suggest that the formal specification language Z provides just such a way of describing migration designs. To support this suggestion we present an extended example based on the specification of a migration-proof communication protocol. This example is particularly appropriate because the possibility that a communicating process may migrate several times between communications greatly complicates the implementation. Yet we still require that communication should be efficient and correct, i.e. that messages should not be lost or duplicated. We make three contributions. First, we suggest a two-level plan for specification which separates issues of what operations do from when they do it. Second, we outline a rigorous proof style which combines formal statements of assumptions and proof steps with informal reasoning. Third, we show that we can link performance measurements with the specification but that we need to do this via finite state machines. >

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.

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).

The Unified Modeling Language (UML) has become a widely adopted standard in the software development industry. Unfortunately, the UML is a semi-formal language which lacks precisely defined constructs. Z language is a formal specification language. Formal languages are used to ensure that systems meet regulations and standards. This paper aims to reduce risks associated with software development and increase safety and reliability. This goal is achieved by formalizing the syntax of (a sub-set of the popular UML diagrams (Use Case diagram, Class diagram, and State Machine diagram) using Z specifications.

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.

This paper examines the classical functions of the psyche--cognition, affection and conation--from a phenomenological viewpoint and finds them to be defined each in terms of the other. It is held that this circularity of definition reflects the fundamental unity of conscious experience and, as a consequence, that the search for the biological substrate underlying individual functions too readily degenerates into a morphological and biochemical phrenology. An alternative approach, based on considerations from the field of artificial intelligence, is discussed. This approach provides a description of mental phenomena as changes of state in a finite-state machine, the next state being determined by both previous states and current inputs. This concept is shown to be compatible with the descriptions of conscious experience outlined in the phenomenology of Karl Jaspers. It is suggested that neurobiological investigations should be directed towards defining the processes by which state changes occur and further seeking to define mental pathology as aberrations of these dynamic processes.

We introduce a meta-model based on formal languages, dubbed formal choreographic languages, to study message-passing systems. Our framework allows us to generalise standard constructions from the literature and to compare them. In particular, we consider notions such as global view, local view, and projections from the former to the latter. The correctness of local views projected from global views is characterised in terms of a closure property. We consider a number of communication properties -- such as (dead)lock-freedom -- and give conditions on formal choreographic languages to guarantee them. Finally, we show how formal choreographic languages can capture existing formalisms; specifically we consider communicating finite-state machines, choreography automata, and multiparty session types. Notably, formal choreographic languages, differently from most approaches in the literature, can naturally model systems exhibiting non-regular behaviour.

Often the most effective diagrams are those which are very simple. However there is a strong tendency, particularly prevalent in visual formal modelling and specification languages, to take a diagrammatic language which at core is very simple, and then add many extensions and features to make it more expressive - often making it so expressive that the diagrams produced in the language are no longer readable; or at least, the diagrams are no longer obviously a more effective form of representation than a text-based one. Both the design of effective visual formal modelling and specification languages, and the effective formalisation of (the semantics of) such visual languages requires the unification of results from visual language theory, cognitive science, empirical psychology and graphic design. Integrating results from such diverse fields is a non-trivial task, which may be approached through a decomposition of the study of issues of effectiveness in diagrammatic languages according to analogous understandings of (written and spoken) natural languages.

The readability of formal requirements specification languages is hypothesized as a limiting factor in the acceptance of formal methods by the industrial community. An empirical study was conducted to determine how various factors of state-based requirements specification language design affect readability using aerospace applications. Six factors were tested in all, including the representation of the overall state machine structure, the expression of triggering conditions, the use of macros, the use of internal broadcast events, the use of hierarchies, and transition perspective (going-to or coming-from). Subjects included computer scientists as well as aerospace engineers in an effort to determine whether background affects notational preferences. Because so little previous experimentation on this topic exists on which to build hypotheses, the study was designed as a preliminary exploration of what factors are most important with respect to readability. It can serve as a starting point for more thorough and carefully controlled experimentation in specification language readability.

Translating meaning representations to behavioural interface specifications

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.

Various works have been done in verifying object constraint language (OCL) by translating it to formal specification language. This paper presents the process of translating OCL to prototype verification system (PVS) using model transformation. PVS is a formal specification language based on higher-order logic and comes with a theorem prover. Two processes have been identified to translate OCL to PVS. The first process translates OCL constraint to PVS specification directly using model-to-text transformation while the second process transforms OCL to PVS model. Both processes are evaluated to identify the advantages and disadvantages. Transforming OCL to PVS model allow the result to be use for other model management operation.

Policy is a flexible mechanism to deal with complex coordination and management of organizational elements in an open system environment. A formal specification framework is proposed for such a kind of system called policy-governed institutional agency. The formal framework includes: an abstract architecture, a formal institutional model, and a formal specification language for this type of systems. The concrete syntax and semantics of the formal specification language are given. The core of the framework has been implemented in a prototype environment.

Standardization of Formal Specification Languages