Using Constraints for Equivalent Mutant Detection

In mutation testing the question whether a mutant is equivalent to its program is important in order to compute the correct mutation score. Unfortunately, answering this question is not always possible and can hardly be obtained just by having a look at the program's structure. In this paper we introduce a method for solving the equivalent mutant problem using a constraint representation of the program and its mutant. In particularly the approach is based on distinguishing test cases, i.e., test inputs that force the program and its mutant to behave in a different way. Beside the foundations of the approach, in this paper we also present the algorithms and first empirical results.Comment: In Proceedings WS-FMDS 2012, arXiv:1207.184

Model selection and testing for an automated constraint modelling toolchain

Constraint Programming (CP) is a powerful technique for solving a variety of combinatorial problems. Automated modelling using a refinement based approach abstracts over modelling decisions in CP by allowing users to specify their problem in a high level specification language such as ESSENCE. This refinement process produces many models resulting from different choices that can be selected, each with their own strengths. A parameterised specification represents a problem class where the parameters of the class define the instance of the class we wish to solve. Since each model has different performance characteristics the model chosen is crucial to be able to solve the instance effectively. This thesis presents a method to generate instances automatically for the purpose of choosing a subset of the available models that have superior performance across the instance space. The second contribution of this thesis is a framework to automate the testing of a toolchain for automated modelling. This process includes a generator of test cases that covers all aspects of the ESSENCE specification language. This process utilises our first contribution namely instance generation to generate parameterised specifications. This framework can detect errors such as inconsistencies in the model produced during the refinement process. Once we have identified a specification that causes an error, this thesis presents our third contribution; a method for reducing the specification to a much simpler form, which still exhibits a similar error. Additionally this process can generate a set of complementary specifications including specifications that do not cause the error to help pinpoint the root cause

Automatically exploiting high-level problem structure in local-search

Constraint Programming is the study of modelling and solving complex combinatorial problems. Systematic-search and local-search are both well-researched approaches to solving constraint problems. Systematic-search exhaustively explores the entire search space and can be used to guarantee optimality, prove infeasibility or enumerate all possible solutions. Conversely, local-search is a heuristic-based approach to solving constraint problems. Often used in industrial applications, local-search is used to discover high-quality solutions quickly, usually sacrificing the ability to cover the entire search space. For this reason, it is preferred in applications where the scale of the problems being solved are beyond what can be feasibly searched using systematic methods. This work investigates methods of using information derived from high-level specifications of problems to augment the performance and scalability of local-search systems. Typically, abstract high-level constraint specifications or models are refined into lowlevel representations suitable for input to a constraint solver, erasing any knowledge of the specifications' high-level structures. We propose that whilst these lower-level models are equivalent in their description of the problems being solved, the original high-level specification, if retained, can be used to augment both the performance and scalability of local-search systems. In doing this, two approaches have been implemented and benchmarked. In the first approach, Structured Neighbourhood Search (SNS), a systematic solver is adapted to support declarative large neighbourhood search, using the high-level types such as sets, sequences and partitions in the original problem specification to automatically construct higher-quality, structured neighbourhoods. Our experiments demonstrate the performance of SNS when applied to structured problems. In the second approach, a novel constraint-based local-search solver is designed to operate on the high-level structures without refining these structures into lower-level representations. The new solver Athanor can directly instantiate and operate on the types in the Essence abstract specification language, supporting arbitrarily nested types such as sets of partitions, multi-sets of sequences and so on. Athanor retains the performance of SNS but boasts a unique benefit; on some classes of problems, the high-level solver is shown to be able to efficiently operate on instances that are too large for low-level solvers to even begin search

Streamlined constraint reasoning : an automated approach from high level constraint specifications

Constraint Programming (CP) is a powerful technique for solving large-scale combinatorial (optimisation) problems. Solving a problem proceeds in two distinct phases: modelling and solving. Effective modelling has a huge impact on the performance of the solving process. Even with the advance of modern automated modelling tools, search spaces involved can be so vast that problems can still be difficult to solve. To further constrain the model a more aggressive step that can be taken is the addition of streamliner constraints, which are not guaranteed to be sound but are designed to focus effort on a highly restricted but promising portion of the search space. Previously, producing effective streamlined models was a manual, difficult and time-consuming task. This thesis presents a completely automated process to the generation, search and selection of streamliner portfolios to produce a substantial reduction in search effort across a diverse range of problems. First, we propose a method for the generation and evaluation of streamliner conjectures automatically from the type structure present in an Essence specification. Second, the possible streamliner combinations are structured into a lattice and a multi-objective search method for searching the lattice of combinations and building a portfolio of streamliner combinations is defined. Third, the problem of "Streamliner Selection" is introduced which deals with selecting from the portfolio an effective streamliner for an unseen instance. The work is evaluated by presenting two sets of experiments on a variety of problem classes. Lastly, we explore the effect of model selection in the context of streamlined specifications and discuss the process of streamlining for Constrained Optimization Problems."This work was supported by: EPSRC funding award EP/N509759/1" -- Fundin

