Showing papers on "Conjunctive normal form published in 2003"

Efficient CNF encoding of Boolean cardinality constraints

Abstract: In this paper, we address the encoding into CNF clauses of Boolean cardinality constraints that arise in many practical applications. The proposed encoding is efficient with respect to unit propagation, which is implemented in almost all complete CNF satisfiability solvers. We prove the practical efficiency of this encoding on some problems arising in discrete tomography that involve many cardinality constraints. This encoding is also used together with a trivial variable elimination in order to re-encode parity learning benchmarks so that a simple Davis and Putnam procedure can solve them.

Theorem Proving Using Lazy Proof Explication

Abstract: Many verification problems reduce to proving the validity of formulas involving both propositional connectives and domain-specific functions and predicates This paper presents an explicating theorem prover architecture that leverages recent advances in propositional SAT solving and the development of proof-generating domain-specific procedures We describe the implementation of an explicating prover based on this architecture that supports propositional logic, the theory of equality with uninterpreted function symbols, linear arithmetic, and the theory of arrays We have applied this prover to a range of processor, cache coherence, and timed automata verification problems We present experimental results on the performance of the prover, and on the performance impact of important design decisions in our implementation

Semidefinite Programs and Combinatorial Optimization

Abstract: Linear programming has been one of the most fundamental and successful tools in optimization and discrete mathematics. Its applications include exact and approximation algorithms, as well as structural results and estimates. The key point is that linear programs are very efficiently solvable, and have a powerful duality theory.

SAT-based unbounded symbolic model checking

Abstract: This paper describes a SAT-based unbounded symbolic model checking algorithm. BDDs have been widely used for symbolic model checking, but the approach suffers from memory overflow. The SAT procedure was exploited to overcome the problem, but it verified only the states reachable through a bounded number of transitions. The proposed algorithm deals with unbounded symbolic model checking. The proposed algorithm deals with unbounded symbolic model checking. The conjunctive normal form is used to represent sets of states and the transition relation, and a SAT procedure is modified to compute the existential quantification required in obtaining a pre-image. Some optimization techniques are exploited, and the depth first search method is used for efficient safety-property checking. Experimental results show the proposed algorithm can check more circuits than BDD-based symbolic model checking tools.

Shatter: efficient symmetry-breaking for Boolean satisfiability

