Formal Notation Research Articles

Modelling Devices for Natural Interaction

We do not interact with systems without first performing some physical action on a physical device. This paper shows how formal notations and formal models can be developed to account for the relationship between the physical devices that we actually press, twist or pull and their effects on systems. We use state diagrams of each but find we have to extend these in order to account for features such as bounce-back, where buttons or other controls are sprung. Critical to all is the fact that we are physical creatures and so formal models have to take into account that physicality.

Aspect-Oriented Action Semantics Descriptions

The modularity of programming language descriptions allows the designer to describe each programming language feature in a separated module that can be studied independently of others. Action Semantics is a formal notation that produce modular descriptions of programming languages. This paper proposes to use concepts of Aspect-oriented programming to improve the modularity of action semantics descriptions. To achieve this goal, an aspect-oriented notation is proposed and applied to describe some programming language concepts.

Towards the Formal Verification of a Java Processor in Event-B

Formal verification is becoming more and more important in the production of high integrity microprocessors. The general purpose formal method called Event-B is the latest incarnation of the B Method: it is a proof-based approach with a formal notation and refinement technique for modelling and verifying systems. Refinement enables implementation-level features to be proven correct with respect to an abstract specification of the system. In this paper we demonstrate an initial attempt to model and verify Sandia National Laboratories' Score processor using Event-B. The processor is an (almost complete) implementation of a Java Virtual Machine in hardware. Thus, refinement-based verification of the Score processor begins with a formal specification of Java bytecode. Traditionally, B has been directed at the formal development of software systems. The use of B in hardware verification could provide a means of developing combined software/hardware systems, i.e. codesign.

FENECIA: failure endurable nested-transaction based execution of composite Web services with incorporated state analysis

Interest in the Web services (WS) composition (WSC) paradigm is increasing tremendously. A real shift in distributed computing history is expected to occur when the dream of implementing Service-Oriented Architecture (SOA) is realized. However, there is a long way to go to achieve such an ambitious goal. In this paper, we support the idea that, when challenging the WSC issue, the earlier that the inevitability of failures is recognized and proper failure-handling mechanisms are defined, from the very early stage of the composite WS (CWS) specification, the greater are the chances of achieving a significant gain in dependability. To formalize this vision, we present the FENECIA (Failure Endurable Nested-transaction based Execution of Composite Web services with Incorporated state Analysis) framework. Our framework approaches the WSC issue from different points of view to guarantee a high level of dependability. In particular, it aims at being simultaneously a failure-handling-devoted CWS specification, execution, and quality of service (QoS) assessment approach. In the first section of our framework, we focus on answering the need for a specification model tailored for the WS architecture. To this end, we introduce WS-SAGAS, a new transaction model. WS-SAGAS introduces key concepts that are not part of the WS architecture pillars, namely, arbitrary nesting, state, vitality degree, and compensation, to specify failure-endurable CWS as a hierarchy of recursively nested transactions. In addition, to define the CWS execution semantics, without suffering from the hindrance of an XML-based notation, we describe a textual notation that describes a WSC in terms of definition rules, composability rules, and ordering rules, and we introduce graphical and formal notations. These rules provide the solid foundation needed to formulate the execution semantics of a CWS in terms of execution correctness verification dependencies. To ensure dependable execution of the CWS, we present in the second section of FENECIA our architecture THROWS, in which the execution control of the resulting CWS is distributed among engines, discovered dynamically, that communicate in a peer-to-peer fashion. A dependable execution is guaranteed in THROWS by keeping track of the execution progress of a CWS and by enforcing forward and backward recovery. We concentrate in the third section of our approach on showing how the failure consideration is trivial in acquiring more accurate CWS QoS estimations. We propose a model that assesses several QoS properties of CWS, which are specified as WS-SAGAS transactions and executed in THROWS. We validate our proposal and show its feasibility and broad applicability by describing an implemented prototype and a case study.

What are the real challenges for Computational Neuroscience?

