Extended State Machine Research Articles

Open-source, Python-based, hardware and software for controlling behavioural neuroscience experiments.

Laboratory behavioural tasks are an essential research tool. As questions asked of behaviour and brain activity become more sophisticated, the ability to specify and run richly structured tasks becomes more important. An increasing focus on reproducibility also necessitates accurate communication of task logic to other researchers. To these ends, we developed pyControl, a system of open-source hardware and software for controlling behavioural experiments comprising a simple yet flexible Python-based syntax for specifying tasks as extended state machines, hardware modules for building behavioural setups, and a graphical user interface designed for efficiently running high-throughput experiments on many setups in parallel, all with extensive online documentation. These tools make it quicker, easier, and cheaper to implement rich behavioural tasks at scale. As important, pyControl facilitates communication and reproducibility of behavioural experiments through a highly readable task definition syntax and self-documenting features. Here, we outline the system's design and rationale, present validation experiments characterising system performance, and demonstrate example applications in freely moving and head-fixed mouse behaviour.

Symbolic Refinement of Extended State Machines with Applications to the Automatic Derivation of Sub-Components and Controllers

Nowadays, extended state machines are prominent requirements specification techniques due to their capabilities of modeling complex systems in a compact way. These machines extend the standard state machines with variables and have transitions guarded by enabling predicates and may include variable update statements. Given a system modeled as an extended state machine, with possibly infinite state space and some non-controllable (parameterized) interactions, a pruning procedure is proposed to symbolically derive a maximal sub-machine of the original system that satisfies certain conditions; namely, some safeness and absence of undesirable deadlocks which could be produced during pruning. In addition, the user may specify, as predicates associated with states, some general goal assertions that should be preserved in the obtained sub-machine. Further, one may also specify some specific requirements such as the elimination of certain undesirable deadlocks at states, or fail states that should never be reached. Application examples are given considering deadlock avoidance and loops including infinite loops over non-controllable interactions showing that the procedure may not terminate. In addition, the procedure is applied for finding a controller of a system to be controlled. The approach generalizes existing work in respect to the considered extended machine model and the possibility of user defined control objectives written as assertions at states.

Fundamental results for learning deterministic extended finite state machines from queries

Regular language inference, initiated by Angluin, has many developments, including applications in software engineering and testing. However, the capability of finite automata to model the system data is quite limited and, in many cases, extended finite state machine formalisms, that combine the system control with data structures, are used instead. The application of Angluin-style inference algorithms to extended state machines would involve constructing a minimal deterministic extended finite state machine consistent with a deterministic 3-valued deterministic finite automaton. In addition to the usual, accepting and rejecting, states of finite automaton, a 3-valued deterministic finite automaton may have “don't care” states; the sequences of inputs that reach such states may be considered as accepted or rejected, as is convenient. The aforementioned construction reduces to finding a minimal deterministic finite automaton consistent with a 3-valued deterministic finite automaton, that preserves the deterministic nature of the extended model that also handles the data structure associated with it. This paper investigates fundamental properties of extended finite state machines in relation to Angluin's language inference problem and provides an inference algorithm for such models.

Formalizing and Verification of an Antivirus Protection Service using Model Checking

Abstract In this paper, a protection service model is proposed for an antivirus system. The proposed model has been focused on maintaining in secure state of the system. According to the proposed antivirus model, the required behavior has been specified as extended state machine diagrams and translated to temporal logic properties by using Computing Tree Logic language. Also the proposed model has been converted to aKripke Structure by using formal verification techniques. For proving the correctness and the reachability of proposed model, some properties of the proposed model are verified by using NuSMV model checker.

Automatic Conversion Method of the Requirements Specification Verification for CTCS Level 3

Chinese Train Control System Level 3(CTCS-3) is a typical complex cyber-physical system which connects the control center, the station and the train. In order to ensure the friendly communication between the different manufacturers equipment, the high reliability is required by the CTCS-3 system. The reliability of a system can be tested with the formal verification method and a lot of formal tools have been developed, such as SPIN, VIS and NuSMV. In this paper, we describe the modeling techniques and abstractions of the control process. The required assembly unit has been specified as extended class. The required behavior has been specified as extended state machine diagrams and translated to temporal logic properties. Then, we propose a method to simplify the steps which transfer a UML model into a formal model. Moreover, the transition can be implemented with development language, where its result-the formal model-can be run by the formal tool and return an analysis result. At last, we take the Radio Block Center (RBC) Handover of CTCS-3 as an example, and the experimental results show the validity and feasibility of this method.

A symbolic model checking approach to verifying satellite onboard software

