Automated String Constraints Solving for Programs Containing String Manipulation Functions

A guided local search with iterative ejections of bottleneck operations for the job shop scheduling problem

We study constraint satisfaction problems (CSPs) that are k-consistent in the sense that any k input constraints can be simultaneously satisfied. In this setting, we focus on constraint languages with a single binary constraint type. Such a constraint satisfaction problem is equivalent to the question whether there is a homomorphism from an input digraph G to a fixed target digraph H. The instance corresponding to G is k-consistent if every subgraph of G of size at most k is homomorphic to H. Let ρ k (H) be the largest ρ such that every k-consistent G contains a subgraph G′ of size at least ρ ∥ E(G)∥ that is homomorphic to H. The ratio ρ k (H) reflects the fraction of constraints of a k-consistent instance that can be always satisfied. We determine ρ k (H) for all digraphs H that are not acyclic and show that lim k→ ∞ ρ k (H) = 1 if and only if H has tree duality. In addition, for graphs H with tree duality, we design an algorithm that computes in linear time for a given input graph G either a homomorphism from almost the entire graph G to H, or a subgraph of G of bounded size that is not homomorphic to H.

Although Constraint Satisfaction Problems (CSPs) are generally known to be NP-complete, placing restrictions on the constraint template can yield tractable subclasses. By studying the operations in the polymorphism of the constraint language, we can construct algorithms which solve our CSP in polynomial time. Previous results for CSPs with Mal’tsev [7] and generalized majority-minority operations [10] were improved to include CSPs with k-edge operations [15]. We present an alternative method to solve k-edge CSPs by utilizing Boolean trees placing the problem in the class NC2 . We do this by arranging the logical formulas describing the CSP into a Boolean tree where each leaf represents a constraint in the CSP. We take the conjunction of the constraint formulas yielding partial solutions at every step until we are left with a solution set at the root of the tree which satisfies all of the constraints.

Constraint solving is one of the main challenges for symbolic execution. Caching is an effective mechanism to reduce the number of the solver invocations in symbolic execution and is adopted by many mainstream symbolic execution engines. However, caching can not perform well on all programs. How to improve caching’s effectiveness is challenging in general. In this work, we propose a partial solution-based caching method for improving caching’s effectiveness. Our key idea is to utilize the partial solutions inside the constraint solving to generate more cache entries. A partial solution may satisfy other constraints of symbolic execution. Hence, our partial solution-based caching method naturally improves the rate of cache hits. We have implemented our method on two mainstream symbolic executors (KLEE and Symbolic PathFinder) and two SMT solvers (STP and Z3). The results of extensive experiments on real-world benchmarks demonstrate that our method effectively increases the number of the explored paths in symbolic execution. Our caching method achieves 1.07x to 2.3x speedups for exploring the same amount of paths on different benchmarks.

A construction of timetabling is considered to be a computationally hard problem. The problem lies not only in NP-completeness, but also in a number of complicated interactions between different users. We present a system of automated timetabling (SAT), as a proposition for a global look at timetabling. It describes four tools for managing timetable. The constraint programming (CP) techniques were used for solving the problem. CP provides both declarativity and flexibility. Moreover it allows easily add a new constraint and model numerous specific constraints that are often encountered in such problems. Additional local search was incorporated into CP to allow effectively optimise timetable.

A symbolic algorithm for the case-split rule in solving word constraints with extensions

Software testing is an integral part of software development lifecycle. Lack of testing can often lead to disastrous consequences including lost of data, fortunes, and even lives. Despite its importance, current software testing practice lacks automation, and is still primarily based on highly manual processes from the generation of test cases up to the actual execution of the test. Although the emergence of helpful automated testing tools in the market is blooming, their adoptions are lacking as they do not adequately provide the right level abstraction and automation required by test engineers. JTst is a Java based automated unit testing tool that addresses some of the aforementioned issues. The main novel features are the fact that JTst automates the test preparation activities, facilitates the test data generation through recombination, and allows concurrent execution of test data, in order to encourage higher product quality at lower testing costs.

This paper investigates the use of abstract domains from Abstract Interpretation (AI) in the field of Constraint Programming (CP). CP solvers are generally very efficient on a specific constraint language, but can hardly be extended to tackle more general languages, both in terms of variable representation (discrete or continuous) and constraint type (global, arithmetic, etc.). For instance, linear constraints are usually solved with linear programming techniques, but non-linear ones have to be either linearized, reformulated or sent to an external solver. We approach this problem by adapting to CP a popular domain construction used to combine the power of several analyses in AI: the reduced product. We apply this product on two well-known abstract domains, Boxes and Polyhedra, that we lift to constraint solving. Finally we define general metrics for the quality of the solver results, and present a benchmark accordingly. Experiments show promising results and good performances.