Event Abstract Back to Event What are the real challenges for Computational Neuroscience? Marc-Oliver Gewaltig1* 1 Honda Research Institute Europe GmbH, Germany The human brain contains some 1011 neurons with some 1015 synaptic connections between them. It is tempting to believe that we can model the brain, once computers are fast enough and computer memory is big enough to store and solve the models for all neurons and their connections. The largest models today have 105 neurons with up to 109 synapses, corresponding to one cubic millimeter of human cortex. These models already require computer clusters, but use simple neuron and synapse models. Larger models merely show what is technically feasible. To model a large neuronal system, we cannot take the best neuron model. Instead, we must use the smallest or fastest model to squeeze our network into the available computer memory. Recent trends in computing technology indicate that faster and more powerful computers will soon be available to a wide group of researchers. The most interesting for scientific computing are: multi-core processors for parallel computing and so-called graphical processing units (GPU), the high-performance engines of 3D graphics cards. These technologies may speed up simulations by orders of magnitude and we may soon be able to simulate big parts of the brain in short times. However, the biggest challenge for computational neuroscience is the complexity of the brain, not its size. Each nerve cell is already so complex that researchers disagree about the appropriate level of description. Even less is known about neural circuits or systems. Conceptual progress in systems neuroscience depends on a concise and powerful notation to develop, analyze, and covey ideas and models of neurons, networks and systems. Today, simulation code is the only reliable source of information about a model. But simulation code cannot replace a formal notation, because it is incomplete and platform. Only with an appropriate formal notation can we cope with the increasing complexity of neural models, because it allows us to formally manipulate, analyze, and enhance our models. Complex models require complex simulation software. Today's simulation code is mostly hand-written for a particular model. But with increasing complexity, it becomes more difficult to validate published results. There are no accepted quality standards to ensure that simulation results indeed describe neuroscientific phenomena rather than errors in the implementation. Researchers must adopt standards and practices long common in software engineering, to keep up with the ever increasing complexity of models, simulation software, and computing hardware. Reviewers must begin to critically review not only the model, but also the simulation methods. Journals must accept that simulation methods must not be banished to the supplementary material section where few are likely to see them. In this talk, I will review recent results and trends in simulation technology for large neural systems and will discuss possible solutions to the challenges posed by the ever increasing complexity of models, simulation software and computing architectures. Conference: Neuroinformatics 2008, Stockholm, Sweden, 7 Sep - 9 Sep, 2008. Presentation Type: Oral Presentation Topic: Workshop Citation: Gewaltig M (2008). What are the real challenges for Computational Neuroscience?. Front. Neuroinform. Conference Abstract: Neuroinformatics 2008. doi: 10.3389/conf.neuro.11.2008.01.150 Copyright: The abstracts in this collection have not been subject to any Frontiers peer review or checks, and are not endorsed by Frontiers. They are made available through the Frontiers publishing platform as a service to conference organizers and presenters. The copyright in the individual abstracts is owned by the author of each abstract or his/her employer unless otherwise stated. Each abstract, as well as the collection of abstracts, are published under a Creative Commons CC-BY 4.0 (attribution) licence (https://creativecommons.org/licenses/by/4.0/) and may thus be reproduced, translated, adapted and be the subject of derivative works provided the authors and Frontiers are attributed. For Frontiers’ terms and conditions please see https://www.frontiersin.org/legal/terms-and-conditions. Received: 28 Jul 2008; Published Online: 28 Jul 2008. * Correspondence: Marc-Oliver Gewaltig, Honda Research Institute Europe GmbH, Offenbach, Germany, marc-oliver.gewaltig@epfl.ch Login Required This action requires you to be registered with Frontiers and logged in. To register or login click here. Abstract Info Abstract The Authors in Frontiers Marc-Oliver Gewaltig Google Marc-Oliver Gewaltig Google Scholar Marc-Oliver Gewaltig PubMed Marc-Oliver Gewaltig Related Article in Frontiers Google Scholar PubMed Abstract Close Back to top Javascript is disabled. Please enable Javascript in your browser settings in order to see all the content on this page.

Towards Automatic Transformation from UML Model to FSM Model for Web Applications

