Nondeterministic Finite State Machines Research Articles

Realtime polymorphic malicious behavior detection in blockchain-based smart contracts

Abstract This paper proposes an innovative approach to achieving real-time polymorphic behavior detection, and its direct application to blockchain-focused smart-contracts. We devise a method based on a non-deterministic finite state machine to perform approximate pattern-matching, using a look-ahead mechanism implemented through a concept similar to that of a sliding window, and using threshold-based similarity checking at every state in the automaton. We introduce and formalize our approach, discuss the challenges we faced and then test it in a real-world environment. The experimental results obtained showed a significant speed-up of our approach, as compared to the classic similarity measures used commonly in such scenarios.

Survey on applications of algebraic state space theory of logical systems to finite state machines

Algebraic state space theory (ASST) of logical systems, developed based on the semi-tensor product (STP) which is a new matrix analysis tool built in recent ten years, provides an algebraic analysis approach for many fields of science, such as logical dynamical systems, finite-valued systems, discrete event dynamic systems, and networked game systems. This study focuses on comprehensively surveying the applications of the ASST method to the field of finite state machines (FSMs). Some necessary preliminaries on the method are first reviewed. Then the applications of the method in the FSM field are reviewed, including deterministic FSMs, nondeterministic FSMs, probabilistic FSMs, networked FSMs, and controlled and combined FSMs. In addition, other applications related to both STP and FSMs are surveyed, such as the application of FSM to Boolean control networks and the application of graph theory to FSMs. Finally, some potential research directions with respect to the ASST method in the FSM field are predicted.

Efficient parallel derivation of short distinguishing sequences for nondeterministic finite state machines using MapReduce

Distinguishing sequences are widely used in finite state machine-based conformance testing to solve the state identification problem. In this paper, we address the scalability issue encountered while deriving distinguishing sequences from complete observable nondeterministic finite state machines by introducing a massively parallel MapReduce version of the well-known Exact Algorithm. To the best of our knowledge, this is the first study to tackle this task using the MapReduce approach. First, we give a concise overview of the well-known Exact Algorithm for deriving distinguishing sequences from nondeterministic finite state machines. Second, we propose a parallel algorithm for this problem using the MapReduce approach and analyze its communication cost using Afrati et al. model. Furthermore, we conduct a variety of intensive and comparative experiments on a wide range of finite state machine classes to demonstrate that our proposed solution is efficient and scalable.

Method for the Functional Diagnosis of Nondeterministic Finite State Machines

The problem of the functional diagnosis of critical systems, described by a nondeterministic finite state machine model, is considered. A new method for solving the problem is proposed, the distinguishing feature of which is the use of the mathematical apparatus of the algebra’s covers. The features and advantages of the method are illustrated by the example of the problem of monitoring the errors of IT system operators.

$\mathcal k$-branching uio sequences for partially specified observable non-deterministic fsms

In black-box testing, test sequences may be constructed from systems modelled as deterministic finite-state machines (DFSMs) or, more generally, observable non-deterministic finite state machines (ONFSMs). Test sequences usually contain state identification sequences, with unique input output sequences ( <small>UIOs</small> ) often being used with DFSMs. This paper extends the notion of <small>UIOs</small> to ONFSMs. One challenge is that, as a result of non-determinism, the application of an input sequence can lead to exponentially many expected output sequences. To address this scalability problem, we introduce <inline-formula><tex-math notation="LaTeX">${\mathcal K}$</tex-math></inline-formula> - <small>UIOs</small> : <small>UIOs</small> that lead to at most <inline-formula><tex-math notation="LaTeX">${\mathcal K}$</tex-math></inline-formula> output sequences from states of <inline-formula><tex-math notation="LaTeX">$M$</tex-math></inline-formula> . We show that checking <inline-formula><tex-math notation="LaTeX">${\mathcal K}$</tex-math></inline-formula> - <small>UIO</small> existence is PSPACE-Complete if the problem is suitably bounded; otherwise it is in EXPSPACE and PSPACE-Hard. We provide a massively parallel algorithm for constructing <inline-formula><tex-math notation="LaTeX">${\mathcal K}$</tex-math></inline-formula> - <small>UIOs</small> and the results of experiments on randomly generated and real FSM specifications. The proposed algorithm was able to construct <small>UIOs</small> in cases where the existing <small>UIO</small> generation algorithm could not and was able to construct <small>UIOs</small> from FSMs with 38K states and 400K transitions.

