Reduced State Space Research Articles

2D Mixture Fraction Studies in a Hot-Jet Ignition Configuration Using NO-LIF and Correlation Analysis

The problem of measuring mixture fraction (defined here as the fractional part of mass originating from the exhaust gas jet) during the mixing of an unsteady hot exhaust gas jet impinging into a quiescent premixed hydrogen/air mixture is addressed. The diagnostic method is based on planar Laser-Induced Fluorescence of nitric oxide (NO) that is seeded to the hot jet and used as a tag for mixture fraction. The research work presented in this paper focusses on the analytical and experimental data employed for the estimation of mixture fraction using NO as a tracer. Since the NO LIF-signal does not solely depend on the amount of NO, but also on temperature and overall chemical composition, additional information is normally required to transform LIF-signals into mixture fraction values. To provide this additional information, the concept of reduced state spaces is applied: Correlations between state variables (temperature and species) are exploited to establish relationships between the measured signal and the mixture fraction. Simple numerical model simulations are used in combination with spectroscopic calculations to check for correlations between NO-LIF signal and mixture fraction. The result is that sharp correlations between NO-LIF signals and mixture fraction exist, provided that chemical reactions have not yet significantly influenced the flow. These correlations display only little sensitivity with respect to changes of the jet temperature, amount of NO seeded to the jet, and jet velocity. Measurements of NO-LIF were then performed for a non-reacting case before ignition, and mixture fraction maps were obtained from the measured LIF-signals by exploiting the correlations. The resulting data reveal the different driving forces behind mixing at regions near to the jet tip and at the radial shear layers.

Quantitative evaluation of time-dependent Petri nets and applications to biochemical networks

Time Petri nets (TPN) are a well-known extension of standard Petri nets, where each transition gets a continuous time interval, specifying the range of the transition's firing time. In contrast, Timed Petri nets are a different time-dependent extension where a time duration is associated with each transition. We sketch a locally defined transformation from a Timed into a Time Petri net. Additionally, we consider time-dependent Petri nets, where the firing of each transition lasts a certain time which is limited by both a lower and an upper bound. These nets can also be transformed locally into TPN and are used in this paper for modelling and analysing biochemical systems, and we present algorithms allowing their quantitative analyses. We consider algorithms which work for arbitrary systems, i.e., bounded as well as unbounded ones, and algorithms, which are suitable for bounded systems only. The crucial point is the state space reduction, which exploits basically two ideas: parametric state description and discretisation of the state space. Altogether, we introduce eight problems, characterised by their input/ output relation. A sketch of the solution idea as well as possible application scenarios to evaluate biochemical systems are given, too.

Application of static analyses for state-space reduction to the microcontroller binary code

This paper describes the application of two abstraction techniques, namely dead variable reduction and path reduction, to the microcontroller binary code in order to tackle the state-explosion problem in model checking. These abstraction techniques are based on static analyses, which have to cope with the peculiarities of the binary code such as hardware dependencies, interrupts, recursion, and globally accessible memory locations. An interprocedural static analysis framework is presented that handles these peculiarities. Based on this framework, extensions of dead variable reduction and path reduction are detailed. A case study using several microcontroller programs is presented in order to demonstrate the efficiency of the described abstraction techniques.

Action Prefixes: Reified Synchronization Paths in Minimal Component Interaction Automata

Component Interaction Automata provide a fitting model to capture and analyze the temporal facets of hierarchical-structured component-oriented software systems. However, the rules governing composition, as is typical for all automata-based approaches, suffer from combinatorial state explosion, an effect that can have significant ramifications on the successful application of the Component Interaction Automata formalism to real-world scenarios. We must, therefore, find some appropriate means to counteract state explosion – one of which is partition refinement through weak bisimulation. But, while this technique can yield the desired state space reduction, it does not consider synchronization cliques, i.e., groups of states that are interconnected solely by internal synchronization transitions. Synchronization cliques give rise to action prefixes that capture pre-conditions for a component's ability to interact with the environment. Current practice does not pay attention to these cliques, but ignoring them can result in a loss of valuable information. For this reason we show, in this paper, how synchronization cliques emerge and how we can capture their behavior in order to make state space reduction aware of the presence of synchronization cliques.

A state space augmentation algorithm for the replenishment cycle inventory policy

