Efficient Reasoning for Nogoods in Constraint Solvers with BDDs

Abstract. When BDDs are used for propagation in a constraint solver with nogood recording, it is necessary to find a small subset of a given set of variable assignments that is enough for a BDD to imply a new variable assignment. We show that the task of finding such a minimum subset is NP-complete by reduction from the hitting set problem. We present a new algorithm for finding such a minimal subset, which runs in time linear in the size of the BDD representation. In our experiments, the new method is up to ten times faster than the previous method, thereby reducing the solution time by even more than 80%. Due to linear time complexity the new method is able to scale well.

On Exploiting Structures for Constraint Solving

The constraint satisfaction problem (CSP) instances modeling problems occurring in practice often have structures which can be exploited to speed-up the constraint solving process. This thesis explores the exploitation of three such structures. The three structures explored in this thesis are: 1. Tree-like relationships: Several CSP instances have tree-like relationships between the variables in them. Such a relationship can be observed by using the tree-width parameter. Given a CSP instance with low tree-width, implying close to tree-like relationship, a treedecomposition of the instance could be used to speed-up the constraint solving process. 2. Compact BDD representation: For some finite-domain constraint problem instances, the solutions of each constraint in those instances might be represented by a compact Binary Decision Diagram (BDD). In which case, it is advantageous to represent the constraints using BDDs

NiVER: Non Increasing Variable Elimination Resolution for Preprocessing SAT instances

The original algorithm for the SAT problem, Variable Elimination Resolution (VER/DP) has exponential space complexity. To tackle that, the backtracking based DPLL procedure [2] is used in SAT solvers. We present a combination of both of the techniques. We use NiVER, a special case of VER, to eliminate some variables in a preprocessing step and then solve the simplified problem using a DPLL SAT solver. NiVER is a strictly formula size not increasing resolution based preprocessor. Best worst-case upper bounds for general SAT solving (arbitrary clause length) in terms of N (Number of variables), K (Number of clauses) and L (Literal count) are 2 , respectively [14]. In the experiments, NiVER resulted in upto 74% decrease in N , 58% decrease in K and 46% decrease in L. In many real life instances, we observed that most of the resolvents for several variables are tautologies. There will be no increase in space due to VER on them. Hence, despite its simplicity, NiVER does result in easier instances. In most of the cases, NiVER takes less than one second for preprocessing. In case NiVER removable variables are not present, due to very low overhead, the cost of NiVER is insignificant. We also study the e#ect of combining NiVER with HyPre [3], a preprocessor based on hyper binary resolution. Based on experimental results, we classify the SAT instances into 4 classes. NiVER consistently performs well in all those classes and hence can be incorporated into all general purpose SAT solvers

Integrating a Variable Ordering Heuristic with BDDs and CSP Decomposition Techniques for Interactive Configurators

The Binary Decision Diagram (BDD) based compilation schemes are quite suitable for representing configuration knowledge bases. It is well-known that the size of BDDs are very sensitive to the variable order. In this paper, we study the variable ordering problem of BDDs when they represent a configuration knowledge. Such a study is crucial to better understand the BDD-based compilation schemes. We introduce a small variant of a classical variable ordering heuristic, that proves empirically useful. It is surprising since such a heuristic is known to fail when BDDs are used in formalverification. We show that a compilation scheme using CSP tree-decomposition is less dependent on the variable order. We also show that, for a good variable order the benefit of tree-decomposition, which reduces space, can drastically diminish

Linear functions for interactive configuration using join matching and CSP tree decomposition

Quick responses are required for interactive configuration. For this an ideal interactive configurator needs to provide the functionalities required for interactive configuration with at most linear time complexity. In this paper, we present such a data structure called Join Matched CSP (JMCSP). When a JMCSP is used to represent a configuration problem, the functionalities required for interactive configuration can be obtained with linear time complexity. Unlike the tree-of-BDDs [Subbarayan, 2005], the JMCSPs while taking advantage of treedecomposition also provide linear configuration functions. Although obtaining a JMCSP is exponential in the tree-width of the input configuration problem, due to tree-like hierarchical nature of configuration problems, this is typically feasible. We present the JMCSP compilation process along with the linear interactive configuration functions on it. The linear functionalities provided by the JMCSPs include computation of all minimum explanations.

On Hybrid SAT Solving Using Tree Decompositions and BDDs

The goal of this paper is to study the benefits of hybridizing the CNF SAT Solvers with BDDs. Towards this we define a metric for the level of hybridization based on a tree decomposition of an input CNF. We also present a new linear time algorithm on BDDs, which is useful for efficient conflict analysis in any BDD-based hybrid SAT solver. Experiments on an implementation of our hybrid solver shows when to use such a hybridization

Knowledge Compilation Properties of Tree-of-BDDs

We present a CNF to Tree-of-BDDs (ToB) compiler with complexity at most exponential in the tree width. We then present algorithms for interesting queries on ToB. Although some of the presented query algorithms are in the worst case exponential in the tree width, our experiments show that ToB can answer non-trivial queries like clausal entailment in reasonable time for several realistic instances. While our ToB-tool compiles all the used 91 instances, d-DNNF compilation failed for 12 or 8 of them based on the decomposition heuristic used. Also, on the succeeded instances, a d-DNNF is up to 1000 times larger than the matching ToB. The ToB compilations are often an order of magnitude faster than the d-DNNF compilation. This makes ToB a quite interesting knowledge compilation form

Comparing Two Implementations of a Complete and Backtrack-Free Interactive Configurator

A product configurator should be complete and backtrack free in the sense that the user can choose freely between any valid configuration and will be prevented from making choices that no valid configuration satisfies. In this paper, we experimentally evaluate a symbolic and search-based implementation of an interactive product configuration algorithm with these properties. Our results show that the symbolic approach often has several orders of magnitude faster response time than the search-based approach due to the precompilation of a symbolic representation of the solution space. Moreover, the difference between the average and worst response time for the symbolic approach is typically within a factor of two, whereas it for the search-based approach may be more than two orders of magnitude