This paper discusses the use of symbolic model checking technology to verify the design of an embedded satellite software control system called the attitude and orbit control system (AOCS). This system is mission critical because it is responsible for maintaining the attitude of the satellite and for performing fault detection, isolation, and recovery decisions. An executable AOCS implementation by Space Systems Finland has been provided in Ada source code form, and we use the input language of the symbolic model checker NuSMV 2 to model the implementation at a detailed level. We describe the modeling techniques and abstractions used to alleviate the state space explosion due to the handling of timers and the large number of system components controlled by the AOCS. The required behavior has been specified as extended state machine diagrams and translated to temporal logic properties. Besides well-known LTL and CTL model checking algorithms, we adapt a previously unexplored form of the liveness-to-safety approach to the problem. The latter new technique turns out to successfully prove all desired properties of the system, outperforming both the LTL and CTL implementations of NuSMV 2.

An abort-aware model of transactional programming

There has been a lot of recent research on transaction-based concurrent programming, aimed at offering an easier concurrent programming paradigm that enables programmers to better exploit the parallelism of modern multi-processor machines, such as multi-core microprocessors. We introduce Transactional State Machines (TSMs) as an abstract finite-data model of transactional shared-memory concurrent programs. TSMs are a variant of concurrent boolean programs (or concurrent extended recursive state machines) augmented with additional constructs for specifying potentially nested transactions. Namely, some procedures (or code segments) can be marked as transactions and are meant to be executed “atomically”, and there are also explicit commit and abort operations for transactions. The TSM model is non-blocking and allows interleaved executions where multiple processes can simultaneously be executing inside transactions. It also allows nested transactions, transactions which may never terminate, and transactions which may be aborted explicitly, or aborted automatically by the run-time environment due to memory conflicts. We show that concurrent executions of TSMs satisfy a correctness criterion closely related to serializability, which we call stutter-serializability, with respect to shared memory. We initiate a study of model checking problems for TSMs. Model checking arbitrary TSMs is easily seen to be undecidable, but we show it is decidable in the following case: when recursion is exclusively used inside transactions in all (but one) of the processes, we show that model checking such TSMs against all stutter-invariant ω-regular properties of shared memory is decidable.

The Research of an Abstract Semantic Framework for Defect Detecting

This paper proposes a non-relational abstract semantic framework. It uses interval set to represent the value of numerical variables and complete lattice to represent Boolean variables and reference variables. It presents the abstract computation method of basic expressions and the nodes of control flow graph. It uses function summaries to represent the context information of function call needed by defects detecting. Based on the results of abstract computation, it uses extended state machine to define defect patterns and proposes a path-sensitive method based on dataflow analysis to detect defects. It avoids the combination explosion of full path analysis by merging the conditions of identical property state at join points in the CFG. Practical test results show that the proposed methods have features of high efficiency, low false positive and low false negative.

Alternative Models of Synthesized Programs for Executing Condition System Controllers

Abstract In this paper, we consider the problem of creating synthesized programs to implement a controller automatically generated through discrete-event control synthesis techniques. The controller is represented as a set of discrete event models comparable to extended state machines, where the individual control components interact with each other and with the plant via condition signals. We discuss three alternative approaches for the synthesized program to represent these control components. We discuss benefits and drawbacks to each.

RELIABILITY MODEL FOR COMPONENT-BASED SYSTEMS IN COSMIC (A CASE STUDY)

Software component technology has a substantial impact on modern IT evolution. The benefits of this technology, such as reusability, complexity management, time and effort reduction, and increased productivity, have been key drivers of its adoption by industry. One of the main issues in building component-based systems is the reliability of the composed functionality of the assembled components. This paper proposes a reliability assessment model based on the architectural configuration of a component-based system and the reliability of the individual components, which is usage- or testing-independent. The goal of this research is to improve the reliability assessment process for large software component-based systems over time, and to compare alternative component-based system design solutions prior to implementation. The novelty of the proposed reliability assessment model lies in the evaluation of the component reliability from its behavior specifications, and of the system reliability from its topology; the reliability assessment is performed in the context of the implementation-independent ISO/IEC 19761:2003 International Standard on the COSMIC method chosen to provide the component's behavior specifications. In essence, each component of the system is modeled by a discrete time Markov chain behavior based on its behavior specifications with extended-state machines. Then, a probabilistic analysis by means of Markov chains is performed to analyze any uncertainty in the component's behavior. Our hypothesis states that the less uncertainty there is in the component's behavior, the greater the reliability of the component. The system reliability assessment is derived from a typical component-based system architecture with composite reliability structures, which may include the composition of the serial reliability structures, the parallel reliability structures and the p-out-of-n reliability structures. The approach of assessing component-based system reliability in the COSMIC context is illustrated with the railroad crossing case study.

Direct Semantics of Extended State Machines.

In this paper we consider a substantial subset of UML 2 state machine notation and assign an axiomatic semantics to this. This semantics is assigned directly to the original models, and does not require pre-processing of the models to reduce them to a more basic form. The advantage of this is that the semantics retains the structure and context information of the model, making it easier to relate semantic analysis results to the model.

A hybrid state machine notation for component specification

A wide range of software units can be classified as state machines. We extend conventional state machine notations by adding regular expressions of events and unions of source states to state machine transitions. Reusable software components are generated from these extended state machine specifications. Component specification and generation are illustrated in Java.