In this work we propose an efficient dynamic programming approach for computing replenishment cycle policy parameters under non-stationary stochastic demand and service level constraints. The replenishment cycle policy is a popular inventory control policy typically employed for dampening planning instability. The approach proposed in this work achieves a significant computational efficiency and it can solve any relevant size instance in trivial time. Our method exploits the well known concept of state space relaxation. A filtering procedure and an augmenting procedure for the state space graph are proposed. Starting from a relaxed state space graph our method tries to remove provably suboptimal arcs and states (filtering) and then it tries to efficiently build up (augmenting) a reduced state space graph representing the original problem. Our experimental results show that the filtering procedure and the augmenting procedure often generate a small filtered state space graph, which can be easily processed using dynamic programming in order to produce a solution for the original problem.

Modular Model Checking of Large Asynchronous Designs with Efficient Abstraction Refinement

Divide-and-conquer is essential to address state explosion in model checking. Verifying each individual component in a system, in isolation, efficiently requires an appropriate context, which traditionally is obtained by hand. This paper presents an efficient modular model checking approach for asynchronous design verification. It is equipped with a novel abstraction refinement method that can refine a component abstraction to be accurate enough for successful verification. It is fully automated, and eliminates the need of finding an accurate context when verifying each individual component, although such a context is still highly desirable. This method is also enhanced with additional state space reduction techniques. The experiments on several nontrivial asynchronous designs show that this method efficiently removes impossible behaviors from each component including ones violating correctness requirements.

Model-Driven System Capacity Planning under Workload Burstiness

In this paper, we define and study a new class of capacity planning models called MAP queueing networks. MAP queueing networks provide the first analytical methodology to describe and predict accurately the performance of complex systems operating under bursty workloads, such as multitier architectures or storage arrays. Burstiness is a feature that significantly degrades system performance and that cannot be captured explicitly by existing capacity planning models. MAP queueing networks address this limitation by describing computer systems as closed networks of servers whose service times are Markovian Arrival Processes (MAPs), a class of Markov-modulated point processes that can model general distributions and burstiness. In this paper, we show that MAP queueing networks provide reliable performance predictions even if the service processes are bursty. We propose a methodology to solve MAP queueing networks by two state space transformations, which we call Linear Reduction (LR) and Quadratic Reduction (QR). These transformations dramatically decrease the number of states in the underlying Markov chain of the queueing network model. From these reduced state spaces, we obtain two classes of bounds on arbitrary performance indexes, e.g., throughput, response time, and utilizations. Numerical experiments show that LR and QR bounds achieve good accuracy. We also illustrate the high effectiveness of the LR and QR bounds in the performance analysis of a real multitier architecture subject to TPC-W workloads that are characterized as bursty. These results promote MAP queueing networks as a new class of robust capacity planning models.

Correct Execution of Reconfiguration for Stateful Components

In component-based software engineering, reconfiguration describes structural changes to the architecture of a component system. For stateful components, not only structural but also behavioural aspects have to be taken into account in reconfiguration. We present a procedure to conduct reconfiguration in systems of concurrent, stateful components that interferes as little as possible with unchanged subsystems. Reconfiguration is described by a plan for adding, deleting and reconnecting components. A plan is executed by a sequence of simple, local steps, which are suitable for implementation in a programming language. We prove that plan execution is indistinguishable from atomic reconfiguration and use this fact for state-space reduction for verifying properties by model checking.

Conditioning for State Space Reduction in Program Model Checking

Conditioning for State Space Reduction in Program Model Checking

Vector Symmetry Reduction

Symmetry reduction is an effective state-space reduction technique for model checking, and works by restricting search to equivalence class representatives with respect to a group of symmetries for a model. A major problem with symmetry reduction techniques is the time taken to compute the representative of a state, which can be prohibitive. In efficient implementations of symmetry reduction, a symmetry is applied to a state as a sequence of operations which swap component identities. We show that vector processing technology, common to modern computers, can be used to implement a vectorised swap operation, which can be incorporated into the representative computation algorithm to accelerate symmetry reduction. Via a worked example, we present details of this vector symmetry reduction method. We have implemented our techniques in the TopSpin symmetry reduction package for the Spin model checker, and present experimental results showing the speedups obtained via vectorisation for two case-studies running on a PowerPC vector processor.

An intruder model with message inspection for model checking security protocols