Verification of softwarehardware hybrid systems is difficult because of the inter process communication, concurrency and synchronization and the configuration of processors. Multi-Processor Systems on Chip (MPSoC) are examples of such hybrid systems, targeted for embedded systems. We focus on the verification of MPSoC software (application running on MPSoC) and the system consisting of the application running on the MPSoC platform. We aim at generating test cases for verifying the software while overcoming the limitations of previous approaches. Metaheuristic approaches get blocked in local optima and constraint programming approaches are slow on complex programs, to satisfy given coverage criteria. We propose to combine metaheuristic and constraint programming solvers in a novel way: executing both the solvers sequentially and splitting and reducing the individual input variable domains. We also propose to generate test cases from the functional test objectives to check the proper functioning of the software running on the hardware platform. We report the results of the preliminary experiments.

Backtracking techniques for the job shop scheduling constraint satisfaction problem

The complexity of constraints is a major obstacle for constraint-based software verification. Automatic constraint solvers are fundamentally incomplete: input constraints often build on some undecidable theory or some theory the solver does not support. This paper proposes and evaluates several randomized solvers to address this issue. We compared the effectiveness of a symbolic solver (CVC3), a random solver, two heuristic search solvers, and seven hybrid solvers (i.e. mix of random, symbolic, and heuristic solvers). We evaluated the solvers on a benchmark generated with a concolic execution of 9 subjects. The performance of each solver was measured by its precision, which is the fraction of constraints that the solver can find solution out of the total number of constraints that some solver can find solution. As expected, symbolic solving subsumes the other approaches for the 4 subjects that only generate decidable constraints. For the remaining 5 subjects, which contain undecidable constraints, the hybrid solvers achieved the highest precision (fraction of constraints that a solver can find a solution out of the total number of satisfiable constraints). We also observed that the solvers were complementary, which suggests that one should alternate their use in iterations of a concolic execution driver.

This paper deals with testing of nondeterministic software systems. We assume that a model of the nondeterministic system is given by a directed graph with two kind of vertices: states and choice points. Choice points represent the nondeterministic behaviour of the implementation under test (IUT). Edges represent transitions. They have costs and probabilities. Test case generation in this setting amounts to generation of a game strategy. The two players are the testing tool (TT) and the IUT. The game explores the graph. The TT leads the IUT by selecting an edge at the state vertices. At the choice points the control goes to the IUT. A game strategy decides which edge should be taken by the TT in each state. This paper presents three novel algorithms 1) to determine an optimal strategy for the bounded reachability game, where optimality means maximizing the probability to reach any of the given final states from a given start state while at the same time minimizing the costs of traversal; 2) to determine a winning strategy for the bounded reachability game, which guarantees that given final vertices are reached, regardless how the IUT reacts; 3) to determine a fast converging edge covering strategy, which guarantees that the probability to cover all edges quickly converges to 1 if TT follows the strategy.

We introduce a new idea for enhancing constraint solving engines that drive many analysis and synthesis techniques that are powerful but have high complexity. Our insight is that in many cases the engines are run repeatedly against input constraints that encode problems that are related but of increasing complexity, and domain-specific knowledge can reduce the complexity. Moreover, even for one formula the engine may perform multiple expensive tasks with commonalities that can be estimated and exploited. We believe these relationships lay a foundation for making the engines more effective and scalable. We illustrate the viability of our idea in the context of a well-known solver for imperative constraints, and discuss how the idea generalizes to more general purpose methods.

In multi-agent problem-solving systems in which agents work asynchronously and in parallel on parts of a problem distributed among them, subproblem communication and integration protocols can have a major impact on problem solving efficiency. Transmitting too soon can necessitate having to take back transmitted partial solutions, wasting communication and processing time. Transmitting too late can complicate integration of partial solutions derived independently. The trade-off between these depends on the nature of the subproblem interdependency among the agents. We present a parameterized distributed constraint satisfaction problem (CSP) generator and a parameterized multi-agent problem-solving simulator: Using these tools, we offer some empirical observations of the tradeoff between strategies for subproblem communication timing. Our goal is to derive domain-independent answers to questions of subproblem sharing in multi-agent systems for problems that can be represented within the CSP paradigm.

Constrained scheduling problems are quite common in project management, manufacturing, distribution, transportation, logistics, supply chain management, software engineering, and computer networks etc. The need to use integer and binary decision variables representing the allocation of different resources to many activities and numerous specific, universal and additional constraints on these decision variables are typical components of the resource-constrained scheduling problems (RCSPs) modeling. It is often necessary to model additional resources and constraints. For these reasons, models are becoming computationally demanding. This is particularly noticeable when methods of operations research (mathematical programing (MP), network programing, and dynamic programming) are used. On the other hand, most RCPSs can be easily modeled as instances of the constraint satisfaction problems (CSPs) and solved using constraint programming (CP) methods. In contrast to the MP-based environment, the CP-based environment methods deal well with binary constraints but worse in optimization. Therefore, the hybrid approach based on integration mathematical programming and constraint logic programming to optimization resource-constrained scheduling problems has been proposed. To evaluate the applicability and computational efficiency of the proposed approach and its implementation programming framework, the illustrative examples of optimization resource-constrained scheduling problems are implemented separately for mathematical programming and hybrid method.