FSM quasi-equivalence testing via reduction and observing absences

There has been significant interest in automatically generating test cases from a non-deterministic finite state machine (FSM). Most approaches check that the behaviours of the system under test (SUT) are allowed by the specification FSM; they therefore test for reduction . However, sometimes one wants all of the behaviours, and so features, of the specification to be implemented and then one is testing for equivalence . In this paper we first note that in order to test for equivalence one must effectively be able to observe the SUT not being able to produce an output y in response to an input x after trace σ ¯ ; we model this as the absence of an output. We prove that the problem of testing for equivalence to FSM M can be mapped to testing for reduction to an FSM R ( M ) that extends M with absences. Thus, one can use techniques developed for testing for reduction when testing for equivalence. We then consider the case where the specification is partial, generalising the result to quasi-equivalence. These results are proved for observable specifications and so we also show how a partial FSM can be mapped to an observable partial FSM from which we can test. • Generalises quasi-reduction and quasi-equivalence to non-observable FSMs. • Any technique, for testing for reduction, can be used for testing for quasi-equivalence. • A partial FSM can be mapped to an observable partial FSM.

A Generalized Method for Synthesizing Multicomponent Interoperable Structures Based on Ontology and a Nondeterministic Finite State Machine

A Generalized Method for Synthesizing Multicomponent Interoperable Structures Based on Ontology and a Nondeterministic Finite State Machine

FSM abstraction based method for deriving test suites with guaranteed fault coverage against nondeterministic Finite State Machines with timed guards and timeouts

Finite State Machine (FSM) based approaches are widely used for deriving tests with guaranteed fault coverage for discrete event systems and as the behavior of many nowadays information and control systems depends on time, classical FSMs are extended by clock variables. Moreover, optionality in the real system’s specifications motivates the studying test derivation against models with the nondeterministic behavior. In this paper, we adapt classical FSM based test derivation methods for nondeterministic FSMs with timed guards and timeouts (TFSMs). We show that unlike classical FSM conformance relation, the check cannot be reduced to checking the correspondence between TFSMs transitions and this violates the main principle of FSM based test derivation methods. Respectively, a proposed approach and the appropriate fault model are based on the FSM abstraction of the given TFSM specification that is used to adequately describe the behavior of a TFSM. The fault domain contains TFSMs with the known upper boundary on the number of FSM abstraction states and allows to avoid explicit enumeration of implementations under test. We study properties of the FSM abstraction for a nondeterministic TFSM and justify that the use of an FSM abstraction allows to adapt classical FSM based test derivation methods when deriving tests with guaranteed fault coverage for TFSMs. A method is proposed for deriving a complete test suite for a complete possibly nondeterministic TFSM when an implementation under test is a deterministic complete TFSM.

Incremental and Heuristic Approaches for Deriving Adaptive Distinguishing Test Cases for Non-deterministic Finite-State Machines

A Master of Science thesis in Computer Engineering by Ayat Saleh entitled, Incremental and Heuristic Algorithms for Deriving Adaptive Distinguishing Test Cases for Nondeterministic Finite State Machines, submitted in September 2017. Thesis advisor is Dr. Khaled El-Fakih. Soft and hard copy available.

Technique of Monitoring a Human Operator’s Behavior in Man-Machine Systems

Monitoring a human operator’s behavior in man-machine systems is aimed at detecting and diagnosing unwanted behavioral deviations of a human operator from the preset sequence of actions, taking into account their possible response to the current state of the system. The human operator’s behavior is described using the nondeterministic finite-state machine (FSM) model. Techniques for constructing and determinizating this model are proposed to ensure the minimal possible loss of information. The solution of the task is illustrated by the example of working IT system operators.

Adaptive distinguishing test cases of nondeterministic finite state machines: test case derivation and length estimation