Automated iterative game design

Computational systems to model aspects of iterative game design were proposed, encompassing: game generation, sampling behaviors in a game, analyzing game behaviors for patterns, and iteratively altering a game design. Explicit models of the actions in games as planning operators allowed an intelligent system to reason about how actions and action sequences affect gameplay and to create new mechanics. Metrics to analyze differences in player strategies were presented and were able to identify flaws in game designs. An intelligent system learned design knowledge about gameplay and was able to reduce the number of design iterations needed during playtesting a game to achieve a design goal. Implications for how intelligent systems augment and automate human game design practices are discussed.Ph.D

Computer Aided Verification

The open access two-volume set LNCS 11561 and 11562 constitutes the refereed proceedings of the 31st International Conference on Computer Aided Verification, CAV 2019, held in New York City, USA, in July 2019. The 52 full papers presented together with 13 tool papers and 2 case studies, were carefully reviewed and selected from 258 submissions. The papers were organized in the following topical sections: Part I: automata and timed systems; security and hyperproperties; synthesis; model checking; cyber-physical systems and machine learning; probabilistic systems, runtime techniques; dynamical, hybrid, and reactive systems; Part II: logics, decision procedures; and solvers; numerical programs; verification; distributed systems and networks; verification and invariants; and concurrency

A numerical method for fluid-structure interactions of slender rods in turbulent flow

This thesis presents a numerical method for the simulation of fluid-structure interaction (FSI) problems on high-performance computers. The proposed method is specifically tailored to interactions between Newtonian fluids and a large number of slender viscoelastic structures, the latter being modeled as Cosserat rods. From a numerical point of view, such kind of FSI requires special techniques to reach numerical stability. When using a partitioned fluid-structure coupling approach this is usually achieved by an iterative procedure, which drastically increases the computational effort. In the present work, an alternative coupling approach is developed based on an immersed boundary method (IBM). It is unconditionally stable and exempt from any global iteration between the fluid part and the structure part. The proposed FSI solver is employed to simulate the flow over a dense layer of vegetation elements, usually designated as canopy flow. The abstracted canopy model used in the simulation consists of 800 strip-shaped blades, which is the largest canopy-resolving simulation of this type done so far. To gain a deeper understanding of the physics of aquatic canopy flows the simulation data obtained are analyzed, e.g., concerning the existence and shape of coherent structures

Programming with Specifications

This thesis explores the use of specifications for the construction of correct programs. We go beyond their standard use as run-time assertions, and present algorithms, techniques and implementations for the tasks of 1) program verification, 2) declarative programming and 3) software synthesis. These results are made possible by our advances in the domains of decision procedure design and implementation. In the first part of this thesis, we present a decidability result for a class of logics that support user-defined recursive function definitions. Constraints in this class can encode expressive properties of recursive data structures, such as sortedness of a list, or balancing of a search tree. As a result, complex verification conditions can be stated concisely and solved entirely automatically. We also present a new decision procedure for a logic to reason about sets and constraints over their cardinalities. The key insight lies in a technique to decompose con- straints according to mutual dependencies. Compared to previous techniques, our algorithm brings significant improvements in running times, and for the first time integrates reasoning about cardinalities within the popular DPLL(T ) setting. We integrated our algorithmic ad- vances into Leon, a static analyzer for functional programs. Leon can reason about constraints involving arbitrary recursive function definitions, and has the desirable theoretical property that it will always find counter-examples to assertions that do not hold. We illustrate the flexibility and efficiency of Leon through experimental evaluation, where we used it to prove detailed correctness properties of data structure implementations. We then illustrate how program specifications can be used as a high-level programming construct ; we present Kaplan, an extension of Scala with first-class logical constraints. Kaplan allows programmers to create, manipulate and combine constraints as they would any other data structure. Our implementation of Kaplan illustrates how declarative programming can be incorporated into an existing mainstream programming language. Moreover, we examine techniques to transform, at compile-time, program specifications into efficient executable code. This approach of software synthesis combines the correctness benefits of declarative programming with the efficiency of imperative or functional programming