The CIP method

CIP is a model-based software development method for embedded systems. The problem of constructing an embedded system is decomposed into a functional and a connection problem. The functional problem is solved by constructing a formal reactive behavioural model. A CIP model consists of concurrent clusters of synchronously cooperating extended state machines. The state machines of a cluster interact by multi-cast events. State machines of different clusters can communicate through asynchronous channels. The construction of CIP models is supported by the CIP Tool, a graphical modelling framework with code generators that transform CIP models into concurrently executable CIP components. The connection problem consists of connecting generated CIP components to the real environment. This problem is solved by means of techniques and tools adapted to the technology of the interface devices. Construction of a CIP model starts from the behaviour of the processes of the real environment, leading to an operational specification of the system behaviour in constructive steps. This approach allows stable interfaces of CIP components to be specified at an early stage, thus supporting concurrent development of their connection to the environment.

A parlog based real-time distributed logic environment

The high complexity of distributed computer systems requires new programming languages and tools which will avoid many of the details that are necessary to take into account with the traditional languages. The new proposals of declarative languages and the advances in compilation techniques will make these languages an alternative to imperative languages in some areas. We propose a real-time distributed environment based on a concurrent logic language. With this approach we try to provide the advantages of a declarative language to real-time distributed system. Because of the interactive features of the distributed systems, these cannot be distributed systems, these cannot be described in usual logical or functional terms and it is necessary to use reactive languages. There is a class of logic languages with a reactive behaviour named Concurrent Logic Languages which are well suited for this kind of problem. We have extended one of these languages (Parlog) with real-time and communications primitives, and we have developed a distributed environment which can create and control remote processes in a very easy and efficient way. The remote execution of processes is based on a remote metacall that we have developed. A prototype of the environment has been implemented using metainterpretation. The real-time extension includes the definition of real-time primitives and the modification of the execution model of Concurrent Logic Languages. We give a new operational semantics for the extended language. We also describe a tool for translating extended state machine specifications to the environment. This will allow the creation of executable prototypes on distributed computer systems and the validation of complex system specifications in an easy way.

Test case verification by model checking

Verification of a test case for testing the conformance of protocol implementations against the formal description of the protocol involves verifying three aspects of the test case: expected input/output test behavior, test verdicts, and the test purpose. We model the safety and liveness properties of a test case using branching time temporal logic. There are four types of safety properties: transmission safety, reception safety, synchronization safety, and verdict safety. We model a test purpose as a liveness property and give a set of notations to formally specify a test purpose. All these properties expressed as temporal formulas are verified using model checking on an extended state machine graph representing the composed behavior of a test case and protocol specification. This methodology is shown to be effective in finding errors in manually developed conformance test suites.

SEDOS: designing open distributed systems

The aim of the ESPRIT SEDOS (software environment for the design of open systems) project is to further develop Estelle, the extended state-transition language, and LOTOS, the language for temporal ordering specifications, to describe services and protocols for distributed architectures and to demonstrate their effectiveness as concretely as possible by deriving simulators and other support tools. The Estelle language is based on extended state machines that communicate through infinite FIFO links. The LOTOS language is based on a temporal ordering of events and rendezvous.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Generating extended state transitions from structured specifications for process control systems

The paper describes a method for providing improved prototyping capabilities in a process control system emulation tool. The tool, the NIST Hierarchical Control System Emulator, allows concurrent execution of modules emulating both physical processes and decision processes. The concurrent modules are specified as extended finite state machines. This paper describes the emulation tool and presents a simple method for transforming code, written with structured control constructs, into an extended state machine representation usable on the Emulator, providing the capability for rapid prototyping of designs. The paper also discusses advantages and disadvantages of this approach against direct use of state tables for specifying processes on the Emulator.

Modularity in the ESM/RTL Framework for Real-Time Systems

The ESM/RTL framework uses extended state machines (ESMs) for representing real-time discrete event processes in both the object to be controlled (the plant) and the controlling software (the controller). Real-time temporal logic (RTL) is used as the assertion language for specifying required plant behaviour and verifying that the controller satisfies this specification.In this paper, a first step towards modularizing the ESM/RTL framework is taken by developing a method to construct higher level ESMs from basic ESMs. ESMs are interpreted as generators of trajectories, and this interpretation can be used to provide an operational semantics for an ESM at any level. The paper concludes with a brief discussion of how the framework supports modular reasoning in RTL.

Specification and implementation of an ISO session layer

This paper describes a novel technique for the specification and implementation of layered communication software. The technique is called Parallel Activity Specification Scheme (PASS) and is based on an extended-state machine model of protocol automata. It allows a convenient description of the communication behavior of concurrent systems and semiautomatic generation of programming language code from the specification. The first large-scale experience gained with this technique was in the specification and implementation of an ISO session layer. The code generation process and the embedding of the session code into a portable OSI operating system environment are described in detail.