The need for automatic testing of large-scale web applications suggests the use of model-based testing technology. Among various modeling languages, UML is widely spread and used for its simplicity, understandability and ease of use. But rigorous analysis for UML model is difficult due to its lack of precise semantics. On the other hand, as a formal notation, FSM provides an avenue for automatic generation of test cases, but the requirement for mathematical basis makes itself academic inventions divorced from real applications. This paper proposes an approach to transforming UML model to FSM model, taking advantage of both languages. As our work focuses on the transformation of UML state diagrams to FSM models, a specific transformation mechanism is presented, which deals with different elements with different mapping rules. To illustrate the mechanism we proposed, an example of a web application for software download is presented. Finally, we give a method for implementation of the mechanism and a tool prototype to support the method.

Formal driven prototyping approach for multiagent systems

Even if Multiagent Systems (MASs) are recognised as an appealing paradigm for designing many computer systems ranging from complex distributed systems to intelligent software applications, they are still difficult to engineer. A common point of MAS engineering methodologies is the production of different work products or models during the different phases. Each work product or model helps to progress towards an implementation of the system under development. Nevertheless, there are very few ways to ensure that the work products and models produced are validated against the requirements. The aim of this paper is to present a formal driven prototyping approach for MAS. This process provides a support for incremental specification leading to an executable model of the system being built. Indeed, this process is based upon a formal organisational framework which uses a formal notation, namely OZS. The process is illustrated through the specification of a multiagent architecture.

Model-Driven Validation of SystemC Designs

Functional test generation for dynamic validation of current system level designs is a challenging task. Manual test writing or automated random test generation techniques are often used for such validation practices. However, directing tests to particular reachable states of a SystemC model is often difficult, especially when these models are large and complex. In this work, we present a model-driven methodology for generating directed tests that take the SystemC model under validation to specific reachable states. This allows the validation to uncover very specific scenarios which lead to different corner cases. Our formal modeling is done entirely within the Microsoft SpecExplorer tool to formally describe the specification of the system under validation in the formal notation of AsmL. We also exploit SpecExplorer's abilities for state space exploration for our test generation, and its APIs for connecting the model to real programs to drive the validation of SystemC models with the generated test cases.

Formal notations are diagrams: Evidence from a production task

Although a general sense of the magnitude, quantity, or numerosity of objects is common in both untrained people and animals, the abilities to deal exactly with large quantities and to reason precisely in complex but well-specified situations--to behave formally, that is--are skills unique to people trained in symbolic notations. These symbolic notations typically employ complex, hierarchically embedded structures, which all extant analyses assume are constructed by concatenative, rule-based processes. The primary goal of this article is to establish, using behavioral measures on naturalistic tasks, that some of the same cognitive resources involved in representing spatial relations and proximities are also involved in representing symbolic notations--in short, that formal notations are a kind of diagram. We examined self-generated productions in the domains of handwritten arithmetic expressions and typewritten statements in a formal logic. In both tasks, we found substantial evidence for spatial representational schemes even in these highly symbolic domains.

Formal Specification and Verification of Real-Time Systems using Graph Grammars

Abstract The importance of real-time systems has enormously increased in the last decade. Application areas that typically need real-time models include railroad systems, intelligent vehicle highway systems, avionics, multimedia and telephony. To assure that such systems are correct, additionally to prove that they provide the required functionality, time constraints must be satisfied. There are already formal specification methods for real-time systems, but most of them are difficult to use by software developers, that are usually not very familiar with mathematical notation but rather specify systems using the objectoriented paradigm. In this paper we propose a formal approach to specify and analyze real-time systems that has an object-oriented flavor. This approach is based on Object-Based Graph Grammars (OBGGs), a formal description technique suitable for the specification of asynchronous distributed systems, and intuitive even for nontheoreticians. We extend OBGGs to enable explicit modeling of time constraints, and define the semantics of the specifications via transition systems. Finally, we translate timed OBGGs to Timed Automata, a formal notation that is wide spread in the area of real-time systems modeling and allows the automatic verification of properties.

FORMAL SPECIFICATION APPROACH OF ROLE DYNAMICS IN AGENT ORGANISATIONS: APPLICATION TO THE SATISFACTION-ALTRUISM MODEL