Model checking security protocols is based on an intruder model that represents the eavesdropping or interception of the exchanged messages, while at the same time performs attack actions against the ongoing protocol session(s). Any attempt to enumerate all messages that can be deduced by the intruder and the possible actions in all protocol steps results in an enormous branching of the model's state-space. In current work, we introduce a new intruder model that can be exploited for state-space reduction, optionally in combination with known techniques, such as partial order and symmetry reduction. The proposed intruder modeling approach called Message Inspection (MI) is based on enhancing the intruder's knowledge with metadata for the exchanged messages. In a preliminary simulation run, the intruder tags the analyzed messages with protocol-specific values for a set of predefined parameters. This metadata is used to identify possible attack actions, for which it is a priori known that they cannot cause a security violation. The MI algorithm selects attack actions that can be discarded, from an open-ended base of primitive attack actions. Thus, model checking focuses only on attack actions that may disclose a security violation. The most interesting consequence is a non-negligible state-space pruning, but at the same time our approach also allows customizing the behavior of the intruder model, in order e.g. to make it appropriate for model checking problems that involve liveness. We provide experimental results obtained with the SPIN model checker, for the Needham–Schroeder security protocol.

Property-based Slicing for Agent Verification

Programming languages designed specifically for multi-agent systems represent a new programming paradigm that has gained popularity over recent years, with some multi-agent programming languages being used in increasingly sophisticated applications, often in critical areas. To support this, we have developed a set of tools to allow the use of model-checking techniques in the verification of systems directly implemented in one particular language called AgentSpeak. The success of model checking as a verification technique for large software systems is dependent partly on its use in combination with various state-space reduction techniques, an important example of which is property-based slicing. This article introduces an algorithm for property-based slicing of AgentSpeak multi-agent systems. The algorithm uses literal dependence graphs, as developed for slicing logic programs, and generates a program slice whose state space is stuttering-equivalent to that of the original program; the slicing criterion is a property in a logic with LTL operators and (shallow) BDI modalities. In addition to showing correctness and characterizing the complexity of the slicing algorithm, we apply it to an AgentSpeak program based on autonomous planetary exploration rovers, and we discuss how slicing reduces the model-checking state space. The experiment results show a significant reduction in the state space required for model checking that agent, thus indicating that this approach can have an important impact on the future practicality of agent verification.

Combining Techniques to Reduce State Space and Prove Strong Properties

An on-the-fly symmetry reduction technique that exploits the lexicographic order on metarepresentations of Maude terms, and a technique that uses auxiliary data to verify strong properties that are not directly expressible in propositional temporal logic are presented. Both are implemented by simple transformations of rewrite theories. They are applied in the verification of a strong-consistency property of a client-server protocol, a simplification of the Chain-Replication protocol.

Equational Abstractions for Reducing the State Space of Rewrite Theories

The combinatorial explosion of state spaces is the biggest problem in applying model checking methods to concurrent systems. In this paper we present a new state-space reduction technique that is tailored to system specifications in Rewriting Logic, a unified semantic framework for concurrency which is based on conditional term rewriting modulo equational theories. The idea is to hide “unimportant” details of the system's behavior (such as internal computations) in the equations, and to represent only “interesting” state changes (such as communication operations) by explicit transitions. We show how this optimization can be implemented by transforming the Rewriting Logic specification, avoiding the construction of the full state space. Moreover we establish the correctness of our technique by proving that the original and the reduced system are weakly bisimilar, and demonstrate its usability by applying it to the concurrent functional programming language Erlang.

Lagrangian relaxation with cut generation for hybrid flowshop scheduling problems to minimize the total weighted tardiness

In this paper, we address a new Lagrangian relaxation (LR) method for solving the hybrid flowshop scheduling problem to minimize the total weighted tardiness. For the conventional LR, the problem relaxing machine capacity constraints can be decomposed into individual job-level subproblems which can be solved by dynamic programming. The Lagrangian dual problem is solved by the subgradient method. In this paper, a Lagrangian relaxation with cut generation is proposed to improve the Lagrangian bounds for the conventional LR. The lower bound is strengthened by imposing additional constraints for the relaxed problem. The state space reductions for dynamic programming for subproblems are also incorporated. Computational results demonstrate that the proposed method outperforms the conventional LR method without significantly increasing the total computing time.

Computation of Performance Bounds for Real-Time Systems Using Time Petri Nets

