Raluca Lefticaru

Automatic State-Based Test Generation Using Genetic Algorithms

Although a lot of research has been done in the field of state-based testing, the automatic generation of test cases from a functional specification in the form of a state machine is not straightforward. This paper investigates the use of genetic algorithms in test data generation for the chosen paths in the state machine, so that the input parameters provided to the methods trigger the specified transitions.

Functional Search-based Testing from State Machines

The application of metaheuristic search techniques in test data generation has been extensively investigated in recent years. Most studies, however, have concentrated on the application of such techniques in structural testing. The use of search-based techniques in functional testing is less frequent, the main cause being the implicit nature of the specification. This paper investigates the use of search-based techniques for functional testing, having the specification in form of a state machine. Its purpose is to generate input data for chosen paths in a state machine, so that the parameter values provided to the methods satisfy the corresponding guards and trigger the desired transitions. A general form of a fitness function for an individual path is presented and this approach is empirically evaluated using three search techniques: simulated annealing, genetic algorithms and particle swarm optimization.

3-Col problem modelling using simple kernel P systems

This paper presents the newly introduced class of (simple) kernel P systems ((s)kP systems) and investigates through a 3-colouring problem case study the expressive power and efficiency of kernel P systems. It describes two skP systems that model the problem and analyses them in terms of efficiency and complexity. The skP models prove to be more succinct (in terms of number of rules, objects, number of cells and execution steps) than the corresponding tissue P system, available in the literature, that solves the same problem, at the expense of a greater length of the rules.

FORMAL VERIFICATION OF P SYSTEMS USING SPIN

This paper presents an approach to P system verification using the Spin model checker. It proposes a P system implementation in PROMELA, the modeling language accepted by SPIN. It also provides the theoretical background for transforming the temporal logic properties expressed for the P system into properties of the executable implementation. Furthermore, a comparison between P systems verification using SPIN and NUSMV is realized. The results obtained show that the PROMELA implementation is more adequate, especially for verifying more complex models, such as P systems that model ecosystems.

Model Checking Kernel P Systems

Recent research in membrane computing examines and confirms the anticipated modelling potential of kernel P systems in several case studies. On the one hand, this computational model is destined to be an abstract archetype which advocates the unity and integrity of P systems onto a single formalism. On the other hand, this envisaged convergence is conceived at the expense of a vast set of primitives and intricate semantics, an exigent context when considering the development of simulation and verification methodologies and tools. Encouraged and guided by the success and steady progress of similar undertakings, in this paper we directly address the issue of formal verification of kernel P systems by means of model checking and unveil a software framework, kpWorkbench, which integrates a set of related tools in support of our approach. A case study that centres around the well known Subset Sum problem progressively demonstrates each stage of the proposed methodology: expressing a kP system model in recently introduced kP-Lingua; the automatic translation of this model into a Promela (Spin) specification; the assisted, interactive construction of a set of LTL properties based on natural language patterns; and finally, the formal verification of these properties against the converted model, using the Spin model checker.

Test Generation from P Systems Using Model Checking

Abstract This paper presents some testing approaches based on model checking and using different testing criteria. First, test sets are built from different Kripke structure representations. Second, various rule coverage criteria for transitional, non-deterministic, cell-like P systems, are considered in order to generate adequate test sets. Rule based coverage criteria (simple rule coverage, context-dependent rule coverage and variants) are defined and, for each criterion, a set of LTL (Linear Temporal Logic) formulas is provided. A codification of a P system as a Kripke structure and the sets of LTL properties are used in test generation: for each criterion, test cases are obtained from the counterexamples of the associated LTL formulas, which are automatically generated from the Kripke structure codification of the P system. The method is illustrated with an implementation using a specific model checker, NuSMV.

A particle swarm optimization based on P systems

This paper presents a novel membrane algorithm, called particle swarm optimization based on P systems (PSOPS), which combines P systems and particle swarm optimization. The PSOPS uses the representation of individuals, evolutionary rules of particle swarm optimization, and a hierarchical membrane structure and transformation or communication-like rules in P systems to design its algorithm. Experiments conducted on seven bench function optimization problems and time-frequency atom decomposition demonstrate the effectiveness and practicality of the introduced method.

Kernel P Systems: Applications and Implementations

This paper explores the modelling capacities of a new class of P systems, called kernel P systems (kP systems). A specific language for describing kP systems and its translation into Promela, the specification language of Spin, are described. This Promela specification has been further used for simulation and property verification with the Spin model checker. Also, a parallel implementation on GPU parallel architectures, realized using CUDA, is presented and the results are compared with the ones obtained using Promela and Spin. A case study, namely the Subset sum problem, which has been modelled with kernel P systems and further implemented in Promela is presented.

An integrated approach to P systems formal verification

This paper presents a method to formally verify P system specifications by first identifying invariants and then checking them, using the NuSMV model checker, against a Kripke structure representation. The method is applied to a basic class of P systems with transformation and communication rules using either maximal parallelism or asynchronous rewriting strategy and for a special variant of P systems with electrical charges, but without active membranes.

Using Genetic Algorithms and Model Checking for P Systems Automatic Design

Membrane computing is a recently developed research field, whose models, P systems, are bio-inspired computational models, abstracted from the structure and the functioning of living cells. Their applications are various and have been reported in biology, bio-medicine, economics, approximate optimization and computer graphics. However, it is a difficult task to design a P system which solves a given problem, especially because of their characteristics, such as nondeterminism, parallelism, possible presence of active membranes. In this paper we propose an approach to P systems automatic design, which uses genetic algorithms and model checking. More precisely, we use a type of fitness function which performs several simulations of the P system, in order to assess its adequacy to realize the given task, complemented by formal verification of the model.