This article deals with the problem of dynamic role-playing in Multi-Agent organisations. The approach presented uses a formal specification notation and is based upon a formal framework which defines the concepts of role, interaction and organisation. Within this framework the problem of dynamic role-playing specification is related to the merging of specifications. The formal notation used composes Object-Z and Statecharts. The main features of this approach are: enough expressive power to represent Multi-Agents dynamic aspects, tools for specification analysis and mechanisms allowing the refinement of a high level specification into a low level specification which can be easily implemented. The last part of this paper presents an application with the specification of a reactive and cooperative MAS model named Satisfaction Altruism. An analysis of the specification validates the agents' behaviours.

Design Patterns for Teaching Type Checking in a Compiler Construction Course

A course in compiler construction seeks to develop an understanding of well-defined fundamental theory and typically involves the production of a language processor. In a graduate degree in software engineering, the development of a compiler contributes significantly to the developer's comprehension of the practical application of theoretical concepts. Different formal notations are commonly used to define type systems, and some of them are used to teach the semantic analysis phase of language processing. In the traditional approach, attribute grammars are probably the most widely used ones. This paper shows how object-oriented design patterns represented in unified modeling language (UML) can be used to both teach type systems and develop the semantic analysis phase of a compiler. The main benefit of this approach is two-fold: better comprehension of theoretical concepts because of the use of notations known by the students (UML diagrams), and improvement of software engineering skills for the development of a complete language processor.

Formal models of appraisal: Theory, specification, and computational model

Cognitive appraisal theories (CATs) explain human emotions as a result of the subjective evaluation of events that occur in the environment. Recently, arguments have been put forward that discuss the need for formal descriptions in order to further advance the field of cognitive appraisal theory. Formal descriptions can provide detailed predictions and help to integrate different CATs by providing clear identification of the differences and similarities between theories. A computational model of emotion that is based on a CAT also needs formal descriptions specifying the theory on which it is based. In this paper we propose a formal notation for the declarative semantics of the structure of appraisal. We claim that this formalism facilitates both integration of appraisal theories as well as the design and evaluation of computational models of emotion based on an appraisal theory. To support these claims we show how our formalism can be used in both ways: first we integrate two appraisal theories; second, we use this formal integrated model as basis for a computational model after identifying what declarative information is missing in the formal model. Finally, we embed the computational model in an emotional agent, and show how the formal specification helps to evaluate the computational model.

The GTO Toolset and Method

A suitable method supported by a toolset with a high degree of automation is a necessity for the successful employment of formal methods in industrial projects. The GTO toolset and method have been developed, and successfully applied, to formal methods in safety-critical control applications related to railway signalling since the mid 1990s.The toolset and method support the entire formal methods process from writing and validating formal specifications, through modelling of the implementation to formal verification and analysis of verification results. One goal the toolset and method was to make formal methods more competitive by streamlining the process so that – at least within an established application area – individual verification tasks could be done in an “assembly line”-like fashion with minimum overhead.In line with this goal, the toolset is intended for use with configurable systems, where a generic specification is applicable to a family of systems and adapted to a specific system using configuration data.The functions carried out by the toolset include static checking and simulation of specifications, checking of configuration data, generation of implementation models from PLC program code or relay schematics, simulation of the implementation model, formal verification by refinement proof, and analysis of failed refinement proofs. Refinement proofs are automatically carried out by a satisfiability (SAT) solver of the user's choice, which is interfaced to the main tool.We will outline the method and functions of the toolset as well as the formal notation – a simple temporal predicate logic – used by the toolset.

From Predicates to Programs: The Semantics of a Method Language

This paper explains how a declarative method language, based upon the formal notations of Z and B, can be used as a basis for automatic code generation. The language is used to describe the intended effect of operations, or methods, upon the components of an object model; each method is defined by a pair of predicates: a precondition, and a post-condition. Following the automatic incorporation of model invariants, including those arising from class associations, these predicates are extended—again, automatically—to address issues of consistency, definition, and dependency, before being translated into imperative programs. The result is a formal method for transforming object models into complete, working systems.

In the Shadows of the Löwenheim-Skolem Theorem: Early Combinatorial Analyses of Mathematical Proofs