Abstract A top-down approach is presented for checking the existence and derivation of an adaptive distinguishing test case (called also an adaptive distinguishing sequence) for a nondeterministic finite state machine (NDFSM). When such a test case exists, the method returns a canonical test case that includes all other distinguishing tests of the given complete observable NDFSM. In the second part of the paper, a constructive approach is provided for deriving a class of complete observable NDFSMs with n states, n &gt; 2, and 2 n − n − 1 inputs such that a shortest adaptive distinguishing test case for each NDFSM in the intended class has the length (height) 2 n − n − 1. In other words, we prove the reachability of the exponential upper bound on the length of a shortest adaptive distinguishing sequence for complete observable NDFSMs while for deterministic machines the upper bound is polynomial with respect to the number of states. For constructing the intended class of NDFSMs for a given n , we propose a special linear order over all the non-empty subsets without singletons of an n -element set. The obtained tight exponential upper bound initiates further research on identifying certain NDFSM classes where this upper bound is not reachable.

Влияние частичности и адаптивности на сложность задачи идентификации состояний автомата

State identification is a long standing problem in the area of Finite State Machine (FSM) based modeling and testing of discrete event systems. For the identification of the current state of the system, so-called homing and synchronizing experiments with FSMs are used whereas for the initial state identification one can perform a distinguishing experiment. The homing, synchronizing, and distinguishing experiments are known as “gedanken” experiments, and the sequences for these experiments can be derived for deterministic and nondeterministic, partial and complete specification FSMs that are used to formally represent the required behavior of systems under investigation. The problems of checking the existence and derivation of homing, synchronizing, and distinguishing sequences are known to become harder as a specification FSM turns to be nondeterministic and partial. It is also known that in some cases the complexity can be reduced through a ‘switch’ from preset to adaptive experiment derivation. In this paper, we study how the partiality and adaptivity affect the complexity of checking the existence of homing/synchronizing/distinguishing sequences for deterministic and nondeterministic FSMs and visualize the complexity issues via appropriate figures. We also mention that the existing solutions to state identification problems are widely used for verification and testing of finite state transition systems.

Testing Timed Nondeterministic Finite State Machines with the Guaranteed Fault Coverage

The behavior of many systems can be properly described by taking into account time constraints, and this motivates the adaptation of existing Finite State Machine (FSM)-based test derivation methods to timed models. In this paper, we propose a method for deriving conformance tests with the guaranteed fault coverage for a complete possibly nondeterministic FSM with a single clock; such Timed FSMs (TFSMs) are widely used when describing the behavior of software and digital devices. The fault domain contains every complete TFSM with the known upper bounds on the number of states and finite boundary of input time guards. The proposed method is carried out by using an appropriate FSM abstraction of the given TFSM; the test is derived against an FSM abstraction and contains timed input sequences. Shorter test suites can be derived for a restricted fault domain, for instance, for the case when the smallest duration of an input time guard is larger than two. Moreover, the obtained test suites can be reduced while preserving the completeness, when all input time guards of the specification and an implementation under test are right closed (or all guards are left-closed). Experiments are conducted to study the length of test suites constructed by different methods.

Testing from Partial Finite State Machines without Harmonised Traces

This paper concerns the problem of testing from a partial, possibly non-deterministic, finite state machine (FSM) ${\mathcal S}$ . Two notions of correctness (quasi-reduction and quasi-equivalence) have previously been defined for partial FSMs but these, and the corresponding test generation techniques, only apply to FSMs that have harmonised traces. We show how quasi-reduction and quasi-equivalence can be generalised to all partial FSMs. We also consider the problem of generating an $m$ -complete test suite from a partial FSM ${\mathcal S}$ : a test suite that is guaranteed to determine correctness as long as the system under test has no more than $m$ states. We prove that we can complete ${\mathcal S}$ to form a completely-specified non-deterministic FSM ${\mathcal S}^{\prime}$ such that any $m$ -complete test suite generated from ${\mathcal S}^{\prime}$ can be converted into an $m$ -complete test suite for ${\mathcal S}$ . We also show that there is a correspondence between test suites that are reduced for ${\mathcal S}$ and ${\mathcal S}^{\prime}$ and also that are minimal for ${\mathcal S}$ and ${\mathcal S}^{\prime}$ .

Parallel algorithms for reducing derivation time of distinguishing experiments for nondeterministic finite state machines

Many approaches have been proposed for deriving tests from finite state machine (FSM) specifications with respect to some established coverage criteria. A fundamental core problem in FSM-based testing relates to the derivation of input sequences that can distinguish states of an FSM specification, aka distinguishing sequences. A major effort in the construction of these sequences is based on the derivation of a successors search-tree labeled by sets of pairs of states of the given machine. We aim at reducing the time associated with such constructions through the use of state-of-the-art parallel technologies. Namely, we propose a parallel algorithm that we implement and evaluate on multicore CPUs and on many-core GPUs. We evaluate two alternative GPU implementations that use the CUDA and Thrust software platforms and a network of workstations based solution. The latter sports a workload partitioning based on Divisible Load Theory. A rigorous set of experiments highlights the differences of the proposed implementations in terms of execution time and speedup.

