Formal specification of human-computer interfaces

A high-level formal specification of a human computer interface is described. Previous work is reviewed and the ASLAN specification language is described. Top-level specifications written in ASLAN for a library and a multiwindow interface are discussed

Provably correct Java implementations of Spi Calculus security protocols specifications

Spi Calculus is an untyped high level modeling language for security protocols, used for formal protocols specification and verification. In this paper, a type system for the Spi Calculus and a translation function are formally defined, in order to formalize the refinement of a Spi Calculus specification into a Java implementation. The Java implementation generated by the translation function uses a custom Java library. Formal conditions on such library are stated, so that, if the library implementation code satisfies such conditions, then the generated Java implementation correctly simulates the Spi Calculus specification. A verified implementation of part of the custom library is further presente

Multi-level agent-based modeling with the Influence Reaction principle

This paper deals with the specification and the implementation of multi-level agent-based models, using a formal model, IRM4MLS (an Influence Reaction Model for Multi-Level Simulation), based on the Influence Reaction principle. Proposed examples illustrate forms of top-down control in (multi-level) multi-agent based-simulations

Systems, methods and apparatus for implementation of formal specifications derived from informal requirements

Systems, methods and apparatus are provided through which in some embodiments an informal specification is translated without human intervention into a formal specification. In some embodiments the formal specification is a process-based specification. In some embodiments, the formal specification is translated into a high-level computer programming language which is further compiled into a set of executable computer instructions

Report on the formal specification and partial verification of the VIPER microprocessor

The formal specification and partial verification of the VIPER microprocessor is reviewed. The VIPER microprocessor was designed by RSRE, Malvern, England, for safety critical computing applications (e.g., aircraft, reactor control, medical instruments, armaments). The VIPER was carefully specified and partially verified in an attempt to provide a microprocessor with completely predictable operating characteristics. The specification of VIPER is divided into several levels of abstraction, from a gate-level description up to an instruction execution model. Although the consistency between certain levels was demonstrated with mechanically-assisted mathematical proof, the formal verification of VIPER was never completed

A framework for protein and membrane interactions

We introduce the BioBeta Framework, a meta-model for both protein-level and membrane-level interactions of living cells. This formalism aims to provide a formal setting where to encode, compare and merge models at different abstraction levels; in particular, higher-level (e.g. membrane) activities can be given a formal biological justification in terms of low-level (i.e., protein) interactions. A BioBeta specification provides a protein signature together a set of protein reactions, in the spirit of the kappa-calculus. Moreover, the specification describes when a protein configuration triggers one of the only two membrane interaction allowed, that is "pinch" and "fuse". In this paper we define the syntax and semantics of BioBeta, analyse its properties, give it an interpretation as biobigraphical reactive systems, and discuss its expressivity by comparing with kappa-calculus and modelling significant examples. Notably, BioBeta has been designed after a bigraphical metamodel for the same purposes. Hence, each instance of the calculus corresponds to a bigraphical reactive system, and vice versa (almost). Therefore, we can inherith the rich theory of bigraphs, such as the automatic construction of labelled transition systems and behavioural congruences

An engineering approach to formal methods

The distinctive features of engineering are discussed, and used to identify how an engineering approach to formal methods might be developed. The key concept in engineering is suggested to be known components that are combined in known ways. This component-based style is illustrated for two application areas at two levels: in high-level specification of communications services, and in low-level specification of digital logic. The underlying formal language is LOTOS (Language Of Temporal Ordering Specification)

Formal modelling for Ada implementations: tasking Event-B

This paper describes a formal modelling approach, where Ada code is automatically generated from the modelling artefacts. We introduce an implementation-level specification, Tasking Event-B, which is an extension to Event-B. Event-B is a formal method, that can be used to model safety-, and business-critical systems. The work may be of interest to a section of the Ada community who are interested in applying formal modelling techniques in their development process, and automatically generating Ada code from the model. We describe a streamlined process, where the abstract modelling artefacts map easily to Ada language constructs. Initial modelling takes place at a high level of abstraction. We then use refinement, decomposition, and finally implementation-level annotations, to generate Ada code. We provide a brief introduction to Event-B, before illustrating the new approach using small examples taken from a larger case study