AbstractThe Löwenheim–Skolem theorem was published in Skolem's long paper of 1920, with the first section dedicated to the theorem. The second section of the paper contains a proof-theoretical analysis of derivations in lattice theory. The main result, otherwise believed to have been established in the late 1980s, was a polynomial-time decision algorithm for these derivations. Skolem did not develop any notation for the representation of derivations, which makes the proofs of his results hard to follow. Such a formal notation is given here by which these proofs become transparent. A third section of Skolem's paper gives an analysis for derivations in plane projective geometry. To clear a gap in Skolem's result, a new conservativity property is shown for projective geometry, to the effect that a proper use of the axiom that gives the uniqueness of connecting lines and intersection points requires a conclusion with proper cases (logically, a disjunction in a positive part) to be proved.The forgotten parts of Skolem's first paper on the Löwenheim–Skolem theorem are the perhaps earliest combinatorial analyses of formal mathematical proofs, and at least the earliest analyses with profound results.

Safety-Oriented Design of Component Assemblies using Safety Interfaces

This paper promotes compositional reasoning in the context of safety-critical systems, and demonstrates a safety-oriented component model using an application from the automotive industry: an Adaptive Cruise Controller (ACC). The application consists of four components for which a set of 18 fault modes have been identified. We show the impact of all single faults and double faults selected from this set, on a safety property associated with the ACC assembly. Analysis related to each fault mode is performed using compositional rules and derived safety interfaces for each component.The derivation of safety interfaces for the ACC components has been supported by implementation of two extensions to the SCADE tool set: (1) a front end that iteratively and automatically builds the environment in which the component is resilient in presence of a given fault, (2) fault mode libraries that can be reused for modeling several classes of faults affecting the input of a component. The result of the study is the illustration of system level safety in presence of certain single and double faults, based on compositional reasoning and the automatically generated interfaces. The component model uses reactive modules as the formal notation. The instantiation of the model in terms of modules specified in SCADE provides a link between formal analysis of components in safety-critical systems and the traditional engineering processes supported by model-based development.

Mixing logics and rewards for the component-oriented specification of performance measures

Formal notations for system performance modeling need to be equipped with suitable notations for specifying performance measures. These companion notations have been traditionally based on reward structures and, more recently, on temporal logics. In this paper we propose an approach that combines logics and rewards, together with a definition mechanism that allows performance measures to be specified in a component-oriented way, thus facilitating the task for non-experts. The resulting Measure Specification Language (MSL) is interpreted both on action-labeled continuous-time Markov chains and on stochastic process algebras. The latter interpretation provides a compositional framework for performance-sensitive model manipulations and emphasizes the increased expressiveness with respect to traditional reward structures for implicit-state modeling notations.

Interactive tool support for CSP || B consistency checking

Abstract CSP || B is an integration of two well known formal notations: CSP and B. It provides a method for modelling systems with both complex state (described in B machines) and control flow (described as CSP processes). Consistency checking within this approach verifies that a controller process never calls a B operation outside its precondition. Otherwise the behaviour of the operation cannot be predicted. In previous work, this check was carried out by manually decomposing the model before preprocessing the CSP processes to perform a hand-written weakest precondition proof. In this paper, a framework is described that mechanises consistency checking in a theorem prover and removes the need for preprocessing. This work is based on an existing PVS embedding of the CSP traces model, but it is extended by introducing a notion of state so that the interaction between processes and machines can be analysed. Numerous rules have been defined (and proved) which enable consistency checking and decomposition via PVS proof. These rules also formally justify the relaxation of previous constraints on CSP || B architectures, thereby widening the scope of CSP || B modelling. The PVS embedding and rules presented in this paper are not only applicable to CSP || B specifications, but to other combined approaches which use a non-blocking semantics for the state-based operations.

A high-level requirements engineering methodology for electronic system-level design

Current electronic systems’ complexity severely limits their validation. Even if development frameworks keep improving and are heavily supported by the industry, methods for hardware/software electronic systems co-design are reaching a major crisis. Although the community is heading towards higher abstraction levels, requirements remain out of the validation scope. We therefore present a requirements engineering methodology that intersects formal, linguistic, and scenario views. Modeling consists in abstracting functionalities’ behaviours in terms of actions, expressed in a semi-formal structured language, later automatically translated in a pure formal notation. Such a mix makes the language accessible to designers and permits automation. Validation is then performed using consistency rules. Finally, an elicitation of missing functionalities is achieved using Boolean algebra.