Abstract: Boolean satisfiability (SAT) solvers have experienced dramatic improvements in their performance and scalability over the last several years according to E. Goldberg et al. (2002) and are now routinely used in diverse EDA applications. Nevertheless, a number of practical SAT instances remain difficult to solve in SAT 2002 Competition (http://www.satlive.org/SATCompetition/submittedbenchs.html) and continue to defy even the best available SAT solvers according to E. Goldberg et al. (2002). Recent work pointed out that symmetries in the Boolean search space are often to blame. A theoretical framework for detecting and breaking such symmetries was introduced in J. Crawford et al. (1996). This framework was subsequently extended, refined, and empirically shown to yield significant speed-ups for a large number of benchmark classes in F. Aloul et al. (2002). Symmetries in the search space are broken by adding appropriate symmetry-breaking predicates (SBPs) to a SAT instance in conjunctive normal form (CNF). The SBPs prune the search space by acting as a filter that confines the search to nonsymmetric regions of the space without affecting the satisfiability of the CNF formula. For symmetry breaking to be effective in practice, the computational overhead of generating and manipulating the SBPs must be significantly less than the run time savings they yield due to search space pruning. In this paper, we present several new constructions of SBPs that improve on previous work. Specifically, we give a linear-sized CNF formula that selects lex-leaders (among others) for single permutations. We also show how that formula can be simplified by taking advantage of the sparsity of permutations. We test these improvements against earlier constructions and show that they yield smaller SNPs and lead to run time reductions on many benchmarks.

SAT Based Predicate Abstraction for Hardware Verification

Abstract: Predicate abstraction is an important technique for extracting compact finite state models from large or infinite state systems Predicate abstraction uses decision procedures to compute a model which is amenable to model checking, and has been used successfully for software verification Little work however has been done on applying predicate abstraction to large scale finite state systems, most notably, hardware, where the decision procedures are SAT solvers We consider predicate abstraction for hardware in the framework of Counterexample-Guided Abstraction Refinement where in the course of verification, the abstract model has to be repeatedly refined The goal of the refinement is to eliminate spurious behavior in the abstract model which is not present in the original model, and gives rise to false negatives (spurious counterexamples)

Checking properties of heap-manipulating procedures with a constraint solver

Abstract: A method for finding bugs in object-oriented code is presented. It is capable of checking complex user-defined structural properties - that is, of the configuration of objects on the heap - and generates counterexample traces with no false alarms. It requires no annotation beyond the specification to be checked, and is fully automatic. The method relies on a three-step translation: from code to a formula in a first-order relational logic, then to a propositional formula, and finally to conjunctive normal form. An off-the-shelf SAT solver is then used to find a solution that constitutes a counter example. This underlying scheme, presented previously, does not scale readily. In this paper, we show how a suite of optimizations results in much improved scalability. The optimizations are based on a special treatment of relations that are known to be functional, and target all steps. The effect of the optimizations is demonstrated by application to the analysis of a red-black tree implementation.

Using SAT based image computation for reachability analysis

Abstract: Satisfiability procedures have shown significant promise for symbolic simulation of large circuits, hence they have been used in many formal verification techniques, including automated abstraction refinement, ATPG etc We show how to use modern SAT solvers like Chaff and GRASP to compute images of sets of states and how to efficiently detect fixed point of the sets of states during reachability analysis Our method is completely SAT based, and does not use BDDs at all The sets of states and transition relation are represented in clausal form, which can be processed by SAT checkers The SAT checker subsequently generates the set of newly reached states in clausal form as well At the heart of our engine lie two efficient algorithms The first algorithm shortens the cubes that the SAT checker generates by a static-analysis algorithm, which significantly reduces the number of cubes the SAT checker needs to enumerate The second algorithm reduces the space required to store sets of states as a set of cubes by a recursive cube-merging procedure We demonstrate the effectiveness of our procedure on ISCAS sequential benchmarks for reachability In particular, our algorithm does not have BDD size explosion surprises and deteriorates in a predictable manner

Comparing Different Prenexing Strategies for Quantified Boolean Formulas

Abstract: The majority of the currently available solvers for quantified Boolean formulas (QBFs) process input formulas only in prenex conjunctive normal form. However, the natural representation of practicably relevant problems in terms of QBFs usually results in formulas which are not in a specific normal form. Hence, in order to evaluate such QBFs with available solvers, suitable normal-form translations are required. In this paper, we report experimental results comparing different prenexing strategies on a class of structured benchmark problems. The problems under consideration encode the evaluation of nested counterfactuals over a propositional knowledge base, and span the entire polynomial hierarchy. The results show that different prenexing strategies influence the evaluation time in different ways across different solvers. In particular, some solvers are robust to the chosen strategies while others are not.

Improving a Probabilistic 3-SAT Algorithm by Dynamic Search and Independent Clause Pairs

Abstract: The satisfiability problem of Boolean Formulae in 3-CNF (3-SAT) is a well known NP-complete problem and the development of faster (moderately exponential time) algorithms has received much interest in recent years. We show that the 3-SAT problem can be solved by a probabilistic algorithm in expected time O(1,3290 n ). Our approach is based on Schoning’s random walk algorithm for k-SAT, modified in two ways.

SBSAT: a State-Based, BDD-Based Satisfiability Solver

Abstract: We present a new approach to SAT solvers, supporting efficient implementation of highly sophisticated search heuristics over a range of propositional inputs, including CNF formulas, but particularly sets of arbitrary boolean constraints, represented as BDDs. The approach preprocesses the BDDs into state machines to allow for fast inferences based upon any single input constraint. It also simplifies the set of constraints, using a tool set similar to standard BDD engines. And it memoizes search information during an extensive preprocessing phase, allowing for a new form of lookahead, called local-function-complete lookahead. This approach has been incorporated, along with existing tools such as lemmas, to build a SAT tool we call SBSAT.

Using Problem Structure for Efficient Clause Learning

Abstract: DPLL based clause learning algorithms for satisfiability testing are known to work very well in practice. However, like most branch-and-bound techniques, their performance depends heavily on the variable order used in making branching decisions. We propose a novel way of exploiting the underlying problem structure to guide clause learning algorithms toward faster solutions. The key idea is to use a higher level problem description, such as a graph or a PDDL specification, to generate a good branching sequence as an aid to SAT solvers. The sequence captures hierarchical structure that is lost in the CNF translation. We show that this leads to exponential speedups on grid and randomized pebbling problems. The ideas we use originate from the analysis of problem structure recently used in [1] to study clause learning from a theoretical perspective.

Resolution and constraint satisfaction

Abstract: We study two resolution-like refutation systems for finite-domain constraint satisfaction problems, and the efficiency of these and of common CSP algorithms. By comparing the relative strength of these systems, we show that for instances with domain size d, backtracking with 2-way branching is super-polynomially more powerful than backtracking with d-way branching. We compare these systems with propositional resolution, and show that every family of CNF formulas which are hard for propositional resolution induces families of CSP instances that are hard for most of the standard CSP algorithms in the literature.

Checking satisfiability of a conjunction of BDDs

Abstract: Procedures for Boolean satisfiability most commonly work with Conjunctive Normal Form. Powerful SAT techniques based on implications and conflicts can be retained when the usual CNF clauses are replaced with BDDs. BDDs provide more powerful implication analysis, which can reduce the computational effort required to determine satisfiability.

Automatic Abstraction of Equations in a Logic of Equality

Abstract: The paper presents a method to automatically abstract equations when translating formulas with equality to equivalent Boolean formulas, allowing the use of a SAT-checker to determine the validity of the original formula The equations are abstracted with a special interpreted predicate that satisfies the properties of symmetry, reflexivity, transitivity, and functional consistency This abstraction is both sound and complete In contrast to previous methods that encode only low-level equations between term variables, the presented abstraction directly encodes top-level equations where the arguments can be nested-ite expressions that select term variables The automatic abstraction was used to formally verifying the safety of pipelined, superscalar, and VLIW processors, and reduced the CNF clauses by up to 50%, while speeding up the formal verification by up to an order of magnitude relative to the e ij method where a new Boolean variable is used to encode each unique low-level equation between term variables A heuristic for partial transitivity resulted in additional speedup for correct benchmarks that require transitivity

The Inference Problem for Propositional Circumscription of Affine Formulas Is coNP-Complete

Abstract: We prove that the inference problem of propositional circumscription for affine formulas is coNP-complete, settling this way a longstanding open question in the complexity of nonmonotonic reasoning. We also show that the considered problem becomes polynomial-time decidable if only a single literal has to be inferred from an affine formula.

Efficient SAT Engines for Concise Logics: Accelerating Proof Search for Zero-One Linear Constraint Systems

Abstract: We investigate the problem of generalizing acceleration techniques as found in recent satisfiability engines for conjunctive normal forms (CNFs) to linear constraint systems over the Booleans. The rationale behind this research is that rewriting the propositional formulae occurring in e.g. bounded model checking (BMC) [5] to CNF requires a blowup in either the formula size (worst-case exponential) or in the number of propositional variables (linear, thus yielding a worst-case exponential blow-up of the search space). We demonstrate that acceleration techniques like observation lists and lazy clause evaluation [14] as well as the more traditional non-chronological backtracking and learning techniques generalize smoothly to Davis-Putnam-like resolution procedures for the very concise propositional logic of linear constraint systems over the Booleans. Despite the more expressive input language, the performance of our prototype implementation comes surprisingly close to that of state-of-the-art CNF-SAT engines like ZChaff [14]. First experiments with bounded model-construction problems show that the overhead in the satisfiability engine that can be attributed to the richer input language is often amortized by the conciseness gained in the propositional encoding of the BMC problem.

On Computing k-CNF Formula Properties

Abstract: The latest generation of SAT solvers (eg [10,7]) generally have three key features: randomization of variable selection, backtracking search, and some form of clause learning We present a simple algorithm with these three features and prove that for instances with constant Δ (where Δ is the clause-to-variable ratio) the algorithm indeed has good worst-case performance, not only for computing SAT/UNSAT but more general properties as well, such as maximum satisfiability and counting the number of satisfying assignments In general, the algorithm can determine any property that is computable via self-reductions on the formula

A top-down proof procedure for generalized data dependencies

Abstract: Data dependencies are well known in the context of relational database. They aim to specify constraints that the data must satisfy to model correctly the part of the world under consideration. The implication problem for dependencies is to decide whether a given dependency is logically implied by a given set of dependencies. A proof procedure for the implication problem, called “chase”, has already been studied in the generalized case of tuple-generating and equality-generating dependencies. The chase is a bottom-up procedure: from hypotheses to conclusion, and thus is not goal-directed. It also entails in the case of TGDs the dynamic creation of new constants, which can turn out to be a costly operation. This paper introduces a new proof procedure which is top-down: from conclusion to hypothesis, that is goal-directed. The originality of this procedure is that it does not act as classical theorem proving procedures, which require a special form of expressions, such as clausal form, obtained after Skolemization. We show, with our procedure, that this step is useless, and that the notion of piece allows infering directly on dependencies, thus saving the cost of Skolemizing the dependencies set and, morever, that the inference can be performed without dynamically creating new constants. Although top-down approaches are known to be less efficient in time than bottom-up ones, the notion of piece cuts down irrelevant goals usually generated, leading to a usable top-down method. With the more recent introduction of constrained and ordered dependencies, some interesting perspectives also arise.

Linear Time Algorithms for Some Not-All-Equal Satisfiability Problems

Abstract: In this paper we consider the problem Not-All-Equal satisfiability (NAESAT) for propositional formulas in conjunctive normal form (CNF). It asks whether there is a (satisfying) model for the input formula in no clause assigning truth value 1 to all its literals. NAESAT is NP-complete in general as well as restricted to formulas with either only negated or unnegated variables. After having pointed out that SAT and NAESAT in the unrestricted case are equivalent from the point of view of computational complexity, we propose linear time algorithms deciding NAESAT for restricted classes of CNF formulas. First we show that a NAESAT model (if existing) can be computed in linear time for formulas in which each variable occurs at most twice. Moreover we prove that this computation is in NC and hence can also be solved in parallel efficiently. Secondly, we show that NAESAT can be decided in linear time for monotone formulas in which each clause has length exactly k and each variable occurs exactly k times. Hence, bicolorability of k-uniform, k-regular hypergraphs is decidable in linear time.

Logical approximation II

Abstract: The paper continues a study of extensional formulas and their representation by normal forms. The notion of extensional formula is extended to the case when extensionality is considered with respect to a binary reflexive relation. It has been proved that extensional formulas can be represented by normal forms of infinite type and “approximated” by normal forms of finite type. All proofs are given formally in fuzzy predicate BL-logic.

Superposition modulo a Shostak theory

Abstract: We investigate superposition modulo a Shostak theory T in order to facilitate reasoning in the amalgamation of T and a free theory F. Free operators occur naturally for instance in program verification problems when abstracting over subroutines. If their behaviour in addition can be specified axiomatically, much more of the program semantics can be captured. Combining the Shostak-style components for deciding the clausal validity problem with the ordering and saturation techniques developed for equational reasoning, we derive a refutationally complete calculus on mixed ground clauses which result for example from CNF transforming arbitrary universally quantified formulae. The calculus works modulo a Shostak theory in the sense that it operates on canonizer normalforms. For the Shostak solvers that we study, coherence comes for free: no coherence pairs need to be considered.

hGen: A random CNF formula generator for hybrid languages

Abstract: hGen is a random CNF (conjunctive normal form) generator of formulas for sublanguages of H(@,\downarrow, A).

A clausal resolution for extended computation tree logic ECTL

Abstract: A temporal clausal resolution method was originally developed for linear time temporal logic and further extended to the branching-time framework of Computation Tree Logic (CTL). In this paper, following our general idea to expand the applicability of this efficient method to more expressive formalisms useful in a variety of applications in computer science and AI requiring branching time logics, we define a clausal resolution technique for Extended Computation Tree Logic (ECTL). The branching-time temporal logic ECTL is strictly more expressive than CTL, in allowing fairness operators. The key elements of the resolution method for ECTL, namely the clausal normal form, the concepts of step resolution and a temporal resolution, are introduced and justified with respect to this new framework. Although in developing these components we incorporate many of the techniques defined for CTL, we need novel mechanisms in order to capture fairness together with the limit closure property of the underlying tree models. We accompany our presentation of the relevant techniques by examples of the application of the temporal resolution method. Finally, we provide a correctness argument and consider future work discussing an extension of the method yet further, to the logic CTL*, the most powerful logic of this class.

Density Condensation of Boolean Formulas

Abstract: The following problem is considered: Given a Boolean formula f, generate another formula g such that: (i) If f is unsatisfiable then g is also unsatisfiable. (ii) If f is satisfiable then g is also satisfiable and furthermore g is “easier” than f. For the measure of this easiness, we use the density of a formula f which is defined as (the number of satisfying assignments) / 2 n , where n is the number of Boolean variables of f. In this paper, we mainly consider the case that the input formula f is given as a 3-CNF formula and the output formula g may be any formula using Boolean AND, OR and negation. Two different approaches to this problem are presented: One is to obtain g by reducing the number of variables and the other by increasing the number of variables, both of which are based on existing SAT algorithms. Our performance evaluation shows that, a little surprisingly, better SAT algorithms do not always give us better density-condensation algorithms. This is a preliminary report of the on-going research.

A proof system and a decision procedure for equality logic

Abstract: . We give an approach for deciding satisfiability of equality logic formulas (E-SAT) in conjunctive normal form. Central in our approach is a single proof rule called equality resolution (ER). For this single rule we prove soundness and completeness. Based on this rule we propose a complete procedure for E-SAT and prove its correctness. Applying our procedure on a variation of the pigeon hole formula yields a polynomial complexity contrary to earlier approaches to E-SAT. Parts of the theory we developed for proving completeness of the proof rule and the algorithm are of interest in itself: we give techniques for removing clauses preserving unsatisfiability, and we give a general theorem globalizing a local commutation criterion for different proof systems. Keywords: equality logic, satisfiability, resolution.