Parallel Algorithms for Generating Distinguishing Sequences for Observable Non-deterministic FSMs

A distinguishing sequence (DS) for a finite-state machine (FSM) is an input sequence that distinguishes every pair of states of the FSM. There are techniques that generate a test sequence with guaranteed fault detection power, and it has been found that shorter test sequences can be produced if DSs are used. Despite these benefits, however, until recently the only published DS generation algorithms have been for deterministic FSMs. This article develops a massively parallel algorithm, which can be used in Graphics Processing Units (GPUs) Computing, to generate DSs from partial observable non-deterministic FSMs. We also present the results of experiments using randomly generated FSMs and some benchmark FSMs. The results are promising and indicate that the proposed algorithm can derive DSs from partial observable non-deterministic FSMs with 32,000 states in an acceptable amount of time.

Testing Timed Nondeterministic Finite State Machines with the Guaranteed Fault Coverage

Nowadays, the behaviour of many systems can be properly described by taking into account time constraints, and this motivates the adaptation of existing Finite State Machine (FSM)- based test derivation methods to timed models. In this paper, we propose a method for deriving conformance tests with the guaranteed fault coverage for a complete possibly nondeterministic FSM with a single clock; such Timed FSMs (TFSMs) are widely used when describing the behaviour of software and digital devices. The fault domain contains every complete TFSM with the known upper bounds on the number of states and finite boundary of input time guards. The proposed method is carried out by using an appropriate FSM abstraction of the given TFSM; the test is derived against an FSM abstraction and contains timed input sequences. Shorter test suites can be derived for a restricted fault domain, for instance, for the case when the smallest duration of an input time guard is larger than two. Moreover, the obtained test suites can be reduced, while preserving the completeness, when all input time guards of the specification and an implementation are right closed (or all intervals are left closed). Experiments are conducted to study the length of test suites constructed by different methods.

Exploiting Evolutionary Modeling to Prevail in Iterated Prisoner’s Dilemma Tournaments

The iterated prisoner’s dilemma is a famous model of cooperation and conflict in game theory. Its origin can be traced back to the Cold War, and countless strategies for playing it have been proposed so far, either designed by hand or automatically generated by computers. In the 2000s, scholars started focusing on adaptive players, that is, able to classify their opponent’s behavior and adopt an effective counter-strategy. The player presented in this paper, pushes such idea even further: it builds a model of the current adversary from scratch, without relying on any pre-defined archetypes, and tweaks it as the game develops using an evolutionary algorithm; at the same time, it exploits the model to lead the game into the most favorable continuation. Models are compact nondeterministic finite state machines; they are extremely efficient in predicting opponents’ replies, without being completely correct by necessity. Experimental results show that such a player is able to win several one-to-one games against strong opponents taken from the literature, and that it consistently prevails in round-robin tournaments of different sizes.

Heuristics for deriving distinguishing experiments of nondeterministic finite state machines

Derivation of input sequences for distinguishing states of a finite state machine (FSM) specification is well studied in the context of FSM-based functional testing. We present three heuristics for the derivation of distinguishing sequences for nondeterministic FSM specifications. The first is based on a cost function that guides the derivation process and the second is a genetic algorithm that evolves a population of individuals of possible solutions (or input sequences) using a fitness function and a crossover operator specifically tailored for the considered problem. The third heuristic is a mutation based algorithm that considers a randomly generated input sequence as a candidate solution, and if the candidate is not a distinguishing sequence, then the algorithm tries to find a solution by appropriately mutating the considered candidate. Experiments are conducted to assess the performance of the considered algorithms with respect to execution time, virtual memory consumption, and quality (length) of obtained sequences. Experiments are conducted using randomly generated machines with a various number of states, inputs, outputs, and degrees of non-determinism. Further, we assess the impact of varying the number of states, inputs, outputs, and degree of non-determinism.

К синтезу адаптивных проверяющих последовательностей для недетерминированных автоматов

К синтезу адаптивных проверяющих последовательностей для недетерминированных автоматов