Time Petri nets (TPNs) have been widely used for the verification and validation of real-time systems during the software development process. Their quantitative analysis consists in applying enumerative techniques that suffer the well known state space explosion problem. To overcome this problem, several methods have been proposed in the literature, that either provide rules to obtain equivalent nets with a reduced state space or avoid the construction of the whole state space. In this paper, we propose a method that consists in computing performance bounds to predict the average operational behavior of TPNs by exploiting their structural properties and by applying operational laws. Performance bound computation was first proposed for timed (Timed PNs) and stochastic Petri nets (SPNs). We generalize the results obtained for Timed PNs and SPNs to make the technique applicable to TPNs and their extended stochastic versions: TPN with firing frequency intervals (TPNFs) and extended TPNs (XTPNs). Finally, we apply the proposed bounding techniques on the case study of a robot-control application taken from the literature.

Robust control of resistive wall modes using pseudospectra

A novel methodology to design robust feedback controllers for the stabilization of resistive wall modes (RWMs) in tokamaks is presented. A linear state space model is used that describes the system composed of the plasma, the resistive wall, the active coils and the magnetic field sensors. The full three-dimensional (3D) geometry of the wall and the coils is taken into account. The control system is represented by a parametrized matrix whose robust stability properties are optimized under variations of the parameters. To make the optimization process feasible, a reduced state space model is constructed by means of a novel technique involving an orthogonal projection. The orthogonality is essential to the robust stability concept used. The latter is based upon the idea of matrix pseudospectra and therefore accounts for the sensitivity of eigenvalues. Furthermore, the transient growth of perturbations is investigated. Namely, in some theoretically stable linear systems, initial perturbations can grow by large factors before they eventually decay, rendering them practically unstable.A detailed analysis of a simple, ITER-like test case provides the following general, conceptual insights into the RWM stabilization problem: (i) it is important to consider not only the eigenvalues themselves, but also their sensitivity, (ii) transient amplification might be an issue requiring consideration and (iii) the transient peak can be substantially reduced by a careful choice of the optimization objective and the sensor configuration.

Real-time state observers based on multibody models and the extended Kalman filter

This work is a preliminary study on the use of the extended Kalman filter (EKF) for the state estimation of multibody systems. The observers based on the EKF are described by first-order differential equations, with independent, non-constrained coordinates. Therefore, it should be investigated how to formulate the equations of motion of the multibody systems so that efficient, robust and accurate observers can be derived, which can serve to develop advanced real-time applications. In the paper, two options are considered: a state-space reduction method and the penalty method. Both methods are tested on a four-bar mechanism with a linear spring-damper. The results enable us to analyze the pros and cons of each method and provide clues for future research.

Automated Interface Refinement for Compositional Verification

Compositional verification is essential for verifying large systems. However, approximate environments are needed when verifying the constituent modules in a system. Effective compositional verification requires finding a simple but accurate over approximate environment for each module. Otherwise, many verification failures may be produced, therefore incurring high computational penalty for distinguishing the false failures from the real ones. This paper presents an automated method to refine the state space of each module within an over approximate environment. This method is sound as long as an over approximate environment is found for each module at the beginning of the verification process, and it has less restrictions on system partitioning. It is also coupled with several state-space reduction techniques for better results. Experiments of this method on several large asynchronous designs show promising results.

Application of the generalised ballot theorem for evaluation of performance in packet buffers with non-first in first out scheduling

Packet scheduling is a vital component to support different classes of service in all-packet networks. In classical queuing systems, the waiting-time performance of non-first in first out buffer scheduling systems could be predicted through the use of analysis. However, all-packet networks feature traffic patterns that do not conform to classical Poisson-like processes, and this greatly complicates the evaluation of their performance. Our novel approach to this problem is through a hybrid combination of analysis and simulation. The authors derive a combinatorial algorithm, using the generalised ballot theorem, which predicts waiting times for low-priority traffic. When this algorithm is combined with prior work on traffic aggregation, the authors achieve a significant reduction in the state space associated with the buffer under study. To numerically test this algorithm, the authors demonstrate its use in simulation, where state space and event count reduction is a fundamental requirement to ensure experiments complete in a timely fashion. Numerical results from these simulations show a very significant reduction in the number of events processed combined with improved state coverage. This is achieved while maintaining a highly accurate representation of packet delays compared with a conventional approach.